JS 笔试题

# JS二期第一次测试（1-7章）

1. 下面符合一个有效的javascript变量定义规则的是？

```

A. _$te$t2

B. with

C. a bc

D. 2a

正确答案：A

解析：

这道题在检测大家的标识符命名规则，B选项 with 是关键字，C 选项多了个空格，D 选项以数字开头了所以都是错误的，最后正确答案为 A

JS关键字链接：https://www.runoob.com/js/js-reserved.html

 

2. 下面哪项会弹 1 ？（）

```

A : if('2' < '15'){alert(1)};

B : if(15-15){alert(1)};

C : if('2' < '15'){alert(1)}else{alert(2)};

D : if('5'+0){alert(1)};

答案:(D)

```

解析：

这里用到了录播视频中的一个知识点，字符串比较，注意字符串比较的时候会按照 Unicode 编码比较，而 “1” 的 Unicode 小于 “2” 的Unicode ，所以 “1”0 小于 “2”, “15” 和 “2” 比较时，会先比较第0位，第0位 “1” 小于 “2”，则认定 “15” 小于 “2”，而不会继续向后比较

明白了字符串比较规则之后，我们再来看看每一个选项

选项 A 和 选项 C 中，'2' < '15' 成立才会 弹出 1，但是 明显 字符串比较时 '2' < '15' 是不成立的

选项 B 15 - 15 结果为 0 ，0 转换成布尔值为 false ，所以也是不成立的

选项 D '5'+0 结果为 “50”，非空字符串转成 布尔值后true，所以是正确答案

 

3. 依次点击4个li标签，哪一个选项是正确的运行结果（）?

```

现有如下html结构

<ul>
 <li>click me</li>
 <li>click me</li>
 <li>click me</li>
 <li>click me</li>
</ul>

运行如下代码：

var elements=document.getElementsByTagName('li');
var length=elements.length;
for(var i=0;i<length;i++){
    elements[i].onclick=function(){
        alert(i);
    }
}

A. 依次弹出1，2，3，4

B. 依次弹出0，1，2，3

C. 依次弹出3，3，3，3

D. 依次弹出4，4，4，4

正确答案：D

```

解析： 这里注意 alert(i) 是在点击事件中，点击事件执行时 for 循环早已经执行完了（3也会被执行完），所有只能拿到 循环执行完之后的结果：4，4，4，4
 

4. 对作用域上下文和 this 的理解，下列代码结果是？

```

var User = {
    count: 1,
    getCount: function () {
        return this.count;
    }
};
console.log(User.getCount()); //what?
var func = User.getCount;
console.log(func()); // what?

A 1 undefined ;

B 1 1 ;

C undefined 1

D undefined undefined;

答案 A ；

```

解析：

这道题重点考察的是大家的 this 指向的理解，

1. 作为对象的方法或属性调用时，this 指向当前对象。User.getCount()，作为一个对象的方法调用，this 指向 User 这个对象，所以 结果 为 1

2. 其余情况 this 指向 window，func() 直接调用的，this 这里指向window，所以结果为 undefined

最终正确答案是 1 undefined

 

5. 下列代码执行结果是？

```

        var length = 10;
        function fn() {
            console.log(this.length);//非对象属性调用，this直接指向window
        }

        var obj = {
        length: 5,
        method: function (fn) {
                fn();
                arguments[0]();
            }
        };

        obj.method(fn,1,2);

A、10 10

B 5 10

C 10 3

D 5 5

答案 C；

```

解析：

这道题重点考察的依然是大家的 this 指向的理解

1. fn(); 这里是直接调用，this 指向window，所有调用的就是我们全局变量中的length，结果为 10

2. arguments[0](); arguments 本身是一个对象(类数组),这里是调用了 对象下的方法，this 指向当前对象，也就是arguments。obj.method(fn,1,2); 这里我们传入了 3 个实参，也就是 arguments.length = 3; 最终调用结果为 3

3.arguments 结果为[fn,1,2] ,此时arguments[0]==>fn，arguments[0]() ==>fn()，但此时的fn()中的this指向的是arguments 本身

具体解析：

arguments[0]：

即fn() {
            console.log(this.length);
        }

arguments[0]()即执行这个函数。而arguments是所有参数的集合（类数组），也是一个对象，这里在对象中调用了this，this就指向对象本身即arguments[]这个类数组，而obj.method(fn,1,2);传入了 3 个实参，也就是说arguments这个类数组的长度为3，所以arguments.length = 3。

 

6. 以下代码运行后，结果为（）

```

var i = 0;

alert( ++i == i++ );

A： true

B，false

C，undefined

D，NaN

答案:(A)

```

解析：

这里要注意运算的优先级

1. 先执行 ++i,这里 i 变成了 1

2. 再执行 i == i, (注意 i++ 中的 ++ 运算优先级最低，会运算完其他之后，最后执行++)

3. i == i 他自己那自然是成立的 所以返回 true

最终结果 为 true

相反如果是alert( i++== ++1 );

就会先执行i++ ,i不变值为0；

再执行0 == ++i;   ++i的值为1,

判断0 == 1，所以结果为false

 

7. 如下代码输出的结果是什么：

```

console.log(1+ "2"+"2");

console.log(1+ +"2"+"2");

console.log("A"- "B"+"2");

console.log("A"- "B"+2);

A.122 122 NaN NaN

B.122 32 NaN NaN2

C.122 32 NaN2 NaN

D.122 32 NaN2 NaN2

答案：C

```

解析：

1. 1+ "2"+"2" : + 碰到字符串会执行字符串连接,所以结果为 '122'

2. 1+ +"2"+"2": 这里重点注意(+"2"),这个 + 号，代表的是正负的正号，正号本身会把字符串正常数字，所以结果变成 1 + 2 + "2",最终结果为 '32'

3. "A"- "B"+"2" : - 号只能用来数字运算，所以 'a' - 'b' 为 NaN，NaN + "2",会进行字符串转换，结果 'NaN2'

4. "A"- "B"+2 : - 号只能用来数字运算，所以 'a' - 'b' 为 NaN，NaN + 2，这里还是数字运算，结果还是为 NaN

最终结果:122 32 NaN2 NaN

 

8. 阅读下列程序，写出 x，y，z 最后的值。

```

        var x = 1, y = z = 0;
        function add(n)
        {
            return n = n + 1;
        }
        y = add(x);
        function add(n)
        {
            return n = n + 3;
        }
        z = add(x);

A. 1 2 4

B. 1 4 4

C. 4 2 4

D. 1 1 1

答案：B

```

解析：JS预解析机制：首先会将所有的var声明的变量即函数，以及所有的函数进行变量提升；遇到同名变量或者函数，后面的后覆盖前面的。如果是通过var声明的变量和函数重名，因为先会解析变量，所以var声明的函数会覆盖var声明的变量。

首先这里会进行预解析:

解析完结果：

        var x,y;
        function add(n)
        {
            return n = n + 1;
        }
        function add(n)
        {
            return n = n + 3;
        }
        x = 1, y = z = 0;
        y = add(x);
        z = add(x);

add 重名了，所以后边覆盖前边的

var x,y;

function add(n)

{

return n = n + 3;

}

x = 1, y = z = 0;

y = add(x);

z = add(x);

x 本身我们没有任何修改，所以他还是赋值时的 1，y 和 z 的操作时完全一样的，结果都为 4

正确答案：1,4,4

 

9. 下面这个JS程序的输出是什么：

```

        function Foo() {
            var i = 0;
            return function() {
                console.log(i++);
            }
        }
        var f1 = Foo(),
        f2 = Foo();
        f1();
        f1();
        f2();

A. 0 1 0

B. 0 1 2

C. 0 0 0

D. 0 0 2

正确答案：A

```

此处f1和f2的返回值都为function() {console.log(i++);}；但是f1和f2是独立的两个函数，相当于f1执行Foo();f2指向Foo2()，所以两个函数的执行没有任何关联；

当f1()执行时，首先查看自身作用域，发现自己没有i，所以就使用父级作用域的i=0,因为i++是先运算再赋值，所以会先打印i=0,在赋值i=1;

当f1()再次执行时，i已经被赋值为1了，所以执行i++时，也会先执行再赋值，打印1,然后给i赋值为1;

当f2()执行时，和f1()执行后的结果没有任何关系，相当于执行了一个新的函数，所以会再次执行i++，打印0;

 

10. 以下代码弹出的值为？（ ）

```

        function f1() {
            var n = 100;
            nAdd = function() {
                n += 1
            }
            function f2() {
                alert(n);
            }
            return f2;
        }
        var result = f1();
        result();
        nAdd();
        result();

A. 100 undefined 101

B. 100 undefined 100

C. 100 101

D. 100 100

答案：C

```

• 重点注意nAdd()执行后并没有打印结果
• result的结果为f2,即函数f2() { alert(n);}
• result()执行，alert(n)中的n自身作用域没有，于是使用父级作用域的100，于是打印100；
• nAdd()执行时，会执行 function() { n += 1 }，因为也是调用的父级作用域的n,所以会将n的值+1；但是nAdd()并没有进行打印
• result()再次执行时，此时n已经变为101，所以会alert 101
• 所以会打印两次，结果分别为 100 101
• 此处的nAdd()在f1()函数中没有var，所以是声明在全局的，所以在外面才可以执行nAdd();但是nAdd的函数体是在f1()中的所以可以调用f1()中的变量n

 

11. 看下列代码输出什么？

```

var foo = "11"+2-"1";

console.log(foo);

A: 1121

B: 131

C: 111

D: 112

答案：C

```

解析：

"11" + "2",字符串连接，结果为: '112', '112' - '1',这里会转换为数字运算 结果为：111

 

12. 请给出这段代码的运行结果（ ）

```

var bb = 1;

function aa(bb) {

bb = 2;

alert(bb);

};

aa(bb);

alert(bb);

A.1 1

B.1 2

C.2 1

D.2 2

答案：C

```

解析：

先执行函数中的 alert(bb) , 输入结果为 2，在解析函数外边的 alert(bb)，但是注意函数中声明了形参 bb 所以函数中的 bb 只是 局部变量，并不影响外边的变量，函数外的 bb 依然是 1

正确答案： 2 1

 

13. 请选择以下代码输出的值

```

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

A.bar bar bar bar

B.bar bar bar undefined

C.bar bar undefined bar

D.undefined bar undefined bar

答案：C

```

重点：函数自执行里this都是指向window，除非更改其this指向

函数中this的指向：

1，作为对象的属性和方法调用，this指向调用的这个对象

2，其余情况都指向window

        /*
            考察对象中的this指向
        */
        var myObject = {
            foo: "bar",
            func: function() {
                var self = this;
                console.log(this.foo);//作为对象的属性调用，this指向该对象，所以打印bar
                console.log(self.foo);//将this赋值给了self，所以self也指向对象，所以打印bar
                (function() {//函数自执行this都是指向window
                    console.log(this.foo);//this 指向window，所以打印undefined
                    console.log(self.foo);//在外层已经将this赋值给了self，所以此处self指向对象本身，所以打印bar
                }());
            }
        };
        myObject.func();

 

14. 以下代码中，会依次出现什么结果？

```

        function fn1() {
            var a = 0;
            function fn2() { 
                ++a; 
                alert(a); 
            }
            return fn2;
        }
        fn1()();
        var newFn = fn1();
        newFn();
        newFn();

A:1,1,2

B:1,1,1

C:0,1,2

D:1,2,3

答案:A

```

解析：

fn1()执行结果为fn2,即fn2的函数体fn2() { ++a; alert(a); }，fn1()()即调用执行了fn2()函数里面的内容。而a在fn2自身作用域里没有，所以就调用父级作用域的a = 0,执行++a后，结果为1

newFn的结果也为fn2()的函数体，但是newFn的执行和fn1()()相当于两次函数调用，每次函数调用之间没有任何关系

newFn()两次调用都相当于，在fn1()中执行了两次 所以第一次执行newFn()，结果为1，第二次执行结果为2

最终结果为1 1 2

 

15. 以下关系运算符输出错误的是？

```

A. console.log([]==0); //true

B. console.log(![]==0); //true

C. console.log({}=={})//false

D. console.log(!{}==![]);//false

答案：D

```

解析：

对象和数字比较，会优先将对象转为数字进行比较；任何类型和数字比较，都会优先转为数字。

Number([])转为数字为0；空数组转为数字返回0，空对象转为数字返回NaN；

逻辑运算符！的优先级大于赋值运算符 ==，所以![]==0，会先指向![]结果为false(注意此处对象不会转为数字)，然后false和0比较返回true;

对象比较的是引用地址，{}不等于{},所以{}=={}不成立;

对象转为布尔值，都转为true，所以!{}就是false。!{}==![]两边都是false，所以最后返回true。

数据类型不一致时，比如[] == "",会转为布尔值进行比较

 

16. 下列关系运算符输出错误的是？

```

A. console.log([1,2]=='1,2'); //true

B. console.log({}=='[object Object]') //true

C. console.log([1,2]=='[1,2]') //false

D. console.log({}==Object) //true

答案：D

```

如果一侧是字符，一侧是其他类型，会优先将其他类型转为字符串进行比较（空对象[] == ""除外）

 

17. 以下代码的运行结果是

 

```

(function() {

var a = b = 5;

})();

console.log(b);

console.log(a);

A. 5 5

B. undefined，undefined

C. 5，undefined

D. 5，Uncaught ReferenceError: a is not defined

答案：D

```

解析：

这里还是作用域问题

注意：var a = b = 5; 这里只是给 a 加了声明，也就是 a 是声明在函数内的，而 b 没有声明

a 声明在函数内，也就是 a 是函数的局部变量，b 没有声明，没有声明就会变成全局变量

在函数外，调用 b ，由于 b 是全局的所以调用 结果为 5

在函数外，调用 a ，由于 a 是局部变量，所以 找不到 就 报错了

 

18. 下面的等式成立的是（）

```

A， parseInt(12.5) == parseFloat(12.5)

B， Number('') == parseFloat('')

C， isNaN('abc') == NaN

D， typeof NaN === 'number'

答案:(D)

```

解析：

1. parseInt(12.5)结果为 12 parseFloat(12.5) 结果为 12.5, 12 == 12.5 结果自然不能成立

2. Number('')结果为0， parseFloat('')结果为 NaN，结果自然也不相等啊

3. isNaN('abc') == NaN，只要看到了 NaN 那等式必须不成立

最终只剩正确答案： typeof NaN === 'number'

 

19. JavaScript 定义 var a="40",var b=7,则执行 a%b 会得到()

```

A.5

B."5"

C.undefined

D.null

答案：A

```

解析：取模会隐士类型转换成数字，结果自然 40%7 = 5

 

20. 下列写法正确的是？（）

A : var i=0; for(;i<10;){ alert(1); i++; } 

B : if(var i=0;i<10;i++){ alert(1); }

C : for(var i=0,i<10;i++;){ alert(1); }

D : for(var i=0;;;;i<10;i-=100;){ alert(1); }

 

答案： A

解析：

注意 for 语句的语法 for(初始值;判断条件;自增语句){执行语句}

1. 排除 B 选项，B 选项 写的是 if

2. C 选中 注意 中间的分隔 应该是 ;号,不是 逗号

3. D选项 这里是 分号但是分号打多了

那最终只有 A 选项了呀