js面试题总结

1.typeof和Object.prototype.toString

typeof是js里面判断变量类型的一种方法，但这种方法没有Object.prototype.toString准确，前者有5种判断结果，分别是function,string,number,object,undefined，后者有7中判断结果，分别是[object Function],[object Number],[object String],[object Object],[object Array],[object Null],[object Undefined]。typeof对于数字类型，null类型以及数组类型的判断不如Object.prototype.toString准确。

下面是我的测试代码和运行结果：

        function func(){

        }
        var str="str";
        var num=1;
        var dou=3.14;
        var num_obj=new Number(1);
        function Person(name){
            this.name=name;
        }
        var person=new Person("hexiang");
        var nul=null;
        var undef=undefined;
        var arry=[];
        var obj={};
        console.log("-----typeof-----");
        console.log("func:"+typeof func);
        console.log("str:"+typeof str);
        console.log("num:"+typeof num);
        console.log("num_obj:"+typeof num_obj);
        console.log("dou:"+typeof dou);
        console.log("person:"+typeof person);
        console.log("nul:"+typeof nul);
        console.log("undef:"+typeof undef);
        console.log("arry:"+typeof arry);
        console.log("obj:"+typeof obj);
        console.log("null:"+typeof null);        console.log("unknown variable:"+typeof unknownvar)
        console.log("-----toString-----");
        console.log("func:"+Object.prototype.toString.call(func));
        console.log("str:"+Object.prototype.toString.call(str));
        console.log("num:"+Object.prototype.toString.call(num));
        console.log("num_obj:"+Object.prototype.toString.call(num_obj));
        console.log("dou:"+Object.prototype.toString.call(dou));
        console.log("person:"+Object.prototype.toString.call(person));
        console.log("nul:"+Object.prototype.toString.call(nul));
        console.log("undef:"+Object.prototype.toString.call(undef));
        console.log("arry:"+Object.prototype.toString.call(arry));
        console.log("obj:"+Object.prototype.toString.call(obj));
        console.log("null:"+Object.prototype.toString.call(null));

结果如下：

-----typeof-----
 func:function
 str:string
 num:number
 num_obj:object
 dou:number
 person:object
 nul:object
 undef:undefined
 arry:object
 obj:object
 null:object

unknown variable:undefined

-----toString-----
 func:[object Function]
 str:[object String]
 num:[object Number]
 num_obj:[object Number]
 dou:[object Number]
 person:[object Object]
 nul:[object Null]
 undef:[object Undefined]
 arry:[object Array]
 obj:[object Object]
 null:[object Null]

2.false和==,===

==号向来是不严谨的，比如‘1‘==1是true的，而‘1‘===1则是false的，特别是当[],0,“”,"0"和false进行比较时，用==都会返回true, ===都会返回false。不过注意null和undefined和false进行比较时，不管是用==还是===都是false的。

3.局部变量和全局变量，连续赋值

以下代码

var a=b=3;

是连续赋值，相当于先执行b=3;再执行var a=b;所以这个时候a,b都是全局变量，这个时候打印a,b肯定都是3，没毛病。

但是下面代码:

(function(){
    var a=b=3
})();

虽然也是先执行b=3,再执行var a=b;但由于代码是包含在闭包中的，所以有var声明的a就是局部变量，没有var声明的b就是全局变量，此时从全局角度来看b是3，a是undefined。

4.this

var myObject={
        foo:"bar",
        func:function(){
            var self=this;
            console.log("outer func:this.foo="+this.foo);
            console.log("outer func:self.foo="+self.foo);
            (function(){
                console.log("inner func:this.foo="+this.foo);
                console.log("inner func:self.foo="+self.foo);
            })();
        }
    };
    myObject.func();

输出:

outer func:this.foo=bar
outer func:self.foo=bar
inner func:this.foo=undefined
inner func:self.foo=bar

注意this在javascript里面根据函数域的不同而不同，(function(){})()是myObject.func()里的一个闭包，形成了一个独立的函数域，因此this在myObject.func里指的是myObject这个对象，在闭包里指的是window对象。

5.严格模式 use strict 的使用及作用

"use strict"; 放在脚本第一行，则下面的所有代码都执行严格模式，放在函数的第一行，则函数里的所有代码都执行严格模式。那么严格模式与正常模式有什么区别呢？

（1）严格模式下不允许不声明就赋值。正常模式下a=2是不会有错的，严格模式下会报"Uncaught ReferenceError: a is not defined"，包括var a=b=2这样的赋值在严格模式下也是不允许的，3里面提到过。

（2）禁止使用with，eval有自己的作用域了（相当于闭包了）

（3）禁止函数中的this指向全局对象，例如下面代码

function hello(){
    console.log(this);
}
hello();

会输出window对象，但是如果hello函数第一行加上“use strict”;会输出undefined

(4)禁止使用caller,arguments.callee等

(5)禁止函数形参重名

(6)禁止使用八进制数字，如012，正常模式下相当于数字10，但是在严格模式下会报错

(7)public,protected,private,implements,interface,package,let,yield,static等关键词不允许使用

(8)还有其他的一些用的比较生辟的，这里就不再赘述了。

6.奇怪的分号

下面两个函数的返回值分别时2和undefined

function a(){
        return {
            a:2
        };
    }
    function b(){
        return
        {
            a:2
        };
    }

因为js中分号并不像c++,java那样是必须的，很多时候js代码只要独立成行的写，解析器会根据能否正常编译来自动判断是否应该有分号。return,break,continue这样的关键词后面紧跟换行的话，解析器一定会在后面自动添加分号，于是b函数相当于

    function b(){
        return;
        {
            a:22
        };
    }

7.NaN是啥？

NaN是not a number的缩写，是一种特殊的Number类型的数值（这他妈太奇怪了），toString.call(NaN)的结果你会发现是[object Number]，isNaN可以判断一个变量（字符串，数字）能否转化为数字，返回true时表示不行，返回false是表示可以。

8.js浮点型计算

和java等多数语言一样，js里0.1+0.02并不等于0.12，而是后面有一长串的小数，我们可以自己实现方法进行准确的计算，比较好的一个方法就是先升幂后降幂的方法。非常简短，如下：

function add(n1,n2){
       var d1=((n1+"").split(".")[1]).length;
       var d2=((n2+"").split(".")[1]).length;
       var r=Math.pow(10,Math.max(d1,d2));
       return (n1*r+n2*r)/r;
}

9.使用定时器解决堆栈溢出的问题

下面代码在队列巨大的时候会导致堆栈溢出，

function bar(){
        var n=list.pop();
        //do something
        if(n!=null){
            bar();
        }
 }

解决堆栈溢出的一个很好的方法是使用定时器，当然这会带来异步的问题，请注意。

function bar(){
        var n=list.pop();
        //do something
        if(n!=null){
            setTimeout(bar,0);
        }
    }

10.&& 和||执行顺序

举个简单的例子吧，0&&1||2返回2,0||1&&2返回2