js面试题总结

1.typeof和Object.prototype.toString

typeof是js里面判断变量类型的一种方法，但这种方法没有Object.prototype.toString准确，前者有6种判断结果，分别是function,string,number,object,undefined,boolean，后者有8中判断结果，分别是[object Function],[object Number],[object String],[object Object],[object Array],[object Null],[object Undefined],[object Boolean]。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

巴特西

js面试题总结

最新文章

热门文章