1.js实现继承有哪几种方法？
function Anima(name){
this.name = name || 'Anima'
this.age = age || 18
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
Anima.protoptye.eat = function (food) {
alert(`${this.name}正在吃：${food}`)
}
方法一：原型链继承
//将父类的实例作为子类的原型
function Cat (){
}
Cat.prototype = new Anima()
方法二: 构造函数继承
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
// Test Code
var cat = new Cat();
方法三: 组合继承
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
Cat.prototype = new Animal();
// 感谢 @学无止境c 的提醒，组合继承也是需要修复构造函数指向的。Cat.prototype.constructor = Cat;
// Test Code
var cat = new Cat();
2.this指向问题（要有例子）
this指向的是调用他的对象（箭头函数不包括）
全局环境
在全局环境下，this 始终指向全局对象（window）, 无论是否严格模式；
console.log(this.document === document); // true
// 在浏览器中，全局对象为 window 对象：
console.log(this === window); // true
this.a = 37;
console.log(window.a); // 37
函数上下文调用
函数直接调用
普通函数内部的this分两种情况，严格模式和非严格模式。
非严格模式下，this 默认指向全局对象window
function f1(){
return this;
}
f1() === window; // true
而严格模式下， this为undefined
function f2(){
"use strict"; // 这里是严格模式
return this;
}
f2() === undefined; // true
对象中的this
对象内部方法的this指向调用这些方法的对象，
函数的定义位置不影响其this指向，this指向只和调用函数的对象有关。
多层嵌套的对象，内部方法的this指向离被调用函数最近的对象（window也是对象，其内部对象调用方法的this指向内部对象， 而非window）。
//1
var o = {
prop: 37,
f: function() {
return this.prop;
}
};
console.log(o.f()); //37
var a = o.f;
console.log(a()): //undefined
var o = {prop: 37};
function independent() {
return this.prop;
}
o.f = independent;
console.log(o.f()); // logs 37
//2
o.b = {
g: independent,
prop: 42
};
console.log(o.b.g()); // logs 42
原型链中的方法的this仍然指向调用它的对象，与以上讨论一致；看个例子，
var o = {
f : function(){
return this.a + this.b;
}
};
var p = Object.create(o);
p.a = 1;
p.b = 4;
console.log(p.f()); // 5
可以看出， 在p中没有属性f，当执行p.f()时，会查找p的原型链，找到 f 函数并执行，但这与函数内部this指向对象 p 没有任何关系，只需记住谁调用指向谁。
以上对于函数作为getter & setter 调用时同样适用。
构造函数中this
构造函数中的this与被创建的新对象绑定。
注意：当构造器返回的默认值是一个this引用的对象时，可以手动设置返回其他的对象，如果返回值不是一个对象，返回this。
function C(){
this.a = 37;
}
var o = new C();
console.log(o.a); // logs 37
function C2(){
this.a = 37;
return {a:38};
}
var b = new C2();
console.log(b.a); // logs 38
3.什么是原型与原型链？
原型：
原型到底是什么？原型是一个可以被复制（或者叫克隆）的一个类，通过复制原型可以创建一个一模一样的新对象。通俗的说，原型就是一个模板，在设计语言中更准确的说是一个对象模板。
var Person = function(name){
this.name = name;
}
Person.prototype.sayHi = function(){
console.log("Hello! I am " + this.name + ".");
}
var joe = new Person("joe");
var john = new Person("john");
joe.sayHi(); //Hello! I am joe.
john.sayHi(); //Hello! I am john.
从上面的代码可以看出来，原型（Person）定义了一些公用的属性和方法；利用原型（Person）创建出来的新对象实例（joe和john对象）会共享原型（Person）的所有属性和方法。
5.箭头函数？
(1). 具有一个参数的简单函数
var single = a => a
single('hello, world') // 'hello, world'
(2). 没有参数的需要用在箭头前加上小括号
var log = () => {
alert('no param')
}
(3).多个参数需要用到小括号，参数间逗号间隔，例如两个数字相加
var add = (a, b) => a + b
add(3, 8) // 11
(4).函数体多条语句需要用到大括号
var add = (a, b) => {
if (typeof a == 'number' && typeof b == 'number') {
return a + b
} else {
return 0
}
}
(5). 返回对象时需要用小括号包起来，因为大括号被占用解释为代码块了
var getHash = arr => {
// ...
return ({
name: 'Jack',
age: 33
})
}
(6).直接作为事件handler
document.addEventListener('click', ev => {
console.log(ev)
})
(7). 作为数组排序回调
var arr = [1, 9 , 2, 4, 3, 8].sort((a, b) => {
if (a - b > 0 ) {
return 1
} else {
return -1
}
})
arr // [1, 2, 3, 4, 8, 9]
6.png、jpg的区别有哪些？
7.闭包的作用？（必须深入理解不然就死了）
8.es6的新特性
9.promise的用法？
Promise是一个构造函数，自己身上有all、reject、resolve这几个眼熟的方法，原型上有then、catch等同样很眼熟的方法。
const promise = new Promise
setTimeOut(function(){
console.log('执行完成');
resolve('随便什么数据');
}, 2000)
Promise的构造函数接受一个参数，是一个函数，并传入两个参数reject和reolve分别表示异步执行操作返回失败和成功的回调函数，其实这里用“成功”和“失败”来描述并不准确，按照标准来讲，resolve是将Promise的状态置为fullfiled，reject是将Promise的状态置为rejected。不过在我们开始阶段可以先这么理解，后面再细究概念。
在上面的代码中，我们执行了一个异步操作，也就是setTimeout，2秒后，输出“执行完成”，并且调用resolve方法。
运行代码，会在2秒后输出“执行完成”。注意！我只是new了一个对象，并没有调用它，我们传进去的函数就已经执行了，这是需要注意的一个细节。所以我们用Promise的时候一般是包在一个函数中，在需要的时候去运行这个函数，如：
function runAsync(){
var p = new Promise(function(resolve, reject){
//做一些异步操作
setTimeout(function(){
console.log('执行完成');
resolve('随便什么数据');
}, 2000);
});
return p;
}
runAsync()
这时候你应该有两个疑问：1.包装这么一个函数有毛线用？2.resolve('随便什么数据');这是干毛的？
我们继续来讲。在我们包装好的函数最后，会return出Promise对象，也就是说，执行这个函数我们得到了一个Promise对象。还记得Promise对象上有then、catch方法吧？这就是强大之处了，看下面的代码：
runAsync().then(function(data){
console.log(data);
//后面可以用传过来的数据做些其他操作
//......
});
在runAsync()的返回上直接调用then方法，then接收一个参数，是函数，并且会拿到我们在runAsync中调用resolve时传的的参数。运行这段代码，会在2秒后输出“执行完成”，紧接着输出“随便什么数据”。
这时候你应该有所领悟了，原来then里面的函数就跟我们平时的回调函数一个意思，能够在runAsync这个异步任务执行完成之后被执行。这就是Promise的作用了，简单来讲，就是能把原来的回调写法分离出来，在异步操作执行完后，用链式调用的方式执行回调函数。
你可能会不屑一顾，那么牛逼轰轰的Promise就这点能耐？我把回调函数封装一下，给runAsync传进去不也一样吗，就像这样：
function runAsync(callback){
setTimeout(function(){
console.log('执行完成');
callback('随便什么数据');
}, 2000);
}
runAsync(function(data){
console.log(data);
});
效果也是一样的，还费劲用Promise干嘛。那么问题来了，有多层回调该怎么办？如果callback也是一个异步操作，而且执行完后也需要有相应的回调函数，该怎么办呢？总不能再定义一个callback2，然后给callback传进去吧。而Promise的优势在于，可以在then方法中继续写Promise对象并返回，然后继续调用then来进行回调操作。
链式操作的用法
所以，从表面上看，Promise只是能够简化层层回调的写法，而实质上，Promise的精髓是“状态”，用维护状态、传递状态的方式来使得回调函数能够及时调用，它比传递callback函数要简单、灵活的多。所以使用Promise的正确场景是这样的：
function runAsync1(){
var p = new Promise(function(resolve, reject){
//做一些异步操作
setTimeout(function(){
console.log('异步任务1执行完成');
resolve('随便什么数据1');
}, 1000);
});
return p;
}
function runAsync2(){
var p = new Promise(function(resolve, reject){
//做一些异步操作
setTimeout(function(){
console.log('异步任务2执行完成');
resolve('随便什么数据2');
}, 2000);
});
return p;
}
function runAsync3(){
var p = new Promise(function(resolve, reject){
//做一些异步操作
setTimeout(function(){
console.log('异步任务3执行完成');
resolve('随便什么数据3');
}, 2000);
});
return p;
}
runAsync1()
.then(function(data){
console.log(data);
return runAsync2();
})
.then(function(data){
console.log(data);
return runAsync3();
})
.then(function(data){
console.log(data);
});
reject的用法
到这里，你应该对“Promise是什么玩意”有了最基本的了解。那么我们接着来看看ES6的Promise还有哪些功能。我们光用了resolve，还没用reject呢，它是做什么的呢？事实上，我们前面的例子都是只有“执行成功”的回调，还没有“失败”的情况，reject的作用就是把Promise的状态置为rejected，这样我们在then中就能捕捉到，然后执行“失败”情况的回调。看下面的代码。
function getNumber(){
var p = new Promise(function(resolve, reject){
//做一些异步操作
setTimeout(function(){
var num = Math.ceil(Math.random()*10); //生成1-10的随机数
if(num<=5){
resolve(num);
}
else{
reject('数字太大了');
}
}, 2000);
});
return p;
}
getNumber()
.then(
function(data){
console.log('resolved');
console.log(data);
},
function(reason, data){
console.log('rejected');
console.log(reason);
}
);
getNumber函数用来异步获取一个数字，2秒后执行完成，如果数字小于等于5，我们认为是“成功”了，调用resolve修改Promise的状态。否则我们认为是“失败”了，调用reject并传递一个参数，作为失败的原因。
运行getNumber并且在then中传了两个参数，then方法可以接受两个参数，第一个对应resolve的回调，第二个对应reject的回调。所以我们能够分别拿到他们传过来的数据。多次运行这段代码，你会随机得到下面两种结果：
或
catch的用法
我们知道Promise对象除了then方法，还有一个catch方法，它是做什么用的呢？其实它和then的第二个参数一样，用来指定reject的回调，用法是这样：
getNumber()
.then(function(data){
console.log('resolved');
console.log(data);
})
.catch(function(reason){
console.log('rejected');
console.log(reason);
});
效果和写在then的第二个参数里面一样。不过它还有另外一个作用：在执行resolve的回调（也就是上面then中的第一个参数）时，如果抛出异常了（代码出错了），那么并不会报错卡死js，而是会进到这个catch方法中。请看下面的代码：
getNumber()
.then(function(data){
console.log('resolved');
console.log(data);
console.log(somedata); //此处的somedata未定义
})
.catch(function(reason){
console.log('rejected');
console.log(reason);
});
在resolve的回调中，我们console.log(somedata);而somedata这个变量是没有被定义的。如果我们不用Promise，代码运行到这里就直接在控制台报错了，不往下运行了。但是在这里，会得到这样的结果：
10.解构赋值？
11.Set集合
12.扩展运算符（...）？
扩展运算符将一个数组转为用逗号分隔的参数序列
(1) 将一个数组，变为参数序列
let arr = [1,2,3,4,5,6,7,8];
console.log(...arr)
(2) 使用扩展运算符展开数组代替apply方法，将数组转为函数的参数
let add = (x, y) => x + y;
let numbers = [3, 45];
console.log(add(...numbers))//48
(3) 使用push将一个数组添加到另一个数组的尾部
// ES5 写法
var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
Array.prototype.push.apply(arr1, arr2);
//push方法的参数不能是数组，通过apply方法使用push方法
// ES6 写法
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
arr1.push(...arr2);
(4) 合并数组
var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e'];
// ES5 的合并数组
arr1.concat(arr2, arr3);
// [ 'a', 'b', 'c', 'd', 'e' ]
// ES6 的合并数组
[...arr1, ...arr2, ...arr3]
// [ 'a', 'b', 'c', 'd', 'e' ]
(5) 将字符串转换为数组
[...'hello']
// [ "h", "e", "l", "l", "o" ]
//ES5
str.split('')
(6)转换伪数组为真数组
var nodeList = document.querySelectorAll('p');
var array = [...nodeList];
//具有iterator接口的伪数组，非iterator对象用Array.from方法
(7)map结构
let map = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let arr = [...map.keys()]; // [1, 2, 3]
13.js判断对象是否为空对象的几种方法？
方法一：将对象转化为json字符串判断字符创是否为{}
let data = {
name : 'adf'
};
let b = JSON.stringify(data);
if (b === '{}') {
alert('是空对象')
}else {
alert('不是空对象')
}
方法二:使用for in 判断
let data = {
// name : 'obj'
}
function isObjNull(data){
for (let i in data){
return alert('不是空对象')
}
return alert('是空对象')
}
isObjNull(data)
方法三：jquery中的isEmptyObject
var data = {};
var b = $.isEmptyObject(data);
alert(b);//true
方法四：使用ES6的Object.keys()方法
var data = {};
var arr = Object.keys(data);
alert(arr.length == 0);//true
14.js判断对象是否为数组的几种方法？
方法一：从原型入手，Array.prototype.isPrototypeOf(obj);
利用isPrototypeOf()方法，判定Array是不是在obj的原型链中，如果是，则返回true,否则false。
let arr = {}
let b = Array.prototype.isPrototypeOf(arr);
alert(b ? "是数组" : "不是数组")
方法二:obj instanceof Array
let arr = [];
alert(arr instanceof Array ? "是数组" : "不是数组")
方法三: Array.isArray()
Array.isArray([1, 2, 3]); // true
Array.isArray({foo: 123}); // false
Array.isArray('foobar'); // false
Array.isArray(undefined); // false
