数据类型

变量

  1. 声明变量
var count;
var amount,level;
var count = 0, amount = 100;
  1. 命名变量

    1. 区分大小写的语言
    • 第一个字符是字母或下划线_,数字不能作为第一个字符
    • 字符必须是字母,数字或者下滑线
    • 变量名不得为保留字
    1. 需要声明并初始化变量,可以为变量分配null值

    2. 声明了变量但是不为其赋值。该值为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
    
    1. 可以不使用var关键字声明一个变量,为隐式声明
    noString = 'abc';
    
    1. 不能使用从未声明过的变量
    var area = length * width;    //width is not defined
    
    注:underfined 是声明未定义,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)
    1. var num1 = 070; 有效56
    2. var num2 = 079; 无效解析为79
    3. 八进制在严格模式是抛出错误
  • 十六进制前两位必须是0X,后跟数字(09及AF)。A~F可以大写可以小写。
    1. 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()方法返回值相同

操作符

一元操作符:只能操作一个值的操作符

  1. 递增和递减操作符(++,--)
    前置性和后置型
    前置递增和递减,变量的值都是在语句被求值以前改变的。
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
  • 主要运用于基本的算术运算,隐式转化数据的类型

布尔操作符

  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()转化,是隐式类型转换。

  1. 乘法
  • 乘积超过了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
  1. 参数
  • 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的值会导致错误(代码将不会执行)
  1. 没有重载
function add(num){
    return num + 100;
}
function add(num){
    return num + 200;
}
add(100)  // 300  只有覆盖,没有重载

推荐阅读更多精彩内容