笔试高频易错题集01

大家在参加面试之前都应该看看的这些题，说不定你笔试就遇到了呢！

        ▼ 判断下面创建对象的方式哪个是错误的：

                 ① 方式一：

    // 01 方式一
    var obj1 = new Object();
    obj1.name = "NZGZ";
    obj1.getName = function () {
        return this.name;
    }
    console.log(obj1.getName());

                ② 方式二：

    //02 方式二
    var obj2 ={
        name:"ZML",
        getName: function () {
            return this.name;
        }
    }
    console.log(obj2.getName());

               ③ 方式三：

    //03 方式三
    var MYClass = function(){
        this.name = "ZDYGZ";
        console.log(this.getName());
    }
    var obj3 = new MYClass();
    console.log(obj3);

              ④ 方式四：

     //04  方式四
    var obj4;
    obj4.name = "CWFS";
    obj4.getName = function () {
        return this.name;
    }
    console.log(obj4);

 

题目分析：Ⅰ 本题考察的是创建对象的方式。创建对象的方式有四种：

                            ⅰ字面量的方式创建对象       var obj = {}

                            ⅱ 采用内置构造函数来创建对象   var  obj = new Object();...

                            ⅲ 采用工厂函数的方式         

                            ⅳ 自定义构造函数的方式

              Ⅱ  题目中的 方式四 是错误的创建对象方式，因为obj4 是基本类型的变量，给它添加属性虽然不报错，但是不是一个对象；其次打印出 obj4.name  的结果是undefined

                            ⅰ 方式一 是内置构造函数的方式创建对象

                            ⅱ 方式二 是字面量的方式创建对象

                            ⅲ 自定义构造函数的方式创建对象 

题目外延伸：

             Ⅰ 利用工厂函数方式创建对象

        function Product(sno,name){
        var o = new Object();
        o.sno =sno;
        o.name = name;
        return o;
    }
    var yangwawa = Product("007","芭比娃娃");
    console.log(yangwawa);

             Ⅱ 自定义构造函数创建对象的常见方式

        function Person(name,age){
        this.name = name;
        this.age = age;
        this.showName = function(){
            console.log(this.name);
        }
    }

          ▼下面输出的各个结果是什么？

//第一处输出结果
    console.log(test);
    function test(){}
    //第二处输出结果
    console.log(typeof test);
    var test ="2017";
    //第三处输出结果
    console.log(test);

题目分析：

         Ⅰ. 本题考察的是 函数和变量声明提升的问题，并且函数和变量同名的情况；函数和变量声明提升的情况有以下三种：

                              ⅰ 变量和变量同名的情况，处理方式是后面的变量会把前面的变量覆盖

                              ⅱ 函数与函数同名的情况 ，处理方式也是后面的覆盖前面的

                              ⅲ 变量和函数同名的情况，处理方式是 函数声明会正常提升，而变量声明可以看作被忽略了（不管函数声明在前还是在后）

         Ⅱ.  输出结果为：         

    //第一处：
    function test (){}
    //第二处：
    function 
//第三处：    
     2017

这里的函数和变量同名，函数的声明正常提升，而变量的声明看作被忽视，变量提升后代码的结构可以看作是这样的：

     function test(){}
    console.log(test); 
    console.log(typeof test);
     test ="2017";
    console.log(test);

      ▼下面输出的各个结果是什么？

   var f = new Number(true);
    if (f == true){
        var a = 10;
    }
    function  fn(){
        var b =20;
        c =30;
    }
    fn();
    console.log(a);
    console.log(b);
    console.log(c);

题目分析：

         Ⅰ. 本题考察的是 js中的作用域和变量的提升；js中只有两种作用域：

                      ⅰ script 标签创建的，全局作用域

                      ⅱ 函数创建的，局部作用域

                      ⅲ js本身没有块级作用域（try...catch除外）

         Ⅱ 输出结果： 10     报错     30

结果分析：

         Ⅰ.  var f = new Number(true);  这句代码，只有传入 true和 1 的 时候  f ==true  为真，其他都是假，所以此处  a = 10

         Ⅱ. 因为 b 在函数 fn中声明的，所以是 b 是局部变量，在外部不能够访问 ，故打印 b 的值会找不到，即 报错

         Ⅲ. c 虽然写在函数 fn中 ，但是它并没有使用var来声明，所以会默认成为 window 的属性，所以可以访问 ，c =30

 

     ▼下面我们将上面的题目稍作修改，输出的各个结果是什么？

    var f = new Number(0);
    if (f == true){
        var a = 10;
    }
    function  fn(){
        var b =20;
        c =30;
    }
    fn();
    console.log(a);
    console.log(b);
    console.log(c);

输出结果 ： undefined   报错    30  

结果分析：注意 if语句中声明的 a 是全局变量，因为js中只有两种作用域，没有块级作用域。

       ▼下面输出的各个结果是什么？

 var str1 = new String("demo1");
    var str2 = new String("demo2");
    var str3 = "demo1";
    console.log(str1 == str2);
    console.log(str1 == str3);

题目分析： Ⅰ. 这道题考察的是 == 的比较；相等比较：

                       ⅰ. 如果比较的是引用类型，那么比较的是他们的地址（因为引用类型的内容是地址）

                       ⅱ. 如果相比较的一个是引用类型，一个是基本类型，那么会有一个隐式转换，比较的是（ 对象.valueof ==基本类型值）

输出结果： false      true 

 

        ▼下面输出的各个结果是什么？

 

 var name = "worid";
    (function(){
        if (typeof  name == undefined){
            var name = "老薛";
            console.log("Goodbye" + name);
        }

        else {
            console.log("Hello " + name);
        }
    })()

 题目分析：这道题和上面的题目很相似。考察的知识点是作用域和变量提升的问题，但是有一个注意点 ， “undefined” == undefined  输出结果不是 true ,而是 false .

打印结果： Hello undefined

结果分析：在函数体中，变量提升，进行if判断时，typeof name  是 "undefined" ,所以执行 else中的内容。

         ▼下面输出的各个结果是什么？





 var a = [];
    if(a){
        console.log([1] == true);
    }
    else {
        console.log("No");
    }






题目分析：


               Ⅰ这道题看似简单，包含的内容有对象和布尔类型的比较，数组与布尔类型的比较，以及if判断中的类型：


                           ⅰ. 对象和布尔类型（true|false）比较，结果永远都是false


                           ⅱ.数组在和布尔类型比较时，只有 [1]==true  结果为true，其他都为false;


                           ⅲ.if 判断的时候，只要是引用类型都为true ,  [0]、[1] 、[] 、{} 这些都是真；


输出结果：true






        ▼下面输出的各个结果是什么？




    var a = {};
    var b = Object.prototype;
    console.log(a.prototype === b);
    console.log(Object.getPrototypeOf(a) === b);






题目分析：


                 Ⅰ 考察 prototype 和 .__proto__


                           ⅰ. prototype 是构造函数的属性 


                           ⅱ. 实例化对象.__proto__  和对象.prototype 不是一回事


                 Ⅱ  Object.getPrototypeOf(对象)  获取对象的原型对象


输出结果：   false        true       


                Ⅰ 对象.prototype指的是访问对象的prototype属性；如果该对象是一个普通的对象（非构造函数），那么不存在该属性。


                Ⅱ 对象.__proto__指的是访问创建该对象的构造函数的原型对象，等价于其构造函数.prototype       


                Ⅲ console.log(a.__proto__ == Object.prototype); 结果为  true 


          


        ▼下面输出的各个结果是什么？




    function f(){}
    var a = f.prototype;
    var b = Object.getPrototypeOf(f);
    console.log(a === b);
    console.log(b == f);




输出结果：  false     false


                        ⅰ. a 是构造函数 f 的原型对象


                        ⅱ.b 是 f 对象的原型对象  ，是空函数  （因为构造函数也是对象，也有它的原型对象）


                        ⅲ. b 和 f 比较，，虽然都是空函数，但是他们都是对象，对象比较时，比较的是地址，所以也是false


              


 






            

            
posted @ 
2017-04-02 17:11 
张晓艳 
阅读(395) 
评论(0) 
 
收藏 
举报