CSS

1、设置元素浮动后，该元素的 display 值是什么（A ）
  A、block
  B、不变
  C、inline
  D、inline-block

解析：当元素设置浮动之后，会完全脱离文档流。块元素脱离文档流之后，高度和宽度都被内容撑开；内联元素脱离文档流后，会变成块元素

JavaScript

数组

1、

1
2
3
4
let arraynew = new Array(5)
arraynew[1] = 1
arraynew[5] = 2
console.log(arraynew.length) // 6

解析：使用 Array() 构造器创建数组，当传一个范围在 0 到 2^32-1 之间的整数时，将返回一个 length 的值等于传入的整数的空数组（是空数组，不是值为undefined的数组，但是获取索引对应的值时，将返回undefined），如果传入的值是其他类型的，则会返回一个新数组，传入的值会依次放入新数组
new Array(‘5’,4,[1,2]) => [‘5’,4,[1,2]]
new Array([1,2]) => [[1,2]]

函数

1、

1
2
3
4
5
6
7
var x = 10
~ function (x) {
  console.log(x)
  x = x || 20 && 30 || 40
  console.log(x)
}()
console.log(x)

解析：自执行函数没有实参，所以第一次打印 x 为 undefined；逻辑与优先级高于逻辑或，x || 20 && 30 || 40 => 20 && 30 返回 30，x || 30 返回 30，30 || 40 返回 30，所以第二次打印结果为 30；外层 x 没有修改，所以为 10

2、

1
2
3
4
5
6
7
8
9
10
let x = [1, 2], y = [3, 4]
~ function (x) {
  x.push('A')
  x = x.slice(0)
  x.push('B')
  x = y
  x.push('C')
  console.log(x, y)
}(x)
console.log(x, y)

解析：函数内形参 x 的值在 x = x.slice(0) 这一步就与全局的 x 的值脱离了关系（即引用地址不同）

3、

1
2
3
4
5
6
7
8
9
let a = 0, b = 0;
function A(a) {
  A = function(b) {
    alert(a+b++)
  }
  alert(a++)
}
A(1)
A(2)

A(1) 执行时，形成一个新的私有作用域，这个私有作用域的代码从上到下执行，走到 A 赋值这里，私有作用域里的函数堆被赋值给全局的 A，导致函数 A(1) 执行完毕后不会被销毁，A(1) 的形参 a 得以保存

4、编写一个ADD函数满足如下需求

add(1); //1
add(1)(2); //3
add(1)(2)(3); //6
add(1)(2, 3); //6
add(1, 2)(3); //6
add(1, 2, 3); //6

1
2
3
4
5
6
7
8
9
10
11
12
function add(...outer){
  add=function(...inner){
    outer.push(...inner)
    return add
  }
  add.toString=function(){
    return add.reduce((x,y) => x+y)
  }
  return add
}
let res=add(1,2)(3)(3,4)(7)
alert(res) // alert会把输出的值转换为字符串 -> toString()

5、下面代码输出结果是什么？

1
2
3
4
5
6
7
8
9
let obj = {
    2: 3,
    3: 4,
    length: 2,
    push: Array.prototype.push
}
obj.push(1);
obj.push(2);
console.log(obj);

输出结果：

1
{2: 1, 3: 2, length: 4, push: Array.prototype.push}

解析：push 方法将值追加到数组中。push 方法具有通用性，可应用在类似数组的对象上。该方法根据 length 属性来决定从哪里开始插入给定的值。如果 length 不能被转成一个数值或者不存在时，则插入的元素索引为 0。如果 length 不存在，将会创建它

6、

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Foo() {
  getName = function(){
    console.log(1)
  }
  return this
}
Foo.getName = function () {
  console.log(2)
}
Foo.prototype.getName = function () {
  console.log(3)
}

new Foo.getName()
new Foo().getName()
new new Foo().getName()

解析
new Foo.getName() -> new (Foo.getName())
new Foo().getName() -> (new Foo()).getName()
new new Foo().getName() -> new ((new Foo()).getName())