ActionScript 3.0 Fundamentals

ActionScript 3.0 Fundamentals

Saurabh Narulahttp://blog.saurabhnarula.com/

Discussion Areas

• ActionScript 3.0 Introduction• AVM2• Programming Fundamentals• ActionScript Language and Syntax • Object Oriented Programming in

ActionScript

ActionScript is the programming language for Adobe Flash Platform.

Language specification is open source

Open Source Compiler – as part of Flex SDK

Open source Virtual Machine – Mozilla Tamarin

Whats not open source ..Flash Player

AIR

Initially designed for controlling simple 2D vector animations, few interactivity features (may be that’s why its single

threaded)

ActionScript executes in ActionScript Virtual Machine (AVM)

A new ActionScript Virtual Machine, called AVM2 – significant performance

improvements over older AVM

Before we get going on ActionScript fundamentals .. Lets have a brief look

and understand what is a virtual machine ..

Virtual Machine is essentially a virtual environment/OS running within

a actual/host operating systems.

In case of AVM, we talk about Process (Application) Virtual

Machines and not System (Platform) Virtual Machines.

Process VMs provide a platform-independent programming

environment that abstracts details of the underlying hardware or OS. Allows program to execute the same way on

all platforms.

Process VM provide high level abstraction, for a high level

programming language. This is done using an interpreter

Programmer writes code in high level/human readable form which a

machine can not understand .. so this source code has to be converted into

machine code, this conversion is performed by Interpreter.

Compiler makes the conversion once.Interpreter converts it every time a

program is executed.

Just in time Compilation (JIT) – offers improved runtime performance

than interpreter.

Interpreter interpret the byte code or sometimes interpret source code

directly without having a byte code. These techniques offer lower

performance.

In case of JIT, a compiler can be used during execution – dynamic

compilation. Remember – compilation from byte code to machine code is much faster than compiling from

source.

AVM2 takes ActionScript bytecode ABC file as an input.

AVM2 Architecture

GC in flash player does not work constantly, only triggered by

allocations.

GC in flash player is iterative, doesn’t guarantee to find all collectible blocks

in one pass.

GC works by

starting at the top of the object trees – Stage, ApplicationDomain/Class Definitions, Stack/Local Variables

Mark the object and any objects they reference.

Go through the heap and free anything that isn't marked.

ActionScript is based on ECMAScript

Event model based on the Document Object Model (DOM) Level 3 Events

Specification

DOM is a convention for representing and interacting with objects in HTML,

XML type documents.

Variables consists of 3 different parts – name, type of the data, actual value

in computer’s memory

Constant is same as variable but can be assigned only once.

Using constants than a literal value makes code more readable. Change the value at one place than having it changed everywhere if using a hard-

coded literal value. For example INTREST_RATE

Data types

Fundamental – single value like string, number, int, boolean etc ..

Complex – set of values like Date.

Creating objects is a way of organizing your code. In OOP related

information and functionality is grouped together in form of objects.

Class is a template or a blueprint of how object should look like, basis of

the object creation.

A Class can have Properties, Methods, Events.

Property is data/information bundled within the object.

To access a property you use “variable name-dot-property

name” structure.

A Method is an operation that object can perform, are not value

placeholders.

Event is essentially an event that happens which ActionScript is aware of

and can respond to.

Event Handling is an action that you perform in response to a particular

event.

Three important elements of Event handling – even source, event,

response.

function eventResponse(eventObject:EventType):void{

// Actions performed in response to the event go here.}

eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Event handling -

Compiler makes note of all the eventResponse() functions.

Event source keeps a list of functions that are listening to each of its events.

When the event happens, object is created for that event’s class and passes it on to eventResponse function.

You directly instantiate a visual object by using it in MXML.

For non visual objects you can instantiate them by using new

operator or by assigning a literal value. Both approaches are same with

a difference of calling base class constructor when using the new

operator.

You can build Flash applications using ActionScript 3.0 without using

Flex SDK (create AS only project in Flash Builder), you can add AS code to

frames in a timeline in Flash Professional.

You can choose to Embed code in MXML files inside <fx:script> tag,

alternatively you can import ActionScript code from an external file and specify the source attribute of the <fx:script> tag. You can also import the unstructured code using the

include statement.

Include an ActionScript Class using import statement.

Flash Builder can be used to create apps using Flex SDK, and ActionScript

only projects.

You use Flash Professional when you want to create your visual assets

(graphics, interactivities etc) and work with timeline/frames and write code in

the same application.

Other third party tools – FDT, TextMate (with AS, Flex bundles) etc.

Class Design Considerations ..

A class can be type value object, display object, supporting class.


Your class can dispatch events if other parts of application need to know of

some change.


Consider creating a subclass if a class exists with a similar functionality.

Lets take a detailed look at ActionScript 3.0 language and

syntax.

Objects and Classes ..

All classes, built in or user defined derive from Object class.

Objects and Classes ..

var obj:*; //untyped object

key differentiator – can hold undefined value, variable of type object cannot

hold undefined.

Packages and namespaces ..

Related concepts but not same.

Packages ..

Implemented using namespaces (we will see later ..)

Packages ..

You can have variables, function, statements at the top level (and not

just classes) but can only be public or internal.

Packages ..

Doesn’t support private classes

Packages ..

Main benefit – helps in avoiding name conflicts

Packages ..

Import statements should be as specific as possible.

Import TestPackage.*; //avoid this – may lead to unexpected name conflicts.

Import TestPackage.SomeClass;

Packages ..

Default access specifier for all members of package is internal.

Packages ..

Resolving name conflicts –

import samples.SampleCode;import langref.samples.SampleCode;

var mySample:SampleCode = new SampleCode(); // name conflict

//use fully qualified names to resolve name conflictsvar sample1:samples.SampleCode = new

samples.SampleCode();var sample2:langref.samples.SampleCode = new

langref.samples.SampleCode();

Namespaces ..

Create your own namespace to define your own access control specifier.

Namespaces ..

You can attach a URI to the namespace definition, this makes sure

that the definition is unique. If URI is not defined, compiler creates a unique identifier string in place of

URI.

Namespaces ..

Cannot redefine a namespace in a same scope.

Namespaces ..

Can apply only one namespace to each declaration.

Namespaces ..

If you apply a namespace, you cannot also apply access control specifier.

Packages are abstractions built on top of namespaces.

mx_internal identifier used in Flex SDK

Variable Scope ..

There is no block level scope, interesting implication of this is that

you can read or write variable before it is declared.

Data Types ..

Primitive type (boolean, int, number, string, uint)

objects are stored as immutable objects, which means passing by

reference is same as passing by value.

Immutable objects - When you have a reference to an instance of object,

the content of the instance can not be altered.

Complex types/values are passed as reference.

Type Checking ..

Can occur at both compile and runtime.

Type Checking ..

You can set compiler to run in strict mode – type checking at both

compile time and runtime or

standard mode – only at runtime

Type Checking ..

Compile time checking is favored in case of large projects, catching type

errors as early as possible is important.

Type Checking ..

when you use untyped object, you are not eliminating type checking but

deferring it to the runtime.

Type Checking ..

Upcast – Use base class to declare the type of a class instance but use a

subclass to instantiate it.

is operator ..

1. Checks if the object is an instance of a particular class, 2. checks the inheritance hierarchy, 3. and if an object is an instance of a class that implements a particular interface.

as operator ..

Returns the value of the expression instead.

Helps in ensuring that you are using a correct type.

Dynamic classes ..

Can attach properties and methods outside the class definition.

Dynamic classes ..

Type checking on dynamic properties is done at the runtime.

Methods attached dynamically do not have access to private properties

References to public properties or methods should be qualified with this

or class name.

Data Types ..

Primitive – Boolean, int, Null, Number, String, Uint, void

Complex – Object, Array, Date, Error, Function,

Type Conversions ..

Type conversions can be either implicit (coercion) or explicit (casting). Implicit conversions usually happen at the run

time.

Implicit Conversions ..

Can happen at runtime – in assignment statements, when values passed as

function arguments, when values are returned from functions, when using +

operator


For user-defined types, implicit conversions succeed when the value to

be converted is an instance of the destination class or a class that

derives from the destination class


For primitive types, implicit conversion happens the same way as

in case of explicit conversion.

Explicit Conversions ..

Good for type safety, will save you from any type conversion errors that

might happen at the runtime.

Casting to int, uint, Number ..

Can cast any data type to one of these, if the conversion fails then

default value 0 for int & uint is assigned and Nan for Number.

Casting to Boolean ..

Casting to Boolean from numeric types results in false if the numeric value is 0

and true otherwise.

Casting to String ..

From any numeric types .. Returns a string representation of number, in case of arrays ..a comma delimited

string of all array elements would be returned.

ActionScript syntax ..

ActionScript is case sensitive.

ActionScript syntax ..

dot operator, literals, semicolons, parentheses, comments, keywords,

reserve words, constants.

Operators, Operator precedence and associatively ..

Primary Operators ..

Used for initializing array, object, group expression, calling a constructor

etc. For eample [], {x:y}, (), new resp.

Other Operators ..

Postfix, Unary, multiplicative, additive, bitwise shift, relational, equality,

bitwise logical, logical, conditional, assignment.

Conditional Statements ..

If, if .. else if, switch,

Looping ..

for, for .. In, for each .. In, while, do .. while

Functions ..

function statements vs. function expressions

Function statements ..

Less verbose, less confusing.

Function Expressions ..

Common use is that they are used only once and then discarded.

Difference between function expression & function statement ..

In case of dynamic classes/objects, delete has no effect on function

statements

Difference between function expression & function statement ..

Can call function statement even before they are defined, not in case of

fn expressions

Functions ..

return statement terminates the function, any statement after return is

not executed.

Nested functions ..

Only available within its parent function unless a reference to the function is passed to outside code

(function closures).

Function parameters ..

All arguments are passed by reference except primitive types.

Functions parameters ..

Number of arguments sent to a function can exceed the number of

parameters defined for that function.

Default parameters ..

Is similar to making a parameter as optional, a parameter with no default value becomes a required parameter.

All parameters with default values should ideally be placed in the end of parameter list in function signature.

The arguments object ..

Arguments is an array that includes all parameters passed to a function,

argument.callee provides a reference to a function itself, which is useful for

recursive calls (in function expressions).

.. (rest) parameter

specify array parameter that would allow you to accept any number of

comma delimited parameters. Use of this makes arguments array

unavailable.

.. (rest) parameter

can be used with other parameters, but should be the last parameter.

Function as Objects ..

Function passed as arguments to another function are passed as

reference.

Functions as objects ..

Functions can have properties, methods like an object. It even has a

read only property called length which stores the number of parameters

defined for that function.

Function scope ..

Same scope rules that apply to variables, apply to functions.

Scope Chain ..

At the time of execution a activation object gets created that stores parameters and local variables,

functions declared in the function body. We can not access activation

object.

Scope chain ..

Scope chain is created that contains the ordered list of objects, against which the identifier declarations

(variables) are checked.

Scope chain ..

Every function that executes has a scope chain, this is stored in an

internal property. For example, for a nested function the scope chain starts with its own activation object, followed

by its parent function’s activation object, until it reaches to global object. The global object is created when the ActionScript program begins, contains

all global variables and functions.

Function closures ..

Object that contains a snapshot of a function and its lexical environment.

Function closures ..

Function closures retain the scope in which they were defined.

Object Oriented Programming in ActionScript

Classes

abstract representation of object, usefulness of such an abstraction is

apparent in big projects.

Class attributes ..

Dynamic – allow properties (classes and properties) to be added at

runtime.Final – can not extend the class.Internal – visible only inside the

current package.Public – visible everywhere

Classes ..

Can have a static property and instance property with the same name

in the same class.

Classes ..

You can have statements in the class definition, which would execute only

once.

Class property attributes ..

Internal, private, protected, public, static, User defined namespaces.

Private variable ..

In case of dynamic classes, accessing a private variable returns undefined

instead of an error.

Private variables ..

Trying to access a private variable in strict mode using dot operator will generate a compile time error, and

undefined in case of accessing using [] bracket.

In standard mode, both cases will return undefined.

Static ..

Can be used with var, const, function. Attach property to class rather than to

instance of the class.

Static ..

Static properties are part of a subclass’s scope chain, within a

subclass a static variable or method can be used without referencing its

class name.

Variable ..

Can be declared using var and const keyword.

Variable ..

variable declared as both const and static must be initialized at the same

time as you declare it.

Instance variables ..

Cannot override var/const directly, can override setters/getters though.

Constructor methods ..

Can only be public, doesn’t return any value.


Can explicitly call the super class constructor by using super(), compiler

calls it if not explicitly called.


When using super statement with super(), always call super() first.

Static methods ..

Does not affect a specific instance of a class, you can use this or super

within the body of the static method. Not inherited but are in scope.

Instance methods ..

Redefine an inherited method, final attribute is used to prevent subclasses

from overriding a method.

Getters and setters ..

Access class properties which are private as if you are accessing directly

instead of calling a method. Avoids using names like getPropertyName(),

setPropertyName()

Getters and setters ..

Can use override attribute on getter and setter functions.

Bound methods ..

Similar to function closure, this reference in a bound method remains bound to the instance that implements the method, whereas this reference is

generic in case of function closure.

Enumerations ..

Custom data types that you create to encapsulate small set of values.

Embedded asset classes ..

[Embed] metadata tag, @Embed in MXML.

Interfaces ..

Method declarations that allow unrelated objects to communicate with

each other, i.e serves as a protocol.

Interfaces ..

Any class that implements interface is responsible for defining the method

implementations.

Interfaces ..

Can not include variables or constants but can include getters and setters.

Interfaces ..

Can be public or internal. Method definitions inside an interface can not have access specifiers. Interfaces can

extend another interface.

Interfaces ..

While implementing an interface, make sure number of parameters and

the data type of each parameter is same, in case of default parameter not necessary to specify the same default

values.

Inheritance ..

Code reuse. Subclass is guaranteed to possess all the properties of its base

class.

Inheritance ..

Can take advantage of polymorphism by inheriting and overriding methods.

Inheritance ..

Instance of a subclass can always be substituted for an instance of the base

class.

Inheritance - Overriding methods

Names of the parameters in the override method do not have to match

the names of the parameters in the base class, as long as the number of

parameters and the data type of each parameter matches.

Inheritance - Static Properties

If an instance property is defined that uses the same name as a static property in the same class or a

superclass, the instance property has higher precedence in the scope chain.

Technology

ActionScript 3.0 Fundamentals