Character Set

Starting in OS X v10.5 (AppleScript 2.0), the character set for AppleScript is Unicode. AppleScript preserves all characters correctly worldwide, and comments and text constants in scripts may contain any Unicode characters.

AppleScript syntax uses several non-ASCII characters, which can be typed using special key combinations. For information on characters that AppleScript treats specially, see the sections Identifiers, Comments, Text, The Continuation Character, and Raw Codes in this chapter, as well as Table 9-1 in Operators Reference.

Identifiers

An AppleScript identifier is a series of characters that identifies a class name, variable, or other language element, such as labels for properties and handlers.

An identifier must begin with a letter and can contain any of these characters:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_

Identifiers are not case sensitive. For example, the identifiers myvariable and MyVariable are equivalent.

AppleScript remembers and enforces the first capitalization it comes across for an identifier. So if it first encounters an identifier as myAccount, it will later, during compilation, change versions such as MyAccount and myaccount to myAccount.

The following are examples of valid identifiers: areaOfCircle, Agent007, axis_of_rotation.

The following are not valid identifiers: C-, back&forth, 999, Why^Not.

AppleScript provides a loophole to the preceding rules: identifiers whose first and last characters are vertical bars (|) can contain any characters. The leading and trailing vertical bars are not considered part of the identifier.

The following are legal identifiers: |back&forth|, |Right*Now!|.

An identifier can contain additional vertical bars preceded by a backslash (\) character, as in the identifier |This\|Or\|That|. Use of the backslash character is described further in the Special String Characters section of the text class.

Keywords

A keyword is a reserved word in the AppleScript language. Keywords consist of lower-case, alphabetic characters: abcdefghijklmnopqrstuvwxyz. In a few cases, such as aside from, they come in pairs.

Table 1-1 lists the keywords reserved in AppleScript 2.0 (which are the same as those used in AppleScript 1.x). For additional information, see Table A-1, which provides a brief description for each keyword and points to related information, where available.

Comments

A comment is text that is ignored by AppleScript when a script is executed. You can use comments to describe what is happening in the script or make other kinds of notes. There are three kinds of comments:

• A block comment begins with the characters (* and ends with the characters *). Block comments must be placed between other statements. That means they can be placed on the same line at the beginning or end of a statement, but cannot be embedded within a simple (one-line) statement.

• An end-of-line comment begins with the characters -- (two hyphens) and ends with the end of the line:

  --end-of-line comments extend to the end of the line

• Starting in version 2.0, AppleScript also supports use of the # symbol as an end-of-line comment. This allows you to make a plain AppleScript script into a Unix executable by beginning it with the following line and giving it execute permission:

  #!/usr/bin/osascript

  Compiled scripts that use # will run normally on pre-2.0 systems, and if edited will display using --. Executable text scripts using #!/usr/bin/osascript will not run on pre-2.0 systems, since the # will be considered a syntax error.

You can nest comments—that is, comments can contain other comments, as in this example:

(*  Here are some

    --nested comments

    (* another comment within a comment *)

*)

The Continuation Character

A simple AppleScript statement must normally be entered on a single line. You can extend a statement to the next line by ending it with the continuation character, ¬. With a U.S. keyboard, you can enter this character by typing Option-l (lower-case L). In Script Editor, you can type Option-Return, which inserts the continuation character and moves the insertion point to the next line.

Here is a single statement displayed on two lines:

display dialog "This is just a test." buttons {"Great", "OK"} ¬

default button "OK" giving up after 3

A continuation character within a quoted text string is treated like any other character.

Literals and Constants

A literal is a value that evaluates to itself—that is, it is interpreted just as it is written. In AppleScript, for example, "Hello" is a text literal. A constant is a word with a predefined value. For example, AppleScript defines a number of enumerated constants for use with the path to (folder) command, each of which specifies a location for which to obtain the path.

{1, 7, "Beethoven", 4.5}

-94596

3.1415

9.9999999999E+10

{product:"pen", price:2.34}

"A basic string."

Operators

An operator is a symbol, word, or phrase that derives a value from another value or pair of values. For example, the multiplication operator (*) multiplies two numeric operands, while the concatenation operator (&) joins two objects (such as text strings). The is equal operator performs a test on two Boolean values.

For detailed information on AppleScript’s operators, see Operators Reference.

Variables

A variable is a named container in which to store a value. Its name, which you specify when you create the variable, follows the rules described in Identifiers. You can declare and initialize a variable at the same time with a copy or set command. For example:

set myName to "John"

copy 33 to myAge

Statements that assign values to variables are known as assignment statements.

When AppleScript encounters a variable, it evaluates the variable by getting its value. A variable is contained in a script and its value is normally lost when you close the script that contains it.

AppleScript variables can hold values of any class. For example, you can assign the integer value 17 to a variable, then later assign the Boolean value true to the same variable.

For more information, see Variables and Properties.

Expressions

An expression is any series of lexical elements that has a value. Expressions are used in scripts to represent or derive values. The simplest kinds of expressions, called literal expressions, are representations of values in scripts. More complex expressions typically combine literals, variables, operators, and object specifiers.

When you run a script, AppleScript converts its expressions into values. This process is known as evaluation. For example, when the following simple expression is evaluated, the result is 21:

3 * 7 --result: 21

An object specifier specifies some or all of the information needed to find another object. For example, the following object specifier specifies a named document:

document named "FavoritesList"

For more information, see Object Specifiers.

Statements

A statement is a series of lexical elements that follows a particular AppleScript syntax. Statements can include keywords, variables, operators, constants, expressions, and so on.

Every script consists of statements. When AppleScript executes a script, it reads the statements in order and carries out their instructions.

A control statement is a statement that determines when and how other statements are executed. AppleScript defines standard control statements such as if, repeat, and while statements, which are described in detail in Control Statements Reference.

A simple statement is one that can be written on a single line:

set averageTemp to 63 as degrees Fahrenheit

A compound statement is written on more than one line, can contain other statements, and has the word end (followed, optionally, by the first word of the statement) in its last line. For example the following is a compound tell statement:

tell application "Finder"

    set savedName to name of front window

    close window savedName

end tell

A compound statement can contain other compound statements.

Commands

A command is a word or series of words used in an AppleScript statement to request an action. Every command is directed at a target, which is the object that responds to the command. The target is usually an application object or an object in macOS, but it can also be a script object or a value in the current script.

The following statement uses AppleScript’s get command to obtain the name of a window; the target is the front window of the Finder application:

get name of front window of application "Finder"

For more information on command types, parameters, and targets, see Commands Overview.

Results

The result of a statement is the value generated, if any, when the statement is executed. For example, executing the statement 3 + 4 results in the value 7. The result of the statement set myText to "keyboard" is the text object "keyboard". A result can be of any class. AppleScript stores the result in the globally available property result, described in AppleScript Constant.

Raw Codes

When you open, compile, edit, or run scripts with a script editor, you may occasionally see terms enclosed in double angle brackets, or chevrons («»), in a script window or in another window. These terms are called raw format or raw codes, because they represent the underlying Apple event codes that AppleScript uses to represent scripting terms.

For compatibility with Asian national encodings, “《” and “》” are allowed as synonyms for “«” and “»” ( (Option- \ and Option-Shift- \, respectively, on a U.S. keyboard), since the latter do not exist in some Asian encodings.

For more information on raw codes, see Double Angle Brackets.