Macromedia Flash Professional 8 UNLEASHED [Electronic resources] نسخه متنی

Functions Built In to Flash

We have covered ways of creating and manipulating user-defined functions thus far. Now we'll focus on some of the built-in functions Flash has to offer. We'll briefly go over some basic built-in functions. Finally, we'll discuss some of the deprecated functions.

Because you know what functions look like, I'll only briefly label the parts:

stop();            //stops a movie clip from playing, and has no parameters
play();            //plays a movie clip, and has no parameters
gotoAndStop(5);    //goes to a specified frame (the parameter) and stops
trace("Flash");    //displays parameter in output window

This list goes on and on.

However, a couple functions deserve mentioning. One of them is the call function.

The call Function

The call function is an interesting function that's brought all the way from Flash 4. This function can run code from any given frame without moving to that frame. It is a deprecated function, and Macromedia recommends using the keyword function to make code available throughout the timeline, as we discussed earlier. However, it's still good to know how to use the call function in case you ever have the need to use it.

The generic template is straightforward. Use the keyword call, followed by a string representing the frame label or a number representing a frame number, enclosed in parentheses. Here is the generic template:

call(frame);

Now that you know what it looks like, let's use the call function in an example.

stop();

trace("This is code from frame two");

trace("This is code from the labeled frame");

stop();
call(2);
call("labeled");
//output: This is code from frame two
//        This is code from the labeled frame

Test the movie. There you have itthe code that was placed in frame 2 as well as the third frame, which was labeled "labeled," runs without the play head ever reaching these frames.

Now that we have covered this unique function, let's move on to some more built-in functions. Flash has predefined a couple of categories for functions in the Actions panel. One such category is the

conversion functions .

Conversion Functions

Conversion functions perform a specific task on objects: they convert objects. Each of the five main data types has its own conversion script that will change it to another data type.

The generic template utilizes the keyword of the object you are trying to convert to, and the expression you are trying to convert follows, enclosed in parentheses, as shown here:

converter(expression);

We will use the following example to change some data from one type to another. After each step, we will use the TRace function and the typeof operator to display the data type of each object following the conversion. Here's the code:

//Start off with a simple string
myString = "string";
trace (typeof myString);
//Now we begin converting the same object
//again and again while checking after each time
myString = Number(myString);
trace (typeof myString);
myString = Array(myString);
trace(typeof myString);
myString = Boolean(myString);
trace(typeof myString);
myString = Object(myString);
trace(typeof myString);
//Finally back to a string
myString = String(myString);
trace(typeof myString);
//output: string
//        number
//        object
//        boolean
//        object
//        string

Chapter 15, "Working with Text," for more information) into true number data types. You can convert Boolean data types into strings to use in sentences.

Let's now move on to the next category of functions: mathematical functions.

Mathematical Functions

Mathematical functions execute mathematical operations on expressions you assign to them. You may be thinking addition, subtraction, and so on, but these operations are much more advanced. Only four mathematical functions are listed in ActionScript:

NOTE

Although only four mathematical functions are in Flash, there is also the Math object, which has several methods for performing other mathematical calculations.

• isFinite

• isNaN

• parseFloat

• parseInt

The first two of the mathematical functions act more like conditionals. Let's see how they work individually.

The first, isFinite, checks to see whether the expression entered is a finite number. If the number is finite, the function returns true. If the expression is not finite (or

infinite ), the function returns false. Here is an example in which we test two numbers and trace the results:

trace(isFinite(15));
//evaluates to true
trace(isFinite(Number.NEGATIVE_INFINITY));
//evaluates to false

The second of these two functions, isNaN, works in the same manner. It checks to see whether the expression entered is not a real number. If the expression is not a real number, the function returns true. If the expression is a real number, the function returns false. Let's take a look:

trace(isNaN(15));
//evaluates to false
trace(isNaN("fifteen"));
//evaluates to true
trace(isNaN("15"));
//evaluates to false

Even though the last example is in fact a string, the interpreter converted it to a number when it was evaluated. Keep this in mind when evaluating numbers as strings.

The next mathematical function is parseFloat. This function takes numbers out of a string literal until it reaches a string character. Then it converts what it has removed into a true number data type. Here are a few examples:

trace(parseFloat("15"));
//output: 15
trace(parseFloat("fifteen"));
//output: NaN
trace(parseFloat("20dollars"));
//output: 20

As you can see in the preceding example, the function takes only the number and drops the rest of the string.

The last mathematical function is parseInt. This function can perform the same task as the parseFloat function, but it can also use a radix, which is useful when working with octal numbers. Here is an example:

trace(parseInt("15", 8));
//output: 13 (a representation of the octal number 15
//that has been parsed)

A few more functions are defined directly in ActionScript, including getProperty(), getTimer(), targetPath(), and getVersion(), all of which return information. There is also eval, escape, and unescape, which perform their desired tasks on expressions.

We have covered a great deal of information about functions; now let's look at some deprecated functions and alternatives to their use.

Deprecated Functions

If you have worked in Flash 4 or even Flash 5, you may notice that some of the functions are not where they used to be. No, they are not completely gone, but they are

deprecated , which means that ActionScript provides new ways of performing the same tasks, and although these functions are still available for use, they might not be in the next release. Therefore, it is a good idea to get out of the habit of using them.

We'll go over each deprecated function briefly and discuss alternatives to their use.

chr

The chr function converts a numeric value to a character based on ASCII standards. It has been replaced by String.fromCharCode. Here are examples of both:

//The old way
trace(chr(64));
//The new way
trace(String.fromCharCode(64));
//output @
//       @

int

The int function takes a number with a decimal point and drops the decimal point. It has been replaced by Math.floor. Here are examples of both:

//the old way
trace(int(5.5));
//the new way
trace(Math.floor(5.5));
//output: 5
//        5

length

The length function returns the number of characters in a string or variable holding a string. It has been replaced by String.length. Here are examples of both:

//First create a variable holding a string
myString = "Flash";
//the old way
trace(length(myString));
//the new way
trace(myString.length);
//output: 5
//        5

mbchr

The mbchr function, like the chr function, converts a numeric value to a character based on ASCII standards. It has been replaced by String.fromCharCode. Here are examples of both:

//the old way
trace(mbchr(64));
//The new way
trace(String.fromCharCode(64));
//output @
//       @

mblength

The mblength function, like the length function, returns the number of characters in a string or variable holding a string. It has been replaced by String.length. Here are examples of both:

//First create a variable holding a string
myString = "Flash";
//the old way
trace(mblength(myString));
//the new way
trace(myString.length);
//output: 5
//        5

mbord

The mbord function converts a character to a number by using the ASCII standard. It has been replaced by String. CharCodeAt. Here are examples of both:

//the old way
trace(mbord("@"));
//the new way
trace(("@").charCodeAt(0));
//output: 64
//        64

mbsubstring

The mbsubstring function removes a set number of characters from a string. It has been replaced by String.substr. Here are examples of both:

//First, create a variable to hold a string
myVar = "Unleashed";
//the old way
trace(mbsubstring(myVar, 0, 2));
//the new way
trace(myVar.substr(0, 2));
//output: Un
//        Un

ord

The ord function, like the mbord function, converts a character to a number by using the ASCII standard. It has been replaced by String. CharCodeAt. Here are examples of both:

//the old way
trace(ord("@"));
//the new way
trace(("@").charCodeAt(0));
//output: 64
//        64

random

The random function returns a random number from a expression given. It has been replaced by Math.random. Here are examples of both:

//the old way
trace (random(5));
//the new way
trace (Math.floor(Math.random()*5));
//output: (2 random numbers between 0-4)

substring

The substring function, like the mbsubstring function, removes a set number of characters from a string. It has been replaced by String.substr. Here are examples of both:

//First, create a variable to hold a string
myVar = "Unleashed";
//the old way
trace(substring(myVar, 0, 2));
//the new way
trace(myVar.substr(0, 2));
//output: Un
//        Un

This is the last of the deprecated functions.