变量
- 声明变量
var count;
var amount,level;
var count = 0, amount = 100;
-
命名变量
- 区分大小写的语言
- 第一个字符是字母或下划线_,数字不能作为第一个字符
- 字符必须是字母，数字或者下滑线
- 变量名不得为保留字
需要声明并初始化变量，可以为变量分配null值
声明了变量但是不为其赋值。该值为undefined。
var current; consoloe.log(current) //underfined
- null与0的行为类似，而underfined行为与NaN类似，null与undefined值他们相等。
var current; //undefined var a = null; console.log( current == a); //true console.log( current === a) //false- 可以不使用var关键字声明一个变量，为隐式声明
noString = 'abc';- 不能使用从未声明过的变量
注：underfined 是声明未定义，is not defined 是使用了从未声明过的变量var area = length * width; //width is not defined
数据类型
js中有5种基本数据类型：undefined，Null，Boolean,Number,String。还有一个复杂的数据类型 object
typeof操作符
undefined -- 这个值未定义
boolean -- 布尔值
string -- 字符串
number -- 数字
object -- 对象或者null
function -- 函数
是一个操作符而不是一个函数
var message = 'some';
console.log(typeof message);
console.log(typeof(message));
两者方式都可以
undefined 类型
使用var声明变量但是未对其加以初始化，就为underfined
var message;
console.log(message); //undefined
console.log(typeof message); //undefined
var message;
console.log(typeof message); //undefined
console.log(typeof a); //undefined
console.log(a); // a is not defined
typeof 给未初始化的变量和未声明的变量都返回了undefined的值
null类型
var car = null;
console.log(car); // null
console.log( typeof car); //object
undefined值是派生自null值，只要保存对象，应该明确让变量保存null值，体现null作为空指针，也有助于区分null和undefined的区别
console.log(null == undefined); true
Boolean类型
var found = true;
var lost = false;
//区分大小写，True，False只是一个标识符
其他数据转为boolean值
| 数据类型 | true | false |
|---|---|---|
| string | 任何非空的字符串 | ""(空字符串) |
| number | 任何非零数字值 | 0和NaN |
| object | 任何对象 | null |
| undefined | 不适用 | undefined |
var message = 'hello world';
if (message){ //参照上表对字符串进行布尔值的转化
alert('true')
}
Number类型
- 最基本的字面格式是十进制 var num = 55；
- 还可以通过八进制或十六进制表示,八进制必须以0为开头，数字序列（0~7）
- var num1 = 070; 有效56
- var num2 = 079; 无效解析为79
- 八进制在严格模式是抛出错误
- 十六进制前两位必须是0X，后跟数字（09及AF）。A~F可以大写可以小写。
- var num1 = 0xA; 10;
在算数计算中，所有的八进制和十六进制都最终转化成十进制。
浮点数
- 几种形式
var floatnum1 = 1.1;
var floatnum2 = .1; //有效，但是不推荐
- 浮点数值的内存空间是整数数值的两倍。js会把浮点数值不失时机的转化为整数值。
- e的用法 小数点后有6个零以上的浮点数值转化为e的表示法
var floatnum1 = 3.125e7; //等于31250000
var floatnum2 = 3e-7; // 等于0.0000003
var num = 3.12e7;
console.log(num); // 3125000
var num2 = 0.000000000008;
console.log(num2) //8e-12
- 浮点数值的最高精度是17位小数。0.1加0.2结果是0.30000000000000004。
console.log(0.300000.toFixed(1)) // 0.3
var s = 0.300000.toFixed(1);
console.log( typeof s); // string
数字的范围
- 由于内存的问题，js能够保存的最小数字是5e-324；最大的数字是1.7976931348623157e308；如果超出的话，则换成Infinity（-Infinity）。如果超出的话是不能参与计算。可以用isFinite()判断数字是否位于最小和最大的数值之间
var result = 900;
console.log(isFinite(result)) // true
var result2 = Number.MAX_VALUE + Number.MIN_VALUE; //表达最大和最小值
console.log(isFinite(result2)); // true
var result3 = Number.MAX_VALUE + Number.MAX_VALUE; //表达最大和最小值
console.log(isFinite(result3)) //false
console.log(isFinite(result2));
if ( Number.MAX_VALUE > Number.POSITIVE_INFINITY){
console.log('大于')
}else{
console.log('小于') // Number.MAX_VALUE 并没有达到无穷大
}
var num = Number.MAX_VALUE + Number.MAX_VALUE;
if ( num > Number.POSITIVE_INFINITY){
console.log('大于')
}else{
console.log('小于') // 无穷大与无穷大并不能做比较
}
NaN
- 非数值的数值。在其他的语言中任何数除以0，报错，js中返回NaN。
- 任何涉及到NaN的操作返回都是NaN
- NaN与任何数都不相等，包括NaN本身。
alert(NaN == NaN) // false
- isNaN()接收到一个值，会尝试将这个值转化成数值。任何不能被转换为数字的值会返回ture；
console.log(iaNaN(NaN)); // true
console.log(isNaN('blue')); // true
console.log(isNaN('1.32元')) // true 内部通过valueOf()函数转化
console.log(isNaN(10)) //false
console.log(isNaN(ture)) // false
- isNaN();会首先调用valueOf()方法，确定返回值是否可以转换，如果不能，基于这个返回值调用toString(),在测试返回值。
数值的转换
有3个函数运用于数值的转换：Number(),parseInt(),parseFloat();Number()可以运用于任何数据的类型，parseInt(),parseFloat()专门运用于将字符串变为数值。
Number();
- 可以运用于任何的数据类型
- 如果是Boolean值，true转化为1，false值转为0；
- 数字值只是简单的传入
- null值，返回的是0
var a = null;
console.log(Number(a)) // 0
- undefined,返回为NaN。
var a ;
console.log(Number(a)) // NaN
- 字符串的话
var a = '123';
console.log(Number(a)) // 123
var a = '0123214';
console.log(Number(a)) // 123214 去掉开头的0
var a = '1.234';
console.log(Number(a)) // 1.234
var a = '0xf';
console.log(Number(a)) // 15十六进制的转化为十进制
var a = '070';
console.log(Number(a)) // 70在这里八进制不能转化为十进制
var a = '';
console.log(Number(a)) // 0
var a = ' 80';
console.log(Number(a)) // 80前面的空的字符串忽略
var a = '1.23元';
console.log(Number(a)) // NaN
// 除此之外的任何形式都是NaN
- 如果是对象，则先调用valueOf(),然后再调用toString()。后再按照前面的方法返回字符串的值；
parseInt()
- 忽略字符串前面的空格，一直找到第一个非空格的字符。如果第一个字符不是数字或者负号的话则返回NaN。然后解析后面的字符，直到遇到了一个非数字的字符
var a = 'fasd12314';
console.log(parseInt(a)) // NaN
var a = '';
console.log(parseInt(a)) // NaN
var a = '1234blue';
console.log(parseInt(a)) // 1234
var a = '123.89';
console.log(parseInt(a)) // 123 . 是一个非数字的字符
var a = '0000231';
console.log(parseInt(a)) // 231
- 在ES3中可以识别八进制的数值进行转换为十进制，但是在ES5中不能识别，因此可以写成parseInt('a',8)或者parseInt('a',16);
console.log(parseInt('0xaf',16)) // 175
console.log(parseInt('af',16)) // 175
console.log(parseInt('af')) // NaN
console.log(parseInt('070',8)) // 56
parseFloat()
- 与parseInt()类似，但是遇见一个无效的数字字符为止。第一个小数点有效，第二个小数点无效
var a = 22.34.5
console.log(parseFloat(a)) // 22.34
- 十六进制的字符串始终会被转为0
var a = '0xa';
console.log(parseFloat(a)) // 0
- 只解析十进制的值，没有第二个参数指定参数的用法
var a = '0xa';
console.log(parseFloat(a,16)); // 0
- 如果字符串是一个可以解析为整数的书（没有小数，或者小数点后面都是零），parseFloat()会返回一个整数。
console.log(parseFloat('1234ble')) // 1234
console.log(parseFloat('0xa')) // 0
console.log(parseFloat('22.5')) // 22.5
console.log(parseFloat('22.34.5')) // 22.5
console.log(parseFloat('009765.8')) // 9765.8
console.log(parseFloat('3.125e7')) // 31250000
toFixed()
var s = 123.090;
console.log(s.toFixed(1)); // 123.1 四舍五入
var s = 123.000;
console.log(s.toFixed(1)); // 123.0
console.log(typeof s.toFixed(1)) //string
String类型
- 字符的字面量 p33
| 字面量 | 含义 |
|---|---|
| \n | 换行 |
| \t | 制表 |
| \b | 空格 |
| ' | 单引号' |
| " | 双引号" |
转义字符只表示一个字符
var text = "this is this letter sigma: \u03a3."
console.log(text.length); // 29
-
字符串的特点
- 字符串是不可变的，要改变变量保存的字符串，首先要销毁原来的字符串，然后再用一个新值的字符串填充变量
var lang = 'java'; lang = lang + 'script';
转化为字符串
toString()方法
- 返回相应值的字符串表现。数值，布尔值，对象和字符串都有toString方法，但是null和undefined没有
var num = 10;
console.log(num.toString()); // 10
var on = true;
console.log(on.toString()); // true
var boo = false;
console.log(boo.toString()) // false
var now = new Date();
console.log(now.toString()); // Tue Jul 04 2017 22:02:45 GMT+0800
var arr = [1,2,3,4];
console.log(arr.toString()); // 1,2,3,4
var a;
console.log(a.toString()); // 报错
var b = null;
console.log(b.toString()) // 报错
- 传递参数，输出数值的基数，可以输出以二进制，八进制，十六进制，以及其他任意的有效进制格式的字符串。
var num = 10;
console.log(num.toString()) //'10'
console.log(num.toString(2)) //'1010'
console.log(num.toString(8)) //'12'
console.log(num.toString(10)) //'10'
console.log(num.toString(16)) //'a'
String()能将任意的类型转为字符串
- 如果有toString()方法，调用该方法后返回相对应的结果
- 如果是null，则返回null
- 如果是undefined，则返回undefined。
var value1 = 10;
console.log(String(value1)) // '10'
var value2 = true;
console.log(String(value2)) // 'true'
var value3 = null;
console.log(String(value3)) // 'null'
var value4;
console.log(String(value4)) // 'undefined'
Object 类型
- 对象是一组数据和功能的集合。对象可以通过执行new创建
var o = new Object();
- 在js中创建实例并没有什么用处，Object类型是所有的实例基础。Object类型所具有的任何属性和方法也同样存在于更具体的对象中。
所有的Object类型都有下面的属性和方法- constructor : 保存着用于创建当前对象的函数
- hasOwnProperty : 用于检查给定的属性在当前的对象实例中（而不是在实例原型）是否存在，如： o.hasOwnProperty('name');
- isPrototypeOf(Object) : 用于检查传入的对象是否是传入对象的原型中
- propertyIsEnumerable(name) : 检查给定的属性是否能够使用for-in语句
- toLocalString() : 返回对象的字符串表示，该字符串与执行环境的地区对应
- toString() : 返回对象的字符串表示
- valueOf() : 返回对象的字符串，数值，布尔值表示，通常与toString()方法返回值相同
操作符
一元操作符：只能操作一个值的操作符
- 递增和递减操作符（++,--）
前置性和后置型
前置递增和递减，变量的值都是在语句被求值以前改变的。
var age = 27;
console.log(++age); // 28
var age2 = 27;
console.log(age++) // 27
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
这四个操作符对任何值都适用
var s = '2';
console.log(++s) //3
console.log(typeof s) // number
var s2 = 'z';
console.log(++s2) // NaN
//字符串将值转换为数字再进行操作
var boo = false;
console.log(++boo) // 1
var f = 1.1;
console.log(--f) // 0.1000000000000009
var o = {
valueOf : function(){
return -1;
}
}
console.log(--0) // -2
//隐式类型转换，上面的几种类型都被转换成了number类型
一元加和减操作符
“+”，“-”，该操作符像Number()对这个值进行转换，而对象则会先调用他们的valueOf(),toString(),在求值。
```js
var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1
var o = {
valueOf : function(){
return -1;
}
}
-s1 // -1
-s2 // -1.1
-s3 // NaN
-b // 0
-f // -1.1
-o // 1
- 主要运用于基本的算术运算，隐式转化数据的类型
布尔操作符
- 逻辑非（!）,非布尔值的类型先按照Boolean()函数转换，后再取反。
逻辑与(&&)
逻辑与操作不一定返回布尔值（同时为true时才返回true），遵循以下操作
- 第一个操作数是对象，则返回第二个操作数
- 第二个操作数是对象，则只有在第一个操作数的求值结果为true才返回该对象
- 两个操作数都是对象，则返回第二个操作数
- 如果有一个操作数是null，则返回null
- 如果有一个操作数是undefined，则返回undefined
- 如果有一个操作数是NaN，则返回NaN。
var found = 'yes';
var s = 'not';
console.log((found && s)) // not
var found = true
var s = [1,2,3];
console.log((found&&s)) // [1,2,3]
console.log('fasd'&&NaN) //NaN
如果第一个数值是false，则只能返回false，短路操作
var found = true;
console.log(found&&someundefined) // 报错
var found = false;
console.log((found&&someundefined)) // false
逻辑或（||）
逻辑或也不一定返回布尔值（有一个为true则为true），但是有一个不是布尔值，也不一定返回布尔值。
var s = 'jfs';
console.log((s||'abc')) // jfs 如果第一个是对象，则返回对象
console.log((false||NaN)) // NaN 如果第一求值是false，则返回第二个
console.log('adsf'||'123') // 如果都是对象则返回第一个
console.log(null||null) // null
console.log(NaN||NaN) //NaN
console.log(undefined|| undefined) // undefined
短路操作符，第一个操作符为true，就不对第二个数求值,利用这种方法，避免为变量赋值null或undefined
var found = true;
var result = (found || someundefined) // true
乘性操作符
定义了3个乘性操作符：乘法，除法，求模。在操作数为非数值的情况下后台会使用Number()转化，是隐式类型转换。
- 乘法
- 乘积超过了js数值的范围，返回Infinity或者-Infinity；
- 一个数为NaN，结果为NaN；
- Infinity与0相乘，结果为NaN；
- Infinity与非0相乘，结果为Infinity或者-Infinity；
- Infinity与Infinity相乘，结果为Infinity；
- 如果一个数不是数值，后台调用Number(),后按照上面的方法
除法
- 商超过了js数值的范围，返回Infinity或者-Infinity；
- 一个数为NaN，结果为NaN；
- Infinity除以Infinity，结果为NaN；
- 零被零相除，结果是NaN
- Infinity与0相乘，结果为NaN；
- 非零的有限数被零除，结果是Infinity或者-Infinity
- Infinity被任何非零的数值相除，结果是Infinity或者-Infinity，符号取决于操作数的复合
- 如果一个数不是数值，后台调用Number(),后按照上面的方法
加法
- 如果一个操作数是NaN,则结果是NaN
- Infinity加Infinity，结果是Infinity；
- -Infinity加-Infinity，结果是-Infinity；
- Infinity加-Infinity，结果是NaN；
- +0加+0，结果是+0；
- -0加-0，结果是-0；
- +0加-0，结果是+0；
不过一个操作数是字符串，那么就应该如下规则 - 两个都是字符串，则是两个字符串拼接
- 一个是字符串，则将另一个转换为字符串，作为字符串的拼接
- 一个是对象，数值，布尔值，则调用他们的toString()方法取得字符串，后拼接
var a ;
var b = null;
console.log(a+b); // NaN
var num1 = 5;
var num2 = 10;
var message = 'this sum is' + num1 + num2 // this sum is 510
var message2 = 'this sum is' + (num1+num2)//this sum is 15
减法
- 两个都是数值，常规数值运算
- 一个操作数是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()函数。
- 如果是对象的话，则先调用valueOf()，如果没有则调用toString()
关系操作符（<,>,<=,>=）
- 两个都是数值，直接比较
- 两个都是字符串，则比较编码
- 一个是数值，则将另一个转换成数值
- 操作数是对象，则调用valueOf(),如果没有valueOf(),则调用toString()
var result = '23' < '3' //true
var result = '23' < 3 //false
var result = 'a' < 3 // false ,'a'转换成NaN，任何操作数与NaN比较，结果都是false
相等操作符
- 相等和不相等"=="和'!=',这两个操作符都会先转换操作数（强制转换），然后再比较他们的相等性
- 布尔值false => 0,true => 1;
- 一个操作数是字符串，另一是数值，比较时先将字符串变为数值
- 一个是对象，另一个不是，则调用valueOf(),得到基本值后进行比较
- null 和undefined 相等
- 在比较相等性之前，不能将null和undefined转换成任何值
- 当一个是NaN时，相等为false，不相等为true。即便是两个都是NaN的情况下，NaN不和任何值相等，也不和自己本身相等
- 如果两个都是对象，则比较他们是不是同一个对象，如果两个操作数指向同一个对象则返回true，否则返回false
null == undefined // true null 和 undefined 相等
'NaN' == NaN // false NaN 与任何值都是false
NaN == NaN // false
NaN != NaN // true NaN自己和本身也不相等
false == 0 // true false转化Number()为0
true == 1 // true true Number()为1
undefined == 0 // false
null == 0 // false 在比较相等性之前，不能将null和undefined 转化成任何值
'5' == 5 // true 字符串5变为数值
全等和不全等（"=="和"==="）
除了在比较之前不转换操作数之外，"=="和"==="没有什么区别 "!="和"!=="
var result1 = ( '55'==55) // true
var result2 = ( '55'===55) //false
null == undefined // true
null === undefined // false
条件操作符
variable = boolean_expressin ? true_value : false_value;
var max = (num1 > num2) ? mun1 : mun2; // 三目运算取两者之间较大值
赋值操作符
var num = 10;
num = num + 10 => num += 10
// *= , /= , %= , += , -= ,
逗号操作符
- 使用逗号可以在一条语句中执行多个操作
var num1 = 1, num2 = 2, num3 = 3;
- 用于赋值，逗号操作符总返回表达式的最后一项
var num = (5,1,4,8) // num 为8
语句
if 语句
if (i > 25){
alert('i > 25')
}else if (i < 0){
alert('i<0')
}else{
alert('其他数值')
}
do-while 语句
var i = 0;
do {
i += 2;
}while(i < 10)
// 循环体中的代码至少被执行一次
var i = 12;
do {
i += 2;
}while(i < 10)
console.log(i) // 14
while 语句
在循环体的代码执行之前对条件做判断，循环体的代码可能永远不会执行
var i = 0;
while(i < 10){
i += 2
}
console.log(i) // 10
for 语句
for 语句也是一种前测试循环语句，他具有执行循环之前初始化变量和定义循环后要执行的代码能力
for ( initialization ; expression ; post-loop-expression ) statement
var count = 10;
for ( var i = 0; i < count; i ++){
console.log(i) // 0,1,2,3,4,5,6,7,8,9
}
// 功能一致
var count = 10;
var i = 0;
while(i<count){
console.log(i);
i ++ ;
}
在for循环的变量初始化表达式中，也可以不使用var关键字
var count = 10;
var i ;
for (i=0; i < count; i ++){
console.log(i)
}
js中不存在块级作用域，因此在循环内部定义的变量可以在外部访问
for ( var i = 0; i < 10 ; i ++){
console.log(i) // 0,1,2,3,4,5,6,7,8,9
}
console.log(i) // 10
for 语句中的初始化表达式，控制表达式，循环后的表达式都是可选的。将这三个表达式全部省略，则是一个无限循环
for (; ;){
doSomething() // 无限循环
}
给出一个控制表达式就是把for循环变成了while循环
var count = 10;
var i = 0;
for ( ; i < count;){
console.log(i);
i ++ ;
}
for-in 语句
用来枚举对象的属性
for (var proName in window){
console.log(proName) // var 操作符不是必须的，但是为了保证使用局部变量，推荐使用
}
for-in 输出的属性名顺序不可预测，返回的先后顺序可能会因为浏览器而异
如果迭代对象的变量值为null 或者 undefined for-in 语句会抛错，但是ES5不再抛出错误，只是不执行循环体
label 语句
给代码中添加一个标签
break 和 continue 语句
break 语句会立即退出当前循环，强制执行循环后面的语句，continue 也是立即退出当前循环，但是会从循环的顶部继续执行
var num = 0;
for ( var i = 1 ; i < 10 ; i ++){
if ( i % 5 == 0){
break
}
console.log(num) // 4 直接跳出for的循环
}
var num = 0;
for ( var i = 1; i < 10 ; i ++){
if ( i%5 == 0){
continue
}
console.log(num) // 8 跳出当前循环语句，但是继续在循环顶部执行
}
var num = 0;
outer:
for (var i = 0; i < 10 ; i ++){
for ( var j = 0; j < 10 ; j ++){
if ( i == 5 && j == 5){
break;
}
num ++
}
}
// 最终num = 95； 当i= 5，j = 5 时只是跳出了j的循环，从i= 6开始
var num = 0;
outer:
for (var i = 0; i < 10 ; i ++){
for ( var j = 0; j < 10 ; j ++){
if ( i == 5 && j == 5){
break outer;
}
num ++
}
}
// 最终num = 55； 当i= 5，j = 5 时不但退出了j的循环，也退出了i的循环
var num = 0;
outer:
for (var i = 0; i < 10 ; i ++){
for ( var j = 0; j < 10 ; j ++){
if ( i == 5 && j == 5){
continue outer;
}
num ++
}
}
// 最终num = 99； 当i= 5， j = 5 时，跳出j的循环，从j= 6开始
var num = 0;
outer:
for (var i = 0; i < 10 ; i ++){
for ( var j = 0; j < 10 ; j ++){
if ( i == 5 && j == 5){
continue outer;
}
num ++
}
}
// 最终num = 95； 当i= 5， j = 5 时，跳出j的循环，从i= 6的循环开始
with语句
主要作用就是将代码的作用域设置到一个特定的对象中
var qs = location.search.substring(1);
var hostName = location.hostName;
var url = location.href;
// 可以改写成如下
with(location){
var qs = search.substring(1);
var hostName = hostName;
var url = host
}
switch 语句
switch(i){
case 25:
alert('25');
break;
case 35:
alert('35');
break;
case 45:
alert('45');
break;
default:
alert('other');
}
如果省略break，就会导致执行完当前的case，继续执行下个case
需要同时执行多个case的话
switch(i){
case 25:
/*合并两种情况*/
case 35:
alert('35 or 25');
break;
case 45:
alert('45');
break;
default:
alert('other');
}
case的值不一定是常量，可以是变量，可以是表达式，可以是字符串
switch('hello world'){ // 字符串
case 'hello'+'world': // 表达式
alert('1');
break;
case 'good'
alert('2');
break;
default :
alert('888')
}
var num = 25;
switch(true){ // 每个case都可以返回一个布尔值
case num < 0:
alert('小于0');
break;
case num == 0 : // 这个地方是判断
alert(0);
break;
}
switch 使用的是全等操作符，所以'10'与10不相等
函数
- 形式
function say(name , message){
alert(name + message);
}
- 函数在定义时不必指定是否返回值，任何函数在任何时候都可以通过return语句后跟着要返回的值
- 函数在执行return语句之后停止并立即退出
- return语句也可以不带有任何返回值，这个时候返回undefined
- 参数
- js函数内部中，参数是用一个数组来表示的，所以并不关心数组中有哪些参数
- 函数体内可以通过arguments对象来访问这个参数数组
function say(){
alert(arguments[0]+ arguments[1]);
}
- 命名形参只是提供了便利，但是不是必需的。
function doAdd(){
if ( arguments.length == 1){
alert(arguments[0]= 10)
}else if ( arguments.length == 2){
alert(arguments[0]+ arguments[1])
}
}
- arguments对象和命名参数一起使用
function doAdd(num1,num2){
if (arguments.length == 0){
console.log(num1+10)
}else if (arguments.length == 2){
console.log(num1+num2)
}
}
- arguments的值与形参一致
var n1 = 10;
var n2 = 20;
doAdd(n1,n2);
function doAdd(num1,num2){
arguments[1] = 10;
console.log(num2); //10
console.log(n2); //20
}
- 没有传递命名参数将被自动赋予undefined值
- 严格模式下，如果没有传入num2,即使设置arguments[1]设为10，num2 依然是undefined，重新修改arguments的值会导致错误（代码将不会执行）
- 没有重载
function add(num){
return num + 100;
}
function add(num){
return num + 200;
}
add(100) // 300 只有覆盖，没有重载
