ECMAScript基本函数、概念区分总结

1.使用Number()和parseInt() parseFloat()转换区别。

详见《JavaScript高级程序设计》P30

Number()可以针对任何类型。

parseInt（）和parseFloat（）都只针对字符串

1.转换空字符串

Number("");//0

parseInt("");//NaN

2.转换包含数字的字符串

console.log(parseInt("1234Blue"));//1234

console.log(parseInt("Blue1234"));//NaN

console.log(Number("1234Blue"));//NaN

console.log(Number("Blue1234"));//NaN

parseInt（）从第一个非空格字符开始解析，直到遇到第一个非字符数字；

parseFloat()从第一个非空格字符开始解析，直到遇到第一个无效的浮点数字字符。（遇到第二个小数点就无效了）

3.parseInt()可指定转换基数，即将字符串按照十进制数值转换成指定进制的数。

console.log(parseInt("10",2));

console.log(parseInt("10",8));

console.log(parseInt("10",10));

console.log(parseInt("0xA"));//10

console.log(parseInt("0xA"，16));//10

console.log(parseInt("0xA"，10));//0

为避免错误的解析，任何时候都要明确指定基数

4.parseFloat()不能解析十六进制等其他进制，只能解析十进制

console.log(parseFloat("0xA"));//0

console.log(parseInt("0xA"));//10

2.两种涉及转换数据进制的方法 toString()、parseInt()

var n=10;

console.log(n.toString(2));//1010

console.log(parseInt(n,2));//2

n.toString(2)是返回把数值转换为相应进制（2）的字符串
parseInt(n,2)是把字符串按照指定进制（2）来解析为十进制数据

3.toString()方法和String()方法的区别

//console.log(null.toString());报错

//console.log(undefined.toString());报错

console.log(String(null));//"null"

console.log(String(undefined));//"undefined"

null和undefined没有toString()方法，使用会报错。数值、布尔值、对象、字符串有这个方法。
String()能将任何类型的值转换为字符串，包括null和undefined

4.自增自减操作符用在其他非数值值。

var s1="2";

var s2="z";

var b=false;

var f=1.1;

var o={

    valueOf: function(){

                 return -1;

            }

};

s1++;

s2++;

b++;

f--;

o--;

console.log(s1);//3

console.log(s2);//NaN

console.log(b);//1，若b之前为true则++后为2

console.log(f);//0.10000000000000009

console.log(o);//-2

5.一元+操作符和-操作符

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;

s2=+s2;

s3=+s3;

b=+b;

f=+f;

o=+o;

console.log(s1);//1

console.log(s2);//1.1

console.log(s3);//NaN

console.log(b);//0

console.log(f);//1.1

console.log(o);//-1

一元+操作符作用类似于Number()转型函数

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;

s2=-s2;

s3=-s3;

b=-b;

f=-f;

o=-o;

console.log(s1);//-1

console.log(s2);//-1.1

console.log(s3);//NaN

console.log(b);//-0

console.log(f);//-1.1

console.log(o);//1

一元键操作符应用于数值时会变成负数。应用于非数值时，和+转换规则类似。

6.两个逻辑非（！）可得到Boolean()方法一样的结果

console.log(!!"blue");//true

console.log(Boolean("blue"));//true

console.log(!!0);//false

console.log(Boolean(0));//false

console.log(!!NaN);//false

console.log(Boolean(NaN));//false

console.log(!!"");//false

console.log(Boolean(""));//false

console.log(!!12345);//true

console.log(Boolean(12345));//true

7.逻辑与（&&）、逻辑或（||）都是短路操作

&&:

短路操作。如果第一个操作数是false，则不会再对第二个操作数求值。

在有一个操作数不是布尔值的情况下，逻辑与操作不一定返回布尔值。规则如下：

若第一个操作数是对象，返回第二个操作数
若第二个操作数是对象，则只有在第一个操作数的求值结果为true才返回第二个操作数
若两个操作数都是对象，则返回第二个操作数

若有一个操作数是null,NaN,undefined,则返回null,NaN,undefined

  var found=true;

  var result=(found && someUndefinedValue);//报错,不能在逻辑与中使用未定义的值

  console.log(result);//不会执行

  var found=false;

  var result=(found && someUndefinedValue);

  console.log(result);//false

||：

短路操作。如果第一个操作数是ture,则不会再对第二个操作数求值。

在有一个操作数不是布尔值的情况下，逻辑或操作不一定返回布尔值。规则如下：

若第一个操作数是对象，返回第一个操作数
若第一个操作数的求值结果为false,则返回第二个操作数
若两个操作数都是对象，则返回第一个操作数

若两个个操作数都是null,NaN,undefined,则返回null,NaN,undefined

  var found=true;

  var result=(found || someUndefinedValue);

  console.log(result);//true

  var found=false;

  var result=(found || someUndefinedValue);//报错

  console.log(result);//不会执行

8.除法与C不同

C是整数除法得到整数，而它是：

console.log(5/3);//1.6666666666666667

js两个整数相除是可以得到小数的。和C除完就是整数不同。

9.加法操作符和减法操作符的区别

如果两个操作数有一个是字符串：

加法是将另一个操作数转换为字符串，然后再将两个操作数拼接起来。

减法是将在后台调用Number()将这个字符串转换为数值，再执行减法计算。

  console.log("sum is "+1+1); //sum is 11

  console.log("sum is "+(1+1)); //sum is 2

  console.log("1"+1);//11

  console.log("1"+"1");//11

  console.log(5-true);//4

  console.log(NaN-1);//NaN

  console.log("5"-3);//2

  console.log("5"-"3");//2

  console.log(5-"3");//2

  console.log(5-"");//5

  console.log("5"-"abc");//NaN

10.相等全等比较规则

关于相等：

如果有一个操作数是布尔值，则在比较之前true转换为1，false转换为0；
如果操作数一为字符串，一为数值，则比较前把字符串转换为数值；
如果操作数一为对象，一不为对象，则调用对象的valueOf()方法，得到基本类型值再按前面的规则进行比较。
null和undefined相等；
比较前，null和undefined不会转换成其他任何值；
有一个操作数是NaN，则相等操作符返回false,不相等操作符返回true。即使两个都是NaN也是不相等；

如果两个操作数都是对象，则如果它们指向同一个对象相等操作符返回true，否则返回false。

  console.log(null==undefined);//true

  console.log("NaN"==NaN);//false

  console.log(NaN==5);//flse

  console.log(NaN!=NaN);//true

  console.log(false==0);//true

  console.log(true==1);//true

  console.log(true==2);//false

  console.log(undefined==0);//false

  console.log(null==0);//false

  console.log("12"==12);//true

关于全等：

	console.log("55"===55);//false

	console.log(null===undefined);//false

11.使用复合赋值操作符不会带来任何性能的提升

如num+=10与num=num+10性能一样。

12.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++;

    }

}

console.log(num);//55

添加标签导致break不仅会退出内部循环，还会退出外部循环。

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++;

    }

}

console.log(num);//95

continue会在i5&&j5之后退出内部循环，继续执行外部循环。

13.switch语句的不常用方法(可先略）

switch ("hello world") {

    case "hello "+"world":

        console.log("Greeting was found.");

        break;

    case "goodbye":

        console.log("Closing was found.");

        break;

    default:

        console.log("Unexpected message.");

}//"Greetint was found."

switch的case值可以是字符串拼接表达式，它与switch的字符串进行比较得到结果。

var num=25;

switch (true) {

    case num<0:

        console.log("Less than 0.");

        break;

    case num>=0&&num<10:

        console.log("Between 0 and 10.");

        break;

    default:

        console.log("More than 10");

}//More than 20

给switch传递true,因为每个case都可以返回一个布尔值。这样每个case按照顺序被求值，直到找到匹配的值或遇到default。

14.函数的return

函数中return之后的语句永远也不会执行
一个函数可以包含多个return
return可以不带任何返回值。这时，函数执行后将返回undefined。

15.关于函数的arguments

(1)arguments与数组类似，但并不是Array实例。

(2）命名参数只提供便利，但不是必须的。

function doAdd() {

    if (arguments.length==1) {

        console.log(arguments[0]);

    }

    else if (arguments.length==2) {

        console.log(arguments[0]+arguments[1]);

    }

    else{

        console.log("lalala");

    }

}

doAdd(10);//10

doAdd(10,20);//30

(3)arguments可以和命名参数一起使用。

function doAdd(num1,num2) {

    if (arguments.length==1) {

        console.log(arguments[0]);

    }

    else if (arguments.length==2) {

        console.log(arguments[0]+num2);

    }

    else{

        console.log("lalala");

    }

}

doAdd(10);//10

doAdd(10,20);//30

（4）arguments值永远与对应的命名参数的值保存同步。

function doAdd(num1,num2) {

   arguments[1]=10;

   console.log(arguments[1]);

   console.log(num2);

}

doAdd(10,10);//10

             //10

doAdd(5,20);//10

            //10

每次执行函数都会重写第二个参数。修改了arguments[1]，也就修改了num2。

但arguments[1]和num2并不是相同的内存空间，它们的内存空间时独立的，但值会同步。

（5）没有传递值的命名参数将自动被赋予undefined值。

18.JS函数没有重载

其他语言中两个函数同名，但签名（接受的参数类型和数量）不同即可成为两个函数。

JS定义了两个相同名字的函数，那该名字就只属于后定义的函数。

巴特西