The document provides an overview of ActionScript 3.0 fundamentals including the ActionScript Virtual Machine, data types, classes, inheritance, interfaces, and object-oriented programming concepts in ActionScript. It discusses topics such as variables, functions, conditional statements, loops, scope, packages, namespaces, and more. The document is intended as educational material for learning the basics of the ActionScript 3.0 programming language.

1. ActionScript 3.0 Fundamentals Saurabh Narula http://blog.saurabhnarula.com/

3. ActionScript is the programming language for Adobe Flash Platform.

4. Language specification is open source Open Source Compiler – as part of Flex SDK Open source Virtual Machine – Mozilla Tamarin

5. Whats not open source .. Flash Player AIR

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

7. ActionScript executes in ActionScript Virtual Machine (AVM) A new ActionScript Virtual Machine, called AVM2 – significant performance improvements over older AVM

8. Before we get going on ActionScript fundamentals .. Lets have a brief look and understand what is a virtual machine ..

9. Virtual Machine is essentially a virtual environment/OS running within a actual/host operating systems.

10. In case of AVM , we talk about Process (Application) Virtual Machines and not System (Platform) Virtual Machines.

11. 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.

12. Process VM provide high level abstraction, for a high level programming language. This is done using an interpreter

13. 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.

14. Compiler makes the conversion once. Interpreter converts it every time a program is executed.

15. Just in time Compilation (JIT) – offers improved runtime performance than interpreter.

16. Interpreter interpret the byte code or sometimes interpret source code directly without having a byte code. These techniques offer lower performance.

17. 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.

18. AVM2 takes ActionScript bytecode ABC file as an input.

19. AVM2 Architecture

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

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

22. 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.

23. ActionScript is based on ECMAScript

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

25. DOM is a convention for representing and interacting with objects in HTML, XML type documents.

26. Variables consists of 3 different parts – name, type of the data, actual value in computer’s memory

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

28. 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

29. Data types Fundamental – single value like string, number, int, boolean etc .. Complex – set of values like Date.

30. Creating objects is a way of organizing your code. In OOP related information and functionality is grouped together in form of objects.

31. Class is a template or a blueprint of how object should look like, basis of the object creation.

32. A Class can have Properties, Methods, Events.

33. Property is data/information bundled within the object.

34. To access a property you use “variable name-dot-property name” structure.

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

36. Event is essentially an event that happens which ActionScript is aware of and can respond to.

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

38. Three important elements of Event handling – even source, event, response.

39. function eventResponse(eventObject:EventType ):void { // Actions performed in response to the event go here. } eventSource .addEventListener( EventType.EVENT_NAME , eventResponse);

40. 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.

41. 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.

42. 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.

43. 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.

44. Include an ActionScript Class using import statement.

45. Flash Builder can be used to create apps using Flex SDK, and ActionScript only projects.

46. 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.

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

48. Class Design Considerations .. A class can be type value object, display object, supporting class.

49. Class Design Considerations .. Your class can dispatch events if other parts of application need to know of some change.

50. Class Design Considerations .. Consider creating a subclass if a class exists with a similar functionality.

51. Lets take a detailed look at ActionScript 3.0 language and syntax.

52. Objects and Classes .. All classes, built in or user defined derive from Object class.

53. Objects and Classes .. var obj:*; //untyped object key differentiator – can hold undefined value, variable of type object cannot hold undefined.

54. Packages and namespaces .. Related concepts but not same.

55. Packages .. Implemented using namespaces (we will see later ..)

56. Packages .. You can have variables, function, statements at the top level (and not just classes) but can only be public or internal.

57. Packages .. Doesn’t support private classes

58. Packages .. Main benefit – helps in avoiding name conflicts

59. Packages .. Import statements should be as specific as possible. Import TestPackage.*; //avoid this – may lead to unexpected name conflicts. Import TestPackage.SomeClass;

60. Packages .. Default access specifier for all members of package is internal.

61. 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 conflicts var sample1:samples.SampleCode = new samples.SampleCode(); var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();

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

63. 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.

64. Namespaces .. Cannot redefine a namespace in a same scope.

65. Namespaces .. Can apply only one namespace to each declaration.

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

67. Packages are abstractions built on top of namespaces.

68. mx_internal identifier used in Flex SDK

69. Variable Scope .. There is no block level scope, interesting implication of this is that you can read or write variable before it is declared.

70. 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.

71. Type Checking .. Can occur at both compile and runtime.

72. 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

73. Type Checking .. Compile time checking is favored in case of large projects, catching type errors as early as possible is important.

74. Type Checking .. when you use untyped object, you are not eliminating type checking but deferring it to the runtime.

75. Type Checking .. Upcast – Use base class to declare the type of a class instance but use a subclass to instantiate it.

76. 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.

77. as operator .. Returns the value of the expression instead. Helps in ensuring that you are using a correct type.

78. Dynamic classes .. Can attach properties and methods outside the class definition.

79. 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.

80. Data Types .. Primitive – Boolean, int, Null, Number, String, Uint, void Complex – Object, Array, Date, Error, Function,

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

82. Implicit Conversions .. Can happen at runtime – in assignment statements, when values passed as function arguments, when values are returned from functions, when using + operator

83. Implicit Conversions .. 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

84. Implicit Conversions .. For primitive types , implicit conversion happens the same way as in case of explicit conversion.

85. Explicit Conversions .. Good for type safety, will save you from any type conversion errors that might happen at the runtime.

86. 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.

87. Casting to Boolean .. Casting to Boolean from numeric types results in false if the numeric value is 0 and true otherwise.

88. 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.

89. ActionScript syntax .. ActionScript is case sensitive.

90. ActionScript syntax .. dot operator, literals, semicolons, parentheses, comments, keywords, reserve words, constants.

91. Operators, Operator precedence and associatively ..

92. Primary Operators .. Used for initializing array, object, group expression, calling a constructor etc. For eample [], {x:y}, (), new resp.

93. Other Operators .. Postfix, Unary, multiplicative, additive, bitwise shift, relational, equality, bitwise logical, logical, conditional, assignment.

94. Conditional Statements .. If, if .. else if, switch,

95. Looping .. for, for .. In, for each .. In, while, do .. while

96. Functions .. function statements vs. function expressions

97. Function statements .. Less verbose, less confusing.

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

99. Difference between function expression & function statement .. In case of dynamic classes/objects, delete has no effect on function statements

100. Difference between function expression & function statement .. Can call function statement even before they are defined, not in case of fn expressions

101. Functions .. return statement terminates the function, any statement after return is not executed.

102. Nested functions .. Only available within its parent function unless a reference to the function is passed to outside code (function closures).

103. Function parameters .. All arguments are passed by reference except primitive types.

104. Functions parameters .. Number of arguments sent to a function can exceed the number of parameters defined for that function.

105. 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.

106. 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).

107. .. (rest) parameter specify array parameter that would allow you to accept any number of comma delimited parameters. Use of this makes arguments array unavailable.

108. .. (rest) parameter can be used with other parameters, but should be the last parameter.

109. Function as Objects .. Function passed as arguments to another function are passed as reference.

110. 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.

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

112. 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.

113. Scope chain .. Scope chain is created that contains the ordered list of objects, against which the identifier declarations (variables) are checked.

114. 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.

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

116. Function closures .. Function closures retain the scope in which they were defined.

117. Object Oriented Programming in ActionScript

118. Classes abstract representation of object, usefulness of such an abstraction is apparent in big projects.

119. 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

120. Classes .. Can have a static property and instance property with the same name in the same class.

121. Classes .. You can have statements in the class definition, which would execute only once.

122. Class property attributes .. Internal, private, protected, public, static, User defined namespaces.

123. Private variable .. In case of dynamic classes, accessing a private variable returns undefined instead of an error.

124. 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.

125. Static .. Can be used with var, const, function. Attach property to class rather than to instance of the class.

126. 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.

127. Variable .. Can be declared using var and const keyword.

128. Variable .. variable declared as both const and static must be initialized at the same time as you declare it.

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

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

131. Constructor methods .. Can explicitly call the super class constructor by using super(), compiler calls it if not explicitly called.

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

133. 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.

134. Instance methods .. Redefine an inherited method, final attribute is used to prevent subclasses from overriding a method.

135. 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()

136. Getters and setters .. Can use override attribute on getter and setter functions.

137. 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.

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

139. Embedded asset classes .. [Embed] metadata tag, @Embed in MXML.

140. Interfaces .. Method declarations that allow unrelated objects to communicate with each other, i.e serves as a protocol.

141. Interfaces .. Any class that implements interface is responsible for defining the method implementations.

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

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

144. 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.

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

146. Inheritance .. Can take advantage of polymorphism by inheriting and overriding methods.

147. Inheritance .. Instance of a subclass can always be substituted for an instance of the base class.

148. 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.

149. 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.