• Introduction
• Getting started: writing and compiling a script
• Statements
• Comments
• Operators
• Equality, relational and logical operators
• Variables (AS 2.0)
• DataTypes (AS 2.0 only)
• Compiler errors
• Flow control
• Loops
• Functions
• Functions in AS 2.0
• Arrays
• Classes

var myNumber = 10;

You have assigned a value to the variable. i.e. stored the value 10 in the variable myNumber.

The trace( ) function prints whatever is between the parentheses to the output window. It displays the value of the argument of trace. To sequence text and variables in a trace function use "+" to add text to number and variables etc.
e.g.

trace("some Text " + someVariable);

So, here is our complete script,

var myNumber = 10;
trace("The value is " + myNumber);

Now execute or run the script. To execute a script hit the keys "Control + Enter" together, or use menu item "Control" - " Test Movie".

After a script is written, the next step is to compile it. Compiling means to write to byte code that Flash understands. The compiler has 2 jobs:

1. error checking - the compiler will examine the script for language correctness or errors.
2. Translate what we have to instructions that the machine can understand.

1. is a declaration statement. It tells the machine "we exist"
2. Assignment(=) statement. Assigns the value 80 to the computer memory space associated with the variable "score". Here we have initialised score. We have given it an initial value.
3. - prints the value of score to the output window.

• They help readers understand our program,
• summarize a function's algorithm,
• identify the purpose of a variable, or
• clarify a segment of code.

There are two types.

1. Multiple Lines ( /* */ )
   
   /*
   An explanation of a section of code or
   a coder's name and date
   and other stuff
   */
   
2. Single Line delimiters (//)
   
   // number of record
   var recordNum ;

The Modulus operator(%) computes the remainder of division between 2 integers.
e.g. 5 % 2 = 1
5/2 = (2*2) + 1(remainder)
Try it out! Ex1.

var x = 3;
var y = 5;
var mult1 = x * y;
trace(x + " times " + y + " = " + mult1);

ex2

var min = 35;
var max = 239;
var addition = min + max;
trace(min + " plus " + max + " = " + addition;

You get the idea. Try all the operators and start writing your own scripts.

x = 5;
If(x>0 || x<4) {
something = true;
}
trace(something);

EITHER CAN BE TRUE

The effect that an assignment has is to store a new value in the left operand's associated memory storage space e.g.

x = 7;

This statement means that the value 7 is assigned to the variable x.

The increment (++) and decrement (--) operators are a shortcut way of adding or subtracting 1 from a variable. E.g.
Prefix increment - ++c; // c = c+1
Postfix increment - c++;
The prefix form of ++ increments the value of the variable before that value is used.

stack[++top] = val;
//Is equivalent to the following 2 lines
top = top +1;
stack[top] = val;

The postfix form of ( --) decrements the value of top after that value is used.

stack[top--] = val;
//Is equivalent to :
stack[top] = v;
top = top -1;

The syntactic form is:
Expression1 ? expr2 : expr3 ;
If expression1 evaluates to a true condition, then expression2 is evaluated, otherwise expression3 is evaluated. E.g.

x = 2;
y = 5;
max = x<y ? 100 : 10;
trace(max);

Bitwise operators operate on the value to base 2 (binary). Operands must be integers.
Left Shift ("<<") - shifts the bits of the left operand some number of positions to the left. e.g.

someNum = 1;

SomeNum = someNum<<1;

SomeNum = someNum<<2;

Right Shift (">>")
SomeNum = someNum >>3;

The leftShift operator inserts "0" from the right.
The Right Shift operator inserts "0" from the left.

• The use of the ":Datatype" is not strictly enforced in AS2 but I strongly recommend it.
• A variable can be composed of letters, numbers and underscore. Upper and lower case letters are different.
• Variables need to be initialised. I.e. given an initial value.
  var myNum:Number; //Declaration
  myNum = 0; //Initialisation
• In AS 1.0, variables are not strictly typed and can change types.`

num = 10;
num = "Test";

Strict datatyping can capture errors.

1. Syntax errors - e.g. var numberOne:
2. Spelling Mistakes - var mc:MoveiClip;
3. DataType Errors - (AS 2.0)

var num1:Number;
var str1:String;
num1 = "Steve";
str1 = 27;

If .. else allows for a kind of either .. or condition.
Template:

If(expression){
Statement1;
}else{
statement2;
}

If expression is true then statement1 is executed.
If expression is false then statement2 is executed.
e.g.

var x = 2;
if(x > 3){
trace("condition is true");
}else{
trace("condition is false");
}

A switch statement is an alternative to complex nested if .. else statements

switch(variable){
case 1:
//Statement1;
break;
case 2:
//Statement2
break;
default:
//statement3;
break;
}

The variable to be evaluated is inserted into the switch argument. If the first variable's value is 1 then statement1 is evaluated. A break statement is inserted after it so that the switch statement is terminated. The default label is the condition for "everything else".

var tester:Number;
tester = random(3);
switch (tester) {
case 1 :
trace("tester = 1");
break;
case 2 :
trace("tester = 2");
break;
case 3 :
trace("tester = 3");
break;
default :
trace("Out of range");
break;
}

template:

while(expression){
statement;
}

The statement is executed as long as the conditions is true. E.g.

var x =0;
while(x < 10){
trace(x);
x++;
}

a do.. while loop executes the statement once before the condition is evaluated.
Template:

do{
//Statements to be executed;
}
while(condition);

E.g.

var x =0;
do{
trace(x);
x++;
}
while (x < 10);

a for loop is used most commonly to step through a fixed length data structure such as an array.
Template:

for(init-statement; expr2;expr3){
// Statements;
}

e.g.

for(var i=0; i<10; i++){
trace(i);
}

the first statement initialises a looping variable
3. sets the condition
3. increments the looping variable( also could be something like i=i+2)

• Function Name - e.g. function someName( )
• Argument list - is enclosed within parentheses after the function name. It contains a comma-separated list of 0 or more arguments. Arguments are passed to the variable with the same name as the argument inside the function.
• Return Type - the datatype of what the function can evaluate to.
• The function Body - is enclosed within a pair of braces { } and contains a sequence of statements.

Here is a template. For AS 1.0 :

Function functionName(arg1, arg2, arg3){
// statements go here
return something if not void return type;
}

example1 (AS 1.0). Type this and compile (Control+Enter):

function test1(arg1, arg2){
// arg1 is passed to the variable with the same name
// in the next line I.e. arg1
trace(arg1);
trace(arg2);
}
// call function
test1(3,"Steve");

Notice that to call a function we write the function name and the argument lists in parentheses. Template to call a function:

functionName(arg1, arg2);

Example 2 with a return value (AS 1.0)

function returnTest(arg1){
var num = arg1 * 10;
return num;
}
// call function
trace(returnTest(5));

ex. 3

// returns the absolute value of number
function abs(number){
return( i < 0 ? -i : i);
}
// call the method
trace(abs(-350.95);

ex 4

// return the smaller of two values.
function min(num1,num2){
return(num1 <= num2 ? num1: num2);
}
trace(min(27,45));

Function functionName(arg1:DataType, arg2:DataType):ReturnType{
// statements go here
return something ;
}

Void is used to specify that there is no return type. E.g.

function noReturn(arg1:Number, arg2:String):Void{
trace(arg2 + " is a string and " + arg1 + " is a number");
}
// call function
noReturn(5,"Steve");

1. The class head - composed of the keyword class and a name
2. the class body - enclosed by braces, contains the member definitions

A class name represents a new data type . e.g.

class Dog{
// data members
var name:String;
var age:Number;
// class method
function setAge(age1:Number){
age = age1;
}
}

Constructors allow us to create an instance of a class . e.g.

var rusty:Dog = new Dog();
// the dot operator (".") allows us to access members and methods of that class.
rusty.setAge(7);
rusty.name = "Rusty";

Go here for more information on classes and OOP programming check out our tutorial on Flash MX 2004 Actionscript 2.0 Class Tutorial.