Javascript基础概念 > 一些笔记（持续更新）（一）

Javascript基础概念 > 一些笔记

新手菜鸟一枚，刚开始学习前端，在学习Javascript的时候遇到的一些自己可能会忘记的东西，在此记录，激励以后的自己可以经常巩固翻阅……..

目录

---

基础概念

命名

ECMAScript标识符（即变量名）按照惯例一般采用驼峰大小写格式。例如：

myScript
doSomethingImportant

---

严格模式

要在整个脚本中启用ECMAScript 5 引入的严格模式（strict mode）时，可以在顶部添加如下代码：

“use strict”

也可以指定函数在严格模式下执行：

function doSomething() {
    "use strict";
    //函数体
}

注意：在严格模式下，一些相同的代码可以得到和非严格模式下不同的结果，如下（2018年腾讯前端笔试题）：

var a = 5;
(function() {
    var a = b = 3;
})();
console.log(a);
console.log(b);

上述代码得到结果为：5，3。（其中因为b前没有var声明，因此会被当做全局变量）
而如果上述代码前添加一行 “use strict”：

"use strict";
var a = 5;
(function() {
    var a = b = 3;
})();
console.log(a);
console.log(b);

则会抛出以下异常：

b is not defined.

因此在严格模式下，全局变量必须显示声明。
除此之外，严格模式下 this 的概念也与非严格模式下不同，如下：

"use strict";
console.log("=".repeat(30));
function test() {
    this.b = 1;
    console.log(this.b);
}
/*test();*/    // *** 报错 TypeError: Cannot set property 'b' of undefined.
               // 严格模式下使用构造函数时如果没有new，this不会指向全局对象，而是报错
new test();    // 正常显示1

这种情况会报错，因为严格模式下，this指向调用该方法的对象，也即.或[]前面的对象，但目前找不到。

之后还会自己重新整理严格模式下语法和行为的改变，先留一个前辈整理的 传送门 ，感谢前辈~

---

变量

ECMAScript的变量是松散类型的，定义变量时使用 var 操作符。

松散类型： 可以用来保存任何类型的数据。

使用 var 操作符定义的变量将成为定义该变量的作用域中的局部变量。若省略 var ，则会创建全局变量。如下：

function test() {
    var msg = "Hi";    //局部变量
    newMsg = "Hello";  //全局变量
}
test();
alert(msg);     //错误 X
alert(newMsg);  //正确 √

同样可以用一个语句定义多个变量，用逗号隔开即可：

var msg = "hi",
    found = false,
    age = 29;

---

数据类型

共6种。其中包括 5 种 简单数据类型

Undefined, Null, Number, String, Boolean

和 1 种 复杂数据类型

Object： 对应的是一个对象或者null。（null被认为是一个空的对象引用。）

使用 typeof 可以得到给定变量的数据类型，如下：

var msg0 = "some string";
alert(typeof msg0);
alert(typeof(msg0));
alert(typeof 45);

var msg = null;
var msg1;
alert(typeof null);   //object
alert(typeof msg);    //object
alert(typeof msg1);   //undefined

typeof 操作符的操作数可以是变量，也可以是数值字面量。此外，typeof是一个操作符而不是一个函数，因此圆括号不是必须的。

1. Undefined类型

只有一个值，即特殊的undefined。使用var声明变量但未对其加以初始化时，这个变量的值就是undefined，例如：

var msg;
var msg1 = undefined;      //没必要
//var msg2;

alert(msg == undefined);   //true
alert(msg1 == undefined);  //true
alert(typeof msg2);        //undefined

由以上可以看出，未声明的变量（msg2）执行 typeof 操作符同样会返回undefined值。

2. Null类型

同样只有一个值，即特殊的null。在这里我做了如下测试加以巩固，结果如下：

var msg = null;
alert(msg == null);                 //true
alert(typeof msg == "object");      //true

3. Boolean类型

有两个字面值：true和false。
在ECMAScript中所有类型的值都有与这两个Boolean值等价的值。可以用 Boolean( ) 将其转化为对应的Boolean值，如下：

    var msg = "hello world";
    var strToBoolean = Boolean(msg);

那么具体每种类型如何转化为true或者false？转换规则见下表：

数据类型	转换为true的值	转换为false的值
Boolean	true	false
String	任何非空字符串	“”（空字符串）
Number	任何非零数字值（包括 ∞）	0和NaN
Object	任何对象	null
Undefined	n/a1	undefined

流控制语句（如 if 语句）会自动执行相应的 Boolean 转换，如下代码：

var msg = "My first message";
if (msg){
    alert("字符串不为空");
}

4. Number类型

包括整数值（十进制、八进制、十六进制）和浮点数值（某些语言中也称双精度数值）。

整数值

八进制字面值第一位必须是 0 。
十六进制前两位为 0x ，后面为0~9以及A~F，字母不区分大小写。
直接看以下代码理解各种情况对应的数值：

var intNum = 55;        // 十进制整数

var octalNum1 = 055;    // 八进制数 55
var octalNum2 = 059;    // 无效的八进制数 —— 解析为十进制数59
var octalNum3 = 08;     // 无效的八进制数 —— 解析为十进制数8

var hexNum1 = 0xA;      //十六进制的10
var hexNum2 = 0x1f;     //十六进制的31

浮点数值

如果小数点后没有跟任何数字，那么数值就会被转换为整数。

var floatNum1 = 1.;     //1
var floatNum2 = 2.0;    //2

浮点数值的最高精度是17位小数，但是在进行算术计算时其精确度远远不如整数。例如0.1 + 0.2 ≠ 0.3，而是0.30000000000000004，也就是会产生舍入误差。因此会有以下结果，这是使用基于IEEE754数值的浮点计算的通病。

alert(0.15 + 0.15 == 0.3);  //true
alert(0.10 + 0.20 == 0.3);  //false
alert(0.1 + 0.2 == 0.3);    //false

NaN

非数值（Not a Number）是一个特殊的数值，这个数值用来表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了），因此非法运算不会影响其他代码的执行。有两个特点：

• 任何涉及NaN的操作都会返回NaN。
• NaN与任何值都不相等，包括其本身。如下：

alert(isNaN(NaN/10));   //true
alert(NaN == NaN);      //false

在上述代码中用到了 isNaN（）函数，该函数可以帮助我们确定传入参数是否“不是数值”。该函数首先会尝试将这个值转换为数值。某些不是数值的值会直接转换为数值。例如数字字符串或者Boolean值：

alert(isNaN(100));      //false
alert(isNaN("100"));    //false
alert(isNaN("string")); //true
alert(isNaN(true));     //false

isNaN也适用于对象，在基于对象调用isNaN函数时，会首先调用对象的valueOf（）方法，然后确定该方法返回的值是否可以转换为数值。如果不能则基于这个返回值再调用toString（）方法，再测试返回值。

数值转换

非数值 → 数值，有3个函数：Number（）、parseInt（）、parseFloat（）。

Number（）：Boolean值对应 0 和 1；null对应 0；undefined对应 NaN；
　　　　　　　如果是字符串：若只包含数字，则转为十进制数值；若为空字符串，则将其转换为0；
　　　　　　　　　　　　　　若包含除数字格式（包括浮点数、十六进制数等）以外的字符，则则转为NaN；
　　　　　　　如果是对象，处理方法同 isNaN（Object）；

var num1 = Number("Hello");     //NaN
var num2 = Number("00111");     //111
var num3 = Number("");          //0
var num4 = Number("true");      //1

parseInt（）：会忽略字符串前面的空格，直到找到第一个非空格字符。如果第一个字符不是数字字符或者负号，返回NaN。（parseInt（）转换空字符串会返回NaN，与Number（）的返回值 0 不同）；如果第一个是数字字符，会继续解析知道解析完所有后续字符或者遇到了一个非数字字符。示例如下：

var num1 = parseInt("1234ABCD");        //1234
var num2 = parseInt("00070");           //70
var num3 = parseInt("");                //NaN
var num4 = parseInt("12.5");            //12
var num5 = parseInt("AF", 16);          //175，对于十六进制可以再传一个基数（16）作为参数，其他同样

parseFloat（）：与parseInt（）函数类似，parseFloat（）也是从第一个字符（位置0）开始解析每一个字符。解析到字符串结尾或者遇见一个无效的浮点数字字符为止，如第二个小数点。因此 “22.34.5”会被转换为22.34。此外，parseFloat会忽略前导的0。十六进制格式的字符串始终会被转换成0。

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("0905.8000");     //905.8
var num6 = parseFloat("3.125e7");       //31250000

5. String类型

表示由零或多个16位Unicode字符组成的字符序列，即字符串。使用”“或’ ‘均可。

字符字面量

也叫转义序列，用于表示非打印字符或者具有其他用处的字符。如下：

\n：换行
\t： 制表
\b：退格
\r： 回车
\f： 进纸
\\： 斜杠 “ \ ”
\’： 单引号 ’
\”： 双引号 ”
\xnn： 以十六进制代码nn表示的一个字符（其中n为0~F）。例如：\x41表示A
\unnnn： 以十六进制代码nnnn表示的一个Unicode字符（其中n为0~F）。例如：\u03a3表示希腊字符Σ

注意在获取 str.length的时候，以上字符字面量只占一位长度。例如：

var text = "sigma: \u03a3.";
alert(text.length);     // 输出结果：9，即 "sigma: Σ."

字符串的特点

ECMAScript中的字符串是不可变的，也就是说字符串一旦创建，它们的值就不能改变，要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。

转换为字符串

有两种方式。toString( )方法和 String( )函数。

toString( )方法：除了 null和 undefined值之外，数值、布尔值、字符串值都有 toString( )方法。字符串值的 toString( )方法将返回该字符串的一个副本。大多数情况下 toString( )方法不必传递参数。但是在调用数值的 toString( )方法时，可以传递一个参数：输出值的基数。可以将数值以二进制、八进制、十进制或者十六进制输出成字符串值（默认无参数输出值为十进制值字符串）。

String( )函数：转型函数。可以将任何类型的值转换为字符串。转换规则为：

如果值有 toString( )方法，则调用该方法（没有参数）并返回相应的结果；
如果值是 null，则返回“null”；
如果值是 undefined，则返回“undefined”；

6. Object类型

ECMAScript中的对象其实就是一组数据和功能的集合。对象可以通过执行new操作符后更要创建的对象类型的名称来创建。而创建 Object类型的实例并为其添加属性和（或）方法，就可以创建自定义对象。

---

操作符

用于操作数据值。包括算术操作符（+ - * / % 等）、位操作符、关系操作符和相等操作符。
在应用于对象时，相应的操作符通常会调用对象的 valueOf( )和（或） toString( )方法，以便取得可以操作的值。

1. 一元操作符

递增（++）和递减（- -）操作符

包括前置型和后置型。对于其基本运算规则，都有了解。就直接举例作为回顾，如下：

var num1 = 2, num2 = 20;
var num3 = 2, num4 = 20;
var num5 = --num1 + num2;   // 21
var num6 = num1 + num2;     // 21
var num7 = num3-- + num4;   // 22
var num8 = num3 + num4;     // 21

这四个操作符对任何值都适用，具体规则如下：

用于包含有效数字字符的字符串时，先将其转换为数字值，再执行加减 1 操作。（String → Number）
用于不包含有效数字字符的字符串时，将变量值设置为 NaN。（String → Number）
用于布尔值 true（或 false）时，先将其转化为 1（或 0）再执行加减 1 操作。（Boolean → Number）
用于浮点数值时，执行加减 1 操作。
用于对象时，先调用 valueOf( )方法以获取可操作的值再对其应用上述规则。若返回为 NaN，则在调用 toString( )后再应用上述规则。

示例如下：

var str1 = "2";
var str2 = "q";
var bool = false;
var flt = "1.1";
var o = {
    valueOf: function() {
        return -1;
    }
}

str1++;     // 3
str2++;     // NaN
bool++;     // 1
flt--;      // 0.10000000000000009;
o--;        // -2

一元加（+）和减（-）操作符

一元加（+）对数值不会产生影响。并且对非数值应用一元加操作符时，该操作符将会像 Number( )转型函数一样对这个值执行转换。
一元减（-）与一元加类似，只不过值会变为负数。此处不做列举。

2. 位操作符

ECMAScript中的所有数字都是以IEEE-754 64位格式存储，但位操作并不能直接操作64位的值。而是先将64位的值转换成32位的整数，然后执行操作，最后再将结果转换回64位。但这个转换过程也导致了一个严重的副效应，即在对特殊的 NaN 和 Infinity 值应用位操作时，这两个值都会被当成 0 来处理。

如果对非数值应用位操作符，会先使用 Number( )函数将该值转换为一个数值（自动完成），然后再应用位操作。得到的结果将是一个数值。

对于有符号的整数，前31位用于表示整数的值，位31（即第32位，第 1 位为位 0）是符号位。在处理有符号整数时，是不能访问位31的。
对于无符号的整数，第32位不再表示符号，因为无符号整数只能是正数。正因如此，无符号整数的值可以更大，因为多出的一位不再表示符号，可以用来表示数值。

按位非（NOT，~）

即按位取反码操作。示例如下：

var num1 = 25;          // 二进制为 00000000000000000000000000011001
var num2 = ~num1;       // 二进制为 11111111111111111111111111100110
alert(num2);            // -26，效果同 -num1 - 1

通过以上示例不难看出非（~）操作的效果为：操作数的负值减 1。但由于按位非是在数值表示的最底层执行操作的，因此速度更快。

按位与（AND，&）

有两个操作数。就是将两个数值的每一位对齐，然后根据以下规则对相同位置上的两个数执行AND操作，规则如下：

除了两个数值都为 1 的时候返回结果为 1，其余情况都为 0。

具体示例如下：

var result = 25 & 3;
// 25 = 0000 0000 0000 0000 0000 0000 0001 1001
//  3 = 0000 0000 0000 0000 0000 0000 0000 0011
alert(result);
//AND = 0000 0000 0000 0000 0000 0000 0000 0001，即 1

可以巧妙地用一个数和 1 进行按位 & 操作来判断该数的奇偶性，效果同（n % 2 === 1），但速度更快。

function assert(n) {
    if (n & 1) {
        console.log("n是奇数");
    } else {
        console.log("n是偶数");
    }
}
assert(3); // "n是奇数"

按位或（OR，|）

同样有两个操作数。将两个数值按位对齐，然后根据以下规则对相同位置上的两个数执行OR（|）操作，规则如下：

只要有一个值是 1 返回结果就为 1，只有在两个位都为 0 的情况下才返回 0。

具体示例如下：

var result = 25 | 3;
// 25 = 0000 0000 0000 0000 0000 0000 0001 1001
//  3 = 0000 0000 0000 0000 0000 0000 0000 0011
alert(result);
// OR = 0000 0000 0000 0000 0000 0000 0001 1011，即 27

我们可以用按位 | 操作来对浮点数进行向下求整运算，并且其实使用 & 操作也可以：

var num = 1.1 | 0;      // 1
var num = 1.1 & -1;     // 1

当然也可以调用函数 Math的 floor( )方法：

var num = Math.floor(1.1);      // 1

其实浮点数是不支持位运算的，所以会先把1.1转成整数1再进行位运算，就好像是对浮点数向下求整。所以1|0的结果就是1。

按位异或（XOR，^）

两个操作数。异或（^）操作规则如下：

两个数值不相同时（有且只有一个 1 时）取 1，两个数值相同时取 0。

具体示例如下：

var result = 25 ^ 3;
// 25 = 0000 0000 0000 0000 0000 0000 0001 1001
//  3 = 0000 0000 0000 0000 0000 0000 0000 0011
alert(result);
//XOR = 0000 0000 0000 0000 0000 0000 0001 1010，即 26

经常可以用按位异或进行两个数的调换，比其通常的使用中间变量更加快捷（并且装B），代码如下：

var num1 = 1, num2 = 2;
num1 ^= num2;           // num1 = num1 ^ num2 = 1 ^ 2 = 3
num2 ^= num1;           // num2 = num2 ^ num1 = 2 ^ (1 ^ 2) = 1
num1 ^= num2;           // num1 = num1 ^ num2 = 3 ^ 1 = 2
console.log(num1);      // 2
console.log(num2);      // 1

左移（<<）

会将数值的所有位向左移动指定的位数。例如将数值 2（二进制为 10）向左移动 5 位，结果就是 64（二进制为1000000），代码如下：

var oldValue = 2;               // 二进制 10
var newValue = oldValue <<5;    // 二进制 1000000，十进制 64

注意左移（<<）不会影响操作数的符号位。换句话说，如果将 -2向左移动 5 位，结果将是 -64。因此更不能按负数的二进制数来考虑左移，否则 -2（… 1111 1110）左移 5 位会变成 -65（… 1101 1111），故不管正负左移都用正数操作。
另外，如果一直左移，最终结果为 0。

可以用左移求2的 n次方运算：

function power(n) {
    return 1 << n;
}
power(5); // 32

有符号的右移（>>）

有符号的右移，会将数值向右移动但保留符号位，与左移操作恰好相反，如64右移5位变为2。

无符号的右移（>>>）

无符号的右移，会将数值的所有32位都向右移动，前面空位补0。因此对于正数的无符号右移，结果与有符号右移相同；但对于负数的无符号右移，则会有如下的巨大变化：

var oldValue = -64;             //二进制：11111111111111111111111111000000，相当于无符号数 4294967232
var newValue = oldValue >>> 5;  //二进制：00000111111111111111111111111110，即 134217726

一个数左移1位会变为原来的2倍，右移1位会变成原来的1/2。

前面提到的左移右移，运算方式总结如下 ↓

对于有符号的右移，负数右移高位补1，正数右移高位补0；
对于无符号的右移，负数、正数右移高位均补0；
负数、正数左移低位补0。

3. 布尔操作符

其实下面这些布尔操作符我们都已经很不陌生了。因此这里主要提一些容易被忽略的点。

逻辑非（！）

可以应用于ECMAScript中的任何值，无论是什么类型都会返回一个布尔值。刚好与 Boolean( )函数转换后的布尔值相反。此外，使用两个逻辑非操作符会得到与 Boolean( )相同的的结果。点击此处查看Boolean( )转换规则。

逻辑与（&&）

逻辑与也可以用于任何类型的操作数，而不仅仅是布尔值。在有操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值，遵循一下规则：

如果第一个操作数是对象，则返回第二个操作数；（Object && true/false → true/false）
如果第二个操作数是对象，则只有在第一个操作数的求值结果为true的情况下才会返回该对象；（true && Object → Object，false && Object → false）
如果两个操作数都是对象，则返回第二个操作数；（Object1 && Object2 → Object2）
如果有一个操作数是null，则返回null；（null && true/false → null，true/false && null → null）
如果有一个操作数是NaN，则返回NaN；（同上）
如果有一个操作数是undefined，则返回undefined；（同上）

逻辑与操作属于短路操作。即如果第一个操作数能决定结果，那么就不会再对第二个操作数求值。如果第一个操作数是false，则第二个操作数将不会进行判断，举例如下：

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

//另一段代码
var found = false;
var result = (found && someUndefinedVariable);  //不会发生错误，第二个操作数未判断
alert(result);  //false

逻辑或（||）

与逻辑与操作类似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此事，它遵循下列规则：

如果第一个操作数是对象，则返回第一个操作数；（Object && true/false → Object）
如果第一个操作数的求值结果为false，则返回第二个操作数；（false && Object → Object）
如果两个操作数都是对象，则返回第一个操作数；（Object1 && Object2 → Object1）
如果两个操作数都是null，则返回null； （null || null → null）
如果两个操作数都是NaN，则返回NaN；（同上）
如果两个操作数都是undefined，则返回undefined；（同上）

逻辑或操作符也属于短路操作符，因此效果与逻辑与操作类似。第一个操作数是true时，就不会对第二个操作数进行判断。

乘性操作符

乘法（*）

除法（/）

求模（%）

加性操作符

加法（+）

减法（-）

关系操作符（>，<，<=，>=）

相等操作符

相等（==）和不相等（!=）

全等（===）和不全等（!==）

全等和不全等要考虑到数据类型，即全等和不全等在比较前不会转换操作数的数据类型，如 “55”!== 55。

条件操作符

对于条件操作符，只要记清楚true/false对应的分别是哪个位置的值就好了。语法形式如下：

variable = boolean_expression ? true_value : false_value;

举例如下：

var max = (num1 > num2) ? num1 : num2;

赋值操作符

包括 =，*=，/=，%=，+=，-=，<<=（左移赋值），>>=（有符号右移赋值），>>>=（无符号右移赋值）。

逗号操作符

可以用于同时声明多个变量。除此之外还可以用于赋值，在用于赋值时逗号操作符会返回表达式中的最后一项，如下示例所示：

var num = (1, 2, 5, 3, 0);  //num的值为0

---

语句

由于在ECMAScript中不存在块级作用域，因此在循环内部定义的变量也可以在外部访问到。
这里提一下以下几种比较有意思的语句：

for-in语句

for-in语句是一种精确的迭代语句，可以用来枚举对象的属性。以下是for-in语句的语法：

for (property in expression) statement

下面是一个示例：

for (var propName in window){
    document.write(propName);
}

这里使用for-in循环显示了BOM中window对象的所有属性。

label语句

使用 label 语句可以在代码中添加标签，以便将来使用。以下是一个示例：

start: for (var i = 0; i < count; i++){
    alert(i);
}

这里定义的 start 标签可以在将来由 break 或 continue 语句引用。加标签的语句一般都要与for语句等循环语句配合使用。

break和continue语句

用于再循环中精确的控制代码的执行。break语句会立即退出循环，强制继续执行循环后面的语句。而continue语句也是立即退出循环，但是退出后会从循环的顶部继续执行。

前面提到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

with语句（大量使用会导致性能下降，严格模式下不允许使用）

将代码的作用于设置到一个特定的对象中。with语句的语法如下：

with (expression) statement;

定义with语句的目的是为了简化多次编写同一个对象的工作，下面是一个示例：

var qs = location.search.substring(1);
var hostname = location.hostname;
var url = location.href;

上面的几行代码都包含了location对象。如果使用with语句，可以把上面的代码改写为：

with(location){
    var qs = search.substring(1);
    var hostname = hostname;
    var url = href;
}

这意味着在with语句的代码块内部，每个变量首先被认为是一个局部变量，而如果在局部环境中找不到该变量的定义，就会查询location对象中是否有同名的属性。如果发现了同名属性，则以location对象属性的值作为变量的值。另外，严格模式下不允许使用with语句。

switch语句

在switch语句中，如果省略某一个case下的break，则会在执行完当前该case后，继续执行下一个case。不过有时需要混合几种情形，可以有意省略break关键字。如下：

switch (i){
    case 25:
        /*合并两种情形*/
    case 35:
        alert("25 or 35");
        break;
    default:
        alert("Other");
}

此外，在 ECMAScript 的 switch 语句中，可以使用任何数据类型（无论字符串、对象等等）。其次，每个case的值不一定是常量，可以是变量、表达式等。示例如下：

switch ("hello world"){
    case "hello" + "world":
        alert("Yep");
        break;
    case "goodbye":
        alert("Bye");
        break;
    default:
        alert("None");
}

/*****************************分割线*********************************/

switch (a){
    case a < 0:
        alert("a＜0");
        break;
    case a >= 0 && a < 10:
        alert("0≤a＜10");
        break;
    default:
        alert("a≥10");
}

---

函数

函数这部分感觉比较有意思的就是对参数的理解。

参数

ECMAScript中函数的参数与大多数其他语言中的函数的参数有所不同。它不介意传递进来多少个参数， 也不在乎传进来的参数是什么数据类型。原因是ECMAScript中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含哪些参数。 数组中不包含元素无所谓，包含多个元素也没关系。实际上在函数体内可以通过arguments对象来访问这个参数数组，从而获取传递给数组的每一个参数。

arguments对象只是与数组类似而并不是Array的实例。可以使用 arguments[index]来访问它的每一个元素（也是从0开始）。用 length 属性来确定传递进来多少个参数。我们可以利用这一点让函数能够接受任意个参数并分别实现适当的功能。示例如下：

function doAdd(){
    if (arguments.length == 1){
        alert(arguments[0] + 10);
    }else if (arguments.length == 2){
        alert(arguments[0] + argument[1]);
    }
}

doAdd(10);      //20
doAdd(10, 20);  //30

因为ECMAScript没有重载，因此虽然这个特性不算完美的重载，但也足够弥补ECMAScript的这个缺憾了。
此外，arguments对象可以与命名参数一起使用。例如：

function doAdd(num1, num2){
    if (arguments.length == 1){
        alert(num1 + 10);
    }else if (arguments.length == 2){
        alert(arguments[0] + num2);
    }
}

/*******************************分割线*******************************/

function doAdd(num1, num2){
    arguments[1] = 10;
    alert(arguments[0] + num2); //此时num2已经变成了10
}

没有重载

在其他语言中，可以用一个函数编写两个定义，只要这两个定义的签名（接受参数的类型和数量）不同即可。但ECMAScript函数没有签名，因为参数是由包含零或者多个值的数组来表示的，而没有函数签名，不可能做到真正的重载。

如果在 JS 中代码中定义了两个名字相同的函数，则后定义的后覆盖前面定义的（名字只属于后定义的函数）。

---

---

1. 是 not applicable 的缩写，意思是“不适用”。 ↩