JS高级程序设计读书笔记（第三章基本概念）

本文链接：https://blog.csdn.net/xiaowei_innocence/article/details/88531313

第三章基本概念

严格模式

“use strict”;

数据类型

ECMAScript 中有 5 种简单数据类型（也称为基本数据类型）： Undefined 、 Null 、 Boolean 、 Number和 String 。还有 1种复杂数据类型—— Object ， Object 本质上是由一组无序的名值对组成的。

typeof

对一个值使用 typeof 操作符可能返回下列某个字符串：
 “undefined” ——如果这个值未定义；
 “boolean” ——如果这个值是布尔值；
 “string” ——如果这个值是字符串；
 “number” ——如果这个值是数值；
 “object” ——如果这个值是对象或 null ；
 “function” ——如果这个值是函数。

undefined

对于未初始化变量和未声明变量都会返回undefined，但是对未声明变量的任何其他操作（处理delete）都会报错。

null

undefined派生于null，所以undefined==null为true
无论在什么情况下都没有必要把一个变量的值显式地设置为 undefined ，可是同样的规则对 null 却不适用。换句话说，只要意在保存对象的变量还没有真正保存对象，就应该明确地让该变量保存 null 值。这样做不仅可以体现 null 作为空对象指针的惯例，而且也有助于进一步区分 null 和 undefined 。

Boolean

在这里插入图片描述

Number

除了以十进制表示外，整数还可以通过八进制（以 8 为基数）或十六进制（以 16 为基数）的字面值来表示。其中，八进制字面值的第一位必须是零（0），然后是八进制数字序列（0～7）。
八进制字面量在严格模式下是无效的，会导致支持的 JavaScript 引擎抛出错误。
对于那些极大或极小的数值，可以用 e 表示法（即科学计数法）表示的浮点数值表示。用 e 表示法表示的数值等于 e 前面的数值乘以 10 的指数次幂。
在默认情况下，ECMASctipt 会将那些小数点后面带有 6 个零以上的浮点数值转换为以 e 表示法表示的数值（例如，0.0000003 会被转换成 3e7）。
浮点数值的最高精度是 17 位小数。
在 ECMAScript中，任何数值除以 0会返回 NaN【但实际上只有 0除以 0 才会返回 NaN，正数除以 0 返回 Infinity，负数除以 0返回-Infinity。】，因此不会影响其他代码的执行。
NaN 本身有两个非同寻常的特点。首先，任何涉及 NaN 的操作（例如 NaN /10）都会返回 NaN ，这个特点在多步计算中有可能导致问题。其次， NaN 与任何值都不相等，包括 NaN 本身。例如，下面的代码会返回 false

 alert(NaN == NaN); //false

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() 方法，再测试返回值。

Number() 函数的转换规则如下。
 如果是 Boolean 值， true 和 false 将分别被转换为 1 和 0。
 如果是数字值，只是简单的传入和返回。
 如果是 null 值，返回 0。
 如果是 undefined ，返回 NaN 。
 如果是字符串，遵循下列规则：
 如果字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即 "1"会变成 1， “123” 会变成 123，而 “011” 会变成 11（注意：前导的零被忽略了）；
 如果字符串中包含有效的浮点格式，如 “1.1” ，则将其转换为对应的浮点数值（同样，也会忽略前导零）；
 如果字符串中包含有效的十六进制格式，例如 “0xf” ，则将其转换为相同大小的十进制整数值；
 如果字符串是空的（不包含任何字符），则将其转换为 0；
 如果字符串中包含除上述格式之外的字符，则将其转换为 NaN 。
 如果是对象，则调用对象的 valueOf() 方法，然后依照前面的规则转换返回的值。如果转换的结果是 NaN ，则调用对象的 toString() 方法，然后再次依照前面的规则转换返回的字符串值。

parseInt() 函数的转换规则如下。
用 parseInt() 转换空字符串会返回 NaN （ Number() 对空字符返回 0）。如
果第一个字符是数字字符， parseInt() 会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。例如， “1234blue” 会被转换为 1234，因为 “blue” 会被完全忽略。类似地， "22.5"会被转换为 22，因为小数点并不是有效的数字字符。

var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt(""); // NaN
var num3 = parseInt("0xA"); // 10（十六进制数）
var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); // 56（八进制数）
var num6 = parseInt("70"); // 70（十进制数）
var num7 = parseInt("0xf"); // 15（十六进制数）

在使用 parseInt() 解析像八进制字面量的字符串时，ECMAScript 3和 5 存在分歧。例如：
//ECMAScript 3 认为是 56（八进制），ECMAScript 5 认为是 70（十进制）【ES5没有解析八进制的能力】

var num = parseInt("070");

为了消除在使用 parseInt() 函数时可能导致的上述困惑，可以为这个函数提供第二个参数：转换时使用的基数（即多少进制）。

var num = parseInt("0xAF", 16); //175
var num1 = parseInt("AF", 16); //175
var num2 = parseInt("AF"); //NaN

var num1 = parseInt("10", 2); //2 （按二进制解析）
var num2 = parseInt("10", 8); //8 （按八进制解析）
var num3 = parseInt("10", 10); //10 （按十进制解析）
var num4 = parseInt("10", 16); //16 （按十六进制解析）

parseFloat() 函数的转换规则如下。
与 parseInt() 函数类似， parseFloat() 也是从第一个字符（位置 0）开始解析每个字符。而且也是一直解析到字符串末尾，或者解析到遇见一个无效的浮点数字字符为止。也就是说，字符串中的第一个小数点是有效的，而第二个小数点就是无效的了，因此它后面的字符串将被忽略。举例来说，“22.34.5” 将会被转换为 22.34。
除了第一个小数点有效之外，parseFloat() 与 parseInt() 的第二个区别在于它始终都会忽略前导的零。 parseFloat() 可以识别前面讨论过的所有浮点数值格式，也包括十进制整数格式。但十六进制格式的字符串则始终会被转换成 0。由于 parseFloat() 只解析十进制值，因此它没有用第二个参数指定基数的用法。最后还要注意一点：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后都是零）， parseFloat() 会返回整数。

var num1 = parseFloat("1234blue"); //1234 （整数）
var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
var num6 = parseFloat("3.125e7"); //31250000

String

数值、布尔值、对象和字符串值（没错，每个字符串也都有一个 toString() 方法，该方法返回字符串的一个副本）都有 toString() 方法。但 null 和 undefined 值没有这个方法。
多数情况下，调用 toString() 方法不必传递参数。但是，在调用数值的 toString() 方法时，可以传递一个参数：输出数值的基数。默认情况下， toString() 方法以十进制格式返回数值的字符串表示。而通过传递基数， toString() 可以输出以二进制、八进制、十六进制，乃至其他任意有效进制格式表示的字符串值。

var num = 10;
alert(num.toString()); // "10"
alert(num.toString(2)); // "1010"
alert(num.toString(8)); // "12"
alert(num.toString(10)); // "10"
alert(num.toString(16)); // "a"

在不知道要转换的值是不是 null 或 undefined 的情况下，还可以使用转型函数 String() ，这个
函数能够将任何类型的值转换为字符串。 String() 函数遵循下列转换规则：
 如果值有 toString() 方法，则调用该方法（没有参数）并返回相应的结果；
 如果值是 null ，则返回 “null” ；
 如果值是 undefined ，则返回 “undefined” 。

var value1 = 10;
var value2 = true;
var value3 = null;
var value4;
alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"

Object

Object 的每个实例都具有下列属性和方法。
 constructor ：保存着用于创建当前对象的函数。对于前面的例子而言，构造函数（constructor）就是 Object() 。
 hasOwnProperty(propertyName) ：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名（ propertyName ）必须以字符串形式指定（例如： o.hasOwnProperty(“name”) ）。
 isPrototypeOf(object) ：用于检查传入的对象是否是传入对象的原型（第 5 章将讨论原型）。
 propertyIsEnumerable(propertyName) ：用于检查给定的属性是否能够使用 for-in 语句（本章后面将会讨论）来枚举。与 hasOwnProperty() 方法一样，作为参数的属性名必须以字符串形式指定。
 toLocaleString() ：返回对象的字符串表示，该字符串与执行环境的地区对应。
 toString() ：返回对象的字符串表示。
 valueOf() ：返回对象的字符串、数值或布尔值表示。通常与 toString() 方法的返回值相同。
由于在 ECMAScript 中 Object 是所有对象的基础，因此所有对象都具有这些基本的属性和方法。

一元操作符

++与–
前置：执行前置递增和递减操作时，变量的值都是在语句被求值以前改变的
后置：递增和递减操作是在包含它们的语句被求值之后才执行的

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2; // 等于 21
var num4 = num1 + num2; // 等于 21

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2; // 等于 22
var num4 = num1 + num2; // 等于 21

还可以用于字符串、布尔值、浮点数值和对象。在应用于不同的值时，递增和递减操作符遵循下列规则。
 在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减 1 的操作。字符串变量变成数值变量。
 在应用于一个不包含有效数字字符的字符串时，将变量的值设置为 NaN （第 4 章将详细讨论）。字符串变量变成数值变量。
 在应用于布尔值 false 时，先将其转换为 0 再执行加减 1 的操作。布尔值变量变成数值变量。
 在应用于布尔值 true 时，先将其转换为 1 再执行加减 1 的操作。布尔值变量变成数值变量。
 在应用于浮点数值时，执行加减 1 的操作。
 在应用于对象时，先调用对象的 valueOf() 方法（第 5 章将详细讨论）以取得一个可供操作的值。然后对该值应用前述规则。如果结果是 NaN ，则在调用toString() 方法后再应用前述规则。对象变量变成数值变量。

var s1 = "2";
var s2 = "z";
var b = false;
var f = 1.1;
var o = {
valueOf: function() {
return -1;
}
};
s1++; // 值变成数值 3
s2++; // 值变成 NaN
b++; // 值变成数值 1
f--; // 值变成 0.10000000000000009（由于浮点舍入错误所致）
o--; // 值变成数值-2

+与-
一元加操作符以一个加号（+）表示，放在数值前面，对数值不会产生任何影响，一元减操作符主要用于表示负数，如下面的例子所示：

var num = 25;
num = +num; // 仍然是 25
var num = 25;
num = -num; // 变成了-25

不过，在对非数值应用一元加操作符时，该操作符会像 Number() 转型函数一样对这个值执行转换。换句话说，布尔值 false 和 true 将被转换为 0 和 1，字符串值会被按照一组特殊的规则进行解析，而对象是先调用它们的 valueOf() 和（或） toString() 方法，再转换得到的值。在将一元减操作符应用于数值时，该值会变成负数（如上面的例子所示）。而当应用于非数值时，一元减操作符遵循与一元加操作符相同的规则，最后再将得到的数值转换为负数。

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
valueOf: function() {
return -1;
}
};
s1 = +s1; // 值变成数值 1
s2 = +s2; // 值变成数值 1.1
s3 = +s3; // 值变成 NaN
b = +b; // 值变成数值 0
f = +f; // 值未变，仍然是 1.1
o = +o; // 值变成数值-1

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
valueOf: function() {
return -1;
}
};
s1 = -s1; // 值变成了数值-1
s2 = -s2; // 值变成了数值-1.1
s3 = -s3; // 值变成了 NaN
b = -b; // 值变成了数值 0
f = -f; // 变成了-1.1
o = -o; // 值变成了数值 1

位操作符

按位非~NOT，按位与&AND，按位或|OR，按位异或^XOR
左移<<，有符号的右移>>，无符号的右移>>>

布尔操作符

非NOT与AND或OR
逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。也就是说，逻辑非操作符遵循下列规则：
 如果操作数是一个对象，返回 false ；
 如果操作数是一个空字符串，返回 true ；
 如果操作数是一个非空字符串，返回 false ；
 如果操作数是数值 0，返回 true ；
 如果操作数是任意非 0 数值（包括 Infinity ），返回 false ；
 如果操作数是 null ，返回 true ；
 如果操作数是 NaN ，返回 true ；
 如果操作数是 undefined ，返回 true 。

alert(!false); // true
alert(!"blue"); // false
alert(!0); // true
alert(!NaN); // true
alert(!""); // true
alert(!12345); // false

逻辑非操作符也可以用于将一个值转换为与其对应的布尔值。而同时使用两个逻辑非操作符，实际
上就会模拟 Boolean() 转型函数的行为。

逻辑与操作可以应用于任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；此时，它遵循下列规则：
 如果第一个操作数是对象，则返回第二个操作数；
 如果第二个操作数是对象，则只有在第一个操作数的求值结果为 true 的情况下才会返回该对象；
 如果两个操作数都是对象，则返回第二个操作数；
 如果有一个操作数是 null ，则返回 null ；
 如果有一个操作数是 NaN ，则返回 NaN ；
 如果有一个操作数是 undefined ，则返回 undefined 。
逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。
对于逻辑与操作而言，如果第一个操作数是 false ，则无论第二个操作数是什么值，结果都不再可能是true 了。

var found = true;
var result = (found && someUndefinedVariable); // 这里会发生错误
alert(result); // 这一行不会执行
var found = false;
var result = (found && someUndefinedVariable); // 不会发生错误
alert(result); // 会执行（"false"）

与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循下列规则：
 如果第一个操作数是对象，则返回第一个操作数；
 如果第一个操作数的求值结果为 false ，则返回第二个操作数；
 如果两个操作数都是对象，则返回第一个操作数；
 如果两个操作数都是 null ，则返回 null ；
 如果两个操作数都是 NaN ，则返回 NaN ；
 如果两个操作数都是 undefined ，则返回 undefined 。

var found = true;
var result = (found || someUndefinedVariable); // 不会发生错误
alert(result); // 会执行（"true"）
var found = false;
var result = (found || someUndefinedVariable); // 这里会发生错误
alert(result); // 这一行不会执行

乘性操作符

乘法*
在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：
 如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而
如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了 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() 将其转换为数值，然后再应用上面的规则。

加性操作符

加法+
如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：
 如果有一个操作数是 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” 。

var result1 = 5 + 5; // 两个数值相加
alert(result1); // 10
var result2 = 5 + "5"; // 一个数值和一个字符串相加
alert(result2); // "55"
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + num1 + num2;
alert(message); // "The sum of 5 and 10 is 510"
var message = "The sum of 5 and 10 is " + (num1 + num2);
alert(message); //"The sum of 5 and 10 is 15"

减法-
与加法操作符类似，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()方法并将得到的字符串转换为数值。

var result1 = 5 - true; // 4，因为 true 被转换成了 1
var result2 = NaN - 1; // NaN
var result3 = 5 - 3; // 2
var result4 = 5 - ""; // 5，因为"" 被转换成了 0
var result5 = 5 - "2"; // 3，因为"2"被转换成了 2
var result6 = 5 - null; // 5，因为 null 被转换成了 0

关系操作符

小于（<）、大于（>）、小于等于（<=）和大于等于（>=）
以下就是相应的规则。
 如果两个操作数都是数值，则执行数值比较。
 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。
 如果一个操作数是对象，则调用这个对象的 valueOf() 方法，用得到的结果按照前面的规则执行比较。如果对象没有 valueOf() 方法，则调用 toString() 方法，并用得到的结果根据前面的规则执行比较。
 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。

var result = "Brick" < "alphabet"; //true
var result = "23" < "3"; //true
var result = "23" < 3; //false
var result = "a" < 3; // false，因为"a"被转换成了 NaN
var result1 = NaN < 3; //false
var result2 = NaN >= 3; //false

相等操作符

在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：
 如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值—— false 转换为 0，而
true 转换为 1；
 如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值；
 如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf() 方法，用得到的基本类型值按照前面的规则进行比较；这两个操作符在进行比较时则要遵循下列规则。
 null 和 undefined 是相等的。
 要比较相等性之前，不能将 null 和 undefined 转换成其他任何值。
 如果有一个操作数是 NaN ，则相等操作符返回 false ，而不相等操作符返回 true 。重要提示：即使两个操作数都是 NaN ，相等操作符也返回 false ；因为按照规则， NaN 不等于 NaN 。
 如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回 true ；否则，返回 false 。
在这里插入图片描述
全
等操作符由 3 个等于号（ === ）表示，它只在两个操作数未经转换就相等的情况下返回 true ，如下面的例子所示：

var result1 = ("55" == 55); //true，因为转换后相等
var result2 = ("55" === 55); //false，因为不同的数据类型不相等

不全等操作符由一个叹号后跟两个等于号（ !== ）表示，它在两个操作数未经转换就不相等的情况下返回 true 。例如：

var result1 = ("55" != 55); //false，因为转换后相等
var result2 = ("55" !== 55); //true，因为不同的数据类型不相等
null === undefined // false

条件操作符

variable = boolean_expression ? true_value : false_value;

赋值操作符

逗号操作符

使用逗号操作符可以在一条语句中执行多个操作，如下面的例子所示：
var num1=1, num2=2, num3=3;
逗号操作符多用于声明多个变量；但除此之外，逗号操作符还可以用于赋值。在用于赋值时，逗号操作符总会返回表达式中的最后一项，如下面的例子所示：
var num = (5, 1, 4, 8, 0); // num 的值为 0

语句

for for-in

for(var i=0;i<10;i++){}
console.log(i);//10
//for-in 语句是一种精准的迭代语句，可以用来枚举对象的属性
for (var propName in window) {
document.write(propName);
}
//ECMAScript 对象的属性没有顺序。因此，通过 for-in 循环输出的属性名的顺序是不可预测的。
//具体来讲，所有属性都会被返回一次，但返回的先后次序可能会因浏览器而异。

switch
虽然 ECMAScript 中的 switch 语句借鉴自其他语言，但这个语句也有自己的特色。首先，可以在switch 语句中使用任何数据类型（在很多其他语言中只能使用数值），无论是字符串，还是对象都没有问题。其次，每个 case 的值不一定是常量，可以是变量，甚至是表达式。

switch ("hello world") {
case "hello" + " world":
alert("Greeting was found.");
break;
case "goodbye":
alert("Closing was found.");
break;
default:
alert("Unexpected message was found.");
}

var num = 25;
switch (true) {
case num < 0:
alert("Less than 0.");
break;
case num >= 0 && num <= 10:
alert("Between 0 and 10.");
break;
case num > 10 && num <= 20:
alert("Between 10 and 20.");
break;
default:
alert("More than 20.");
}

ECMAScript 函数的参数与大多数其他语言中函数的参数有所不同。ECMAScript 函数不介意传递进来多少个参数，也不在乎传进来参数是什么数据类型。也就是说，即便你定义的函数只接收两个参数，在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数，而解析器永远不会有什么怨言。之所以会这样，原因是 ECMAScript 中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含哪些参数（如果有参数的话）。如果这个数组中不包含任何元素，无所谓；如果包含多个元素，也没有问题。实际上，在函数体内可以通过 arguments 对象来访问这个参数数组，从而获取传递给函数的每一个参数。
关于 arguments 的行为，还有一点比较有意思。那就是它的值永远与对应命名参数的值保持同步。
关于参数还要记住最后一点：没有传递值的命名参数将自动被赋予 undefined 值

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

严格模式对如何使用 arguments 对象做出了一些限制。首先，像前面例子中那样的赋值会变得无效。也就是说，即使把 arguments[1] 设置为 10 ， num2 的值仍然还是 undefined 。其次，重写arguments 的值会导致语法错误（代码将不会执行）。

没有重载

如果在 ECMAScript中定义了两个名字相同的函数，则该名字只属于后定义的函数。

小结

JavaScript 的核心语言特性在 ECMA-262 中是以名为 ECMAScript 的伪语言的形式来定义的。ECMAScript 中包含了所有基本的语法、操作符、数据类型以及完成基本的计算任务所必需的对象，但没有对取得输入和产生输出的机制作出规定。理解 ECMAScript 及其纷繁复杂的各种细节，是理解其在Web 浏览器中的实现——JavaScript 的关键。目前大多数实现所遵循的都是 ECMA-262 第 3 版，但很多
也已经着手开始实现第 5 版了。以下简要总结了 ECMAScript 中基本的要素。
 ECMAScript 中的基本数据类型包括 Undefined 、 Null 、 Boolean 、 Number 和 String 。
 与其他语言不同，ECMScript 没有为整数和浮点数值分别定义不同的数据类型， Number 类型可用于表示所有数值。
 ECMAScript 中也有一种复杂的数据类型，即 Object 类型，该类型是这门语言中所有对象的基础类型。
 严格模式为这门语言中容易出错的地方施加了限制。
 ECMAScript 提供了很多与 C 及其他类 C 语言中相同的基本操作符，包括算术操作符、布尔操作符、关系操作符、相等操作符及赋值操作符等。
 ECMAScript 从其他语言中借鉴了很多流控制语句，例如 if 语句、 for 语句和 switch 语句等。ECMAScript 中的函数与其他语言中的函数有诸多不同之处。
 无须指定函数的返回值，因为任何 ECMAScript 函数都可以在任何时候返回任何值。
 实际上，未指定返回值的函数返回的是一个特殊的 undefined 值。
 ECMAScript 中也没有函数签名的概念，因为其函数参数是以一个包含零或多个值的数组的形式传递的。
 可以向 ECMAScript 函数传递任意数量的参数，并且可以通过 arguments 对象来访问这些参数。
 由于不存在函数签名的特性，ECMAScript 函数不能重载。