关于作用域及作用域链
首先我们需要知道一些基本概念。
- 每一个执行环境关联了一个变量对象。环境中定义的所有变量和函数都保存在这个对象中。 全局执行环境关联的变量对象被认为是window对象,因此所有的全局变量和函数都作为window对象的属性和方法创建的。
- 如果执行环境是函数,则将其活动对象作为变量对象。
- 当函数调用时,该函数的执行环境被压入一个环境栈中。而在函数执行之后,该函数的执行环境弹出,把控制权交给之前的执行环境。
- 执行环境有一个内部scope属性,表示作用域链。作用域链的第0位始终是当前执行环境的变量对象,第一位是父级执行环境的变量对象,一直延伸到全局执行环境(始终是作用域链的最后一位)。
关于闭包
- 闭包就是能够读取其他函数内部变量的函数。
- 用途:读取其他函数内部变量,并使变量的值始终保持在内存中。
- 缺点:由于闭包会使得函数中的变量都被保存在内存中,内存消耗很大,所以不能滥用闭包,否则会造成网页的性能问题。
- 本质:父函数执行结束之后,父函数的执行环境会被弹出环境栈,但与之关联的变量对象依然保存在内存中,并未被销毁(因为它在子函数的作用域链中)
关于原型及原型链
- 所有对象都有自己的原型对象,由于原型对象也是对象,所以它也有自己的原型。因此,就会形成一个“原型链”。
所有对象的原型最终都可以上溯到Object.prototype,Object.prototype的原型是null。 - 读取对象的某个属性时,JavaScript 引擎先寻找对象本身的属性,如果找不到,就到它的原型去找,如果还是找不到,就到原型的原型去找。如果直到最顶层的Object.prototype还是找不到,则返回undefined。
- 每个函数都有一个prototype属性,指向一个对象。对于普通函数来说,该属性基本无用。
对于构造函数来说,生成实例的时候,该属性会自动成为实例对象的原型。prototype对象有一个constructor属性,默认指向prototype对象所在的构造函数。 - 每个对象都有_proto_属性,指向自己的原型对象。由于这个属性不标准,因此一般不提倡使用。
- 原型对象的所有属性和方法,都能被实例对象共享。
function Cat(name, color) {
this.name = name;
this.color = color;
}
var cat1 = new Cat('大毛', '白色');
console.log(Object.getPrototypeOf(cat1) === Cat.prototype) //true
console.log(Object.getPrototypeOf(Cat.prototype) === Object.prototype) //true
console.log(Object.getPrototypeOf(Cat) === Function.prototype) //true
console.log(Object.getPrototypeOf(Function.prototype) === Object.prototype) //true
//实例对象cat1的原型链为:Cat.prototype => Object.prototype => null
// Cat也是对象,它的原型链为: Function.prototype => Object.prototype => null
var o = {
name: 'liming',
age: 23
}
console.log(Object.getPrototypeOf(o) === Object.prototype) //true
//实例对象o的原型链为: Object.prototype => null
关于继承
- 原型链继承
function Animal(name) {
this.name = name || 'animal';
this.sleep = function () {
console.log(this.name + '正在sleeping!');
}
}
Animal.prototype.eat = function (food) {
console.log(this.name + '正在吃:' + food);
};
function Dog() {
this.age = 4
this.sayAge = function () {
console.log('age is ' + this.age);
}
}
Dog.prototype = new Animal( '二狗')
var dog = new Dog()
console.log(dog.age) //4
console.log(dog.sayAge()) //age is 4
console.log(dog.name) //二狗
console.log(dog.sleep()) //二狗正在sleeping!
console.log(dog.eat('骨头')) //二狗正在吃:骨头
console.log(dog instanceof Dog) //true
console.log(dog instanceof Animal) //true
console.log(dog instanceof Object) //true
- 实现:将父类的实例作为子类的原型
- 缺点:创建子类实例时,无法向父类构造函数传参;当父类构造函数中存在引用类型的值,该值会被所有子类实例所共享。
- 优点:简单,易于实现。
- 构造函数继承
function Dog() {
Animal.call(this, '二狗')
}
var dog = new Dog()
console.log(dog.name) //二狗
console.log(dog.sleep()) //二狗正在sleeping!
console.log(dog instanceof Dog) //true
console.log(dog instanceof Animal) //false
console.log(dog instanceof Object) //true
- 实现:在子类构造函数中调用父类构造函数。
- 缺点:无法继承父类原型的方法与属性。
- 优点:可以向父类构造函数传参,当父类构造函数中存在引用类型的值,不会被所有子类实例所共享。
- 组合继承
function Dog() {
Animal.call(this, '二狗')
}
Dog.prototype = new Animal()
Dog.prototype.constructor = Dog
var dog = new Dog()
console.log(dog.name) //二狗
console.log(dog.sleep()) //二狗正在sleeping!
console.log(dog.eat('骨头')) //二狗正在吃:骨头
console.log(dog instanceof Dog) //true
console.log(dog instanceof Animal) //true
console.log(dog instanceof Object) //true
特点:组合继承避免了原型链继承和构造函数继承的缺陷,融合了他们的优点,成为最常用的继承模式。
使用原型链实现对原型属性和方法的继承,通过构造函数实现对实例属性和方法的继承。
缺点:调用两次父类构造函数,子类实例对象的原型会有父类的实例属性。
- 寄生式继承
var clone = Object.create(new Animal('二狗'))
clone.age = 4
clone.sayAge = function () {
console.log('age is ' + this.age);
}
console.log(clone.age) //4
console.log(clone.sayAge()) //age is 4
console.log(clone.name) //二狗
console.log(clone.sleep()) //二狗正在sleeping!
console.log(clone.eat('骨头')) //二狗正在吃:骨头
console.log(clone instanceof Animal) //true
console.log(clone instanceof Object) //true
特点:以一个对象为原型,创建一个新对象,然后对新对象进行增强,返回新对象。
- 寄生组合继承
function Dog() {
Animal.call(this, '二狗')
this.age = 4
this.sayAge = function () {
console.log('age is ' + this.age);
}
}
var clone = Object.create(Animal.prototype)
Dog.prototype = clone
Dog.prototype.constructor = Dog
var dog = new Dog()
dog.colors.push('black')
console.log(dog.age) //4
console.log(dog.sayAge()) //age is 4
console.log(dog.name) //二狗
console.log(dog.sleep()) //二狗正在sleeping!
console.log(dog.eat('骨头')) //二狗正在吃:骨头
console.log(dog instanceof Dog) //true
console.log(dog instanceof Animal) //true
console.log(dog instanceof Object) //true
- 特点:解决了组合继承的缺点。
关于this
简单说,this就是属性或方法“当前”所在的对象,指向是可变的。
- 全局环境使用this,它指的就是顶层对象window。
- 构造函数中的this,指的是实例对象。
- 如果对象的方法里面包含this,this的指向就是方法运行时所在的对象。
注意点:
- 避免多层 this,切勿在函数中包含多层的this。
- 避免数组处理方法中的 this
- 避免回调函数中的 this
固定this值
- call() 第一个参数就是this所要指向的那个对象,后面的参数则是函数调用时所需的参数。
- apply() 与call方法类似,区别是它接收一个数组作为函数执行时的参数。
- bind() 将函数体内的this绑定到某个对象,然后返回一个新函数。参数就是所要绑定this的对象,及函数调用时所需的参数。每运行一次,就返回一个新函数。
- 如果第一个参数为空、null和undefined,则默认传入全局对象。以上三个方法定义在Function.prototype上,所以任何函数都具有这三个方法。
关于执行机制
看了网上很多资料,讲的都大同小异,我按照自己的理解整理了一下,欢迎纠错。
- js是单线程语言,同步任务会按行执行,异步任务会进入Event Table并注册函数,当指定的事情完成时,Event Table会将这个函数移入Event Queue。
- 主线程内的任务执行完毕为空,会去Event Queue读取对应的函数,进入主线程执行。
- Event Queue分为宏任务队列(script,定时器等)与微任务队列(promise,process.nextTick等),先执行微任务队列,在执行宏任务队列,每个队列均遵守先进先出的原则。
- 上述过程会不断重复。
console.log("1")
setTimeout(function() {
console.log("2")
process.nextTick(function() {
console.log("3")
})
new Promise(function(resolve) {
console.log("4")
resolve()
}).then(function() {
console.log("5")
})
})
process.nextTick(function() {
console.log("6")
})
new Promise(function(resolve) {
console.log("7")
resolve()
}).then(function() {
console.log("8")
})
setTimeout(function() {
console.log("9")
process.nextTick(function() {
console.log("10")
})
new Promise(function(resolve) {
console.log("11")
resolve()
}).then(function() {
console.log("12")
})
})
// 1 7 6 8 2 4 3 5 9 11 10 12
- 先打印1,没有问题,遇到setTimeout,setTimeout(简写为s1)会进入宏任务事件队列。
- process.nextTick进入微任务事件队列。
- 遇到promise立即执行,打印7,then函数进入微任务事件队列。
- 再遇到setTimeout,setTimeout(简写为s2)会进入宏任务事件队列。
- 执行微任务事件队列里面的任务,打印 6 和 8 (因为process.nextTick是先进入队列的,故先执行,遵守先进先出原则)。
- 执行宏任务事件队列里面的任务,先执行s1,在执行s2。
- 执行s1,打印2和4,s1里面的process.nextTick和then函数又进入微任务事件队列,然后打印3和5。
- 执行s2,打印9和11,s2里面的process.nextTick和then函数又进入微任务事件队列,然后打印10和12。