10.5 Me

The keyword me represents the current script—the script or script object that is running the code where the keyword me appears. Thus:

script myScript
        me -- «script myScript»
end script
run myScript
me -- «script», the anonymous top-level script
parent of me -- «script AppleScript»

See also Section 9.7.3. In situations where you would say of me after a word, you may say my before that word instead.

We saw the keyword me used earlier (Section 9.7) as a way to force AppleScript to attempt to interpret a term as belonging to the current script object, so that it will use the inheritance chain.

The keyword me can be useful in a tell block, to specify the current script as the target instead of the tell block's target. For example, this doesn't work:

on reverseString(s)
        set the text item delimiters to ""
        return (reverse of characters of s) as string
end reverseString
tell application "Finder"
        set name of folder 1 to reverseString(get name of folder 1) -- error
end tell

The problem is that when we come to the handler call reverseString( ) in the next-to-last line, the target is the Finder. So AppleScript passes it along to the Finder, which doesn't know what to do with it. The target for reverseString needs to be me, even though the target of everything else in that line should be the Finder. This is just the kind of situation where me comes in handy:

        set name of folder 1 to my reverseString(get name of folder 1)

But me won't also resolve a terminology clash between a name defined by the target and a name within your script. In that case, you'll have to use pipes around the name, to suppress its terminological interpretation in terms of the target. For instance, returning to an earlier example, how can we refer to the global variable home in the context of a tell block directed at the Finder, which has a property home? This doesn't work:

set home to "Ojai"
tell application "Finder"
        get my home -- error
end tell

The problem is not that my failed to retarget the message. It did retarget it! The problem is that the term home is still being resolved in accordance with the Finder's dictionary. So when the message arrives at our script, it doesn't speak of our variable home, but of some mysterious property that our script doesn't know how to interpret. Use of pipes solves the problem:

set home to "Ojai"
tell application "Finder"
        get |home| -- "Ojai"
end tell

There is no need for my, because the pipes cause AppleScript to take home as a name in scope within the script, and so it targets the script for us.

You may also encounter a need to use pipes around the name of a handler call, but now you must use me as well as the pipes. This is because a handler call is always directed at the target unless you explicitly say otherwise. In this example, the only way to call the script's entab( ) instead of Mailsmith's entab command is to put the name in pipes and use me:

on entab(s)
        return "tab" & s
end entab
tell application "Mailsmith"
        tell message window 1
                my |entab|("let")
        end tell
end tell

The pipes suppress the use of Mailsmith's terminology; the my routes the message to your script instead of Mailsmith. If you use me but no pipes, the message is sent to the script using Mailsmith's terminological encoding, and the script won't understand it; if you use pipes but no me, the message is sent to Mailsmith stripped of its terminological encoding, and Mailsmith won't understand it.