200道前端基础题及答案（下）

前言

在近半年多，养成了一个收集一些的笔面试题的习惯。之前发过一部分，链接：100道前端笔面试题及答案
近期又够了100题，分享给大家

101. 如何清空和截断数组arr

var arr = [1,2,3,4]

答案：
清空：arr.length = 0;
截断：arr.length = n;其中n表示需要截断的位置

102. 下面代码的执行结果是什么？

var arr = [1,0,'',null,undefined,false,true,NaN]
var res = arr.filter(Boolean)
console.log(res)

答案：[1,true]
解析：数组的filter函数，用于遍历数组，将符合条件的成员过滤出来。

103. 封装一个方法hasClass，用于检测元素是否具有指定类名

function hasClass(el,className){
    return el.classList.contains(className)
}

104. 标准盒模型下，块级元素宽度如何计算？

答案：元素宽度 = content宽度 + 左右padding + 左右border

105. 字符串对象中的substring函数和slice函数的区别？
     相同点：
     （1）substring与slice都是用于字符串截取
     （2）都可以接受两个参数start和end，分别表示开始索引和结束索引位（不包含end位置）
     不同的是：
     （1）如果end substring会将start和end交换;
     而slice会直接返回空串,表示没截取到
     （2）如果start或者end有负数
     substring会把小于0的数，当成0来计算
     而slice允许是负数，表示倒数第几位开始或结束

106. 一道和em有关的题，问s5、s6的font-size和line-height分别是多少px？

结构

    
1
    
1

样式
.p2 {font-size: 16px; line-height: 2;}
.s5 {font-size: 2em;}
.s6 {font-size: 2em; line-height: 2em;}

答案：
p2：font-size: 16px; line-height: 32px
s5：font-size: 32px; line-height: 64px
s6：font-size: 32px; line-height: 64px
解释
p2 line-height: 2自身字体大小的两倍
s5 数字无单位行高，继承原始值，s5的line-height继承的2，自身字体大小的两倍
s6 无需解释

107. 说说CSS权重值

!important 无穷大
行间样式 1000
id 100
类 伪类 属性 10
标签 伪元素 1
通配符 0

108. 如何获取浏览器窗口高度和宽度

答案：
window.innerHeight
window.innerWidth
解析：不包含地址栏书签栏等

109.以下代码的执行结果是什么？

var i = 0, j = 0;
for (; i < 10, j < 5; i++, j++) {
    k = i + j
}
console.log(k)

答案：8
解析：注意for循环的执行顺序

110. 找到数组arr中的最大值，写出三种方法

var arr = [1,3,4,-1,0,10,15,7]
方法1
var max = arr.sort(function (a, b) {
    return b - a
})[0]
方法2
var max = Math.max(...arr);
方法3
var max = -Infinity
for (var i = 0; i < arr.length; i++) {
    if (max < arr[i]) {
        max = arr[i]
    }
}

111. 求出下面代码的执行结果

var a = 1
var b = a++
console.log(a, b)
var x = 1
var y = ++x
console.log(x, y)

答案：2 1 2 2
解析：注意++运算符放前和放后的区别

112.下面代码的执行结果是什么？

function fn(){
    alert(1)
}
alert(fn())

答案：分别弹出1 和 undefined
解析：先执行fn()，弹出1，函数返回值为undefined。所以alert(fn())相当于执行alert(undefined)

113. 下面代码的执行结果是什么？

function fn(){
    var a = 0
    function innerFn(){
        a++;
        console.log(a)
    }
    return innerFn;
}
fn()()
var newFn = fn()
newFn()
newFn()

答案：1 1 2
解析：闭包实现私有变量

114. 下面代码的执行结果是什么？

var a = 100
function fn(){
    alert(a)
    var a = 10
    return this.a
}
alert(fn())

答案：undefined 100
解析：执行fn()预编译的结果，局部变量a声明提升，弹出undefined，返回window.a，所以第二次弹出100

115. 下面代码的执行结果是？

var arr1 = [1,2,3,4]
var arr2 = arr1.concat()
arr2.push(arr1.splice(1,0))
console.log(arr1,arr2)

答案：[1, 2, 3, 4] [1, 2, 3, 4，[]]
解析：concat用于连接数组，不改变原数组，返回连接后的新数组。
splice表示截取，可接受三个参数，第一个表示从第几位开始，第二个表示截取长度，第三个要添加的新数据，该函数返回截取部分
这里splice截取0位，所以返回[]数组，所以最后面push到arr2上，所以arr2为[1, 2, 3, 4，[]]

116. 下面代码的执行结果是？

var arr = new Array(3)
arr[1] = 5
arr[2] = 12
console.log(arr[0])

答案：undefined
解析：数组通过new构造函数Array产生时，如果传递一个数字，会创建对应长度的数组，数组的每一项为空，访问时值为undefined

117. 下面代码的执行结果是什么呢？

var a = 100;
console.log(a++);
console.log(++a);

答案：100 102
解析：关于++运算符，如果++在前，就先去++再运行语句。如果++在后面，就先运行语句，后执行变量++

118. 下面代码的执行结果是什么？

var a = !(3 <= 1)
var b = ("abc" == "abc") && ("cc" != "dd")
var c = (4 >= 4) && (5 <= 2)
var d = (2 < 3) || (3 < 2)
console.log(a, b, c, d)

答案：true true false true
解析：第一个！相当于取反，3<=1结果是false，取反是true
接着b，关于&&运算符，当前面表达式结果为true时，返回后面表达式的结果，由于后面表达返回true，所以b的值为true
接着c，同理，返回后面表达式的结果，5<=2,返回false。即c为false
接着d，关于||运算符，如果前面表达式返回true，这结果就为前面表达式的结果。即这里d为true

119. 下面地址栏说法正确的是？

A.window.location.search获取的值是问号到#号之间的内容，包含问号不包含#号
B.修改地址栏中的#号后面的值页面不会刷新
C.window.location与window.location.href相同
D.window.location.hash获取的是#号及其后面的内容
答案：ABCD

120. 下面代码的执行结果是？

var str = 'abcdef'
str.length = 2
console.log(str)

答案：abcdef

121. 下面代码的执行结果是什么？

function fn(){
    return foo;
    foo = 1;
    function foo(){}
    var foo = 'abc'
}
console.log(typeof fn())

答案：function
解析：预编译过程，先变量声明提升，再函数声明整体提升

122. 下面代码的执行结果是什么？

var x = 1;
var obj = {
    x:2,
    foo:{
        x:3,
        fn:function(){
            return this.x
        }
    }
}
var f = obj.foo.fn
console.log(f())
console.log(obj.foo.fn())

答案：1 3
解析：关于this关键字，f()的时候，里面this执行window，所以打印出1；而obj.foo.fn()执行，里面的this指向foo，所以打印3

123. 下面代码的执行结果是什么？

var x = 1;
var obj = {
    x: 2,
    foo: function () {
        setTimeout(function () {
            var x = 3;
            console.log(this.x)
        },1000)
    }
}
obj.foo()

答案：1
解析：setTimeout里面this指向window

124.下面代码的执行结果是什么？

var x = 1;
function fn() {
    this.x = 2;
    return x
}
var f = new fn();
console.log(f.x)

答案：2
解析：关于new关键字，在通过new生成对象时，里面this执行该对象，并且返回该对象。
但是要注意，如果显示返回一个引用值，则new的结果为该引用值

125.下面代码的执行结果是什么？

var fn = function foo(){}
console.log(typeof foo)

答案：undefined
解析：具名函数表达式，函数名只会在函数里面使用。在函数外部是不存在的

126. 下面代码的执行结果是？

var a = 12;
if(true){
    console.log(a)
    let a = 2
}

答案：Uncaught ReferenceError: Cannot access 'a' before initialization
解析：TDZ的原因，默认不能再定义之前使用

127. 下面代码的执行结果是什么？

var a = [1,2,3,4,1,2,3,4,5,6,'a',undefined,null,false,true]
var s = new Set(a)
console.log(s.size)

答案：11
解析：Set数据结果换将传入的数组去重

128. 下面代码的执行结果是什么？

let x = 1;
function foo(y=x){
    let x = 2
    console.log(y)
}
foo()

答案：1

129. 下面代码的执行结果是什么？

fn(1)
var a = 2
function fn(a){
    console.log(a)
}

答案：1
解析：预编译会导致变量和函数有提升效果，所以可以在函数声明之前使用调用函数。调用函数是将形参a赋值为1，所以打印出局部a，即1

130. 下面代码的执行结果是什么？

let x = 1
function f1(x,y=x){
    console.log(y)
}
function f2(y=x){
    let x = 0
    console.log(y)
}
f1(2)
f2()

答案：2 1
解析：f1执行值传递x的值为2，所以y的默认值为2；而f2执行时候，y的默认值为x，去全局里找x为1；所以先后分别打印2和1

131. 下面那个属性对input和textarea元素都生效

A.readonly
B.disabled

答案：B
解析：比如在input类型为checkbox时，设置readonly，是一样可以选择是否选中

132. 下面代码的执行结果是什么？

function F(){}
var f = new F
console.log(f.prototype)

答案：undefined
解析：prototype是函数身上的属性，并非是实例身上的属性

133. 下面代码的执行结果是什么？

if(false){
    var a = 12
    let b = 5
}
console.log(a)
console.log(b)

答案：undefined Uncaught ReferenceError: b is not defined
解析：预编译的时候var声明的变量会有提升效果，值为undefined。let声明的遍历有块级作用域的概念，在外面不能使用。

134. 求两个数组的差集，例如[1,2,3]和[2,3,4]的差集就是[1,4]

let arr1 = [1,2,3,4,5]
let arr2 = [4,5,6,7,8]
let a = new Set(arr1)
let b = new Set(arr2)
let arr3 = new Set(arr1.filter(x=>!b.has(x)))
let arr4 = new Set(arr2.filter(x=>!a.has(x)))
let diff = [...arr3,...arr4]
console.log(diff)//[1,2,3,6,7,8]

135. 下面代码的执行结果是什么？

var [a='a',b=a,c='c'] = [1,2,undefined]
console.log(a,b,c)

答案：1,2,'c'
解析：解构赋值，a和b分别赋值为1,2；而c不同，变量默认没有赋值的时候就是undefined，同理如果赋值为undefined相当于没有赋值，所以使用默认值'c''

136. 下面代码的执行后，ul里面的内容顺序是为？

//HTML代码

    
1
    
2
    
3

//js代码
var list =  document.getElementById('list')
var li = list.querySelectorAll('li')
list.replaceChild(li[2],li[1])
list.insertBefore(li[1],list.children[2])

答案：1 3 2

137. 下面代码的执行结果是什么？

var a = 1;
function a(a){
    console.log(a)
    var a = 2
}
console.log(a)
a(3)

答案：1 Uncaught TypeError: a is not a function
解析：预编译导致变量声明提升以及函数整体提升，预编译之后，执行语句将a赋值为1,所以在执行a(3)会报错

138. 下面代码的执行结果是什么

var name = 'Alice';
(function(){
    if(name === 'undefined'){
        var name = 'Tom'
        console.log(name)
    }else{
        console.log(name)
    }
})()

答案：Tom
解析：立即函数执行时，由于if语句中有声明name，所以在预编译的时候会将name提升，并且值为undefined，所以打印Tom

139. 下面代码的执行结果是什么

var name = 'Alice'
(function(){
    if(name === 'undefined'){
        var name = 'Tom'
        console.log(name)
    }else{
        console.log(name)
    }
})()

答案： Uncaught TypeError: "Alice" is not a function
解析：由于'alice'后面没有结束符号，下面跟着()，便以为是函数。导致结果报错

140. 下面代码的执行结果是什么？

var a = 1;
function fn(){
    a = 2;
    console.log(a);
    console.log(this.a);
    var a;
    console.log(a)
}
fn()

答案：2 1 2
解析：考查预编译的知识点

141. 下面代码的执行结果是什么？

if (!'a' in window){
    var a = 1
}
console.log(a)

答案：undefined
解析：预编译会将if语句里面的变量声明a提升，值为undefined

142. 下面代码的执行结果是？

var obj = {
    val: 2,
    del: function () {
        this.val *= 2;
        console.log(val)
    }
}
obj.del()

答案：1
解析：我们知道执行obj.del()之后，obj.val变成了4，但是需要注意val找变量的时候，会沿着作用域查找，会找到外面被声明的的val，而非obj对象上的。

143. 下面代码的执行结果是什么？

var name = 'Alice';
var  obj = {
    name:'Tom',
    getName:function(){
        return function(){
            return this.name
        }
    }
}
console.log(obj.getName()())

答案：Alice
解析：谁调用this指向谁，obj.getName()执行时this指向obj，而执行完后返回一个function，这个function执行时没人调用，所以里面this指向window，最后输出window上的name

144. 下面代码的执行结果是什么？

var name = 'Alice';
var  obj = {
    name:'Tom',
    getName:function(){
        var self =  this;
        return function(){
            return self.name
        }
    }
}
console.log(obj.getName()())

答案：Tom
解析：self将this保存下来了，也就是self指向的是obj

145. 下面代码的执行结果是什么？

var a = 1;
setTimeout(() => {
    a = 2;
}, 0);
console.log(a)

答案：1

146. 下面代码的执行结果是什么

(function (){
    var  a = b = 1;
})()
console.log(typeof a === "undefined")
console.log(typeof b === "undefined")

答案：true false
解析：暗示全局变量，凡是未声明就赋值的变量归window所有

147. 下面代码的执行结果是什么？

var a = (function(foo){
    return typeof foo.bar;
})({foo:{bar:1}})

答案：undefined
解析：立即执行函数中，参数foo的值为{foo:{bar:1}，所以foo.bar是不存在的

148. 下面代码的执行结果是什么？.

function f(){
    return f;
}
console.log(new f() instanceof f)

答案：false
解析：new f()返回的是f函数本身，即相当于问f instanceof f，答案是false

149. 下面代码的执行结果是什么？

function A() { }
A.prototype.n = 1;
var b = new A();
A.prototype = {
    n:2,
    m:3
}
var c = new A()
console.log(b.n,b.m)
console.log(c.n,c.m)

答案：1 undefined 2 3

150. 下面代码的执行结果是什么？

console.log(false.toString());
console.log([1,[2],3].toString());
console.log(1..toString());
console.log(2.toString())

答案：'false' '1,2,3' '1' SyntaxError

151. 下面代码的执行结果是什么？

console.log([]!==[])

答案：true
解析：不存在隐式类型转换的!==和===

152. 下面代码的执行结果是什么？

var a = 1;
console.log(a++)
console.log(++a)
console.log(a)

答案：1 3 3
解析：关于++运算符，++在前先++，++在后后++

153. 下面代码的执行结果是什么？

var a = { n: 1 }
var b = a;
a.x = a = { n: 2 }
console.log(a.n, b.n)
console.log(a.x, b.x)

答案：2 1 undefined {n:2}

154. 下面代码的执行结果是什么呢？

console.log(c);
var c;
function c(a){
    console.log(a)
    var a = 3;
    function a(){}
}
c(1)

答案：function c(a){...} function a(){}
解析：预编译导致变量和函数提升，并且先变量声明提升，而后函数整体提升

155. 下面代码的执行结果是什么？

console.log(typeof a)
function a(){}
var a;
console.log(typeof a)

答案：function function
解析：预编译先变量声明提升，而后函数整体提升

156. 下面代码的执行结果是什么？

var a;
var b = 'undefined'
console.log(typeof a,typeof b, typeof c)

答案：undefined string undefined
解析：变量未赋值，默认为undefined；b被赋值为字符串undefined，所以类型是string；未声明的变量使用typeof检测，返回undefined

157. 下面代码的执行结果是什么？

var obj = {n:1}
function fn(a){
    a.n = 2
}
fn(obj)
console.log(obj.n)

答案：2

158. 下面代码的执行结果是什么？

var x = 10;
function fn(){
    console.log(x)
}
function show(f){
    var x = 20;
    f()
}
show(fn)

答案：10

159. 下面代码的执行结果是什么?

Object.prototype.bar = 1;
var foo = {
    g: undefined
}
console.log(foo.bar)
console.log('bar' in foo)
console.log(foo.hasOwnProperty("bar"))
console.log(foo.hasOwnProperty('g'))

答案：1 true false true

160. 下面代码的执行结果是什么？

Object.prototype.a = 1;
var obj = {
    b:2
}
for(var i in obj){
    console.log(obj[i])
}

答案：2 1
解析：for in循环中，会先变量obj自身属性的key，然后再去变量原型上的属性

161. 下面代码的执行结果是什么？

function fn1() {
    return {
        a: 1
    }
}
function fn2() {
    return
    {
        b: 1
    }
}
console.log(fn1())
console.log(fn2())

答案：{a:1} undefined
解析：当函数return那行没跟任何东西时，则会当成没有任何返回内容

162. 下面代码的执行结果是什么？

console.log((function () { return typeof arguments })())

答案：object
解析：函数中arguments是类数组，本质是object

163. 下面代码的执行结果是什么？

console.log(Boolean(false))
console.log(Boolean(""))
console.log(Boolean(null))
console.log(Boolean('0'))
console.log(Boolean(0))
console.log(Boolean(NaN))

答案：false false false true false false
解析：关于Boolean的使用

164. 下面代码的执行结果是什么呢？

var x = 1;
if(function fn(){}){
    x += typeof fn;
}
console.log(x)

答案：1undefined

165. 下面代码的执行结果是什么呢？

console.log('b' + 'a' + +'a' + 'a')

答案：baNaNa
解析：前面'b' + 'a'变成'ba'，接着+（+"a"）,+'a'的一元运算符，结果是NaN，所以变成baNaN，最后加'a'

166. 下面代码的执行结果是什么？

var obj = {
    a: 1,
    b: 2
}
Object.setPrototypeOf(obj, { c: 3 })
Object.defineProperty(obj,'d',{value:4,enumerable:false})
for (const key in obj) {
    console.log(key)
}

答案：a b c
解析:由于d属性在定义的时候，其配置设置项enumerable值为false，所以在forin的时候，该属性是不会被遍历出来的

167. 下面代码的执行结果是什么？

var x = 1;
var f = {
    x:2,
    getx:function(){
        return this.x;
    }
}
console.log(f.getx())
var xGetter = f.getx;
console.log(xGetter())

答案：2 1
解析：谁调用，this指向谁

168. 下面代码的执行结果是什么？

var x = 1;
x += typeof fn;
console.log(x);
function fn() { }

答案：1function

169. 下面代码的执行结果是什么呢？

var a = [1,2,3]
console.log(a.join())

答案：1,2,3
解析：数组的join方法用于按指定字符连接数组元素，不传默认情况按英文逗号连接

170. 下面代码的执行结果是什么？

var a = [1]
var b = ['2']
console.log(b - a)

答案：1
解析：考查减号运算符，如果减号两边都是数组，且两个数组都只有一个成员，且此成员是数字或者是数字字符串，就会将里头的当数字相减

171. 下面代码的执行结果是什么？

var b = 1;
function outer(){
    var  b = 2
    function inner(){
        b++;
        var b = 3;
        console.log(b)
    }
    inner()
}
outer()

答案：3

172. 下面代码的执行结果是什么？

console.log(1 > 2 > 3)
console.log(1 < 2 < 3)

答案：false true

173. 下面代码的执行结果是什么？

(function(){
    console.log(1)
    setTimeout(function(){
        console.log(2)
    },100)
    setTimeout(function(){
        console.log(3)
    },0)
    console.log(4)
}())

答案：1 4 3 2

174. 下面代码的执行结果是什么？

function sum(x,y){
    if(y != undefined){
        return x + y
    }else{
        return function(y){
            return x + y
        }
    }
}
console.log(sum(1,2))
console.log(sum(1)(2))

答案：3 3

175. 执行下面代码，当用于点击页面中的“按钮”时，会打印出什么？

for (var i = 0; i < 5; i++) {
    var btn = document.createElement('button');
    btn.appendChild(document.createTextNode('按钮' + i));
    btn.addEventListener('click', function () {
        console.log(i);
    });
    document.body.appendChild(btn)
}

答案：每个按钮被点击时，都会打出一个5
解析：在点击之前，for循环已经执行完，当这个时候访问i时，已经变成了5

176. 下面代码的执行结果是什么？

var length = 10;
function fn(){
    console.log(this.length)
}
var obj={
    length:5,
    method:function(fn){
        fn();
        arguments[0]();
    }
}
obj.method(fn,1)

答案：10 2
解析：fn执行时，this指向window；而使用arguments获取参数fn执行时，fn里头的this执行该arguments，而arguments中有个length属性，表示传递的参数个数

177. 下面代码的执行结果是什么？

(function(x){
    return (function(y){
        console.log(x)
    }(2))
}(1))

答案：1

178. 下面代码的执行结果是什么？

var a = {},
    b = {key:'b'},
    c = {key:'c'};
a[b] = 123;
a[b] = 456;
console.log(a[b])

答案：456
解析：当对象作为对象的key时，会变成[object Object],所以a[b]和a[b]其实是一样的

179. 下面代码的执行结果是什么？

var obj = {
    foo: 'bar',
    fn: function () {
        var self = this;
        console.log(this.foo, self.foo);//
        (function () {
            console.log(this.foo, self.foo);//undefined bar
        }());
    }
}
obj.fn();

答案：bar bar undefined bar
解析：obj.fn执行时，fn里面this指向调用者obj，而当fn里头的立即执行函数执行时，里面的this指向window

180. 下面有关循环说法正确的是？

A. for in循环遍历不到继承的属性
B. do while在判断条件前会执行一次代码块
C. for循环中三个表达式可以省略，分号也可以省略
D. while循环语句至少会执行循环体一次
答案：B

181. 以下哪个不是JavaScript中的错误类型？
     A. 语法错误
     B. 系统错误
     C. 类型错误
     D. 引用错误
     答案：B

182. 下面代码的执行结果是什么？

function fn(){
    return;
}
console.log(fn())

答案：undefined
解析：当函数无明确返回时或者return后面没有啥时，则函数执行结果为undefined

183. 下面代码的执行结果是什么？

var obj = {a:1}
console.log(obj && obj.a)

答案：1
解析：关于&&运算符，当&&前面的表达式的值转成布尔值为真时，则返回后面表达式的结果

184. 下面代码的执行结果是什么？

var x = 5, y = 12;
console.log(x < 10 && y > 1)
console.log(x == 5 || y == 5)
console.log(!(x == y))
console.log(!!x == x)

答案：true true true false
解析：关于逻辑运算符的基本使用

185. 如何遍历对象身上的属性，非原型继承而来的属性？

答案：可通过for in 循环遍历出所有属性，再通过对象身上的hasOwnProperty()判断遍历出来属性是对象身上的还是原型上的，代码如下

function fn(obj) {
    if(typeof obj === 'object'){
        //不考虑数组
        for (const key in obj) {
            if (Object.hasOwnProperty.call(obj, key)) {
                console.log(key)
            }
        }
    }else{
        return
    }
}
fn({a:1})

186. 题目：

｛a:[{id: xxx，parentId: xxx}]，b:[{id: xxx，parentId: xxx}，{id: xxx，parentId: xxx}]｝
删除对象中a，b数组中所有对象的id 和 parentID，并给每个对象添加一个isHstory属性
要的效果：｛a:[{isHistory: 1}]，b:[{isHistory: 1}，{isHistory: 1}］｝

解答：

function delId(obj) {
    //传入必须是对象，否则不处理
    if (typeof obj == "object" && (!Array.isArray(obj))) {
        //遍历对象中的每一项
        for (const key in obj) {
            if (Object.hasOwnProperty.call(obj, key)) {
                const item = obj[key];
                //找出对象中类型为数组的属性
                if (Array.isArray(item)) {
                    // 遍历数组
                    for (const val of item.values()) {
                        // 找出数组中类型是对象的所有成员，删除和添加属性即可
                        if (typeof val == "object"&&(!Array.isArray(val))) {
                            console.log(val)
                            // 1.删除对象的id 和 parentId属性
                            delete val.id;
                            delete val.parentId;
                            // 2.对象添加一个isHstory属性
                            val.isHistory = 1;
                        }
                    }
                }
            }
        }
    }
}
// 测试代码
const obj = {
    a: [{ id: 'xxx', parentId: 'xxx' }],
    b: [{ id: 'xxx', parentId: 'xxx' }, { id: 'xxx', parentId: 'xxx' }]
}
delId(obj);
console.log(obj);//｛a:[{isHistory: 1}]，b:[{isHistory: 1}，{isHistory: 1}］｝

187. 关于JS赋值操作符描述错误的是？

A.赋值操作符的顺序是从左往右
B.i=j=k="hello"的含义是将三个变量都初始化为"hello"
C.赋值表达式的顺序是从右往左
D.赋值表达式的值就是右操作数的值
答案：A

188. 关于this正确的是（多选）

A.this对象不能用于箭头函数中
B.apply和call能改变函数执行时的当天对象，让this指向其他对象
C.由于js的动态性，this的指向需要在运行时才能确定具体指啥
D.this总是指向当前的对象
答案：BCD

189. 关于JS函数说法错误的是？

A.函数可以通过定时器去调用
B.自执行函数可以形成一个独立的作用域
C.delete可以删除全局函数
D.如果函数无明确返回值，或者调用了没有参数的return语句，那么返回的都是undefined
答案：C

190. 下面语句执行结果是什么？

console.log('111'<'33')
console.log(1>=-Infinity)
console.log('100'+'200')

答案：true true 100200

191. 下面说法正确的是（多选）

A.直接调用Math.Max时它并不接受数组
B.对于系统内置对象，使用toString不会得到想要的结果，而是[object Objcet]
C.函数中的length属性返回函数中的形参个数
D.arguments对象用于描述传递给函数的参数的类数组对象
答案：ABCD

192. 下面的代码的执行结果是什么？

function foo(a) {
    var b = a * 2
    function bar(c) {
        console.log(a,b,c)
    }
    bar(b*3)
}
foo(2)

答案：2 4 12

193. 下面代码的执行结果是什么？

function foo(str,a){
    eval(str);
    console.log(a,b)
}
var b = 2
foo('var b = 3',1)

答案：1 3
解析：eval会将传递进来的字符串作为js语句并执行，会改变原本函数的作用域

194. 下面代码的执行结果是什么？

function foo(str){
    'use strict';
    eval(str);
    console.log(a);
}
foo('var a = 1')

答案：ReferenceError：a is not defined
解析：在严格模式下，eval运行时有其自己的词法作用域，意味着其中的声明无法修改所在的作用域

195. 下面代码的执行结果是什么？

var a = 1;
(function foo(){
    var a = 2;
    console.log(a)
})()
console.log(a)

答案：2 1

196. 下面代码的执行结果是什么？

var a = 1;
(function foo(lobal){
    var a = 2;
    console.log(a)
    console.log(lobal.a)
})(window)
console.log(a)

答案：2 1 1

197. 画一条0.5px的直线？

height: 1px;
transform: scale(0.5);

198. 画一个三角形？

div{
        width: 0;
        height: 0;
        border-width: 100px;
        border-style: solid;
        border-color: transparent #0099CC transparent transparent;
        transform: rotate(90deg); /*顺时针旋转90°*/
}

199. 下面执行结果是？

function foo(x) {
    var tmp = 3;
    return function (y) {
        alert(x + y + (++tmp));
    }
}
var bar = foo(2); // bar 现在是一个闭包
bar(10);

答案：16
解析：es6通常用let const块级作用域代替，闭包缺点，ie中会引起内存泄漏，严格来说是ie的缺点不是闭包的问题

200. 请问0.1+0.2等于多少？

答案：0.30000000000000004
解析：由于以下两个原因，导致0.1 + 0.2 != 0.3
1.在十进制转换为二进制的过程中，会产生精度的损失
2.二进制浮点数进行对阶运算时，也会产生精度的损失

以上是目前收集的所有内容！