标签：
任何语言的核心必然会描述这门语言最基本的工作原理。而描述的内容通常都要设计这门语言的语法、操作符、数据类型、内置功能等用于构建复杂解决方案的基本概念。
语法
ECMAScript的语法大量借鉴了C及其他类语言（如Java和Perl）的语法。因此，熟悉那些语言的开发人员在接受ECNAScript更加宽松的语法时，一定会有一种轻松自在的感觉。
区分大小写
要理解的第一个概念就是ECMAScript中的一切（变量、函数和操作符）都区分大小写。标识符
所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以使按照下列格式规则组合起来的一或多个字符：
□ 第一个字符必须是字母、下划线（_）活一个美元符号（$）；
□ 其他字符可以是字母、下划线、美元符或数字。
标识符中的字母也可以包含扩展的ASCII或Unicode字母字符（如à和?），但不推荐这样做。
按照惯例，ECMAScript标识符采用驼峰大小写格式，也就是第一个字母小写，剩下的每个有意义的单词的首字母大写，例如：myFirstJavaScriptName。虽然没有强制要求使用这种格式，但为了与ECMAScript内置的函数和对象命名格式保持一致，可以将其当作一种最佳实践。
注释
ECMAScript使用C风格的注释，包括单行注释和块级注释。单行注释以两个斜杠开头，如：
//单行注释
块级注释以一个斜杠和一个星号（/*）开头，以一个星号和一个斜杠（*/）结尾，如：
/*
*这是一个多行
*（块级）注释
*/
虽然上面注释中的第二和第三行都以一个星号开头，但这不是必需的。之所以以星号开头，纯粹是为了提高注释的可读性。
严格模式
ECMAScript 5引入了严格模式（strictmode）的概念。严格模式是为JavaScript定义了一种不同的解析与执行模型。在严格模式下，ECMAScript3中的一些不确定的行为将得到处理，而且对某些不安全的操作也会抛出错误。要在脚本中启用严格模式，可以在顶部添加如下代码：
“use strict”;
这行代码看起来像是字符串，而且也没有赋值给任何变量，但其实它是一个编译指示（pragma），用于告诉支持的JavaScript引擎切换到严格模式。这是为不破坏ECMAScript3语法而特意选定的语法。
在函数内部的上方包含这条编译指示，也可以指定函数在严格模式下执行：
function doSomething(){
“usestrict”;
//函数体
}
严格模式下，JavaScript的执行结果会有很大不同。支持严格模式的浏览器包括IE10+、Firefox4+、Safari5.1+、Opera12和Chrome。
语句
ECMAScript中的语句以一个分号结尾；如果省略分号，则由解析器确定语句的结尾，如下例所示：
var sun = a + b //即使没有分号也是有效的语句——不推荐
var diff = a –b; //有效的语句——推荐
虽然语句结尾的分号不是必须的，但我们建议任何时候都不要省略它。因为加上这个分号可以避免很多错误（例如不完整的输入），开发人员也可以放心地通过删除多余的空格来压缩ECMAScript代码（代码行结尾处没有分号会导致压缩错误）。另外，加上分号也会在某些情况下增进代码的性能，因为这样解析器就不必再话时间推测应该在哪里插入分号了。
可以使用C风格的语法把多条语句组合到一个代码块中，即代码块以左花括号（{）开头，以右花括号（}）结尾。
虽然条件控制语句（如if语句）只在执行所调语句的情况下菜要求使用代码块，但最佳实践是始终在控制语句中使用代码块——即使代码块中只有一条语句。
关键字和保留字
ECMA-262描述了一组具有特定用途的关键字，这些关键字可用于表示控制语句的开始或结束，或者用于执行特定操作符等。按照规则，关键字也是语言保留的，不能用作标识符。下表是ECMAScript的全部关键字（带*号上标的是第5版新增的关键字）：
|
break |
do |
instanceof |
typeof |
|
case |
else |
new |
var |
|
catch |
finally |
return |
void |
|
continue |
for |
switch |
while |
|
debugger* |
function |
this |
with |
|
default |
id |
throw |
|
|
delete |
in |
try |
|
ECMA-262还描述了另外一组不能用作标识符的保留字。尽管保留字在这门语言中还没有任何特定的用途，但它们有可能在将来被用作关键字。以下是ECMA-262第三版定义的全部保留字：
|
abstract |
enum |
int |
short |
|
boolean |
export |
interface |
static |
|
byte |
extends |
long |
super |
|
char |
final |
native |
synchoronized |
|
class |
float |
package |
throws |
|
const |
goto |
private |
transient |
|
debugger |
implements |
protected |
volatile |
|
double |
import |
public |
|
第5版把在非严格模式下运行时的保留字缩减为下列这些：
|
class |
enum |
extends |
super |
|
const |
export |
import |
|
在严格模式下，第5版还对以下保留字施加了限制：
|
implements |
package |
public |
|
interface |
private |
static |
|
let |
protected |
yield |
注意，let和yield是第5版新增的保留字，其他保留字都是第3版定义的。
变量
ECMAScript的变量是松散类型的，所谓松散类型就是可以用来保存任何类型的数据。换句话说，每个变量仅仅是一个用于保存值的占位符而已。定义变量时要使用car操作符（注意var是一个关键字），后跟变量名，如下所示：
var message;
这行代码定义了一个名为message的变量，该变量可以用来保存任何值（像这样未经过初始化的变量，会保存一个特殊的值——undefined）。ECMAScript也支持直接初始化变量，因此在定义变量的同时就可以设置变量的值：
var message = “hi”;
再次，变量message中保存了一个字符串值”hi”。像这样初始化变量并不会把它标记为字符串类型；初始化的过程就是给变量赋一个值那么简单。因此，可以在修改变量值的同时修改值的类型，如：
var message = “hi”;
message = 100;
在这个例子中，变量message一开始保存了一个字符串”hi”，然后该值又被一个数字值100取代。虽然不建议修改变量所保存值的类型，但这种操作在ECMAScript中完全有效。
有一点必须注意，即使用var操作符定义的变量将成为定义该变量的作用域中的局部变量。也就是说，如果在函数中使用var定义一个变量，那么这个变量在函数退出后就会被销毁，例如：
function test(){
var message = “hi”;//局部变量
}
test();
alert(message);//错误！
这里，变量message是在函数中使用var定义的。当函数被调用时，就会创建该变量并为其赋值。而在此之后，这个变量又会被立即销毁，因此例子中的下一行代码就会导致错误。不过，可以像下面这样省略var操作符，从而创建一个全局变量：
function test(){
message = “hi”;//全局变量
}
test();
alert(message);//hi
这个例子省略了var操作符，因而message就成了全局变量。这样，只要调用过一次test()函数，这个变量就有了定义，就可以在函数外部的任何地方被访问到。
虽然省略var操作符可以定义全局变量，但这也不是我们推荐的做法。因为在局部作用域中定义的全局变量很难维护，而且如果有意地忽略了var操作符，也会由于相应变量不会马上就有定义而导致不必要的混乱。给未经声明的变量赋值在严格模式下会导致抛出ReferenceError。
可以使用一条语句定义多个变量，只要像下面这样把每个变量（初始化或不初始化均可）用逗号分隔开即可：
var message = “hi”, found = false , age = 29;
这个例子定义并初始化了3个变量。同样由于ECMAScript是松散类型的，因而使用不同类型初始化变量的操作可以放在一条语句中来完成。虽然代码里的换行和变量缩进不是必需的，但这样做可以提高可读性。
在严格模式下，不能定义名为eval或arguments的变量，否则会导致语法错误。
数据类型
ECMAScript中有5种简单数据类型（也称为基本数据类型）：Undefined、Null、Boolean、Number和String。还有一种负责数据类型——Object，Object本质上是由一组无序的名值对组成的。ECMAScript不支持任何自定义类型的机制，而所有值最终都将是上述6种数据类型之一。乍一看，好像只有6种数据类型不足以表示多有数据；但是，由于ECMAScript数据类型具有动态性，因此的确没有再定义其他数据类型的必要了。
typeof操作符
鉴于ECMAScript是松散类型的，因此需要有一种手段来检测给定变量的数据类型——typeof就是负责提供这方面信息的操作符。对一个值使用typeof操作符可能返回下列某个字符串：
□ “undefined”——如果这个值未定义；
□ “boolean”——如果这个值是布尔值；
□ “string”——如果这个值是字符串；
□ “number”——如果这个值是数值；
□ “object”——如果这个值是对象或null；
□ “function”——如果这个值是函数。
下面是几个使用typeof的例子：
var message = "hi";
alert(typeof typeofTest);//function
alert(typeof message);//string
alert(typeof message1);//undefined
alert(typeof null);//object
alert(typeof 123);//number
这几个例子说明，typeof操作符的操作数可以使变量（message），也可以是数值字面变量。注意，typeof是一个操作符而不是函数，因此例子中的圆括号尽管可以使用，但不是必须的。
有些时候，typeof操作符会返回一些疑惑但技术上却正确的值。比如，调用typeof null会返回“object”，因为特殊值null被认为是一个空的对象引用。Safari 5及之前版本、Chrome 7及之前版本在对正则表达式调用typeof操作符会返回”function”，而其他浏览器在这种情况下会返回”object”。
从技术角度将，函数在ECMAScript中是对象，不是一种数据类型。然而，函数也确实有一些特殊的属性，因此通过typeof操作符来区分函数和其他对象是有必要的。
Undefined类型
Undefined类型只有一个值，即特殊的undefined。在使用var声明变量但未对其加以初始化时，这个变量的值就是undefined，例如：
var message;
alert(message == undefined);//true
这个例子只声明了变量message，但未对其进行初始化。比较这个变量与undefined字面量，结果表名它们是相等的。这个例子与下面的例子是等价的：
var message = undefined;
alert(message == undefined);//true
这个例子使用undefined值初始化了变量message。但没必要这么做，因为未经初始化的值默认就会取得undefined值。不过，包含undefined值的变量与尚未定义的变量还是不一样的。例如：
var message;
//下面这个变量并没有声明
//var age;
alert(message);//”undefined”
alert(age);//产生错误
运行以上代码，第一个警告框会显示变量message的值，即”undefined”。而第二个警告框——由于传递给alert()函数的是尚未声明的变量age——则会导致一个错误。对于尚未声明过的变量，只能执行一项操作，即使用typeof操作符检测其数据类型（对未经声明的变量调用delete不会导致错误，但这样做没什么实际意义，而且在严格模式下确实会导致错误）。
然而，如在typeof小节中的测试代码一样，对未经初始化的变量执行typeof操作符也会返回undefined值，而对未声明的变量执行typeof操作符同样也会返回undefined值。这样的结果有其合理性。因为虽然这两种变量从技术角度看有本质区别，但实际上无论对哪种变量也不可能执行真正的操作。
Null类型
Null类型是第二个只有一个值的数据类型，这个特殊的值是null。从逻辑角度来看，null值表示一个空对象指针，而这也正是使用type操作符检测null值会返回”object”的原因。
如果定义的变量准备在将来用于保存对象，那么最好将该变量初始化为null而不是其他值。这样一来，只要直接检查null值就可以知道相应的变量是否已经保存了一个对象的引用。
实际上，undefined值是派生自null值的，因此ECMA-262规定对它们的相等性测试要返回true：
alert(null ==undefined);//true
这里，位于null和undefined之间的相等操作符（==）总是返回true，不过要注意的，这个操作符处于比较的目的会转换其操作数。
尽管null和undefined有这样的关系，但它们的用途完全不同。如前所述，无论在什么情况下都没有必要把一个变量的值显式地设置为undefined，可是同样的规则对null却不适用。换句话说，只要意在保存对象的变量还没有真正保存对象，就应该明确地让该变量保存null值。这样不仅可以体现null作为空对象指针的惯例，而且也有助于进一步区分null和undefined。
Boolean类型
Boolean类型是ECMAScript中使用得最多的一种类型，该类型只有两个字面值：true额false。这两个值与数字值不是一回事，因此true不一定等于1，而false也不一定等于0。需要注意的是，Boolean类型的字面值true和false是区分大小写的。虽然Boolean类型的字面值只有两个，但ECMAScript中所有类型的值都有与这两个Boolean值等价的值。要将一个值转换为其对应的Boolean值，可以调用转型函数Boolean()，如：
var message = “hi”;
var BooleanFromMessage = Boolean(message);
这个例子中，字符串message被转换成了一个Boolean值，该值被保存在BooleanFromMessage变量中。可以对任何数据类型的值调用Boolean()函数，而且总会返回一个恶Boolean值。至于返回的这个值是true还是false，取决于要转换的数据类型及其实际值。
|
数据类型 |
转化为true的值 |
转化为false的值 |
|
Boolean |
true |
false |
|
String |
任何非空字符串 |
“”(空字符串) |
|
Number |
任何非零数字值(包括无穷大) |
0和NaN |
|
Object |
任何对象 |
null |
|
Undefined |
n/a（not applicable ， 不适用） |
undefined |
这些转换规则对理解控制语句（如if语句）自动执行相应的Boolean转换非常重要，例如：
var message = “hi”;
if(message){
alert(message);
}
运行这个示例，就会显示一个警告框，因为字符串message被自动转换成了对应的Boolean值（true）。由于存在这种自动执行的Boolean转换，因此确切地知道在流程控制语句中使用的是什么变量至关重要。错误地使用一个对象而不是一个Boolean值，就有可能彻底改变应用程序的流程。
Number类型
Number类型应该是ECMAScript中最令人关注的数据类型了，这种类型使用IEEE754格式来表示整数和浮点数值。为支持各种数值类型，ECMA-262定义了不同的数值字面量格式。
最基本的数值字面量格式是十进制整数，十进制整数可以像下面这样直接在代码中输入：
var intNum =55;//整数
除了以十进制表示外，整数还可以通过八进制或十六进制的字面值来表示。其中，八进制字面值的第一位必须是零（0），然后是八进制数字序列（0~7）。如果字面值中的数值超出了范围，那么前导零将被忽略，后面的数值将被当作十进制数值进行解析。
八进制字面量在严格模式下是无效的，会导致支持的JavaScript引擎抛出错误。
十六进制字面值的前两位必须是0x，后跟任何十六进制数字（0~9及A~F）。其中字母A~F可以大写也可以小写。
在进行算术运算时，所有以八进制和十六进制表示的数值最终都将被转换成十进制数值。
alert("0x1A+023+12 = 十六进制1A + 八进制23 + 十进制12 = 十进制26 + 十进制19 + 十进制12 = " + (0x1A+023+12) );
上面的代码会在页面中弹出：
0x1A+023+12 = 十六进制1A + 八进制23 + 十进制12 = 十进制26 + 十进制19 + 十进制12 = 57
更直接的：
alert("0x1A+023+12 = 十六进制1A = 十进制26 = " + 0x1A );
将会在页面中弹出：
0x1A = 十六进制1A = 十进制26 = 26
浮点数值
所谓浮点数值，就是该数值中必须包含一个小数点，并且小数点后面必须至少有一位数字。虽然小数点前面可以没有整数，但不推荐这种写法。以下是浮点数值的几个例子：
var floatNum1 =1.1;
var floatNum2 =0.1;
var floatNum3 =.1;//有效，但不推荐
由于保存浮点数值需要的内存控件是保存整数值的两倍，因此ECMAScript会不失时机地将浮点数值转换为整数值。显然，如果小数点后面没有跟任何数字，那么这个数值就可以作为整数值来保存。同样地，如果浮点数值本身表示的就是一个整数（如1.0），那么该值也会被转换为整数，如下面的例子所示：
var floatNum1 =1.;//小数点后面没有数字——解析为1
var floatNum2 =10.0;//整数——解析为10
对于那些极大或极小的数值，可以用e表示法（即科学计数法）表示的浮点数值表示。用e表示法表示的数值等于e前面的数值乘以10的指数次幂。ECMAScript中e表示法的格式也是如此，即前面是一个数值（可以是整数也可以是浮点数），中间是一个大写或小写的字母E，后面是10的幂中的指数，该幂值将用来与前面的数相乘。如：
var floatNum =3.125e7;//等于31250000
在这个例子中，使用e表示法表示的变量floatNum的形式虽然简洁，但它的十几只则是31250000。在此，e表示法的实际含义就是”3.125乘以 ”。
也可以使用e表示法表示极小的数值，如：0.00000000000000003，这个数值可以使用更简洁的3e-17表示。在默认情况下，ECMAScript会将那些小数点后面带有6个零以上的浮点数值转换为以e表示法表示的数值。浮点数值的最高精度是17位小数，但在进行算术计算时其精度远远不如整数。例如0.1+0.2的结果不是0.3，而是0.30000000000000004。这个小小的舍入误差会导致无法测试特定的浮点数值。例如：
if(0.1+0.2 ==0.3){
alert(“You got 0.3.”);
}
程序将永远无法执行alert(“You got 0.3.”);语句。
数值范围
由于内存的限制，ECMAScript并不能保存世界上所有的数值。ECMAScript能够表示的最小数值保存在Number.MIN_VALUE中——在大多数浏览器中，这个值是5e-324；能够表示的最大数值保存在Number.MAX_VALUE中——在大多数浏览器中，这个值是1.7976931348623157e+308。如果某次计算的结果得到了一个超出JavaScript数值范围的值，那么这个数值将自动转换成特殊的Infinity值。具体来说，如果这个数值是负数，则会被转换成-Infinity（负无穷），如果这个数值是正数，则会被转换成Infinity（正无穷）。
如上所述，如果某次计算返回了正或负的Infinity值，那么该值将无法参与下一次的计算，因为Infinity不是能够参与计算的数值。要想确定一个数值是不是有穷的（欢聚换说，是不是位于最小和最大的数值之间），可以使用isFinite()函数。这个函数在参数位于最小与最大数值之间时会返回true。
NaN
NaN，即非数值（Not aNumber）是一个特殊的数值，这个数值用于表示一个本来要返回是指的操作数未返回数值的情况（这样就不会抛出错误了）。例如，在其他编程语言中。任何数值除以0都会导致错误，从而停止代码执行。但在ECMAScript中，任何数值除以0会返回NaN，因此不会影响其他代码的执行。
NaN本身有两个非同寻常的特点，首先，任何涉及NaN的操作都会返回NaN，这个特点在多步计算中有可能导致问题。其次，NaN与任何值都不相等，包括NaN本身。针对NaN的这两个特点，ECMAScript定义了isNan()函数。这个函数接受一个参数，该参数可以是任何类型，而函数会判断这个参数是否“不是数值”。isNaN()在接收到一个值之后，会尝试将这个值转换为数值。某些不是数值的值会直接转换为数值，例如字符串”10”或Boolean值。而任何不能被转换为数值的值都会导致这个函数返回true：
alert(isNaN(NaN));//true
alert(isNaN(10));//false(10是一个整数)
alert(isNaN("10"));//false(可以被转换成数值10)
alert(isNaN("blue"));//true(不能转换成数值)
alert(isNaN(true));//false(可以被转换成数值1)
尽管有点不可思议，但isNan()确实也适用于对象。在基于对象调用isNaN()函数时，会首先调用对象的valueof()方法，然后确定该方法返回的值是否可以转换为数值。如果不能，则基于这个返回值再调用tostring()方法，再测试返回值。
数值转换
有3个函数可以把非数值转换为数值：Number()、parseInt()和parseFloat()。第一个函数，即转型函数Number()可以用于任何数据类型，而另外两个函数则专门用于把字符串转换成数值。这3个函数对于同样的输入会有返回不同的结果。
Number()函数的转换规则如下。
（1） 如果是Boolean值，true和false将分别转换为1和0。
（2） 如果是数字值，只是简单的传入和返回。
（3） 如果是null值，返回0。
（4） 如果是undefined，返回NaN。
（5） 如果是字符串，遵循下列规则：
（5.1）如果字符串中只包含数字（包含前面带正号或负号的情况），则将其转换为十进制数值，如果有前导零将会被忽略。
（5.2）如果字符串中包含有效的浮点格式，则将其转换为对应的浮点数值，同样，也会忽略前导零；
（5.3）如果字符串中包含有效的十六进制，则将前期转换为相同大小的十进制整数值；
（5.4）如果字符串是空的（不包含任何字符），则将其转换为0；
（5.5）如果字符串中包含上述格式之外的字符，则将其转换为NaN。
（6）如果是对象，则调用对象的valueof()方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的tostring()方法，然后再一次按照前面的规则转换返回的字符串值。
由于Number()函数在转换字符串时比较复杂而且不够合理，因此在处理整数的时候更常用的是parseInt()函数。parseInt()函数在转换字符串时，更多的是看其是否符合数值模式。它会忽略字符串前面的空格，直至找到第一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN；也就是说，用parseInt()转换空字符串会返回NaN。如果第一个字符是数字字符，parseInt()会继续解析第二个字符，知道解析完所有后续字符或者遇到了一个非数字字符。例如“123www”会被转换为123，“www”则会被忽略。类似地，“22.5”会被转换为22，因为小数点并不是有效的整数字符。
如果字符串中的第一个字符是数字字符，parseInt()也能够识别出各种整数格式（八进制、十进制、十六进制）。也就是说，如果字符串以”0x”开头且后跟数字字符，就会将其当作一个十六进制整数；如果以”0”开头且后跟数字字符，则会将其当作一个八进制数来解析。如：
alert(parseInt("123456www"));//123456
alert(parseInt(""));//NaN
alert(parseInt("0xB"));//11
alert(parseInt("22.5"));//22
alert(parseInt("010"));//10
alert(parseInt("0xz"));//NaN
在使用parseInt()解析像八进制字面量的字符串时，ECMAScript3和5存在分歧。例如：
//ECMAScript3认为是56（八进制），ECMAScript5认为是0（十进制）
var num = parseInt(“070”);
在ECMAScript 3JavaScript引擎中，”070”被当成八进制字面量，因此转换后的值是十进制的56。而在ECMAScript 5 引擎中，parseInt()已经不具有解析八进制值的能力，因此前导的零会被认为无效，从而将这个值当成”0”，结果就得到十进制的0。在ECMAScript 5中，即使是在严格模式下也会如此。
为了消除在使用parseInt()函数时可能导致的上述困惑，可以为这个函数提供第二个参数：转换时使用的基数（即多少进制）。如果知道要解析的值是十六进制格式的字符串，那么指定基数16作为第二个参数，可以保证得到正确的结果，例如：
var num =parseInt(“0xAF” , 16);//175
实际上，如果指定了16作为第二个参数，字符串可以不带前面的”0x”，如：
var num1 =parseInt(“AF” , 16);//175
var num2 =parseInt(“AF”);//NaN
这个例子中的第一个转换成功了，而第二个则失败了，差别在于第一个转换传入了基数，明确告诉parseInt()要解析一个十六进制格式的字符串；而第二个转换发现第一个字符不是数字字符，因此就自动终止了。
指定基数会影响到转换的输出结果。例如：
alert(parseInt("11" , 2));//3
alert(parseInt("11" , 3));//4
alert(parseInt("11" , 8));//9
alert(parseInt("11" , 10));//11
alert(parseInt("11" , 16));//17
不指定基数意味着让parseInt()决定如何解析输入的字符串，因此为了避免错误的解析，建议无论在什么情况下都明确指定基数。
多数情况下，要解析的都是十进制数值，因此始终将10作为第二个参数是非常必要的。
与parseInt()函数类似，parseFloat()也是从第一个字符（位置0）开始解析每个字符。而且也是一直解析到字符串末尾，或者解析到预见一个无效的浮点数字字符为止。也就是说，字符串中的第一个小数点是有效的，而第二个小数点就是无效的了，因此它后面的字符串将被忽略。
除了第一个小数点有效之外，parseFloat()与parseInt()的第二个区别在于它始终都会忽略前导的零。parseFloat()可以识别前面讨论过的所有浮点数值格式，也包括十进制整数格式。但十六进制格式的字符串则始终会被转换成0。由于parseFloat()只解析十进制值，因此它没有用第二个参数指定基数的用法。最后还要注意一点：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后都是零），parseFloat()会返回整数。
String类型
String类型用于表示由零或多个16位Unicode字符组成的字符序列，即字符串。字符串可以由双引号（”）或单引号(‘)表示。
与PHP中的双引号和单引号会影响对字符串的解释方式不同，ECMAScript中的这两种语法形式没有什么区别。用双引号表示的字符串和用单引号表示的字符串完全相同。不过，以双引号开头的字符串也必须以双引号结尾，而以单引号开头的字符串必须以单引号结尾。
字符字面量
String数据类型包含一些特殊的字符字面量，也叫转义序列，用于表示非打印字符，或者具有其他用途的字符，如下表所示：
|
字面量 |
含义 |
|
\n |
换行 |
|
\t |
制表 |
|
\b |
空格 |
|
\r |
回车 |
|
\f |
进纸 |
|
\\ |
斜杠 |
|
\’ |
单引号，在用单引号表示的字符串中使用。例如：’He said,\’hey.\’’ |
|
\” |
双引号，在使用双引号的字符串中使用。例如：”He said \“hey.\”” |
|
\xnn |
以十六进制代码nn表示的一个字符（其中n为0~F）。例如，\x41表示”A” |
|
\unnnn |
以十六进制代码nnnn表示的一个Unicode字符（其中n为0~F）。例如，\u03a3表示希腊字母∑ |
这些字符字面量可以出现在字符串中的任意位置，而且也将被作为一个字符来解析，如下面的例子所示：
var text = “Thisis the letter sigama:\u03a3.”;
这个例子中的变量text有28个字符，其中6个字符长度的转义序列表示1个字符。
任何字符串的长度都可以通过访问其length属性取得，例如：
alert(text.length);//输出28
这个属性返回的字符数包括16位字符的数目。如果字符串中包含双子姐字符，那么length属性可能不会精确地返回字符串中的字符数目。
字符串的特点
ECMAScript中的字符串是不可变的，也就是说，字符串一旦创建，它们的值就不能改变。要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。
转换为字符串
要把一个值转换为一个字符串有两种方式。第一种是几乎每个值都会有的tostring()方法。这个方法唯一要做的就是返回相应值的字符串表现。
数值、布尔值、对象和字符串都有tostring()方法。但null和undefined值没有这个方法。
多数情况下，调用tostring()方法不必传递参数。但是，在调用数值的tostring()方法时，可以传递一个参数：输出数值的基数。默认情况下，tostring()方法以十进制格式返回数值的字符串表示。而通过传递基数，tostring()可以输出以二进制、八进制、十六进制，乃至其他任意有效进制格式表示的字符串值。例如：
var num = 10;
alert(num.toString());//10
alert(num.toString(2));//1010
alert(num.toString(4));//22
alert(num.toString(8));//12
alert(num.toString(10));//10
alert(num.toString(16));//a
通过上面的例子可以看出，通过指定基数，toString()方法会改变输出的值。而数值10根据基数的不同，可以在输出时被转换为不同的数值格式。注意，默认的（没有参数）输出值与指定基数10时的输出值相同。
在不知道要转换的值是不是null或undefined的情况下，还可以使用转型函数String()，这个函数能够将任何类型的值转换为字符串。String()函数遵循下列转换规则：
□ 如果值有toString()方法，则调用该方法（没有参数）并返回相应的结果；
□ 如果值是null，则返回”null”；
□ 如果值是undefined，则返回”undefined”。
要把某个值转换为字符串，可以使用加号操作符把它与一个字符串(“”)加在一起。
Object类型
ECMAScript中的对象其实就是一组数据和功能的集合。对象可以通过执行new操作符后跟要创建的对象类型的名称来创建。而创建Object类型的实例并为其添加属性和（或）方法，就可以创建自定义对象，如：
var obj = new Object();
这个语法与Java中创建对象的语法相似；但在ECMAScript中，如果不给构造函数传递参数，则可以省略后面的那一对圆括号。也就是说，在像前面这个示例一样不传递参数的情况下，完全可以省略圆括号（但不推荐这样的做法）：
var obj = new Object;//有效，但不推荐省略圆括号
仅仅创建Object的实例并没有什么用处，但关键是要理解一个重要的思想：即在ECMAScript中，（就像Java中的java.lang.Object对象一样）Object类型是多有它的实例基础。换句话说，Object类型所具有的任何属性和方法也同样存在于更具体的对象中。
Object的每个实例都具有下列属性和方法。
□ Constructor：保存着用于创建当前对象的函数。对于前面的例子而言，构造函数（constructor）就是Object()。
□ hasOwnProperty(propertyName)：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名（propertyName）必须以字符串形式指定。
□ isPropertyOf(object)：用于检查传入的对象是否是另一个对象的原型。
□ propertyIsEnumerable(propertyName)：用于检查给定的属性是否能够使用for-in语句来枚举。与hasOwnProperty()方法一样，作为参数的属性名必须以字符串形式指定。
□ toLocaleString()：返回对象的字符串表示，该字符串与执行环境的地区对应。
□ toString()：返回对象的字符串表示。
□ valueof()：返回对象的字符串、数值或布尔值表示、通常与toString()方法的返回值相同。
由于在ECMAScript中Object是所有对象的基础，因此多有对象都具有这些基本的属性和方法。
操作符
ECMAScript-262描述了一组用于操作数据的操作符，包括算术操作符（如加号和减号）、位操作符、关系操作符和相等操作符。ECMAScript操作符的与众不同之处在于，它们能够适用于很多值，例如字符串、数字值、布尔值，设置对象。不过，在应用于对象时，相应的操作符通常都会调用对象的valueof()和（或）toString()方法，以便取得可操作的值。
一元操作符
只能操作一个值的操作符叫做一元操作符。一元操作符是ECMAScript中最简单的操作符。
递增和递减操作符
递增和递减操作符直接借鉴自C，而且各有两个版本：前置型和后置型。顾名思义，前置型应该位于要操作的变量之前，而后置型则应该位于要操作的变量之后。因此，在使用前置递增操作符给一个数值加1时，要把两个加号（++）放在这个数值变量前面，如：
var age = 21;
age++;
在这个例子中，前置递增操作符把age的值变成了22（为21加上1）。实际上，执行这个前置递增操作与执行以下操作的效果相同：
var age = 21;
age = age + 1;
执行前置递减操作的方法也类似，结果会从一个数值中减去1。使用前置递减操作符时，要把两个减号（--）放在相应变量的前面，如：
var age = 21;
age--;
这样age变量的值就减少为20。
执行前置递增和递减操作时，变量的值都是在语句被求职以前改变的：
var age = 21;
var anotherAge =--age + 2;
alert(age);//20
alert(anotherAge);//22
这个例子中变量anotherAge的初始值等于变量age的值前置递减之后加2。由于限制性了剪发操作，age变成了20，所以加上2的结果就是22。
由于前置递增和递减操作与执行语句的优先级相等，因此整个语句会从左至右被求值。
后置型递增和递减操作符的语法不变（仍然分别是++和--），只不过要放在变量的后面而不是前面。后置型递增和递减与前置型有一个非重要的区别，即递增和递减操作是在包含它们的语句被求值之后才执行。前置与后置的效果比较：
//前置型
var num1 = 10 ;
var num11 = --num1 + 2;
alert("前置型结果：num1=" + num1 + "; num11=" + num11);//前置型结果：num1=9; num11=11
//后置型
var num2 = 10;
var num21 = num2-- + 2;
alert("前置型结果：num2=" + num2 + "; num21=" + num21);//后置型结果：num2=9; num21=12
上面的例子中结果有些差异，是因为前置型递减操作会按照语句的顺序执行，在语句
var num11 = --num1 + 2;
中num1先执行了递减操作，然后执行加操作和赋值操作，此时num1的值为9，加2后num11的值为11；而在语句
var num21 = num2--+ 2;
中先执行num2+2操作和赋值操作，此时num2的值仍为10，所以num2+2=12，在执行完上述操作后num2递减操作。
前置型和后置型递增、递减操作符对任何值都适用，也就是它们不仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象。在应用于不同的值时，递增和递减操作符遵循以下规则：
□ 在应用域一个包含数字字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。
□ 在应用于一个不含有效数字字符的字符串时，将变量的值设置为NaN。字符串变量变成数值变量。
□ 在应用于布尔值false时，先将其转换为0再执行加减1的操作。布尔值变量变成数值变量。
□ 在应用于布尔值true时，先将其转换为1再执行加减1的操作。布尔值变量变成数值变量。
□ 在应用于浮点数值时，执行加减1的操作。
□ 在应用于对象时，先调用对象的valueof()方法以取得一个可供操作的值。然后对该值应用前述规则。如果结果是NaN，则再调用toString()方法后再应用前述规则。对象变量变成数值变量。
一元加和减操作符
绝大多数开发人员对一元加和减操作符都不会陌生，而且这两个ECMAScript操作符的作用与数学书上将的完全一样。一元加操作符以一个加号（+）表示，放在数值前面，对数值不会产生任何影响。不过，在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换。换句话说，布尔值false和true将被转换为0和1，字符串值会按照一组特殊的规则进行解析，而对象是先调用它们的valueof和（或）toString()方法，再转换得到的值。
一元减操作符应用于数值时，该值会变成负数。而当应用于非数值时，一元减操作符遵循与一元加操作符相同的规则，最后再将得到的数值转换为负数。
位操作符
位操作符用于在最基本的层次上，即按内存中表示数值的位来操作数值。ECMAScript中的所有数值都以IEEE-754 64位格式存储，但位操作符并不直接操作64位的值。而是先将64位的值转换成32位的整数，然后执行操作，最后再将结果转换回64位。对于开发人员来说，由于64位存储格式是透明的，因此整个过程就像是只存在32位的整数一样。
对于有符号的整数，32位中的前31位用于表示整数的值。第32位用于表示数值的符号：0表示正数，1表示负数。这个表示符号的位叫做符号位，符号位的值决定了其他位数值的格式。其中，正数以纯二进制格式存储，31位中的每一位都表示2的幂。第一位（叫做位0）表示 ，以此类推。没有用到的位以0填充，即忽略不计。例如，数值18的二进制表示是00000000000000000000000000010010，或者更简洁的10010。这是5个有效位，这5位本身就决定了实际的值。
负数同样以二进制码存储，但使用的格式是二进制补码。计算一个数值的二进制补码，需要经过下列3个步骤：
（1） 求这个数值绝对值的二进制码（例如，要求-18的二进制补码，先求18的二进制码）；
（2） 求二进制反码，即将0替换为1，将1替换为0；
（3） 得到的二进制反码加1。
按照上面三个步骤求-18的补码，首先就要求的18的二进制码，即：
0000 0000 0000 0000 0000 0000 0001 0010
然后，求其二进制反码，即0和1互换：
1111 1111 1111 1111 1111 1111 1110 1101
最后二进制反码加1：
1111 1111 1111 1111 1111 1111 1110 1110
这样就得到了-18的二进制表示，即11111111 1111 1111 1111 1111 1110 1110。要注意的是，在处理有符号整数时，是不能访问位31的。
ECMAScript会尽力向我们隐藏所有这些信息。换句话说，在以二进制字符串形式输出一个负数时，我们看到的只是这个负数绝对值的二进制码前面加上了一个负号。如：
var num = -18;
alert(num.toString(2));//-10010
要把数值-18转换成二进制字符串时，得到的结果是”-10010”。这说明转换过程理解了二进制补码并将其以更合乎逻辑的形式展现了出来。
在ECMAScript中，当对数值应用位操作符时，后台会发生如下转换过程：64位的数值被转换成32位数值，然后执行位操作，最后再将32位的结果转换成64位数值，这样，表面上看起来好像是在操作32位数值，就跟在其他语言中以类似方式执行二进制操作一样。但这个转换过程也导致了一个严重的副效应，即在对特殊的NaN和Infinity值应用为操作符时，这两个值都会被当成0来处理。
如果对非数值应用位操作符，会先使用Number()函数将该值转换为一个数值（自动完成），然后再应用位操作。得到的结果将是一个数值。
按位非（NOT）
按位非操作符由一个波浪线（~）表示，执行按位非的结果就是返回数值的反码。按位非是ECMAScript操作符中少数几个与二进制计算有关的操作符之一。如：
var num1 = 25;//二进制00000000000000000000000000011001
var num2 = ~num1;//二进制11111111111111111111111111100110
alert(num2);//”-26”
这里得到-26，验证了按位非操作的本质：操作数的负值减1。
按位与（AND）
按位与操作符由一个和号字符（&）表示，它有两个操作符数。从本质上讲，按位与操作就是将两个数值的每一位对齐，然后对每一位进行AND操作，也就是只有两个数值的该位同时为1，结果中的该位才为1，否则为0。如：
alert(25&3);//1
该语句的底层计算：
25 二进制：0000 0000 00000000 0000 0000 0001 1001
3 二进制：0000 00000000 0000 0000 0000 0000 0011
-----------------------------------------------------------------------------
AND = 0000 0000 0000 0000 0000 0000 0000 0001
按位或（OR）
按位或操作符由一个竖线符号（|）表示，同样也有两个操作数。在有一个味是1的情况下就返回1，而只有在两个位都是0的情况下才返回0。
按位异或（XOR）
按位异或操作符由一个插入符号（^）表示，也有两个操作数。按位异或与按位或的不同之处在于，这个操作在两个数值对应位上只有一个1时才返回1，如果对应的两位都是1或都是0，则返回0。
左移
左移操作符由两个小于号（<<）表示，这个操作符会将数值的所有位向左移动指定的位数。比如，如果将数值2（二进制码为10）向左移动5位，结果就是64（二进制码为1000000）。
注意，左移不会影响操作数的符号位。换句话说，如果将-2向左移动5位，结果将是-64，而非64。
有符号的右移
有符号的右移操作符由两个大于号（>>）表示，这个操作符会将数值向由移动，但保留符号位。有符号的右移操作与左移操作七号相反，即如果将64向右移动5位，结果变回2。
无符号右移
无符号右移操作符由3个大于号（>>>）表示，这个操作符会将数值的所有32位都向右移动。对正数来说，无符号右移的结果与有符号右移相同。如果将64无符号右移5位，结果仍为2。但是对于负数来说，情况就不一样了。首先，无符号右移是以0来填充空位，而不是像有符号右移那样以符号位的值来填充空位。随意，对正数的无符号右移与有符号右移结果相同，但对负数的结果就不一样了。其次，无符号右移操作会把负数的二进制码当成正数的二进制码。而且，由于负数以其绝对值的二进制补码形式表示，因此就会导致无符号右移后的结果非常之大。
布尔操作符
在一门编程语言中，布尔操作符的重要性堪比相等操作符。如果没有测试两个值关系的能力，那么诸如if…else个循环之类的语句就不会有用武之地了。布尔操作符一共有3个：非（NOT）、与（AND）、或（OR）。
逻辑非
逻辑非由一个叹号（!）表示，可以应用于ECMAScript中的任何值。无论这个值是什么数据类型，这个操作符都会返回一个布尔值。逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。下表中列出了逻辑非操作符返回的结果：
|
操作数 |
返回值 |
|
对象 |
false |
|
空字符串 |
true |
|
非空字符串 |
false |
|
0 |
true |
|
任意非0数值（包括Infinity） |
false |
|
null |
true |
|
NaN |
true |
|
undefined |
true |
逻辑非操作符也可以用于将一个值转换为与其对应的布尔值。而同时使用两个逻辑非操作符，实际上就会模拟Boolean()转型函数的行为，其中，第一个逻辑非操作会基于无论什么操作数返回一个布尔值，而第二个逻辑非操作则对该布尔值求反，于是就得到了这个值真正对应的布尔值。当然，最终结果与对这个值使用Boolean()函数相同。
逻辑与
逻辑与操作符由两个和号（&&）表示，有两个操作数，逻辑与的真值表如下所示：
|
第一个操作数 |
第二个操作数 |
结果 |
|
true |
true |
true |
|
true |
false |
false |
|
false |
true |
false |
|
false |
false |
false |
逻辑与操作可以应用于任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；此时，它遵循下列规则：
如果第一个操作数是对象，则返回第二个操作数；
如果第二个操作数是对象，则只有在第一个操作数的求值结果为true的情况下才会返回该对象；
如果两个操作数都是对象，则返回第二个操作数；
如果有一个操作数是null，则返回null；
如果有一个操作数是NaN，则返回NaN；
如果有一个操作数是undefined，则返回undefined。
逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。对于逻辑与操作而言，如果第一个操作数是false，则无论第二个操作数是什么值，结果都不再可能是true了。
逻辑或
逻辑或操作符由两个竖线符号（||）表示，有两个操作数，逻辑或的真值表如下：
|
第一个操作数 |
第二个操作数 |
结果 |
|
true |
true |
true |
|
true |
false |
true |
|
false |
true |
true |
|
false |
false |
false |
与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循下列规则：
如果第一个操作数是对象，则返回第一个操作数；
如果第一个操作数的求值结果为false，则返回第二个操作数；
如果两个操作数都是对象，则返回第一个操作数；
如果两个操作数都是null，则返回null；
如果两个操作数都是NaN，则返回NaN；
如果两个操作数都是undefined，则返回undefined。
与逻辑与操作符相似，逻辑或操作符也是短路操作符。也就是说，如果第一个操作数的求值结果为true，就不会对第二个操作数求值了。
乘性操作符
ECMAScript定义了3个乘性操作符：乘法、除法和求模。这些操作符与Java、C或者Perl中的相应操作符用途类似，只不过在操作数为非数值的情况下会执行自动的类型转换。如果参与乘法计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。也就是说，空字符串将被当作0，布尔值true将被当作1。
乘法
乘法操作符由一个星号（*）表示，用于计算两个数值的乘积。其语法类似与C，在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：
如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果有一个操作数有负号，那么结果就是负数。如果乘积超过了ECMAScript数值的表示范围，则返回Infinity或-Infinity；
如果有一个操作数是NaN，则发结果是NaN；
如果是Infinity与0相乘，则结果是NaN；
如果是Infinity与非0数值相乘，结果是Infinity或-Infinity，取决于有符号操作数的符号；
如果是Infinity与Infinity相乘，结果是Infinity；
如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。
除法
除法操作符由一个斜线符号（/）表示，执行第二个操作数除第一个操作数的计算。与乘法操作类似，除法操作符对特殊的值也有特殊的处理规则：
如果操作数都是数值，执行常规的触发计算，即两个正数或两个负数相除的结果还是正数，而如果只有一个操作数有负号，那么结果就是负数。如果商超过了ECMAScript数值的表示范围，则返回Infinity或-Infinity；
如果有一个操作数是NaN，则结果是NaN；
如果是Infinity被Infinity除，则结果是NaN；
如果是零被零除，则结果是NaN；
如果是非零的有限数被零除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
如果是Infinity被任何非零数值除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。
求模
求模（余数）操作由一个百分号（%）表示，与另外两个乘性操作符类似，求模操作符会按照下列特殊规则来处理特殊的值：
如果操作数都是数值，执行常规的触发计算，返回取得的余数；
如果被除数是无穷大值而除数是有限大的数值，则结果是NaN；
如果被除数是有限大的数值而除数是零，则结果是NaN；
如果是Infinity被Infinity除，则结果是NaN；
如果被除数是有限大的数值而除数是无穷大的数值，则记过是被除数；
如果被除数是零，则结果是零；
如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。
加性操作符
加法和减法这两个加性操作符应该说是编程语言中最简单的算术操作符了。但是在ECMAScript中，这两个操作符却有一系列的特殊行为。与乘性操作符类似，加性操作符也会在后台转换不同的数据类型，然而，对于加性操作符而言，相应的转换规则还稍微有点复杂。
加法
如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：
如果有一个操作数是NaN，则结果是NaN；
如果是Infinity加Infinity，则结果是Infinity；
如果是-Infinity加-Infinity，则结果是-Infinity；
如果是Infinity加-Infinity，则结果是NaN；
如果是+0加+0，则结果是+0；
如果是-0加-0，则结果是-0；
如果是+0加-0，则结果是+0。
不过，如果有一个操作数是字符串，那么就要应用如下规则：
如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来；
如果只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来。
如果有一个操作数是对象、数值或布尔值，则调用它们的toString()方法取得相应的字符串值，然后再应用前面关于字符串的规则。对于undefined和null，则分别调用String()函数并取得字符串”undefined”和”null”。
减法
减法操作符（-）是另一个极为常见的操作符，与加法操作符类似，ECMAScript中的减法操作符在处理各种数据类型转换时，需要遵循一些特殊规则：
如果两个操作数都是数值，则执行常规的算术减法操作并返回结果；
如果有一个操作数是NaN，则结果是NaN；
如果是Infinity减Infinity，则结果是NaN；
如果是-Infinity减-Infinity，则结果是NaN；
如果是Infinity减-Infinity，则结果是Infinity；
如果是-Infinity减Infinity，则结果是-Infinity；
如果是+0减+0，则结果是+0；
如果是+0减-0，则结果是-0；
如果是-0减-0，则结果是+0；
如果有一个操作数是字符串、布尔值、null或undefined，则先在后台调用Number()函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果就是NaN；
如果有一个操作数是对象，则调用对象的valueof()方法以取得该对象的数值。如果得到的值是NaN，则减法的结果就是NaN。如果对象没有valueof()方法，则调用其toString()方法并将得到的字符串转换为数值。
关系操作符
小于（<）、大于（>）、小于等于（<=）和大于等于（>=）这几个关系操作符用于对两个值进行比较，比较的规则与数学中的规则一样。这几个操作符都返回一个布尔值。
与ECMAScript中的其他操作符一样，当关系操作符的操作数使用了非数值时，也要进行数据转换或完成某些奇怪的操作：
如果两个操作数都是数值，则执行数值比较。
如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
如果一个操作数是数值，则将另一个操作数转换为一个数值，日在年后执行数值比较。
如果一个操作数是对象，则调用这个对象的valueof()方法，用得到的结果按照前面的规则执行比较。如果对象没有valueof()方法，则调用toString()方法，并用得到的结果根据前面的规则执行比较。
如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
在使用关系比较操作符比较两个字符串时，会执行一种奇怪的操作。很多人都会认为，在比较字符串值时，小于的意思是“在字母表中的位置靠前”，而大于则意味着“在字母表中的位置靠后”，但实际上完全不是那么回事。在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。经过这么一番比较之后，再返回一个布尔值。由于大写字母的字符编码全部小于小写字母的字符编码，因此就会看到如下所示的奇怪现象：
var result = “Brick”< “alphabet”;//true
在这个例子中，字符串”Brick”被认为小于字符串”alphabet”。原因是字母B的字符编码为66，而字母a的字符编码是97。如果真正按字母表顺序比较字符串，就必须把两个操作数转换为相同的大小写形式（全部大写或全部小写），然后再执行比较，如下所示：
var result = “Brick”.toLowerCase()< “alphabet”.toLowerCase();//false
通过将两个操作数都转换为小写形式，就可以得出”alphabet”按字母表顺序排在”Brick”之前的正确判断了。
另一种奇怪的现象发生在比较两个数字字符串的情况下，比如下面这个例子：
var result = “23”< “3”;//true
确实，当比较字符串”23”是否小于”3”时，结果居然是true。这是因为两个操作数都是字符串，而字符串比较的是字符编码(“2”的字符编码是50，而”3”的字符编码是51)。不过，如果像下面例子中一样，将一个操作数改为数值，比较的结果就正常了：
var result = “23”< 3;//false
此时，字符串”23”会被转换成数值23，然后再与3进行比较，因此就会得到合理的结果。在比较数值和字符串时，字符串都会被转换成数值，然后再以数值方式与另一个数值比较。当然，这个规则对前面的例子是适用的。可是当另一个操作数不能转换为数值时，结果就会是false，如：
var result = “a”< 3;//false
原因是”a”被转换成NaN，而NaN与任何操作数进行比较，结果都会返回false。按照常理，如果一个值不小于另一个值，则一定是大于或等于那个纸。然而，在与NaN进行比较时，这条规则是不适用的，结果否会返回false。
相等操作符
确定两个变量是否相等是编程中的一个非常重要的操作。在i比较字符串、数值和布尔值的相等性时，问题还比较简单。但在涉及到对象的比较时，问题就变得复杂了。最早的ECMAScript中的相等和不等操作会在执行比较之前，先将对象转换成相似的类型。后来，有人提出了这种转换到底是否合理的质疑。最后，ECMAScript的解决方案就是提供两组操作符：相等和不相等——先转换再比较，全等和不全等——仅比较而不转换。
相等和不相等
ECMAScript中的相等操作符由两个等号（==）表示，如果两个操作数相等，则返回true。而不相等操作符由叹号后跟等号（!=）表示，如果两个操作数不相等，则返回true。这两个操作符都会先转换操作数（通常称为强制转型），然后再比较它们的相等性。
在转换不同的数据类型时，相等和不相等操作符都会遵循下列基本规则：
如果有一个操作数是布尔值，则在比较之前先将其转换为数值——false转换为0，而true转换为1；
如果一个操作符是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值；
如果一个操作数是对象，另一个操作数不是，则调用对象的valueof()方法，用得到的基本类型值按照前面的规则进行比较；
这两个操作符在进行比较时则要遵循下列规则。
（1） null和undefined是相等的。
（2） 要比较相等性之前，不能将null和undefined转换成其他任何值。
（3） 如果有一个操作数是NaN，则相等操作符返回false，而不相等操作符返回true。重要提示：即使两个操作数都是NaN，相等操作符也返回false，因为按照规则，NaN不等于NaN。
（4） 如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回true；否则返回false。
全等和不全等
除了在比较之前不转换操作数之外，全等和不全等操作符与相等和不相等操作符没有什么区别。全等操作符由3个等于号（===）表示，它旨在两个操作数未经过转换就相等的情况下返回true。如下面的例子所示：
var result1 = (“55”==55);//true，因为转换后相等
var result2 = (“55”===55);//false,因为不同的数据类型不相等
不全等操作符由一个叹号后跟两个等号（!==）表示，它在两个操作数未经转换就不相等的情况下返回true。
条件操作符（三元操作符）
条件操作符应该算是ECMAScript中最灵活的一种操作符了，而且它遵循与Java中的条件操作符相同的语法形式：
variable =boolean_expression ? true_value : false_value;
本质上，这行代码的含义就是基于对boolean_expression求值的结果，决定给变量variable赋什么值。如果求值结果为true，则给变量variable赋true_value值；如果求值结果为false，则给变量variable赋false_value值。
赋值操作符
简单的复制操作符由等于号（=）表示，其作用就是把右侧的值赋给左侧的变量。如果在等于号的前面再添加乘性操作符、加性操作符或位操作符，就可以完成复合赋值操作。如：
var num = 10;
num += 10;//等同于 num = num+ 10;
每个主要算术操作符（以及个别的其他操作符）都有对应的复合赋值操作符：
(1) 乘/赋值（*=）;
(2) 除/赋值（/=）;
(3) 模/赋值（%=）;
(4) 加/赋值（+=）;
(5) 除/赋值（-=）;
(6) 左移赋值（<<=）;
(7) 有符号右移/赋值（>>=）;
(8) 无符号右移/赋值（>>>=）;
逗号操作符
使用逗号操作符可以在一条语句中执行多个操作，如下面的例子所示：
var num1 =1,num2 = 2,num3 = 3;
逗号操作符多用于声明多个变量；除此之外，逗号操作符还可以用于赋值语句。在用于赋值语句时，逗号操作符总返会返回表达式中的最后一项，如：
var num =(5,1,4,8,0);//num的值为0
由于0是表达式中的最后一项，因此num的值就是0。虽然逗号的这种使用方式并不常见，但这个例子可以帮我们理解逗号的这种行为。
语句
ECMA-262规定了一组语句（也称为流控制语句）。从本质上看，语句定义了ECMAScript中的主要语法，语句通常使用一或多个关键字来完成给定任务。语句可以很简单，例如通知函数退出；也可以比较复杂，例如指定重复执行某个命令的次数。
if语句、do-while语句、while语句、for语句。
for-in语句
for-in语句是一种精准的迭代语句，可以用来枚举对象的属性。以下是for-in语句的语法：
for(property inexpression) statement
下面是一个例子：
/*在js中获得对象的所有可读属性*/
function displayProp(obj){
var names="";
for(var name in obj){
names+=name+": "+obj[name]+", ";
}
return names;
}
ECMAScript对象的属性没有顺序。因此通过for-in循环输出的属性名的顺序是不可预测的。具体来讲，所有属性都会被返回一次，但返回的先后次序可能会因浏览器而异。
但是，如果表示要迭代的对象的变量值为null或undefined，for-in语句会抛出错误。ECMAScript5更正了这一行为；对这种情况不再抛出错误，而只是不执行循环体。为了保证最大限度的兼容性，建议在使用for-in循环之前，先监测确认该对象的值不是null或undefined。
label语句
使用label语句可以在代码中添加标签，以便将来使用。以下是label语句的语法：
label:statement
如：
start:for(var i= 0 i < count ; i++){
alert(i);
}
break和continue语句
break和continue语句用于在循环中精确地控制代码的执行。其中，break语句会立即退出循环，强制继续执行循环后面的语句。而continue语句虽然也是立即退出循环，但退出循环后会从循环的顶部继续执行，也就是跳出本次循环并立即进入下一次循环。如：
for(var i = 1 ; i < 10 ; i++){
if(i%3==0){
alert(i);//3,6,9
continue;
}
}
上面的例子会弹出三次警告框3，6，9；把continue替换成break之后，会发现，只弹出了一次警告框3。
break和continue语句都可以域label语句联合使用，从而返回代码中特定的位置。这种联合使用的情况多发生在循环嵌套的情况下，如：
var num = 0;
outermost:
for(var i = 0 ; i < 10 ; i++){
for(var j = 0 ; j < 10 ; j++){
if(i == 5 && j == 5){
break outermost;
}
num++;
}
}
alert(num);//55
在这个例子中，outermost标签表示外部的for语句，如果每个循环正常执行10此，则num++语句就会正常执行100次。欢聚换说，如果两个循环都自然结束，num的值应该是100。但内部循环中的break语句带了一个参数：要返回的标签。添加这个标签的结果将导致break语句不仅会退出内部的for语句（即，使用变量j的循环），而且也会退出外部的for语句（即，使用变量i的循环）。为此，当变量i和j都等于5时，num的值正好是55.同样，continue语句也可以像这样与label语句联用，如：
var num = 0;
outermost:
for(var i = 0 ; i < 10 ; i++){
for(var j = 0 ; j < 10 ; j++){
if(i == 5 && j == 5){
continue outermost;
}
num++;
}
}
alert(num);//95
在这种情况下，continue语句会强制继续执行循环——退出内部循环，执行外部循环。当j是5时，continue语句执行，而这也意味着内部循环少执行了5次，因此num的结果是95。
with语句
with语句的作用是将代码的作用域设置到一个特定的对象中。with语句的语法如下：
with(expression)statement;
定义with语句的目的主要是为了简化多次编写同一个对象的工作，如：
var qs =location.search.substring(1);
var hostName =location.hostname;
var url =location.location.href;
上面几行代码都包含location对象。如果使用with语句，可以把上面的代码改写成如下所示：
with(location){
var qs =search.substring(1);
var hostName =hostname;
var url =href;
}
在重写后的例子中，使用with语句关联了location对象。这意味着在with语句的代码块内部，每个变量首先被认为是一个局部变量，而如果在局部环境中找不到该变量的定义，就会查询location对象中是否有同名的属性。如果发现了同名属性，则以location对象属性的值作为变量的值。
严格模式下不允许使用with语句，否则将视为语法错误。
由于大量使用with语句会导致性能下降，同时也会给调试代码造成困难，因此在开发大型应用时，不建议使用with语句。
switch语句
switch语句与if语句的关系最为密切，而且也是在其他语言中普遍使用的一种流控制语句。ECMAScript中switch语句的语法域其他基于C的语言非常接近，如下所示：
switch(expression){
casevalue:statement;
break;
casevalue:statement;
break;
casevalue:statement;
break;
default:statement;
}
switch语句中的每一种情形（case）的含义是：“如果表达式等于这个值（value），则执行后面的语句（statement）”。而break关键字会导致代码执行流跳出switch语句。如果省略break关键字就会导致执行完当前case后，继续执行下一个case。最后的default关键字在用在表达式不匹配前面任何一种情形的时候，执行机动代码。
虽然ECMAScript中的switch语句借鉴自其他语言，但这个语句也饿有自己的特色。首先，可以在switch语句中使用任何数据类型，无论是字符串，还是对象都没有问题。其次，每个case的值不一定是常量，可以是变量，甚至是表达式。
函数
函数对任何语言来说都是一个核心的概念。通过函数可以封装任意多条语句，而且可以在任何地方、任何时候调用执行。ECMAScript中的函数使用function关键字来声明，后跟一组参数以及函数体。基本语法：
function functionName(arg0 , arg1 , . . .,argN){
statements;
}
ECMAScript中的函数在定义时不必指定是否返回值。实际上，任何函数在任何时候都可以通过return语句后跟要返回的值来实现返回值。
推荐的做法是要么让函数始终都返回一个值，要么永远都不要返回值。否则，如果函数有时候返回值，有时候不返回值，会给调试代码带来不便。
严格模式对函数有一些限制：
(1) 不能把函数命名为eval或arguments；
(2) 不能把参数命名为eval或arguments；
(3) 不能出现两个命名参数同名的情况。
如果发生以上情况，就会导致语法错误，代码无法执行。
理解参数
ECMAScript函数的参数与大多数其他语言中函数的参数有所不同。ECMAScript函数不介意传递进来多少个参数，也不在乎传进来参数是什么数据类型。也就是说，即便你定义的函数只接收两个参数，在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数，而解析器永远不会有什么怨言。之所以会这样，原因是ECMAScript中的参数在背部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含那些参数（如果有参数的话）。如果这个数组中不包含任何元素，无所谓；如果包含多个元素，也没有问题。实际上，在函数体内可以通过arguments对象来访问这个参数数组，从而获取传递给函数的每一个参数。
其实，arguments对象只是与数组类似（它并不是Array的实例），因为可以使用方括号语法访问它的每一个元素（即第一个元素是arguments[0]，第二个元素是argument[1]，以此类推），使用length属性来确定传递进来多少个参数。
关于arguments的行为，有一点比较有意思。那就是它的值永远与对应命名参数的值保持同步。如：
function doAdd(num1 , num2){
arguments[1]= 10;
alert(arguments[0]+ num2);
}
每次执行这个doAdd()函数都会重写第二个参数，将第二个参数的值修改为10。因为arguments对象中的值会自动反映到对应的命名参数，所以修改arguments[1],也就修改了num2，结果它们的值都会变成10。不过，这并不是说读取这两个值会访问相同的内存空间；它们的内存空间是独立的，但它们的值会同步。但这种影响是单向的：修改命名参数不会改变arguments中对应的值。另外还要记住，如果只传递了一个参数，那么为arguments[1]设置的值不会反应到命名参数中。这是因为arguments对象的长度是由传入的参数个数决定的，不是由定义函数的命名参数的个数决定的。
关于参数还要记住最后一点：没有传递值的命名参数将自动被赋予undefined值。这就跟定义了变量但又没有初始化一样。
严格模式对如何使用arguments对象做出了一些限制。首先，像前面例子中那样的赋值会变得无效。也就是说，即使把arguments[1]设置为10，num2的值仍然还是undefined。其次，重写arguments的值会导致语法错误（代码将不会执行）。
ECMAScript中的所有参数传递的都是值，不可能通过引用传递参数。
没有重载
ECMAScript函数不能像传统意义上那样实现重载。而在其他语言（如Java）中，可以为一个函数编写两个定义，只要这两个定义的签名（接受的参数的类型和数量）不同即可。如前所述，ECMAScript函数没有签名，因为其参数是由包含零或多个值的数组来表示的。而没有函数签名，真正的重载是不可能做到的。
如果在ECMAScript中定义了两个名字相同的函数，则该名字只属于后定义的函数，如：
function add(a , b){
alert(a+ b);
}
function add(){
alert(“后面的add方法：” + (arguments[0]+ arguments[1]));
}
add(5 , 6);
运行后弹出警告框中的内容为：后面的add方法：11，而不是11，虽然完全按照第一个add的签名传递的参数，但仍是调用的后面的add方法。
标签：
原文地址：http://blog.csdn.net/goskalrie/article/details/51483376
