Saturday, April 28, 2018

Functions, which are known as methods in Java, are named
blocks of code that can be called by using the name of the function. This
allows you to create a block of code that can be re-used without having to
duplicate the code every time it is used. Functions are defined by using the
function keyword. Functions can also be given parameters. Parameters are values
that the function can use. You can have a function use as many parameters as
you need by separating them with commas. Functions may also optionally return a
value by using the return keyword. An example of a function would be:

function square(number) {

return number *
number;

}

This function would simply return the square of the number
passed to it. To use this function, you simply need to call it, like this:

x = square(2);

The parameter passed can be a variable or it can be a
constant value. A constant being any value that will never change, such as the
2 above.

It is also possible to assign a function to a variable,
allowing you to pass a function to a another function. In the earlier section
you seen a function being created in-line to be assigned to a variable. To
assign an already existing function to a variable you simply uses the
function’s name without any parentheses and followed by a semi-colon.

variable_holding_square = square;

Objects are similar to functions. Objects are essentially a
combination of variables combined with the functions used to manipulate those
variables. This, along with the topic of creating objects, will be covered in
chapter 5. However, using existing objects is very common in JavaScript and a
requirement of Create.js so we will briefly have to cover using existing
objects.

While it is possible to create an empty object and add
things to it to make it a unique object, more often you will be creating
objects of a certain type called a class. You use a class by creating an
instance of it. The variables in every instance are unique to that instance.
You can, in theory, have as many instances of a class as you wish (in reality
you have a limited amount of memory so you are limited to the number of
instances). In fact, your movie is itself an instance of the MovieClip class.

To create an instance of a movie clip you can quite often
just use Animate to drag the object (be it dynamic text, a movie clip, or a
component) onto the current frame and give it an instance name using the
properties panel. Some classes are not visual in nature so you have to manually
create them using the new operator as follows.

variable_name = new ClassName();

Objects do take up memory. This memory will continue to be
used until all references to an object have been removed. To remove an object
(or at least one of the reference to the object) you use the delete keyword.
All variables that are assigned to that object need to be deleted (or changed
to refer to something else) before the object will be removed from memory.

delete variable_name;

To access a variable or function that belongs to an object,
you use periods. An exception to this is if you are writing code within the
class in that case, you refer to the object using this. Some classes, such as
Math, have what is known as static methods. These are functions that can be
called without having to create an instance of the object by simply using the
name of the class Here are some examples.

otherMovieClip.gotoAndPlay(1);

Math.cos(angle);

otherMovieClip._x = 23;

otherMovieClip._y = 32;

this.gotoAndPlay(“labelToPlay”);

And that is all there is to basic JavaScript programming. Next chapter we will apply this knowledge to the creation of a simple Animate game.

Saturday, April 21, 2018

Simply stated, an array is a list. The size
of the list determines how many pieces of information, known as elements, can
be put into it. Any part of the list can be accessed, if you know where in the
list it is stored.

There are several ways of creating an
instance of an array, as follows:

x = new Array();

x = [];

x = new Array(size);

x = new Array (element1, element2, ...,
elementN);

x = [element1, element2, ..., elementN)];

The first two methods create an array that
has no elements. While this may not seem useful, it is possible to add new
elements to an array, which we will discuss later. The third method creates an
array with a specific number of elements. These elements are initially empty,
but new values can be assigned to them, as we will discuss later. The final two
methods creates a populated array. The size of the array will depend on the
number of elements that are declared, but in theory any number of elements can
be specified. This type of constructor is very useful in cases when you want to
have some type of table of predefined values that can be accessed.

The power of an array comes from the
ability to access and modify the elements of the array. Elements of an array
have an index number associated with them. The first element of an array is
referenced with the number 0, the second is 1, and so on. Some people find
using element 0 confusing, so will simply ignore that element and start storing
stuff in element 1. If you are going to do this, remember that the last element
of an array is one less than the size of the array.

To access the element, you simply use the
array variable's name, followed by the index number in square brackets. The
index does not have to be a number, but can be a variable that contains the
index number. For example, the following program adds the third and fourth
elements (index values 2 and 3) and places the result in the first (index 0)
element.

index = 3;

list = new Array(0, 1, 2, 3, 4, 5);

result = list[2] + list[index];

list[0] = result;

The Array class has functions for modifying
and getting information about the array. It also has a read-only property
variable named length that holds the current length of the array. Action Script
allows you to change the size of the array at any time. Many other programming
languages are not quite as flexible. The Action Script Dictionary that is
included with Macromedia Flash covers these functions in detail.

Now we come to a rather interesting
additional for statement that is included with Action Script, the for..in
statement. This is what is known as an iterative for function. It is used to
iterate through all the variables of the indicated object. The format for this
command is for (variable_holding_index in object) The variable_holding_index is
simply the name of the variable that holds the index. Here is a sample to
illustrate how this can be used.

Saturday, April 14, 2018

Looping is a very common programming task. A loop is
essentially a block of code that executes until certain conditions are met. JavaScript supports three types of looping statements. The while statement, the do
... while statement, and the for statement. The first two types of loops are
very similar so we will look at them together.

The While statement always has a statement or block of
statements tied to it. The condition of the while statement is tested. If the
condition is true then the statement or block of code gets executed. When the
block of code is finished executing the while statement condition is tested
again. If it is still true, the statement or block gets executed again. This
continues until the condition is false, at which point the program continues
execution on the line after the statement of block of statements. Here is a use
of the while statement to see how long an object will fall before hitting the
ground.

var distRemain = meters_to_fall;

var vel = 0;

var time = 0;

while (distRemain > 0) {

vel += 9.8;

distRemain -=
vel;

++time;

}

One thing that starting programmers must watch out for is
the infinite loop. This is a loop that will never end, meaning that the program
is stuck until stopped by the user. Most web browsers will only let loops run a
certain amount of time before brining up a dialog box telling the user about
the problem and letting the user cancel the script.

The problem with the while loop is that it’s possible that
the statement or block after the while statement will never be executed.
Sometimes you always want the statement or block to be executed at least once.
This is what the do ... while statement does. In this example we want to find
the length of time an object will decay rounded up to the nearest half life
interval. A half life is the length of time a decaying object takes to be
reduced to half of it’s original mass.

var life = startinglife;

var duration = 0;

do {

life /= 2;

++duration;

} while (life > 1);

console.log ("Lifespan of object is " +
(duration * halflife));

The most common type of loop in programming is the for loop.
The purpose of this type of loop is to count through a series of numbers. The
format of the for statement is:

for (start_condition; end_condition; increment){ /*loop
action*/ }

The start condition starts the variable that will be
counting to it's initial value. This will generally be 0 or 1, but can be any
value. If there is no need to initialize a variable, you can skip this part of
the statement by simply having the semicolon. I would consider having a
/*none*/ comment before the semi-colon so you know that there is no loop
initialization.

The end condition is simply a boolean statement like you
would use with an if statement. The loop continues until this condition is no
longer true. The condition can be any boolean condition, and could even consist
of a function call.

The increment portion is where the counting variable is
changed. It is called at the end of every loop iteration. Generally you will be
increasing the counter by 1, but it is valid to decrease the counter, or do any
other mathematical operation or call any function you wish. The following
sample will add the numbers 1 to 10 together.

var cntr, value = 0;

for (cntr = 1; cntr <= 10; ++cntr) {

value += cntr;

}

The for statement seems complex. When you get right down to
it, the for statement is really a macro statement that makes a while loop behave
as a counter. One way of better understanding a for loop is to look at the loop
as a while loop. By doing this, you will see what the three parts inside the
for loop really do. Here is the above example as a while loop.

var cntr, value = 0;

cntr = 1; // the start condition

while(cntr <= 10) // the end condition {

value += cntr;
// the loop action

++cntr; // the
increment

}

Repeating things a set number of times is
important, but where for loops tend to be used the most is with arrays and objects
so we will continue our discussion as part of our look at arrays and objects.

Saturday, April 7, 2018

The Switch statement is a convenient way of handling
situations where you need to handle many actions based on the value of a
variable. The Switch statement starts of with the switch statement which
contains an expression that should evaluate into a number. After the switch
statement is a block of code which consists of case statements and an optional
default statement.

switch (number)

{

case 1:

console.log("The
number is one");

break;

case 2:

console.log("The
number is two");

break;

case 3:

console.log("The
number is three");

break;

default:

console.log("The
number is not one, two or three");

}

After each of the case statements is the code you want to
execute if the variable being switched equals the value of the case. The code
should end with a break statement, which causes the program to skip over the
rest of the switch block. If there is no break statement, all code in the
following case statement will also be executed. In some cases, this is exactly
what you want to happen, as it allows you to define a group of numbers that all
do the same action. Forgetting the break statement is a very common mistake for
beginners to make and is even something that experts have made resulting in
devastating results.

The default statement will be executed if none of the case
statements match the value of the switch expression. No break statement is
needed after the default code, though I usually do have a break statement out
of habit. While the default statement is optional, it is a good habit to always
have a default action, even if the default is simply a trace statement telling
you that you have reached code that should not be reached.

The switch statement we have above could be done with if
statements as you can see below.

if (number == 1) {

console.log("The number is one");

} else if (number == 2) {

console.log("The number is two");

} else if (number == 3) {

console.log("The number is three");

} else {

console.log("The
number is not one, two or three");

}

The choice between using switch and if statements is more of
a cosmetic one with JavaScript. Switch statements are a convenience statement
designed to replace large numbers of if then else statements in a more readable
way.

The switch statement comes directly from the C programming
language. While I am a fan of that language, being one of the first programming
languages that I learned, I have been bitten by the switch statement too many
times and have uncovered bugs in other people’s code due to the forgetting of a
break statement frequently. Therefore, I am happy that new languages are
replacing the default fall-through behavior with default break behavior
requiring a statement to fall through.

Another common bug with the switch statement is not having a
default block when a case does not cover all possibilities. The result of not
having a default is essentially a default that does nothing which may be what
you want. It could also be an indication that you expect only the values in the
case to exist. Having a default that reports an error if it is reached is
recommended in this situation.

About Me

I am a programmer who can program in a large variety of programming
languages (including some Assembly Language) but am currently focused
on interactive web development which means my current focus is on Flash
and JavaScript. When I am not programming for clients, I am working on my
game site.