History
A AppleScript plan was an outgrowth of the HyperCard project. HyperCard experienced an English language-based scripting language known as HyperTalk which could be utilized for embedding logic & behavior into the HyperCard fold. Apple engineers recognized that the similar scripting language can exist as designed to be utilized by using any application, and a AppleScript plan was natural.

AppleScript expected extensive upgrades to the Mac OS to operate (watch beneath for details). Great deal of the underlying technology changes were processed section of the massive System 7 release, notably the key Apple Events concept. Per se, Apple Cases were vying for creator attention along sustaining numerous more freshly technologies introduced at a equivalent instance (balloon help, publish and subscribe, etc.). Apple Cases were among the virtually all hard of the Technique 7 technologies to implement, requiring a re-rescript of major portions of the "low level" code around an application. Apple's have application framework, MacApp, did not directly trend lines Apple Cases for occasionally instance.

AppleScript wwhen freed around October 1993 as section of System 7.1.1 (System 7 Pro, the first major upgrade to System 7). QuarkXpress (ver. Trine.Two) was one of a number 1 major software system applications that supported AppleScript, & following AppleScript was widely adopted in a publication section of the Apple market. These are arguable that the independent cause that a Macintosh remained a powerhouse in the publication market when Quark (& more applications) were ported to Microsoft Windows, was that Mac users may automate complex workflows.

A move to Mac OS X and its Cocoa frameworks has made AppleScript inherit its have. Cocoa applications offer basic scriptability sustaining there is no effort on the a portion of the creator, & come "well-scriptable" for the dollars and cents of writing the document. AppleScript Studio, released using Mac OS X v10.2, allows users to build entire applications using AppleScript and Cocoa objects.

Basic concepts
AppleScript was designed to exist as utilized primarily as a scripting language, offering users an intelligent mechanism to control & exchange tools by using various applications.

Before System 7 the Mac OS application runtime had lone the rudimentary event model that can specify the little & fixed total of online-subordinate cases prefer "key was pressed" or even "mouse was clicked". For each one application was responsible decoding these on line-subordinate cases into meaningful high-level user actions, prefer "select cut from the Edit menu". Around several suits a code for reading a event & decoding it was mixed together; for example a code treating a click will decode it to finding a Quit item from either a File menu, and so quit the application immediately.

Adding AppleScript trend lines called upon andy skinner to fully separate this decryption from either carrying out the command, a project Apple known as factorization (...a application). Application developers were encouraged to write ii complete event treating "stacks", 1 for treating a online-subordinate cases (clicks, etc.), & an additional for high-level cases (AppleEvents). A actual operate code that handled these commands, it used to become that decoded, was to be wholly separated & known as identically from either two stacks.

AppleScript in MacOS X
Around Mac OS X AppleScript is simpler for developers to implement, particularly for those applications existence developed inside Cocoa. Unlike the Mac OS in which cases come handled per applications, under Cocoa, cases come decoded into a "high level" command per NSApplication object, & a messages dispatched directly to the right object. That is, totally Cocoa applications come "factored" by default, a creator doesn't write any of a event treating code (unremarkably) & writes merely the "work methods" that victims cases might call for.

the second major benefit is that Cocoa objects come presented to the outside globe (more applications & possibly machines) within a standardized format that anyone could examine directly. Under Cocoa AppleScript is lot "thinner"; a script engine decodes a script, translates object list from either individual-readable to their internal format, then calls victims methods on the target application directly.

The natural language metaphor
Whereas Apple Cases come how else to send messages into applications, AppleScript occurs as particular language designed to send Apple Cases. Inside keeping sustaining a Mac OS tradition of ease-of-apply, a AppleScript language is designed on the natural language metaphor, just as a graphical user interface is designed on the desktop metaphor. AppleScript softwcome are usually decipherable by anyone, & editable by virtually all. A language is depending largely in HyperCard's HyperTalk language, touch refer non simply to the HyperCard globe of cards & stacks, however theoretically to any document. To this prevent, a AppleScript team introduced a Apple Event Object Model (AEOM), which specified the objects any particular application "knew".

Typically, AEOM defined the total of objects, rather "document" or even "paragraph", & a actions that can be done to the babies, prefer "cut" & "close". A technique as well defined ways to refer to properties of objects, and so 1 can refer to the "third paragraph of the document 'Good Day'", or even a "color of the last word of the front window". AEOM utilizes an application lexicon to associate a Apple Cases by using individual-readable terms, leaving a translation back & forth between individual-readable AppleScript & bytecode Apple Events. To discover what elements of the program come scriptable, lexicon for supported applications can be viewed. (In the Xcode and Script Editor applications, this is under File → Open Dictionary.)

To designate which application is intended to become the target of such the message, AppleScript utilizes a "tell" construct:

tell application "Microsoft Word" quit prevent tell

Though for cases in the "Core Suite" (activate, open, reopen, close, print, & quit), a application can be supplied when a direct object to intransitive commands:

quit application "Microsoft Word"

A construct of an object hierarchy can be expressed using nested interferes:

tell application "QuarkXpress" tell document 1 tell website 2 tell text pack 1 placed word Quintet to "Apple" prevent tell prevent tell prevent tell prevent tell

A construct of an object hierarchy can also exist as expressed utilizing nested prepositional phrases:

picture element Sevener of row Trinity of Pettifoggery image "my bitmap"

which in another programming language might be expressed when successive function calls:

getTIFF("my bitmap").getRow(Iii).getPixel(Vii);

Numerous applications don't store pointers directly into anything however the last-place level objects; e.g., a word processor almost certainly has an object that comes back completely of the characters within the document, however might not use at times objects representing web sites, paragraphs or even documents as a whole. Since a authors meant AppleScript to become added to existent applications forgoing as well very much redesign, it as well provided another way to write accessors called iterators. Applying iterators takes a creator exclusively to keep track of the todays location of an object, & provide a method to buy the "next one". For example, paragraph objects can be supported sustaining the single pointer to a todays paragraph, & the method that finds the next one by wanting to find a go to character. Note a similarities between a AEOM model & a substantially other recent DOM system used within XML. Each decay a document into the hierarchy of objects, & offer the computer programmer a standardized reiterative method to access the contents. Differences between the systems lie primarily in the user-level syntax, by owning AppleScript introducing a total of different ways to refer to any particular object. E.g., AppleScript includes syntax for ordinal number counting, "the first paragraph", also when primal, "paragraph one". Also a cost themselves may be known as text or even numerically, "five", "fifth" & "5" come completely supported.

AppleScript on its own
AppleScript require nin depend on more applications. For super elementary tasks, AppleScript may be utilized for self-contained applets. For example, a code:

placed pix to 72 placed guide to text returned of (display dialog "Enter in the number of inches" default guide "1") display dialog guide & "in = " & (answer * pix) & "px"

will bring higher the dialog box requesting a total of inches from a user. This total is so converted to pixels, assuming 72 pixels per inch. Another panel is so brought higher displaying a symptom.

AppleScript Studio
By using Mac OS X, AppleScript has grown well beyond its humble beginnings. AppleScript Studio is a development environment, which comes free by using Macintosh OS X, which utilizes AppleScript when a primary programing language, around conjunction sustaining a Cocoa framework used to construct gui.

Using Mac OS X v10.3 ("Panther") AppleScript Studio and Project Builder have been rolled into the Xcode IDE. Interface Builder, another component of Xcode, lets your family build the interface around the drag-and-drop fashion (similar to Visual Basic) and then "run" a interface to view what a forms & menus looks such as.

Panther likewise accompany an enhanced version of Script Editor, a minimalist editor for compiling & running off AppleScripts. Of these freshly feature of this editor even is that if busy people best-mouse press (or control-click) on the redaction vicinity, you acquire the pop-higher menu using the big range of choices for script fragments to paste into the code. This is an fantabulous feature for population learning to write AppleScript. From either that menu, smart shoppers can besides open higher a directory in which these scripts come saved, & get a load at the babies. Wise shoppers can likewise add your systems have scripts (although we require to restart Script Editor for these changes to show higher in the crop up menu).

AppleScript dialects
AppleScript at a start supported the idea of multiple accent: different syntactical representations of the equivalent script. A standard accent was English; French, and Japanese dialects were also produced. (The C dialect was publicly discussed, but never shipped.) a idiom can redefine a keywords & possibly a grammar of a language, and then that, e.g., commands in the Japanese accent experienced the verb at the prevent. Because AppleScript places scripts around the compiled form, it may compile the script around 1 accent & decompile it in another. When the design was the technical indicator profits, couple of application developers provided nomenclature around multiple languages, which intended that scripts were a confusing mix of languages within virtually all lawsuits. Trend lines for multiple idiom was drop inside Apple in Mac OS 8.5.

AppleScript language essentials
basic information types come boolean, string, whole number, real, names, record & object different types may coexist around the names, including nested lists records come lists of key-value pairs standard control flow using if/else constructions & repetition (for, piece, within) loops variables come instantiated whilst utilized, & are non strictly typed script objects may encapsulate methods & data script objects might inherit behavior from either the parent script "tell" construct wont to identify target of message applications may define nomenclature at runtime runtime compilation conceivable applying "run script" construct persistence & modularity conceivable applying "store script" & "load script"

Applets and Droplets
These are imaginable to save an AppleScript script as an viable file or even applet. In case the script has a process handler:

to run (*...*) prevent run

so this is invoked whenever a user double-clicks a applet. (In case no handlers in a script, the entire script occurs as rerun handler.)

In case a script has an open handler:

to open(SomeItems) (*...*) prevent open

so the applet becomes a droplet: whenever the user drags & drops filesystem things onto a script, it is launched & a open handler is invoked using a names of assumed name to the dropped things.

(Note: "on" occurs as synonym for "to" when starting the handler; for instance, "on run" instead of "to run".)

Open Scripting Architecture

An crucial aspect of a AppleScript implementation was the Open Scripting Architecture (OSA). Apple provided OSA for third-person scripting/automation products like QuicKeys and UserLand Frontier, to functiin on an equal status using AppleScript. AppleScript was implemented as a scripting component, and a basic specification for interfacing such components to the OSA were public, allowing for more developers to add their have scripting components to the body. Public client APIs for loading, saving & compiling scripts would act a equivalent for everthing such components, which as well intended that applets and droplets may hang on to scripts in any of people scripting languages.

One of the virtually all interesting features of a architecture, the ability to write language extensions (known as a "scripting addition", or even "osax" for "Open Scripting Architecture eXtension") , which were according to Hypercard's external commands. Because an extension adds terms to the language, it another time became problematic to predict how else the AppleScript compiler would behave given a specific syntax based upon which OSAX were installed at runtime. A coiners of the term osax, Jon Pugh and Donald Olson consider the proper spelling to apply wholly lowercase letters, "osax" & "osaxen".