计算机科学与技术外文翻译

毕业设计（论文）外文资料

原文及译文

专业计算机科学与技术班级08104121

学号0810411504

姓名

指导教师

原文出处：Flash 8 ActionScript Bible, Joey Lott and Robert Reinhardt, Published by Wiley Publishing, Inc.

Flash 8 ActionScript Bible

Joey Lott and Robert Reinhardt

Understanding Datatypes

When we talk about data, we‘re talking about information or values. These values can be of many types. For example, even in a very simple movie you might still have a number, some text, and a MovieClip instance. All three of these examples are data of different types —what ActionScript calls datatypes.

Flash is actually capable of performing datatype conversions when necessary. However, this can lead to some poor coding practices on the part of ActionScript developers. For this reason, the ActionScript 2.0 standards require that you pay closer attention to the datatypes you are using.

In ActionScript, you‘ll work with many different datatypes. However, for the sak e of understanding how these datatypes work, you can consider them in two basic categories: primitive types and reference types. The primitive types are called primitive because they are the basic foundational datatypes, not because they lack importance. The reference datatypes are called reference types because they reference the primitive types.

Primitive datatypes include strings, numbers, Booleans, undefined, and null. We‘ll examine each of these primitive datatypes a little more closely in this chapter. Reference datatypes are all objects, which is the subject of much of the rest of this book, so we‘ll defer the majority of the discussion of reference datatypes to those later chapters.

Working with Strings

Strings are characters or words. String values must always be enclosed in either single quotes or double quotes. Here are a few examples of strings:

“a”

‘b’

“1”

“Joey”

‘123’

‘abc’

“****”

Strings are used whenever you want to work with characters or words. For example, you can use strings to populate text fields in your movie, or you can use strings to programmatically create names for new MovieClip instances. You‘ve also already seen how

strings can be used with actions such as trace(). The trace() action requires that you provide it with a message to display in the Output panel. That message must evaluate to a string value.

trace(“I know him; Marley’s Ghost!”);

As already mentioned, you can use either double quotes or single quotes when defining a string value. Which you choose is often purely a matter of personal preference. There are two rules that you must follow, however, if you want your code to work without error. First, you must have a matching closing quote for every opening quote. And whichever type of quote you use to open the string literal must be used to close it. In other words, mismatched quotes are not allowed. Here are two examples of correctly matched quotes on string literals: “here is a string”

‘here is a string’

And here are three examples of incorrect quotes on string literals:

“here is a string’

‘here is a string”

“here is a string

There are times when more than personal preference might dictate which type of quotes you choose to use. Notice what would happen if you tried the following:

trace(‘I know him; Marley’s Ghost!’);

This line of code would actually cause an error because it would interpret the apostrophe as the closing quote and then fail to know what to do with the remainder of the string. This is easily remedied by using double quotes around the string:

trace(“I know him; Marley’s Ghost!”);

The inverse is true as well, of course — if you want to use a double quotation mark as a character in a string literal, you can use single quotes around the entire value. The problem arises when you want to use both single and double quotation marks as characters within a string literal. There is an easy way to accommodate this: by using special characters. To learn more about special characters, see Chapter 11.

Working with Numbers

In Flash, all numbers are treated as the number datatype. Positive, negative, floating point, integer, and so forth, are all simply considered numbers, with no further differentiation generally required on your part.

To define a number, you need only type the number without any quotes. The following are examples of numbers.

6

12

-1

3.3

1.8

Number datatypes allow you to perform all kinds of mathematical operations, as shown in the following examples:

trace(5 + 5); // Displays: 10

trace(5 –4); // Displays: 1

trace(5 / 2); // Displays: 2.5

It is important to understand when to use numbers and when to use strings. If you try to use a string when you really want to use a number, you can end up with unexpected results. For example:

trace(“5”+ “5”); // Displays: 55

In the example, the resulting value of addedAges is “55”, not 10 (as you may expect). This is because ActionScript treats the two values as strings and concatenates them, rather than adding the numeric values.

However, it should also be understood that there are legitimate reasons for numbers to be treated as strings. For example, even though a phone number is composed of numbers, it is usually treated as a string. And if you want to format the phone number with spaces, parentheses, dashes, and so on, it is necessary that the phone number be treated as a string by enclosing the value in quotation marks.

Using Booleans

Boolean data is data that can hold only two values: true and false. Boolean variables are used to test conditions within your Flash movie. Boolean values are used commonly in conditional expressions within statements such as the if statement and control structures such as the for and while statements. For more information about conditional statements and control structures, read the section ―Using Statements That Control Flow: Control Structures‖ la ter in this chapter.

Understanding the undefined and null Datatypes

ActionScript has two additional primitive datatypes — undefined and null — with which you‘ll want to familiarize yourself. In order to have a better understanding of these datatypes, it is useful to first be familiar with variables. Therefore, we‘ll interweave the discussion of these two datatypes with the discussion of variables later in this chapter.

Casting Data

ActionScript allows you to tell Flash to convert a value to a specific datatype by what is known as casting. When you cast a value, you use the following syntax:

Datatype(value)

For example, you can cast a string to a number as follows:

Number(“123”)

When you are casting data you have to be careful. Some casting will have unexpected results. For example, the numeric value of 0 can be converted to a Boolean false, and any nonzero value will be converted to true. For example:

trace(Boolean(0)); // Displays: false

trace(Boolean(1)); // Displays: true

Therefore, if you convert the string values of true and false, they will both convert to the Boolean true value because both string values are nonzero values.

trace(Boolean(“true”)); // Displays: true

trace(Boolean(“false”)); // Displays: true

Using Variables

In Flash movies you‘re going t o be using a lot of data. Now, with all that data floating around, you‘re going to want some way to keep track of it. This is where variables become very useful.

A variable is a named container that you can use to hold or reference some particular data. Once you have created a variable, you can store and retrieve data in the variable. Although a variable can contain only one value at a time, you can use the same variable to contain or reference different data at different times. For example, if you create a variable named nYear, it may contain the value of 2005 at one point, but at another point it may contain the value 2006.

Consider a rental storage space as a metaphor for a variable. You can rent a space (declaring the variable), and when you do so, you can begin to place things in that space (assigning data to the variable). At a later time, you may want to view the things from the storage space (retrieving the value from the variable), or you may decide to place other contents in the storage space (assigning a new value to the same variable). And when you are done with the storage space, you can stop renting it (deleting the variable).

Declaring Variables

Before you can meaningfully use a variable, you must first bring it into being by declaring it. Flash 8 and ActionScript 2.0 let you declare variables using strong typing. Strong typing means that when you create the variable, you also specify the type of data that it can hold. When you export your movie, Flash then makes sure that you consistently tried to store the correct type of data in that variable. If Flash detects that you mismatched the datatype with the variable at any point, an error message is generated, alerting you to the fact. This is helpful

for ensuring that your Flash applications are well planned and designed using good coding practices.

To declare a variable using strong typing, use the following pattern:

var variableName:Datatype;

The var keyword lets Flash know that you are declaring a variable. The variable name is up to your choosing, but it should follow the rules for variable naming (see the next section, ―Naming Variables‖). A colon separates the name of the variable and the name of the datatype, and there should be no space between the name, colon, or datatype. If you have code hinting turned on, you should get a drop-down list of built-in datatypes from which you can select. Alternatively, if you have defined your own custom datatype (see Chapter 5), you can declare a variable of that type as well. You‘ll also see that the line en ds with a semicolon.

Here is an example in which you declare a variable named nQuantity as a number:

var nQuantity:Number;

Now, you‘ve declared a variable with the name nQuantity, and you‘ve told Flash that all values you assign to the variable must be numbers. The variable has been created, but you have not defined any value for it yet. If you use trace() to display the value of the variable, you can see that this is so:

trace(nQuantity);

When you test this, you should see the value undefined appear in the Output panel. The value undefined is a special value that Flash uses for any variable that has not yet been assigned any value.

Once a variable has been declared, you can assign a value to it using a simple assignment statement with an equals sign:

var nQuantity:Number;

nQuantity = 6;

You can also declare the variable and assign a value, or initialize the variable, all on one line:

var nQuantity:Number = 6;

In addition to the undefined value, there is another special value, null, that you can assign to a variable that indicates that the variable does not contain any other, specific value. While undefined is used to indicate no value has been assigned to a variable, you can use null to indicate that a variable has intentionally been left without any other value. It is often a good practice to initialize your variables to some value other than undefined. And because null allows you to quickly distinguish between values intentionally or unintentionally left without another value, it is a good practice to initia lize your variables to null when you don‘t have any

other specific value to assign to them:

var nQuantity:Number = null;

You can use a variable in any situation in which you could use the value the variable contains. You‘ve already seen an example of this with the trace() actions. You can use a variable to tell Flash what message to output:

var sMessage:String = “Welcome!”;

trace(sMessage);

You can also perform other kinds of operations using variables, just as you would on the actual values themselves. For example:

var nQuantity:Number = 6;

var nPrice:Number = 9.99;

trace(nQuantity * nPrice); // Displays: 59.94

Naming Variables

Now that you‘ve looked at declaring and defining variables, the next thing to examine is how to name the variables. There are two main parts to this discussion. First, there is the matter of using valid variable names that Flash will understand, so we‘ll look at the rules for naming variables. Second, we‘ll examine some additional guidelines for naming variables that, while not strictly enforced by Flash, will aid you in creating more readable code.

The following are the rules that you must follow for Flash to be able to understand your variable names:

◆The first character must be an underscore (_), a dollar sign ($), or a letter. The first

character cannot be a number. Although underscores and dollar signs are allowable as the first character, in practical application, you will almost always start the variable name with a letter.

◆The subsequent characters must be underscores (_), dollar signs ($), letters, or

numbers.

◆Variable names can have no spaces.

◆The name cannot be a keyword or other special value recognized by Flash. For

example, the names MovieClip, true, String, and undefined are not allowable variable names because they already have other meanings in ActionScript.

◆The name must be unique (within its scope). If you create two variables with the same

name in the same scope (more on scope in Chapters 4 and 5), the latter will overwrite the former.

Next, let‘s talk about some good n aming conventions that you can use. First, because you‘ll want to be using strong typing with all your variables, it is a good idea to have a

convenient way to be reminded of what type of value a variable can hold. A system named Hungarian notation has bee n devised that can assist in this. For our purposes, we‘ll use a modification of Hungarian notation specifically designed for ActionScript. With this system, you can prefix each variable name with a character (or, in some cases, several characters) that can help you to remember what type of datatype the variable can hold. You may have already seen this in the previous examples in this chapter. When we define a variable named nQuantity, the variable name is prefixed with the character n. This tells us that the variable holds a number value. Table 3-1 shows a list of other recommended prefixes.

Table 3-1: Modified Hungarian Notation ActionScript Prefixes for Common Classes Prefix Datatype

a Arra y

bmp BitmapData

b Boolean

bt Button

c Color

cam Camera

cm ContextMenu

cmi ContextMenuItem

d Date

lc LocalConnection

lv LoadVars

m MovieClip

mcl MovieClipLoader

mic Microphone

n Number

nc NetConnection

ns NetStream

o Object

pj PrintJob

rs RecordSet

s String

snd Sound

so SharedObject

t TextField

tf TextFormat

vid Video

xml XML

xmls XMLSocket

This modified Hungarian notation convention is completely optional, but it can be very useful. It helps not only you, but also others who may read your code. By adding the appropriate prefix to the variable name, it makes it immediately clear what type of datatype the variable can hold.

It‘s also important when naming your variables to make the names as descriptive as possible. For example, the variable name nQuantity is much more descriptive than nQ. Of course, the level of descriptiveness required depends on the context. For example, if your Flash application deals with quantities of widgets as well as cogs, nQuantity might not be sufficiently clear. It would be better, in such a case, to have variables named nQuantityCog and nQuantityWidget, for example. The more descriptive the variable name, the better, in most situations. Just remember, though, that most likely you‘ll be typing the same variable name multiple times, so it is important to achieve the correct balance between descriptiveness and name length. You can always use abbreviations in the variable names if appropriate. For example, rather than defining a variable named nQuantityWidget you might find it easier to define a variable named nQntyWidget.

Remember that you cannot use spaces in your variable names. However, when you want to make your variable names descriptive, the names will often consist of more than one word. There are two conventions that are commonly used when naming variables with multiple words. The first of the two conventions is to use the underscore (_) to separate your words in the variable name. An example of this method follows:

var sFirst_name:String = “Joey”;

The second of these conventions is what is known as the interCap method (also known as studlyCaps or camelCaps). The word ―interCap‖ refers to the capitalization of the first letter of each word subsequent to the first, using no spaces or underscores—internal capitalization. An example of this method is the following:

var sFirstName:String = “Joey”;

It would behoove you to use one of these conventions. Pick one that you like, and if you decide you prefer the other one later on, switch to it. In this book we tend to prefer the interCap method, so you see a preference for it in the examples. But neither convention is more correct or offers any advantages over the other one.

It is also important to remember that ActionScript is case-sensitive. This means that sFirstName, sFirstname, SfirstName, and so on are all different variables. If you accidentally

type the name of a variable with incorrect capitalization, the result will be that Flash will not recognize that the variable is defined. Here is an example:

var sFirstName:String = “Joey”;

trace(sFirstName); // Displays: Joey

trace(sfirstName); // Displays: undefined

Using Expressions

Anyone who has taken even very basic arithmetic (using addition and subtraction and the like) has worked with expressions. Expressions are simply those parts of statements that evaluate to be equal to something. Here are some very simple examples:

1

“abcd”

nQuantity

Even though these examples are all either simple values or variables, they all evaluate to a single value, and therefore, are considered expressions. Slightly more complex (although still simple) expressions might look something like this:

1 + 1

“a”+ “b”

nQuantity * nPrice

Expressions are an important part of ActionScript. You use expressions in all kinds of situations.

For example, you can use an expression within a trace() statement:

trace(“Welcome!”);

You can also use expressions in variable assignment statements:

var nQuantity:Number = 6;

var nPrice:Number = 9.99;

var nTotal:Number = nQuantity * nPrice;

We‘ll also look at other kinds of expressions that perform comparisons and tests. F or example:

6 < 10

55 == 56

In the preceding examples, we use comparison operators to determine how two values compare. The first expression is determining whether 6 is less than 10. That expression evaluates to true. The second expression determines whether 55 is equal to 56. That expression evaluates to false.

There are many other examples of expressions, and we‘ll examine some of them

throughout the rest of this chapter.

Working with Operators

As you have seen, expressions can be composed of a single value. But expressions can also be more complex by combining several different values to make one expression. In expressions involving multiple values, there are two types of ActionScript elements involved: operands and operators. The operands are the values on which the operation acts. The operators determine the action taken. In the expression 4 + 5, for instance, there are two values, or operands — 4 and 5 — and there is one operator: the plus operator (+).

In the Actions toolbox you can see that the operators are grouped into six categories: arithmetic, assignment, bitwise, comparison, logical, and miscellaneous. The following sections take a closer look at each of these groups, and the operators of which they are composed. We‘ll look at each of these groups in the order they are listed in the Actions toolbox, with the exception of the bitwise operators. We‘ll look at the bitwise operators after the rest because, except in specialized situations, you are more likely to use the other operators than you are to use bitwise operators.

Working with Arithmetic Operators

The arithmetic operators should be familiar to you because they are, for the most part, the operators you used in math class. They are the operators used on number operands for mathematical computations. The result of an operation using an arithmetic operator is a number value. Table 3-2 lists all the arithmetic operators.

Table 3-2: Arithmetic Operators

Operator Name Example Result + Plus x + y x + y

- Minus/Negation x –y

-x x –yx * (-1)

* Multiply x * y x * y

/ Divide x / y x / y

% Modulo x % y Remainder of x / y

The addition, subtraction, multiplication, and division operators don‘t really require any discussion.They work just as you would expect them to.

The modulo operator (%) may be new to you. Even if it is not new, you might need a little refresher on what it does. Quite simply, it returns the value of the remainder after the first operand is divided by the second. In the following example, we use the modulo operator with a variable nYear and the second operand of 4. The result is 0. This means that 2004 is divisible by 4. In practical terms, the implication of this is that the year 2004 is a leap year.

var nYear:Number = 2004;

trace(nYear % 4); // Displays: 0

Also worth pointing out is that the minus and negation operators use the same character, but operate differently. The negation operator has the same effect as multiplying a number by –1. For example, this operation:

y = -x;

is the same as this operation:

y = x * (-1);

Working with Assignment Operators

Table 3-3 presents a rather daunting list of operators that all fall under the category of assignment operators. But don‘t be scared off just yet. In fact, there is only one fundamental operator in the bunch—the equals sign (=). This one should not be a new operator to you. It does just as you would expect it to do: It assigns the value of the operand on the right to the operand on the left. The remainder of the operators are compound assignment operators that function as shortcuts, as you‘ll see in a moment.

In the following example, the operand on the left (nQuantity) is assigned the value of the operand on the right (6):

nQuantity = 6;

Of course, you might want to use expressions that are slightly more complex than simply nQuantity = 6. You might, for instance, want to add several operands together on the right side of the equals sign operator, as in the following:

nQuantity = 6 + 36 + 24;

In this case, you notice that the addition takes place before the assignment. In other words, nQuantity is assigned the value of the sum of 6, 36, and 24, not just the value of 6. This is due to the operator precedence of the plus operator (+) being greater than that of the assignment operator (=). See the section later in this chapter titled ―Cons idering Operator Precedence.‖ Additionally, you can find a complete list of operators and their precedence in the Flash Help system.

Table 3-3: Assignment Operators

Operator Name Example What It Means = Equals(assignment) x = y x = y

+= Add by value x += y x = x + y

-= Subtract by value x -= y x = x - y

*= Multiply by value x *= y x= x * y

/= Divide by value x /= y x = x / y

%= Modulo by value x %= y x = x % y

<<= Left shift by value x <<= y x = x << y

>>= Right shift by value x >>= y x = x >> y >>>= Right shift zero fill by value x >>>= y x = x >>> y &= Bitwise AND by value x &= y x = x & y

|= Bitwise OR by value x |= y x = x | y

^= Bitwise XOR by value x ^= y x = x ^ y

As mentioned, there is really only one fundamental operator in the assignment operator category —the equals sign. Each of the additional operators merely saves you some time typing. For example, the following expression:

nQuantity += 6;

is the shorthand version of the following:

nQuantity = nQuantity + 6;

Either of the two preceding expressions means that you want Flash to add 6 to the current value of nQuantity. It just so happens that the former variation is shorter and quicker to type.

The operators that are compounded with the equals (=) operator are either mathematical operators or bitwise operators (covered in the following sections of this chapter). In each case, the compound operator follows the same pattern. For example:

nQuantity *= 6;

is the same as:

nQuantity = nQuantity * 6;

Working with Comparison Operators

Comparison operators allow you to compare operands. The result of a comparison is a Boolean value: true or false. These operators are most often used in expressions called conditionals within if...else blocks, and control of flow expressions within for and while blocks. (You learn about these types of statements later in this chapter.) But the basic premise is that if the conditional expression evaluates to true, a block of code is executed, and if it evaluates to false, the block of code is skipped over.

Using comparison operators (see Table 3-4), you can compare strings, numbers, and Boolean values. These primitive datatypes are equal only if they contain the same value. You can also compare reference data types such as objects, functions, and arrays. But reference data types are equal only if they reference the same object, whether or not they contain the same value.

Table 3-4: Comparison Operators

Operator Name

== Equals

!= Not equals

> Greater than

< Less than

>= Greater than or equal

<= Less than or equal

=== Strict equality

!== Strict inequality Perhaps the most common mistake made in programming is confusing the equality equals operator (==) with the assignment equals operator (=). In fact, even among seasoned professionals, it is not uncommon to make this error on occasion. The difference is so tiny in print, but the result is so drastic. Take, for instance, the following example:

var nQuantity:Number = 999;

if (nQuantity = 4){

trace(“if condition true”);

}

trace(nQuantity);

What would you expect th is code to do? Even if you don‘t know what some of the code structures mean, you can probably figure out that after nQuantity is assigned a value of 999, you want the code to check to see if nQuantity is equal to 4. If that condition is true, it should write a message to the Output panel. Finally, it writes the value of nQuantity to the Output panel.

You might expect that the final value of nQuantity is still 999. But because the wrong operator was mistakenly used in the if condition (nQuantity = 4), nQuantity has been assigned the value of 4! Can you see the problems that have been caused by one missing character? So, the corrected code looks more like this:

var nQuantity:Number = 999;

if (nQuantity == 4){

trace(“if condition true”);

}

trace(nQuantity);

Any datatype can be compared using the equality operators. String characters are first converted to the ASCII values and then compared, character by character. Therefore, ―a‖is less than ―z‖ and lowercase letters have higher values than their uppercase count erparts. Tables 5-5 and 5-6 show examples of numbers and strings being compared, using the equality

operators along with the resulting value of the expression.

Table 3-5: Number Comparison

Expression Result

6 == 6 true

6 != 6 false

6 > 6 false

6 < 6 false

6 >= 6 true

6 <= 6 true

Table 3-6: String Comparison

Expression Result

“Joey”== “Joey”true

“joey”!= “Joey”true

“joey”> “Joey”true

“Joey”< “Joseph”true

The only two operators in this category that you have not yet looked at are the strict equality (===) and strict inequality (!==) operators. These operators work much like the nonstrict counterparts (== and !=) with one difference: They don‘t perform datatype conversions automatically. What this means is that when using the regular equality equals operator (==), Flash automatically converts the operands to the same datatype before testing for equality. Therefore, the values 5 and “5”are equal when testing using the regular equality operator (==) but not when using the strict equality operator (===). Table 3-7 gives some examples of the difference between using regular and strict equality operators.

Table 3-7: Strict Equality and Inequality Operators

Regular Regular Result Strict Strict Result

6==6 true 6===6 true

6!=6 false 6!==6 false 6==”6”true 6===”6”false

6!=”6”false 6!==”6”true

译文：Flash 8 ActionScript 宝典，[美]Joey Lott, Robert Reinhaedt著，Wiley 出版社

Flash 8 ActionScript 宝典

Joey Lott, Robert Reinhardt

了解数据类型

只要谈到数据，就会谈到值。这些值可以有许多类型。例如，即使在一个非常简单的影片中，也会有一个数字、一些文本和一个MovieClip实例；它们都是具有不同类型（在ActionScript中称之为数据类型）的数据。

实际上，Flash可以在需要的时候执行数据类型转换。但是，这可能会使Acti。nScript 开发者养成某些拙劣的编码习惯。因此，ActionScript 2.0标准要求对正在使用的数据类型给予足够的注意。

在ActionScript中，将使用许多不同的数据类型。但是，为了了解这些数据类型如何工作，可以认为它们有两种基本的分类——简单类型和引用类型。简单数据类型之所以被称之为‖简单‖类型，是因为它们是基础的数据类型，而不是因为它们缺乏重要性。引用数据类型之所以被称之为‖引用‖类型，是因为它们引用简单类型。

简单数据类型包括字符串(String)、数字(Number)、布尔型（Boolean）、undefined和null。我们将在本章中更多地介绍这些简单数据类型。引用数据类型就是所有的对象，它们是本书其他章节的主题，因此，我们将对引用数据类型的主要讨论留到后面的章节中。

使用字符串数据

字符串是多个字符或多个宇。字符串的值必须用单引号或双引号引起来。下面是几个字符串的例子：

―a‖

?b‘

―l‖

―Joey‖

?123‘

?abc‘

―****‖

只要想使用多个字符或多个宇，就要使用字符串。例如，可以使用字符串来填充影片中的文本区域，或者使用字符串通过程序给新的MovieClip实例创建一个名字。我们已经见过如何在动作中使用字符串了，如trace()中的字符串。Trace()动作要求开发者给它提供一条在Output面板中显示的消息，这条消息就必须是字符串值：trace (―I kn o w him; Marley‘s Gh o st!‖);

如前所述，当定义一个字符串值时，可以使用双引号或单引号。究竟选择哪一个常

常完全是由个人爱好所决定的。但是，如果想让代码不出错误，有两个规则还是必须遵守的：第一，必须对每个开始的引号匹配一个结束的引号。第二，使用哪种类型的引号来开始字符串，就必须用哪种类型的引号来结束字符串。换句话说，不允许有不匹配的引号。下面是两个正确匹配了引号的例子：

―here is a string‖

?here is a string‘

下面是三个没有正确匹配引号的例子：

―here is a string‘

?here is a string‖

―here is a string

有些时候，更多的个人爱好可能会限制选择使用哪种类型的引号。试一试下面的例子，请注意会发生的事情：

trace ( ?I kn o w him; Marley‘s Gh o st !‘) ;

这行代码实际上会产生一个错误，因为它认为撇号是结束的引号，所以它就不知道用这个字符串的剩余部分做什么了。如果在字符串两边使用双引号，就可以很容易地修改这个错误了：

trace (―I kno w him; Marley‘s Gh ost!¨);

反之亦然。如果想在一个字符串中将一个双引号标记当做一个字符来用，可以在整个值的两边使用单引号。如果想在一个字符串中将单引号和双引号标记两者都当做字符来用，问题就来了。有一个简单的方法来处理这个问题：使用特殊字符。有关特殊字符的详细内容，请参见第1 1章。

使用数字数据

在Flash中，所有的数字都被当做“数字”数据类型。正数、负数、浮点数、整数等，都被简单地认为是数字，这通常不需要做进一步的解释。

为了定义一个数字，只需要输入不带任何引号的数字即可。下面是几个数字的例子：6

12

-1

3.3

1. 8

数字数据类型可以执行各种数学运算，如下面的例子所示：

trace(5 + 5); //显示10

trace(5 – 4); //显示1

trace(5 / 2); //显示2.5

了解什么时候使用数字而什么时候使用字符串是重要的。假如在实际上想用一个数

字的时候却用了一个字符串，就会得到不希望的结果。例如

trace ("5" + "5") ; //显示55

在这个例子中，结果值是“55”而不是10（所希望的）。这是因为ActionScript将这两个值当做字符串并将它们“连接”起来，而不是当做数字值将它们加起来。

当然，还应该了解，把数字当做字符串也有些合理的原因o例如，尽管电话号码是由数字组成的，但通常还是把它当做字符串o如果想用空格、括号、破折号等来对电话号码进行格式设置，就需要将电话号码放入引号中当成字符串来用。

使用布尔数据

布尔数据是只能取true（真）和false（假）两个值的数据。在Flash影片中，布尔变量常用于测试条件。布尔值常用于条件语句（如if语句）和控制结构（如for和while 语句）的条件表达式中。有关条件语句和控制结构的详细内容，请参见本章后面的“使用控制流程的语句——控制结构”一节。

理解undefined和null数据类型

ActionScript有两个另外的基本数据类型——undefined（未定义）和null（空值）。开发者应该熟悉它们。为了更好地理解这些数据类型，先熟悉变量是有用的。因此，我们将在本章的后面交替地讨论这两种数据类型和变量。

转换数据

通过被称为“转换( Casting)”的方法，ActionScript允许你告诉Flash将一个值转换成一个指定的数据类型。当转换一个值时，使用如下语法：

Datatype(value)

例如，可以像下面这样将一个字符串转换成数字：

Number(―123‖)

当转换数据时必须小心。某些转换可能会产生不希望的结果。例如，数宇0可以被转换成布尔值false，任何非零值将被转换成true，例如：

trace (Boolean (0) ) : //显示false

trace (Boolean (1) ) ; //显示true

因此，如果转换true和false的字符串值，它们两者都将被转换成布尔值true，因为这两个字

符串的值都是非零值：

氛参使用变量

trace (Boolean (―true‖) ) ; //显示true

trace (Boolean (―flase‖) ) ; //显示true

使用变量

在Flash影片中，将会用到许多数据。现在，由于这些数据到处都是，所以我们打算用某种办法来跟踪它们。这就是变量变得有用的原因。

变量是一个可以用来保存或引用某个特殊数据的命名了的容器。一旦创建了一个变量，就可以在该变量中保存和取回数据。尽管一个变量一次只能容纳一个值，但可以使用同一个变量在不同的时候容纳或引用不同的数据。例如，如果创建了一个名为nYear 的变量，它在一个时候可以容纳2005这个值，但在另一个时候可以容纳2006这个值。

用一个出租仓库空间来比喻一个交量。可以租一个空间（声明变量），租了之后，就可以在那个空间放置东西了（给变量赋值）。后来，可能想看一下仓库空间中放置的东西（从变量中取回数据），或者可能决定在该仓库空间中放置别的东西（给同一个变量赋予一个新值）。当用这块仓库空间办完事后，可以不再租用它（删除该变量）。

声明变量

在能有意识地使用一个变量之前，必须首先声明它以使其存在。Flash 8和ActionScript 2.0允许使用强化输入法来声明变量o强化输入法表示，当创建一个变量时，指定它可以保存的数据类型。当导出影片时，Flash就确保用户始终想向那个变量中存入正确数据类型的数据。如果Flash在任何时候发现没能匹配该变量的数据类型，就会产生一条出错消息，提醒用户注意这个实际情况。这有助于确保Flash应用程序是用良好的编程习惯进行周密的规划和设计的。

为了用强化输入法来声明变量，请使用如下的格式：

var variableName:Datotype ;

var关键宇让Flash知道正在声明一个变量。变量名由用户取，但它应该遵守变量的命名规则（参见下一节——“命名变量”）。用冒号来分隔变量的名字和数据类型的名字-在名字、冒号、数椐类型之间不应该有空格。如果启用了代码提示，就会获得一个内置数据类型的下拉列表，可以从该下拉列表中选择数据类犁。另外，如果定义过自己的自定义数据类型（参见第5章），也可以声明一个那种数据类型的变量。还可以看到，该行是用一个分号来结束的。

下面的例子声明了一个名为nQuantity的数字数据类型的变量：

var nQuantity : Number ;

现在，已经声明了一个名为nQuantity的变量，并且已经告诉Flash，赋予该变量的所有值都必须是数字。变量已经被创建了，但还没有给它定义任何值。如果用trace()来显示该变量的值，就可以知道的确是这样：

trace(nQuantity) ;

当对它进行测试时，会见到undefined值出现在Output面板中。undefined值是一个特殊的值，Flash用它来表示还没有被赋予任何值的变量。

变量一旦被声明了，就可以通过使用一个具有等于符号的简单赋值语句来给它赋值：var nQuantity :Number ;

nQuantity = 6 ;

还可以在一行中声明一个变量并对其赋值，或初始化该变量

var nQuantity : Number = 6;

除了undefined值，还有另一个特殊的值——null,可以将它赋予一个变量，表示该变量没有容纳任何其他指定的值。undefined值常用于表示还没有给一个变量赋值，null值表示一个变量已经被有意留下束而没有任何其他值。将变置初始化为不是undefined的某个值常常是一个好的习惯。因为null可以使用户迅速地区分有意或无意留下来、没有其他值的变量，所以当没有任何其他指定的值要赋予变量时，将变量初始化为null常常是一个好的习惯：

var nQuantity : Number = null ;

可以在能使用一个变量所容纳的值的任何地方使用该变量o我们已经在trace()动作中看见了这样的一个例子。可以用一个变量来告诉Flash要输出什么消息：var sMessage : String = ―Welcome !‖ ;

trace (sMessage) ;

还可以使用变量来执行其他种类的操作，就像使用实际值那样。例如：

var nQuantity : Number = 6 ;

var nPrice : Number = 9.99 ;

trace (nQuantity * nPrice) ; //显示59.94

命名变量

现在已经知道声明和定义变量了，下一步要做的事情就是命名变量。这个问题要分成两个主要部分来讨论。第一，要注意使用Flash理解的、有效的变量名字。因此，我们要探讨命名变量的规则。第二，我们将考察某些用于命名变量的其他指导方针，Flash 并不强求这样，但它们将有助于刨建更可读的代码。

为了让Flash能够理解变量，必须遵守如下规则：

◆第一个字符必须是下划线（_ ）、美元符号（$ ）或字母。第一个字符不能是

数字。尽管可以用下划线和美元符号来作为第一个字符，但在实际应用中，通

常应该用一个字母来开始一个变量名。

◆接下来的字符必须是下划线（_ ）、美元符号（$ ）、字母或数字。

◆在变量名中不能有空格。

◆名字不能是关键宇或其他被Flash识别的特殊的值。例如，MovieClip，true，String，

undefined就是不被允许的变量名，因为它们在ActionScript中已经有其他意义

了。

◆名字必须是惟一的（在它的作用域中）。如果在同一个作用域（有关作用域的详

细内容，请参见第4章和第5章）中创建了两个名字相同的变量，那么后面的

一个就将覆盖前面的一个。

接下来，让我们介绍一些好的、可以用的命名习惯。第一，因为希望在所有变量中都使用强化输入法，所以要是有一个方便的方法来提醒一个变量可以保存什么类型的值