本文共 3755 字,大约阅读时间需要 12 分钟。
当执⾏ JS 代码时,会⽣成执⾏环境,只要代码不是写在函数中的,就是在 全局执⾏环境中,函数中的代码会产⽣函数执⾏环境,只此两种执⾏环境。
b() // call bconsole.log(a) // undefinedvar a = 'Hello world'function b() { console.log('call b') }
想必以上的输出⼤家肯定都已经明⽩了,这是因为函数和变量提升的原因。通 常提升的解释是说将声明的代码移动到了顶部,这其实没有什么错误,便于⼤ 家理解。但是更准确的解释应该是:在⽣成执⾏环境时,会有两个阶段。第⼀ 个阶段是创建的阶段, JS 解释器会找出需要提升的变量和函数,并且给他们提前在内存中开辟好空间,函数的话会将整个函数存⼊内存中,变量只声明并 且赋值为undefined ,所以在第⼆个阶段,也就是代码执⾏阶段,我们可以 直接提前使⽤
b() // call b secondfunction b() { console.log('call b first')}function b() { console.log('call b second')}var b = 'Hello CSDN'
var 会产⽣很多错误,所以在 ES6中引⼊了 let 。 let 不能在声明前使 ⽤,但是这并不是常说的 let 不会提升, let 提升了,在第⼀阶段内存也 已经为他开辟好了空间,但是因为这个声明的特性导致了并不能在声明前使⽤
call
和apply
都是为了解决改变 this 的指向。作⽤都是相同的,只是传参的⽅式 不同。let a = { value: 1 }function getValue(name, age) { console.log(name) console.log(age) console.log(this.value) }getValue.call(a, 'yck', '24')getValue.apply(a, ['yck', '24'])
bind 和其他两个⽅法作⽤也是⼀致的,只是该⽅法会返回⼀个函数。并且我 们可以通过 bind 实现柯⾥化
对于实现以下⼏个函数,可以从⼏个⽅⾯思考
Function.prototype.myBind = function (context) { if (typeof this !== 'function') { throw new TypeError('Error') } var _this = this var args = [...arguments].slice(1) // 返回⼀个函数 return function F() { // 因为返回了⼀个函数,我们可以 new F(),所以需要判断 if (this instanceof F) { return new _this(...args, ...arguments) } return _this.apply(context, args.concat(...arguments)) } }
Function.prototype.myCall = function (context) { var context = context || window // 给 context 添加⼀个属性 // getValue.call(a, 'yck', '24') => a.fn = getValue context.fn = this // 将 context 后⾯的参数取出来 var args = [...arguments].slice(1) // getValue.call(a, 'yck', '24') => a.fn('yck', '24') var result = context.fn(...args) // 删除 fn delete context.fn return result}
Function.prototype.myApply = function (context) { var context = context || window context.fn = this var result // 需要判断是否存储第⼆个参数 // 如果存在,就将第⼆个参数展开 if (arguments[1]) { result = context.fn(...arguments[1]) } else { result = context.fn() } delete context.fn return result}
prototype
属性,除了 Function.prototype.bind()
,该属性指向原 型。__proto__
属性,指向了创建该对象的构造函数的原型。其实这个属性指 向了 [[prototype]]
,但是 [[prototype]]
是内部属性,我们并不能访问到,所以使 ⽤_proto_
来访问。__proto__
来寻找不属于该对象的属性,__proto__
将对象连接起来组 成了原型链。Object.prototype.toString.call(xx)
。这样我们就可以获得类似 [object Type]
的字符串。instanceof
可以正确的判断对象的类型,因为内部机制是通过判断对象的原型链中是不 是能找到类型的 prototype
function a() { return () => { return () => { console.log(this) } } }console.log(a()()())
箭头函数其实是没有 this 的,这个函数中的 this 只取决于他外⾯的第⼀个不是箭头函数的函数的 this。在这个例⼦中,因为调⽤ a 符合前⾯代 码中的第⼀个情况,所以 this 是 window 。并且 this 旦绑定了上下⽂,就不会被任何代码改变
function foo() { console.log(this.a) }var a = 1foo()var obj = { a: 2,foo: foo}obj.foo()// 以上两者情况 `this` 只依赖于调⽤函数前的对象,优先级是第⼆个情况⼤于第⼀个情况// 以下情况是优先级最⾼的,`this` 只会绑定在 `c` 上,不会被任何⽅式修改 `this` 指向var c = new foo() c.a = 3console.log(c.a)// 还有种就是利⽤ call,apply,bind 改变 this,这个优先级仅次于 new
async 和 await 相⽐直接使⽤ Promise 来说,优势在于处理 then 的调 ⽤链,能够更清晰准确的写出代码。缺点在于滥⽤ await 可能会导致性能问 题,因为 await 会阻塞代码,也许之后的异步代码并不依赖于前者,但仍然 需要等待前者完成,导致代码失去了并发性
下⾯来看⼀个使⽤ await 的代码。
var a = 0var b = async () => { a = a + await 10 console.log('2', a) // -> '2' 10 a = (await 10) + a console.log('3', a) // -> '3' 20}b() a++console.log('1', a) // -> '1' 1
await 10
之前变量 a 还是 0 ,因为在 await
内部 实现了 generators
, generators
会保留堆栈中东⻄,所以这时候 a = 0 被保存了 下来。await
是异步操作,遇到 await
就会⽴即返回⼀个pending
状态的 Promise
对 象,暂时返回执⾏代码的控制权,使得函数外的代码得以继续执⾏,所以会先执⾏console.log('1', a)
转载地址:http://onozi.baihongyu.com/