渡一开班考试题（二）

11个月前 ⋅ 0

24、下列代码的执行结果是什么？（A）[单选题]

var arr1 = [3, 4];
var arr2 = arr1;
arr2[0] = 1;         
arr2 = [4, 5];
arr2[1] = 2;
arr1[1] = 0;
console.log(arr1, arr2)

A. [1, 0] [4, 2]
B. [3, 0] [4, 2]
C. [4, 2] [1, 0]
D. [4, 2] [3, 0]
解析：

var arr1 = [3, 4];
var arr2 = arr1; // arr2 = [3, 4]，此时 arr2 和 arr1的引用是相同的
arr2[0] = 1; // arr2 = [1, 4],由于 arr1 和 arr2 的引用是相同的，所以 arr1 = [1, 4]
arr2 = [4, 5]; // arr2 = [4, 5]，由于给arr2 重新赋值了，所以arr1 和 arr2 的引用不相同了，此时arr1还是原来的值 [1, 4]
arr2[1] = 2; // arr2 = [4, 2]
arr1[1] = 0; // arr1 = [1, 0]
console.log(arr1, arr2)

25、下列描述中，关于 js 函数定义方式，正确的是（C）[单选题]
A. function add(a,b){return a+b;} 函数表达式
B. var add = new Function('a', 'b', 'return a+b') 函数表达式
C. function add (a,b) { return a+b; }函数声明
D. var add = function (a,b) { return a+b; }; 函数声明
E. var add = new Function('a', 'b', 'return a+b'); 函数声明
解析：
创建函数的三种方式：

  • function test() {} 函数声明
  • var test = function () {} 函数表达式
  • var test = new Function() Function构造函数，不推荐使用这种语法来定义函数，因为这段代码会被解释两次：第一次是将它当做常规ECMAScript代码，第二次是解释传给构造函数的字符串。这样会影响性能。

26、阅读以下代码，控制台打印的结果为？（C）[单选题]

function sum (a, b) { 
  return a + b;
}
sum(1, "2");

A.  NaN  
B:. TypeError  
C. "12"
D. 3
解析：阅读文档：《 js 运算符》

27、阅读以下代码，控制台打印的结果为：(A)。[单选题]

function bar(){
  return foo;
  foo = 10;
  function foo() {}
  var foo = 11;
}
console.log(bar())

A. function foo () {}
B. 10
C. 100
D. undefiend
解析：
阅读文档：《预编译》，可以知道bar函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    foo: undefined
}
3. 将实参值和形参统一
AO = {
    foo: undefined
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    foo: function () {}
}

预编译结束后，函数内部的程序相当于：

return foo; // 函数直接 return foo，不再执行下面的程序
foo = 10;
foo = 11;

所以函数的结果为 function () {}。此题选择 A

28、以下代码的结果为什么？（B）[单选题]

function foo(a) {
  var a;
  return a;
}
function bar(a) {
  var a = 'bye';
  return a;
}
console.log([foo('hello'), bar('hello')])

A. ["hello", "hello"]
B. ["hello", "bye"]
C. ["bye", "bye"]
D. 其他
阅读文档：《预编译》，
1、foo函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    a: undefined
}
3. 将实参值和形参统一
AO = {
    a: 'hello'
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    a: 'hello'
}

预编译结束后，函数内部的程序相当于：

return a;

所以 foo 函数的结果为'hello'。

2、bar函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    a: undefined
}
3. 将实参值和形参统一
AO = {
    a: 'hello'
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    a: 'hello'
}

预编译结束后，函数内部的程序相当于：

a = 'bye';
return a;

所以 bar 函数的结果为 'bye'。

所以此题选择 B。

29、阅读以下代码，控制台打印的结果为：(B)。[单选题]

function test(a, b){
  console.log(a);
  console.log(b);
  var b = 234;
  console.log(b);
  a = 123;
  console.log(a);
  function a(){};
  var a ;
  b = 234;
  var b = function(){};
  console.log(a);
  console.log(b);
}
test(1);

A. 1          undefined   234   123   123               ƒ (){}
B. ƒ a(){}   undefined   234   123   123               ƒ (){}
C. ƒ a(){}   undefined   234   123   123               234
D. 1          undefined   234   123   undefined     ƒ (){}
解析：
阅读文档：《预编译》，可以知道 test 函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    b: undefined,
  a: undefined,
}
3. 将实参值和形参统一
AO = {
    b: undefined,
  a: 1,
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    b: undefined,
  a: function () {},
}

预编译结束后，函数内部的程序相当于：

console.log(a); // function () {}
console.log(b); // undefined
b = 234;
console.log(b); // 234
a = 123;
console.log(a); // 123
b = 234;
b = function(){};
console.log(a); // 123
console.log(b); // function () {}

所以此题选择 B。

30、阅读以下代码，写出控制台的结果：{渡一教育}。

var user = '渡一教育';
function first(){
  console.log(user);
};
function second(){
  var user = '工程师';
  first();
}
second();

31、阅读以下代码，控制台打印的结果依次为：{10}，{5}。

function fun(num) {
  console.log(num);
  var num = 5;
  console.log(num);
}
fun(10)

解析：
阅读文档：《预编译》，可以知道 fun 函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    num: undefined,
}
3. 将实参值和形参统一
AO = {
  num: 10,
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    num: 10,
}

预编译结束后，函数内部的程序相当于：

console.log(num); // 10
num = 5;
console.log(num); // 5

32、阅读以下代码，控制台打印的结果依次为：{undefined}，{200}。

global = 100
function fn(){
    console.log(global);
    global = 200;
    console.log(global);
    var global = 300
}
fn()
var global;

解析：
阅读文档：《预编译》，可以知道 fn 函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    global: undefined,
}
3. 将实参值和形参统一
AO = {
  global: undefined,
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    global: undefined,
}

预编译结束后，函数内部的程序相当于：

console.log(global); // 由于AO中已经有了global，故只会在AO中查找，值为 undefiend
global = 200;
console.log(global); // 200
global = 300

33、阅读以下代码，控制台打印的结果依次为：{undefined}，{20}。

var val = 12;
function fun1(){
  console. log(val);
  var val = 20;
  console.log(val);
}
fun1();

A. 12  20
B. 12  12
C. undefined  20
D. 20  undefined
解析：
阅读文档：《预编译》，可以知道 fun1 函数在预编译阶段：

1. 创建AO对象
var AO = {}
2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
AO = {
    val: undefined,
}
3. 将实参值和形参统一
AO = {
  val: undefined,
}
4. 在函数体里面找函数声明，值赋予函数体
AO = {
    val: undefined,
}

预编译结束后，函数内部的程序相当于：

console. log(val); // 由于AO中已经有了val，故只会在AO中查找，值为 undefiend
val = 20;
console.log(val); // 20

34、以下代码的结果为什么？（C）[单选题]

(function(){
  var x = y = 1;
})();
console.log(y);
console.log(x);

A. 1, 1
B. 报错, 报错
C. 1, 报错
D. 其他
解析：
赋值操作符的结合性是从左到右的，故整段代码相当于：

(function(){
  y = 1;
  var x = y;
})();
console.log(y);
console.log(x);

由于 y 为未经声明的变量，为暗示全局变量，故在全局中有y，所以在全局中能够打印出y为1
由于 x 为在局部作用域中声明的变量，故不在全局中，所以在全局中使用x会报错

35、以下代码的结果为什么？（A）[单选题]

var name = 'World!';
(function () {
  if (typeof name === 'undefined') {
    var name = 'Jack';
    console.log('Goodbye ' + name);
  } else {
    console.log('Hello ' + name);
  }
})();

A. Goodbye Jack
B. Hello Jack
C. Hello undefined
D. Hello World
解析：
在if中的 变量会提升至 局部作用域顶部，故函数代码为这样：

var name = 'World!';
(function () {
  var name;
  if (typeof name === 'undefined') {
    name = 'Jack';
    console.log('Goodbye ' + name);
  } else {
    console.log('Hello ' + name);
  }
})();

所以，会进入到if判断中，打印出 Goodbye Jack

36、以下代码的结果为什么？（A）[单选题]

String.prototype.giveLydiaPizza = function () {
    return "Just give Lydia pizza already!";
};

var name = "Lydia";
console.log(name.giveLydiaPizza());

A. "Just give Lydia pizza already!"
B. TypeError: not a function
C. SyntaxError
D. undefined
解析：
在代码第6行使用了字符串的方法，由于字符串为原始值，故会经过包装类的包装，所以第六行实际上隐式的为：

console.log(new String(name).giveLydiaPizza())

由于 实例对象上没有 giveLydiaPizza 方法，所以会沿着 实例对象的 proto向上查找，实例对象的 proto__ 即为 构造函数的 prototype，所以会执行函数，打印出返回的字符串

37、所有对象都有原型，是正确的的吗？（B）[单选题]

A. 对
B. 错误
解析：

var obj= Object.create(null);
console.log(obj.__proto__);

38、关于下段代码正确的结论是：（A）[单选题]

var F = function(){};
Object.prototype.a = function(){};
Function.prototype.b = function(){};
var f = new F();

A. f能取到a，但取不到b
B. f能取到a,b
C. F能取到b，不能取到a
D. F能取到a，不能取到b
解析：看图：
image.png

39、以下代码的结果为什么？（A）[单选题]

Array.isArray( Array.prototype )

A. true
B. false
C. error
D. other
解析：Array.prototype 为一个数组，Array.isArray是判断一个变量是否为数组。

40、以下对call() 和 apply() 说法哪些是正确的 （ABCD）[多选题]
A. apply()函数有两个参数：第一个参数是上下文，第二个参数是参数组成的数组;
B. 如果第一个参数是null，则使用全局对象代替；
C. call和apply的意思一样,只不过是参数列表不一样.
D. 通过apply可以将数组转换为参数列表的集合
解析：不用解析，全对

41、以下代码的执行结果是什么？（B）[单选题]

var name = "window";
var person = {
  name: "邓小宝",
  sayName: function(){
    console.log(this.name);
  }
};
var animal = {
  name: "崽崽",
};

person.sayName();
person.sayName.call(animal);
person.sayName.apply(window);

A. window 邓小宝 崽崽
B. 邓小宝 崽崽 window
C. 崽崽 邓小宝 window
D. window 崽崽 邓小宝

解析：看文档： 《js中的this指向为什么？》

42、关于 this 的工作原理，下面 4 种情况的描述哪一个是错误的？（C）[单选题]
A. 在全局范围内，this指向全局对象（浏览器下指window）
B. 对象函数调用时，this指向当前对象
C. 全局函数调用时，this指向全局函数
D. 使用new实例化对象时，this指向新创建的对象
解析：
抠字眼儿，C 应该是 对象

43、请阅读以下代码，该代码在浏览器中执行，输出的结果是什么？（B）[单选题]

var obj = {};
obj.log = console.log;
obj.log.call(console, this);

A. undefined
B. window
C. console
D. obj
解析：
obj.log.call(console, this) 相当于 console.log(this); 此时 this 为全局对象 window

44、以下代码执行后，console 的输出是？（A）[单选题]

function Foo(){
  console.log(this.age);
}
Foo();

A. undefined
B. null
C. TypeError
解析：
阅读文档：《js中的this指向为什么？》

45、以下代码的执行结果是什么？（A）[单选题]

function Person(firstName, lastName) {
  this.firstName = firstName;
  this.lastName = lastName;
}

const lydia = new Person("Lydia", "Hallie");
const sarah = Person("Sarah", "Smith");

console.log(lydia);
console.log(sarah);

A. Person {fistName: "Lydia", lastName: "Halli" }  undefined
B. Person {firstName: "Lydia", lastName: "Hallie"}  Person(firstName: "Sarah", lastName: "Smith"}
C. Person {firstName: "Lydia", lastName: "Hallie"}  { }
D. Person { firstName: "Lydia", lastName: "Hallie"}  ReferenceError

解析：
就是考函数执行的结果，函数里面return的值为返回的结果，所以 sarah 的值为undefiend
构造函数在 new 时，会隐式的创建this，如下：

function Person(firstName, lastName) {
  // var this = {}
  this.firstName = firstName;
  this.lastName = lastName;
  // return this
}

46、以下代码的结果为什么？（D）[单选题]

function sidEffecting(arr) {
  arr[0] = arr[2];
}
function bar(a,b,c) {
  c = 10
  sidEffecting(arguments);
  return a + b + c;
}
console.log(bar(1, 1, 1));

A. 3
B. 12
C. error
D. 21
解析：
阅读文档：《arguments》

整道题的分析：

  1. 确定console 的结果 为 bar 函数的运行结果
  2. 首先确定 bar 函数的实参 a b c 都传入了，所以arguments 和 形参 a b c的值是同步的
  3. 进入到 bar 函数内部。首先更改 c 的值 为 10，因为 更改了 参数 从，所以 此时arguments 为 [1, 1, 10]
  4. 执行sidEffecting函数，并传入 arguments
  5. 在 sidEffecting 内，让arr[0] = arr[2]，由于arr为引用值。所以相当于让 bar函数中的arguments [0] = arguments [2]，故bar函数内 arguments  = [10, 1, 10]
  6. 由于arguments的更改，所以 bar 函数的参数a 为 10，参数b为2， 参数c为10
  7. bar 函数 return a + b + c; 结果为返回 10 + 1 + 10 = 21
  8. 所以选择 D

47、以下代码的执行结果是什么？（C）[单选题]

function fn(arg1, arg2){
  console.log(arg1, arg2);
  arguments[0] = "duyi";
  arg2 = "web";
  console.log(arg1);
  console.log(arguments[1]);
};
fn("html","css");

A. "duyi" "web" "duyi" "web"
B. "html" "web" "duyi" "web"
C. "html" "css" "duyi" "web"
D. "html" "css" "web" "duyi"
解析：
阅读文档：《arguments》
整道题的分析：

function fn(arg1, arg2){
  console.log(arg1, arg2); // "html" "css
  arguments[0] = "duyi"; // arguments[0] 与 arg1同步，故arg1 = "duyi"
  arg2 = "web"; // arg2 与 arguments[1] 同步，故 arguments[1] = "web"
  console.log(arg1); // "duyi"
  console.log(arguments[1]); // "web"
};
fn("html","css");

48、下面代码的输出是什么? （C）[单选题]

function getAge(){
  "use strict";
  age = 21;
  console.log(age);
}

getAge();

A. 21  
B. undefined  
C. ReferenceError  
D. TypeError
解析：
在严格模式下，变量必须声明，否则报错

49、以下代码中,为class为test的div对象设置红色背景的正确js代码为：（B）[单选题]

<div class="test"></div>

A. document.getElementsByClassName("test").style.backgroundColor="red";
B. document.getElementsByClassName("test")[0].style.backgroundColor="red";
C. document.getElementsByClassName("test")[0].style.background-color="red";
D. document.getElementsByClassName("test").style.background-color="red";
解析：
通过 getElementsByClassName 获取的为类数组，想要定位到 指定的元素，必须要指定索引，故排除 AD
在css中凡是用短横线"-" 连接的复合单词，在js中都会变为 小驼峰 式使用，故排除C，选择B

50、如何阻止IE和各大浏览器默认行为：（BD）[多选题]
A. window.event.cancelBubble = true;
B. window.event.returnValue = false;
C. event.stopPropagation();
D. event.preventDefault();
解析：
A 为在IE浏览器下取消冒泡、C 为在非IE浏览器下取消冒泡

51、阅读以下代码，单击按钮时event.target是什么？（C）[单选题]

<div onclick = "console. log('first div')" > 
<div onclick="console.log('second div')">
  <button onclick="console.log('button')">
    Click!
  </button>
 </div>
</div >

A. div外部
       B. div内部
       C. button
       D. 所有嵌套元素的数组
解析：
event.target 为 触发事件的源对象，当点击 button 按钮时，源对象即为 button，故选择 C

52、阅读以下代码，单击下面的html片段打印的内容是什么?（A）[单选题]

<div onclick="console.log('div)">
  <p onclick="console.log('p')">
    Click here!
  </p>
</div>

A. p div  
B. div p  
C. p  
D. div
解析：
事件会由子冒泡到父，故会先打印 出 'p'，再打印出 'div'

53、阅读以下代码，控制台中打印的结果为：{2}。

<div class="content"></div>
<div class="content"></div>
<div class="content"></div>
var oDivMap = document.getElementsByClassName('content');
oDivMap[1].className ='wrapper';
console.log(oDivMap.length)

解析：
在第一次获取 class 为 content 的元素时，oDivMap 内有三个元素
但是，后来更改第 2 个 元素的 class 为 wrapper，由于 getElementsByClassName 是实时的，所以此时获取class为content的元素的长度时，长度为2。

54、setTimeout(go, 10);表示的意思是：（C）[单选题]
A. 间隔10秒后，go()函数执行一次
B. go()函数持续调用10次
C. 间隔10毫秒后，go()函数执行一次
D. 间隔10分钟后，go()函数执行一次
解析：setTimeout 第一个参数为成周期性执行的函数，第二个参数为周期，单位为ms

55、以下代码执行后，console 输出的信息是？（D）[单选题]

for(var i = 0; i < 5; i++){
  setTimeout(function () {
    console.log(i)
  }, 1000)
}

A. 1 2 3 4 5
B. 0 1 2 3 4
C. 4 4 4 4 4
D. 5 5 5 5 5
解析：
在1000ms后打印i，i已经变为了5，所以会打印出 5个 5

56、阅读以下代码，下列选项中正确的是（B）。

function buildList(list) {
  var result = [];
  for (var i = 0; i < list.length; i++) { 
    var len = result.length;
    var item = "item" + i;
    result[len] = function () {
      console.log(item + list[i]);
    };
  }
  return result;
}
function testList() {
  var fnlist = buildList([1, 2, 3]);

  for (var j = 0; j < fnlist.length; j++) {
    fnlist[j](); 
  }
}
testList();

A. item2item0 item2item1 item2item2
B. item2undefined item2undefined item2undefined
C. item0undefined item1undefined item2undefined
D. item0item0 item1item1 item2item2

解析：闭包：能够读取其他函数内部变量的函数。

57、阅读以下代码，控制台打印的结果为：{shanshan}。

function foo() {
  var name = "shanshan";
  return function() {
    console.log(name);
  };
}
var bar = foo();
bar();

解析：闭包：能够读取其他函数内部变量的函数。

58、阅读以下代码，控制台打印的结果为：{5}。

function addCount(count) {
  return function(add) {
    count = count + add;
    console.log(count);
  };
}
addCount(2)(3);

解析：闭包：能够读取其他函数内部变量的函数。

59、阅读以下代码，控制台打印的结果为：{lily}。

function sayHello(name) {
  var text = name; 
  var say = function () {
    console.log(text);
  };
  return say;
}

var say2 = sayHello("lily");
say2();

解析：闭包：能够读取其他函数内部变量的函数。

60、阅读以下代码，控制台打印的结果依次为：{1}，{2}。

function fn() {
  var num = 0;
  return function () {
    num += 1;
    console.log(num);
  };
}
var f = fn();
f();
f();

解析：闭包：能够读取其他函数内部变量的函数。

61、以下代码的结果为什么？（B）[单选题]

var a = Date(0);
var b = new Date(0);
var c = new Date();
console.log( [a === b, b === c, a === c] )

A. [true, true, true]
B. [false, false, false]
C. [false, true, false]
D. [true, false, false]
解析：

var a = Date(0); // 得到当前的字符串时间
var b = new Date(0); // 得到一个实例对象
var c = new Date(); // 得到一个实例对象
console.log( [a === b, b === c, a === c] )

62、以下表达式不会出现错误的有：（BCD）[多选题]
A. 2.toString()
B. 2..toString()
C. 2 .toString()
D. (2).toString()
解析：
在数字后面用 "." 会被认为是一个数字，所以 A是会报错的

63、阅读以下代码，控制台输出的结果为？（A）[单选题]

var arr = [1, 2, 3, 4, 5];
console.log(arr.length);
arr.length = 2;
console.log(arr);
arr.length = 3;
console.log(arr);

A. 5 [1, 2] [1, 2, empty]
B. 5 [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
C. 5 [1, 2] [1, 2, 3]
解析：

var arr = [1, 2, 3, 4, 5];
console.log(arr.length); // 5
arr.length = 2; // arr = [1, 2]
console.log(arr);
arr.length = 3; // arr = [1, 2, empty]
console.log(arr);

64、阅读以下代码，控制台中依次输出：{3}，{"abc"}，{3}。

var str = 'abc';
console.log(str.length);
str.length = 1; 
console.log(str); 
console.log(str.length);

解析：

var str = 'abc';
console.log(str.length); // 3
str.length = 1;  // 由于 str 为一个原始值，要调用length属性，会创建一个包装类为 length 赋值，然后立即销毁
console.log(str);  // 'abc'
console.log(str.length); // 3

65、阅读以下代码，控制台中输出的结果为：{undefined}。

var name = 'shanshan';
name += 10;
var type = typeof(name); 
if (type.length === 6) { 
  type.text = 'string'; 
}
console.log(type.text);

解析：

var name = 'shanshan';
name += 10;  // name 为 "shanshan10"
var type = typeof(name);  // type 为 "string"
if (type.length === 6) {  // 因为 "string" 的长度 为 6，故进入到 if循环中
  type.text = 'string';  // 让 "string" 的 身上拥有 text 属性，此时为了不报错，系统会 new String("string").text = "string";但是注意实例会马上销毁
}
console.log(type.text); // 打印type的text，由于在上一步中已经销毁了，所以值为undefined

66、阅读以下代码，控制台打印的结果，依次为：{1}，{undefined}，{2}。

(function () {
  try {
    throw new Error();
  } catch (x){
    var x = 1,
        y = 2;
    console.log(x);
  }
  console.log(x);
  console.log(y);
}())

解析：
在  catch 中的 声明，会将声明提升到 父级作用域的顶部，故上述代码相当于：

(function () {
  var x, y;

  try {
    throw new Error();
  } catch (x){
    x = 1,
    y = 2;
    console.log(x);
  }
  console.log(x);
  console.log(y);
}())

接着还用解释吗？不需要了