JavaScript程序设计——第2章 ECMAScript基础

2.1 [/b]语法（[/b]Syntax[/b]）[/b][/b]
ECMAScript的基础概念：
l 区分大小写[/b]。ECMAScript中，变量、函数名、运算符以及其他一切东西都是区分大小写的。
l 变量是弱类型[/b]。ECMAScript中的变量无特定类型，定义变量时只用var运算符，可以将它初始化为任意的值。例如：
var color =”red”
var num=25
var visibe=true
l 每行结尾的分号可有可无[/b]。
l 注释与[/b]Java[/b]、[/b]C[/b]和[/b]PHP[/b]都相同[/b]。单行注释以双斜线（//）开头。多行注释以单斜线和星号（/*）开头，以星号加单斜线结尾（*/）
l 括号表明代码块[/b]。

2.2 [/b]变量（[/b]Variables[/b]）[/b][/b]
ECMAScript中变量用var运算符加变量名定义，如var text=“hello”。因为ECMAScript中变量是弱类型，所以也可以这样声明：var text1=“hello”，text2=34。也可以不给变量初值，而直接声明一个变量，var text。
可以把变量初始化为字符串类型的值，之后再设置为数字值，如：
var text=”hello world”;
alert(test);//输出 hello world
test=55;
alert(test);//输出 55
ECMAScript中，也可以在使用变量之前不必声明这个变量。如：
var Test=”hello”;
Test2=Test1+”world”;
alert(Test2);//输出 hello world
ECMAScript的解释程序遇到未声明过的标识符时，用该变量名创建一个全局变量，并将其初始化为指定的值。

变量名的命名规则：
l 第一个字符必须是字母、下划线或美元符号
l 余下的字符可以是下划线、美元符号或任何字母或数字字符
l Camel标记法——首字母是小写的，接下来的单词都以大写字母开头，如myTestValue。
l Pascal标记法——首字母是大写的，接下来的单词都以大写字母开头，如MyTestValue。

2.3 [/b]关键字（[/b]Keywords[/b]）[/b][/b]
根据规定，关键字是保留的，不能用作变量名或函数名。下面是ECMAScript关键字的完整列表：

break	else	new	var
case	finally	return	void
catch	for	switch	while
continue	function	this	with
default	if	throw
delete	in	try
do	instanceof	typeof

如果把关键字用作变量名或函数名，可能得到“Identifier expected”（应该有标识符）这样的错误信息。

2.4 [/b]保留字（[/b]Reserved Words[/b]）[/b][/b]
保留字在某种意义上是为将来的关键字而保留的单词。因此，它不能被用作变量名或函数名。
保留字的完整列表如下：

abstract	enum	int	short
boolean	export	interface	static
byte	extends	long	super
char	final	native	synchronized
class	float	package	throws
const	goto	private	transient
debugger	implements	protected	volatile
double	import	public

如果将保留字用作变量名或函数名，那么除非将来的浏览器实现了该保留字，否则很可能收不到任何错误消息。当浏览器将其实现后，该单词将被看作关键字，如此将出现关键字错误。

2.5 [/b]原始值和引用值（[/b]Primitive and Reference Values[/b]）[/b][/b]
在ECMAScript中，变量可以存放两种类型的值，即原始值和引用值。
l 原始值（primitive value）是存储在栈（stack）中的简单数字段，也就是说，它们的值直接存储在变量访问的位置。
l 引用值（reference value）是存储在堆（heap）中的对象，也就是说，存储在变量处的值是一个指针（point），指向存储对象的内存处。
为变量赋值时，ECMAScript的解释程序必须判断该值是原始类型还是引用类型。要实现这一点，解释程序则会判断该值是否为ECMAScript的原始类型之一，即是否为Undefined、Null、Boolean和String型。由于这些原始类型占据的空间是固定的，所以将它们存储在较小的内存区域——栈中。这样便于迅速查询变量的值。
如果是一个引用类型的值，会在堆中为它分配空间。由于引用值的大小会改变，所以不能把它放在栈中，否则会降低变量查询的速度。相反，放在变量的栈空间中的值是该对象存储在堆中的地址，地址大小固定，所以把它存储在栈中对性能没有任何负面影响。

2.6 [/b]原始类型（[/b]Primitive Values[/b]）[/b][/b]
每种原始类型定义了它包含的值的范围及其字面量表示形式。ECMAScript提供了typeof运算符来判断一个值是否在某种类型的范围内。可以用这种运算符判断一个值是否表示一种原始类型，如果它是原始类型，还可以判断它表示哪种原始类型。

2.6.1 typeof[/b]运算符[/b][/b]
typeof运算符有一个参数，即要检查的变量或值。例如：
var Temp=”hello world”;
alert(typeof Temp);//输出 string
alert(typeof 95);//输出 number
对变量或值调用typeof运算符将返回下列值之一：
l undefined，如果变量是undefined型。
l boolean，如果变量是boolean型。
l number，如果变量是number型。
l string，如果变量是string型。
l object，如果变量是一种引用类型或null型。

2.6.2 Undefined[/b]类型[/b][/b]
Undefined类型只有一个值，即undefined。当声明变量为初始化时，该变量的默认值是undefined。
值undefined并不等同于未定义的值。但是，typeof运算符并不真正区分这两种值。
var Temp;
alert(typeof Temp);//输出undefined
alert(typeof Temp2);//输出undefined，注意Temp2为声明
上例中，如果对Temp2使用除typeof外的运算符的话，会引起错误，因为其它运算符只能用于已声明变量上。
alert（Temp2==undefined）//引发错误
当函数无明确返回值时，返回的也是undefined。
function testFunc()
{
}
alert(testFunc()==undefined);//输出为 true

2.6.3 Null[/b]类型[/b][/b]
Nulll类型只有一个专用值null，即它的字面量。值undefined实际上是从值努力了派生来的，因此ECMASript把它们定义为相等。
alert(null==undefined);//输出 true
尽管这两个值相等，但它们含义不同。undefined是声明了变量但未对其初始化赋值，null则用于表示尚未存在的对象。如果函数或方法要返回的是对象，返回的通常是null。

2.6.4 Boolean[/b]类型[/b][/b]
它有两个值：true和false。即使false不等于0，但0可以在必要时被转换成false。

2.6.5 Number[/b]类型[/b][/b]
Number类型即可以表示32位整数，也可以表示64位浮点数。直接输入的任何数字都被看作该类型的字面量。如var Num=55表示它的值由字面量55定义。
定义八进制整数，首字母必须是0，如var Num=070，表示十进制的56。
定义十六进制证书，开头必须用0x，如var Num=0xAB，表示十进制的171。
定义浮点数，必须包括小数点和小数点后一位数字，如，用1.0而不是1。（浮点数在计算前，真正存储的是字符串）
采用科学计数法，把一个数表示为一个数字加e，后面加乘10的倍数，如3.125e7表示31250000，或3-e7表示0.0000007。ECMAScript默认把具有6个或6个以上前导0的浮点数转换成科学计数法。
几个特殊的Number类型：
l Number.MAX_VALUE[/b]和Number.MIN_VALUE[/b]。它们定义了Number集合的外边界。所有ECMAScript数都必须在这两个值之间，不过计算生产的数值结果可以不落在这两个数之间。
l Number.POSITIVE_INFINITY[/b]。当计算生成的数大于Number.MAX_VALUE时，被赋予Number.POSITIVE_INFINITY，意味着不再有数字值。如果返回的是无穷大值，那么生成的结果不能用于其他计算。
l Number.NEGATIVE_INFINITY[/b]。当计算生成的数小于Number.MIN_VALUE时，被赋予Number. NEGATIVE _INFINITY，意味着不再有数字值。如果返回的是负无穷大值，那么生成的结果不能用于其他计算。
l Infinity[/b]。当计算结果为无穷大时，用Infinity表示无穷大值。即Number.POSITIVE_INFINITY值为Infinity，Number.NEGATIVE_INFINITY值为-Infinity。
l NaN[/b]。表示非数（Not a Number）。该值发生在类型转换失败时。例如，要把单词“Blue”转换成数值就会失败，因为没有与之等价的数值。与无穷大值一样，NaN不能用于计算，并且它与自身不相等，如alert(NaN==NaN)，结果会返回false。

2.6.6 String[/b]类型[/b][/b]
它是唯一没有固定大小的原始类型。字符串变量是由双引号（”）和单引号（’）声明的。
下面是一些特殊字符：

/n	换行
/t	制表符
/b	空格
/r	回车
/f	换页符
//	反斜杠
/’	单引号
/”	双引号
/0nnn	八进制代码nnn（n是0到7中的一个八进制数字）表示的字符
/xnn	十六进制代码nnn（n是0到F中的一个八进制数字）表示的字符
/unnnn	十六进制代码nnn（n是0到F中的一个八进制数字）表示的Unicode字符

2.7[/b]转换（[/b]Conversions[/b]）[/b][/b]

2.7.1 [/b]转换成字符串[/b][/b]
ECMAScript中的Boolean值、数字和字符串的原始值都是伪对象（pseudo-objects），这意味着它们具有属性和方法。例如，要获得字符串的长度，可以采用下面的代码：
var Color=”blue”;
alert(Color.length);//输出 4
3种主要的原始值Boolean值、数字和字符串都有toString()方法，可以把它们的值转换为字符串。
Boolean型的toString()方法只是输出”true”和”false”，结果由变量的值一样。
Number型的toString()方法有两种模式：默认模式和基模式。采用默认模式，toString()方法只是用相应的字符串输出数字值，在此模式下，无论采用什么表示法声明数字，Number类型的的toString()方法返回的都是数字的十进制表示。采用基模式，可以用不同的基数出数字，如下例：
var Num=0;
alert(Num1.toString(2));//输出1010
alert(Num1.toString(8));//输出12
alert(Num1.toString(16));//输出 A
HTML采用十六进制数表示每种颜色，在HTML中处理数字时这种功能非常有用。

2.7.2 [/b]转换成数字[/b][/b]
ECMAScript提供了两种把非数字的原始值转换成数字的方法：
l parseInt()[/b]，把值转换成整数
l parseFloat()[/b]，把值转换浮点数
只有对String类型调用这些方法，它们才能正确运行，对其他类型返回的都是NaN。
在判断字符串时候是数字值前，parseInt()和parseFloat()都会仔细分析该字符串。parseInt()首先查看位置0处的字符，判断它是否是个有效数字；如果不是，parseInt()方法返回NaN，不再继续执行。如果该字符是有效字符，该方法将查看位置1处的字符，进行同样的测试，知道发现非有效数字的字符为止，此时parseInt()方法把该字符之前的字符串转换成数字。例如字符串“1234blue”支持整数，它将返回为数字1234。不过，字符串“22.5”将被转换成22，因为对于整数来说，小数点是无效字符。
parseInt()方法也有基模式，基由该方法的第二个参数指定。例如var Num= parseInt(“AF”,16)，输出175。
parseFloat()处理方式与parseInt()相似。不过，对于该方法来说，遇到的第一个小数点是有效字符，如果有两个小数点，第二个将会看作无效字符。例如字符串“22.34.5”被解析为22.34。
使用parseFloat()方法的另一个不同之处在于，字符串必须以十进制形式表示浮点数，而不能用八进制或十六进制形式。该方法会忽略前导0，所以八进制0908将被解析为908。对于十六进制0xA，该方法将返回NaN，因为在浮点数中，x不是有效字符。此外parseFloat()方法没有基模式。

2.7.3 [/b]强制类型转换（[/b]Type Casting）[/b][/b]
ECMAScript中可用的3种强制类型转换如下：
l Boolean(value)[/b]——把给定的值转换成Boolean型。当要转换的值至少有一个字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，将返回false。
l Number(value)[/b]——把给定的值转换成数字（可以是整数或浮点数）。与parseInt()和parseFloat()处理方式相似，只是它转换的整个值，而不是部分值。不同的值调用Number()方法会发的情况如下：

用法	结果
Number(false)	0
Number(true)	1
Number(undefined)	NaN
Number(null)	0
Number(“5.5”)	5.5
Number(“56”)	56
Number(“5.6.7”)	NaN
Number(new Object())	NaN
Number(100)	100

l String(value)[/b]——把给定的值转换成字符串。要执行这种强制类型转换，只需要调用作为参数传递进来的值得toString()方法。强制转换成字符串和调用toString()唯一不同之处在于，对null或undefined值强制类型转换可以生成字符串而不引发错误：
var s1=String(null);//”null”
var Temp=null;
var s2=Temp.toString();//不能工作，提示错误
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。

2.8 [/b]引用类型（[/b]Reference Types[/b]）[/b][/b]
引用类型通常叫做类（class），也就是说，遇到引用值时，所处理的就是对象。
对象是由new运算符加上要实例化的类的名字创建的，例如，下面创建了Object累的实例：
var o=new Object();

2.8.1 Object[/b]类[/b][/b]
ECMAScript中的所有类都是由这个类继承而来，Object类中所有属性和方法都会出现在其他类中。
Object[/b]类具有的属性[/b](Property)[/b]：[/b][/b]
l Constructor[/b]——对创建对象的函数的引用（指针）。对于Object类，该指针指向原始的Object()函数。
l Prototype[/b]——对该对象的对象原型的引用。对于所有的类，它默认返回Object对象的一个实例。
Object[/b]类具有的方法[/b](method)[/b]：[/b][/b]
l HasOwnProperty(property)[/b]——判断对象是否有某个特定的属性。必须用字符串制定该属性。
l IsPrototypeOf(object)[/b]——判断该对象是否为另一个对象的原型。
l PropertyIsEnumerable(property)[/b]——判断给定的属性是否可以用for…in语句进行枚举。
l ToString()[/b]——返回对象的原始字符串表示。对于Object类，ECMA-262没有定义这个值，所以不同的ECMAScript实现具有不同的值。
l ValueOf()[/b]——返回最适合该对象的原始值。对于许多类。该方法返回的值都与toString()的返回值相同。
上述的每种属性和方法都会被其他类覆盖。

2.8.2 Boolean[/b]类[/b][/b]
Boolean类是Boolean原始类型的引用类型。要创建Boolean对象，只需要传递Boolean值最为参数：
var BooleanObject=new Boolean(true);
Boolean对象将覆盖object类的valueOf()方法，返回原始值，即true或false。ToString()方法也会被覆盖，返回字符串“true”或“false”。

2.8.3 Number[/b]类[/b][/b]
Number类是Number原始类型的引用类型。要创建Number对象，采用下列代码：
var NumberObject=new Number(55);
所有Number类的特殊值都是Number类的静态属性（如Number.MAX_VALUE）。
要得到数字对象的原始值，只需要使用valueOf()方法。
Number类的其他几个处理数值的方法：
l toFixed()[/b]方法返回的是具有指定位数小数的数字的字符串表示。例如：
var NumberObject=new Number(99);
alert(NumberObject.toFixed(2));//输出 99.00
toFixed()方法能表示具有0到20位小数的数字，超出这个范围的值会引发错误。
l toExponential()[/b]方法返回的用科学记数法表示的数字的字符串形式。例如：
var NumberObject=new Number(99);
alert(NumberObject.toExponential(1));//输出 9.9e+1
l toPrecision()[/b]方法根据最有意义的形式来返回数字的预定形式或指数形式。它有一个参数，即用于表示数的数字总数（不包括指数）。例如：
var NumberObject=new Number(99);
alert(NumberObject. toPrecision(1));//输出 1e+2
因为用1位数字不可能表示99，所以该方法进行舍入，从而得到尽可能接近真实值得数。

2.8.4 String[/b]类[/b][/b]
String类是String原始类型的引用类型，用如下方式创建：
var StringObject=new String(“hello world”);
String对象的valueOf()和toString()方法都会返回String型的原始值。
其它一些String类的方法:
l charAt()[/b]方法返回的是包含指定位置处的字符的字符串。
l charCodeAt()[/b]方法返回的是包含指定位置处的字符的字符代码。
l concat()[/b]方法，用于把一个或多个字符串连接到String对象的原始值上。该方法返回的是String原始值，保持原始的String对象不变：
var StringObject=new String(“hello “);
var Result=StringObject.concat(“world”);
alert(Result);//输出 hello world
alert(StringObject);//输出 hello
可以直接用“+”连接字符串：
var StringObject=new String(“hello “);
var Result=StringObject+“world”;
alert(Result);//输出 hello world
alert(StringObject);//输出 hello
l indexOf()[/b]方法是从字符串的开头开始检索子串，返回指定的子串在另一个字符串的位置。
l lastIndexOf()[/b]方法是从字符串的结尾开始检索子串，返回指定的子串在另一个字符串的位置。
l localeCompare()[/b]方法是对字符长进行排序。它有一个参数，即要进行比较的字符串，返回的是-1，0，1三个值之一。其中“-1”表示String对象按照字母顺序排在参数中的字符串之前；“0” 表示String对象等于参数中的字符串；“1” 表示String对象按照字母顺序排在参数中的字符串之后。
l slice()[/b]，接受一个或两个参数。第一个参数是要获取的子串的起始位置，第二个参数是要获取子串终止前的位置（如果省略，默认为字符串的长度），然后返回的是要处理的字符串的子串。对于负数的参数，该方法会用字符串的长度加上参数。
l substring()[/b]，接受一个或两个参数。第一个参数是要获取的子串的起始位置，第二个参数是要获取子串终止前的位置（如果省略，默认为字符串的长度），然后返回的是要处理的字符串的子串。对于负数的参数，该方法会将其作为0处理（就是忽视它）。
l toLowerCase()[/b]方法把字符串转换成全小写的。[/b]
l toLocaleLowerCase()[/b]方法把字符串转换成全小写的。并且它是基于特定区域实现的。[/b]
l toUpperCase()[/b]方法把字符串转换成全大写的[/b]
l toLocaleUpperCase()[/b]方法把字符串转换成全大写的。并且它是基于特定区域实现的。[/b]
注意，String类的所有属性和方法都可应用于String原始值上，因为它们是伪对象。

2.8.5 instanceof[/b]运算符[/b][/b]
在使用typeof运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回object，所以ECMAScript引入了instanceof来解决这个问题。
instanceof用于识别正在处理的对象的类型，它要求开发者明确地确认对象为某特定类型，如：
var StringObject=new String(“hello world”);
alert(StringObject instanceof String);//输出 true

2.9 [/b]运算符（[/b]Operator[/b]）[/b][/b]
[/b]
2.9.1 [/b]一元运算符（[/b]Unary operator）[/b][/b]
1.delete[/b]——删除对以前定义的对象属性或方法的引用。删除引用后，其值会被设置为undefined。delete运算符不能删除开发者未定义的属性和方法。
2.void[/b]——对任何值都返回undefined。该运算符通常用于避免输出不应该输出的值。（没有返回值的函数真正返回的都是undefined）。
3.[/b]前增量[/b]/[/b]前减量运算符[/b]。前增量（++），就是在数值上加1，如++Num等价于Num+1。前减量（--），就是从数值上减1，如—Num等价于Num-1。它们的运算都发生在表达式之前。
4. [/b]后增量[/b]/[/b]后减量运算符[/b]。后增量（++），就是在数值上加1，如Num++等价于Num+1。后减量（--），就是从数值上减1，如Num—等价于Num-1。它们是在计算过包含它们的表达式后才进行增量或减量运算的。
5.[/b]一元加法和一元减法[/b]。一元加法（+）对数字没有任何影响，但对字符串，会把字符串转化为数字。当对字符串操作时，只有对以“0x”开头的字符串，一元运算符才把它转换为十进制的值。一元减法（1）与加法相似，此外还会对该值求负。

2.9.2 [/b]位运算符（[/b]Bitwise [/b]operator）[/b][/b]
位运算符是在数字底层进行操作的。所有整数字面量都默认为有符号数，只有用ECMAScript的位运算符才能创建无符号数。
1.[/b]位运算[/b]NOT[/b]由否定号（～）表示。它实质上是对数字求负，然后减1，例如25变为-26。
2.[/b]位运算[/b]AND[/b]由和号（&）表示，直接对数字的二进制形式进行运算。把每个数字位对齐，然后按位进行与运算。
3.[/b]位运算[/b]OR[/b]由符号（|）表示，直接对数字的二进制形式进行运算。把每个数字位对齐，然后按位进行或运算。
4.[/b]位运算[/b]XOR[/b]由符号（^）表示，直接对数字的二进制形式进行运算。把每个数字位对齐，然后按位进行异或运算，即当只有一个数为存放的是1时，它才返回1。
5.[/b]左移运算[/b]由两个小于号（<<）表示。它把数字中的所有位数向左移动指定的数量。例如，把2左移5位，结果为64（等于二进制中的1000000）。左移运算用0填充空位，使结果为完整的32位数字。左移运算保留数字的符号位。
6.[/b]有符号右移运算[/b]由两个大于号（>>）表示。它把32位数字中的所有数位整体右移，同时保留符号位。有符号右移运算恰好与左移运算相反。
7.[/b]无符号右移运算[/b]由三个大于号（>>>）表示。它把无符号32位数字中的所有数位整体右移。对于正数，无符号右移运算与有符号右移运算一样。对于负数，将被作为正数来处理。例如，-64右移5位，将得到13421726。

2.9.3 Boolean[/b]运算符[/b][/b]
有三种运算符：
1.[/b]逻辑[/b]NOT[/b]由感叹号（！）表示。它返回的一定是Boolean值。
有如下行为：
l 如果运算数是对象，返回false。
l 如果运算数是数字0，返回true。
l 如果运算数是0以外的任何数字，返回false。
l 如果运算数是null，返回true。
l 如果运算数是NaN，返回true。
l 如果运算数是undefined，发生错误。
判断ECMAScript变量的Boolean值时，无论运算数是什么类型，第一个NOT返回Boolean值，第二个NOT对该Boolean值求负，从而给出变量真正的Boolean值。
2.[/b]逻辑[/b]AND[/b]由双和号（&&）表示。如果某个运算数不是原始的Boolean型值，AND运算并不一定返回Boolean值：
l 如果一个运算数是对象，另一个是Boolean值，返回该对象。
l 如果两个运算数都是对象，返回第二个对象。
l 如果某个运算数是Null，返回null。
l 如果某个运算数是NaN，返回NaN。
l 如果某个运算数是undefined，发生错误。
3.[/b]逻辑[/b]OR[/b]由双竖线（||）表示。如果某个运算数不是Boolean值，OR运算并不一定返回Boolean值：
l 如果一个运算数是对象，另一个是Boolean值，返回该对象。
l 如果两个运算数都是对象，返回第一个对象。
l 如果某个运算数是Null，返回null。
l 如果某个运算数是NaN，返回NaN。
l 如果某个运算数是undefined，发生错误。

2.9.4 [/b]乘性运算符（[/b]Multiplicative operators）[/b][/b]
1.[/b]乘法（[/b]Multiply）运算符[/b]由“*”表示，在ECMAScript中还有一些特殊行为：
l 如果运算数都是数字，执行常规的乘法运算，。如果结果太大或太小，生成的结果就是Infinity或-Infinity。
l 如果某个运算数是NaN，结果为NaN。
l Infinity乘以0，结果为NaN。
l Infinity乘以0以外的任何数字，结果为Infinity或-Infinity，由第二个运算数的符号决定。
l Infinity乘以Infinity，结果为Infinity。
2.[/b]除法（[/b]Divide）运算符[/b]由“/”表示，也有特殊行为：
l 如果运算数都是数字，执行常规的除法运算，。如果结果太大或太小，生成的结果就是Infinity或-Infinity。
l 如果某个运算数是NaN，结果为NaN。
l Infinity被Infinity除，结果为NaN。
l Infinity被任何数字除，结果为Infinity。
l 0除以一个非无穷大数字，结果为Infinity。
l Infinity除以0以外的任何数字，结果为Infinity或-Infinity，由第二个运算数的符号决定。
3.[/b]取模（[/b]Modulus）运算符[/b]由“%”表示，也有特殊行为：
l 如果运算数都是数字，执行常规的算术除法运算，返回除法运算得到的余数。
l 如果被除数是Infinity，或者除数是0，结果为NaN。
l Infinity被Infinity除，结果为NaN。
l 如果除数是无穷大的数，结果为被除数。
l 如果被除数为0，结果为0。

2.9.5 [/b]加性运算符（[/b]Additive operators）[/b]
1.[/b]进加性运算符（[/b]+[/b]）[/b]如果两个运算数都是数字，将执行算术加法，根据加法规则返回结果。如果遇到特殊值，它有一些特殊方式：
l 某个运算数是NaN，结果为NaN。
l Infinity加Infinity，结果为Infinity。
l -Infinity加-Infinity，结果为-Infinity。
l Infinity加-Infinity，结果为NaN。
l +0加+0，结果为+0。
l -0加+0，结果为+0。
l -0加-0，结果为-0。
l 如果两个运算数都是字符串，把两个字符串连接到第一个字符串上。
l 如果只有一个运算数是字符串，把另一个运算数转换成字符串，结果是两个字符串连接成的字符串。

2.[/b]减性运算符（[/b]-[/b]）[/b]与加法运算符一样，但也有一些特殊处理规则：
l 如果两个运算数都是数字，将执行算术减法，返回结果。
l 某个运算数是NaN，结果为NaN。
l Infinity减Infinity，结果为NaN。
l -Infinity减-Infinity，结果为NaN。
l Infinity减-Infinity，结果为Infinity。
l -Infinity减Infinity，结果为-Infinity。
l +0减+0，结果为+0。
l -0减+0，结果为-0。
l -0减-0，结果为-0。
l 某个运算数不是数字，结果为NaN。

2.9.6 [/b]关系运算符（[/b]Relational operator）[/b]
关系运算符小于（<）、大于（>）、小于等于（<=）和大于等于（>=）执行的是两个数的比较运算，比较方式与算术比较运算相同。每个关系运算符都返回一个Boolean值。
对两个字符串的进行关系运算，将会把第一个字符串中每个字符的代码与第二个字符串中相对应位置上的字符的代码进行数值比较（该比较是根据字符对应的ASCII码进行）。
如果是字符串和数字进行比较，ECMAScript会把字符串转换成数字，然后按照数字顺序比较它们。如果该字符串不能转换成数字，它将被转换为NaN，根据规则，任何包含NaN的关系都要返回false。

2.9.7 [/b]等性运算符（[/b]Equality [/b]operator）
1.等号和非等号
等号由“==”表示，当且仅当两个运算数相等时，它返回true。非等号由“！=”表示，当且仅当两个操作数不相等时，它返回true。为确定两个运算数是否相等，这两个运算数都会进行类型转换。转换规则如下：
l 如果一个运算数是Boolean值，在检查相等性之前，把它转换成数字值。false转换为0，true转换为1。
l 如果一个运算数是字符串，另一个是数字，在检查相等性之前，要尝试把字符串转换成数字。
l 如果一个运算数是对象，另一个是字符串，在检查相等性之前，要尝试把对象转换成字符串（调用toString()方法）。
l 如果一个运算数是对象，另一个是数字，在检查相等性之前，要尝试把对象转换成数字。在进行比较时，该运算还应遵守以下规则：
n 值null和undefined相等。
n 在检查等性时，不能把null和undefined转换成其他值。
n 如果某个运算数是NaN，等号将返回false，非等号返回true。即使两个运算数都是NaN，等号仍然返回false，因为根据规则，NaN不等于NaN。
n 如果两个运算数是对象，那么比较的是它们的引用值。如果两个运算数指向同一个对象，那么等号返回true，否则两个运算数不等。

2.全等号和非全等号
全等号（===）和非全等号（！==）所做的与等号和非等号相同，只是它们在检查相等性前，不执行类型转换。

2.9.8 条件运算符（Conditional operator）
条件运算符的形式：
variable=boolean_expression ? true_value : false_value;
该表达式根据boolean_expression的计算结果有条件的为变量赋值。如果boolean_expression为true，就把true_value赋给变量，如果它是false，就把false_value赋给变量。

2.9.9 赋值运算符（Assignment operator）
简单的复制运算由等号（=）实现，只是把等号右边的值赋予等号左边的变量。
复合的复制运算符：
l 乘法/赋值（*=）
l 除法/赋值（/=）
l 取模/赋值（%=）
l 加法/赋值（+=）
l 减法/赋值（-=）
l 左移/赋值（<<=）
l 有符号右移/赋值（>>=）
l 无符号右移/赋值（>>>=）

2.9.10 逗号运算符（Comma operator）
用逗号运算符可以在一条语句中执行多个运算。例如：var Num1=1,Num2=2,Num3=3;

2.10 语句（Statement）

2.10.1 if语句
语法如下：
if (condition) statement1 else statement2
还可嵌套多个if语句：
if (condition1) statement1 else if (condition2) statement2 else statement3

2.10.2 迭代（Iterative）语句
1.do-while语句
do
{
statement
}while (expression);
该语句是后测试循环，即退出条件在执行过循环内部的代码之后计算。这意味着在计算表达式之前，至少会执行循环主体一次。
2.while语句
while
{
statement
}
该语句是前测试循环，即退出条件在执行循环内部的代码之前计算。因此，循环主体可能根本不被执行。
3.for语句
for (initialization; expression; post-loop-expression) statement
该语句是前测试循环，而且在进入循环之前，能够初始化变量，并定义循环后要执行的代码。
4.for-in[/b]语句[/b]
该语句是严格的迭代语句，用于枚举对象的属性。语法如下：
for (property in expression) statement

2.10.3 有标签的语句（Labeled statement）
给语句加标签，可以便于以后调用：
label : statement
例如：start: var Count = 10;
这个例子中，标签start可被break语句或continue语句引用。

2.10.4 break语句和continue语句
break语句可以立即退出循环，阻止再次反复执行任何代码。continue语句只是推出当前循环，根据控制表达式还允许继续进行下一次循环。

2.10.5 with语句
with语句用于设置代码在特定对象中的作用域。语法如下：
with (expression) statement;
例如：
var sMessage = “hello world”;
with(sMessage)
{
alert(toUpperCase()); //输出“HELLO WORLD”
}
这段代码中，with语句作用于字符串，所以在调用toUpperCase()方法时，解释程序将检查该方法是否是本地函数。如果不是，它将检查伪对象sMessage，看它是否为该对象的方法。然后警告将输出“HELLO WORLD”，因为解释程序找到了字符串“hello world”的toUpperCase()方法。
with语句是运行缓慢的代码段，尤其是在已设置了属性值时。大多数情况下，最好避免使用。

2.10.6 switch语句
可以用它为表达式提供一系列情况（case）。语法如下：
switch (expression) {
case value: statement
break;
case value: statement
break;
case value: statement
break;
...
case value: statement
break;
default: statement
}
上面表示“如果expression等于value，就执行statement”，关键字break会使代码跳出switch语句。没有break，代码执行就会继续进入下一个情况。关键字default说明表达式的结果不等于任何一种情况时的操作。
在ECMAScript中，该语句可用于字符串，而且能用不是常量的值说明情况：
var BLUE = “blue”, RED = “red”, GREEN = “green”;
switch (sColor) {
case BLUE: alert(“Blue”);
break;
case RED: alert(“Red”);
break;
case GREEN: alert(“Green”);
break;
default: alert(“Other”);
}

2.11 函数（Function）
函数由关键字function、函数名和一组参数以及置于括号中的要执行的代码声明。语法如下：
function functionName(arg0,arg1,…argN){
statement
}
例如：
function sayHi(Name,Message){
alert(“Hello”+name+”,”+Message);
}
函数可以通过其名字加置于括号中的参数调用。调用sayHi()函数的代码如下：
sayHi(“Nicholas”,”how are you today?”);
如果函数有返回值，不必明确声明它，只需要使用return运算符后跟要返回的值即可。函数在执行过return语句后停止执行代码，因此return后的代码都不会被执行。
如果函数无返回值，可以调用没有参数的return运算符退出函数。但记住，如果函数没有返回值或调用了没有参数的return,那么它真正返回的值是undefined。

2.11.1 无重载（No overloading）
ECMAScript中的函数不能重载。可用相同的名字在同一个作用域中定义两个函数，而不会引发错误，但真正使用的是后一个函数。但可以使用arguments对象避开这种限制。

2.11.2 arguments对象
在函数代码中，使用arguments，开发者无需明确指出参数名，就能访问它们。例如前例中的sayHi()中，第一个参数是message。用arguments[0]也可以访问这个值，即第一个参数的值（第一个参数位于位置0，第二个位置为1，以此类推）。因此，无需明确命名就可以重写函数：
function sayHi(){
if (arguments[0]==”bye”){
return;
}
alert(arguments[0]);
}
可以引用属性arguments.length来检测传递给函数的参数个数。
用arguments对象判断传递给函数的参数个数，即可模拟函数重载：
function doAdd() {
if(arguments.length == 1) {
alert(arguments[0] + 10);
} else if (arguments.length == 2) {
alert(arguments[0] + arguments[1]);
}
}
doAdd(10); //输出 “20”
doAdd(30, 20); //输出 “50”

2.11.3 Function[/b]类[/b]
Function类可以表示开发者定义的任何函数。用function类直接创建函数的语法如下：
var function_name=new Function(argument1,argument2,…,argument,function_body);
每个argument都是一个参数，最后一个参数是函数主体（要执行的代码），这些参数必须是字符串。如下面这段代码：
function sayHi(Name,Message){
alert(“Hello”+name+”,”+Message);
}
还可以如下定义它：
var sayHi=new Function (“Name”,”Message”,”alert(/”Hello/”+Name+/”,/”+Message+/”);”);
Function对象也有标准的length属性、valueOf()方法和toString()方法。

2.11.4 闭包（Closure）
闭包是指词法表示包括不必计算的变量的函数，也就是说，该函数能使用函数外定义的变量。在ECMAScript中，全局变量是一个简单的闭包实例：
var sMessage = “Hello World!”;
function sayHelloWorld() {
alert(sMessage);
}
sayHelloWorld();

2.12 [/b]小结[/b]
本节介绍了ECMAScript的基础：
l 一般语法
l 用关键字var定义变量
l 原始值和引用值
l 基础的原始类型（Undefined,Null,Boolean,Number,String）
l 基础的引用类型（Object,Boolean,Number,String）
l 运算符和语句
l 函数