this
定时器不是作用域
const o = {
aaa() {
// console.log(this)
setTimeout(() => {
console.log(this)
},0)
}
}
o.aaa()//o,17行的this是15行的this，而15行的this是o，因为aaa是被o调用的
拿到getNameFunc函数，然后执行的时候是自执行，所以是window
const object = {
name: 'MyObject',
getNameFunc() {
console.log(this);
return () => {
console.log(this);
}
}
}
var a = object.getNameFunc;
a()()//window window
2.先拿到object.getNameFunc()的值再执行，箭头函数中的this是getNameFunc
下的this，由于getNameFunc的调用方式是通过myobject调用的，所以this是myobject
const myobject = {
name:'My Object',
getNameFunc(){
return()=>{
return this.name;
}
}
}
window.name = 'The Window'
myobject.getNameFunc()()//MyObject
3.setTimeout的作用域里的this永远指向window
const obj2 = {
aaa() {
//aaa(),它的this指向obj2;
setTimeout(function () {
//setTimeout内部的this永远指向window;
setTimeout(function () {
console.log(this);//window
})
setTimeout(() => {
console.log(this);
/* window,向外寻找,最先找到的setTimeout的作用域,
而这个作用域里的this永远指向window. */
})
})
setTimeout(() => {
setTimeout(function () {
console.log(this);//window
})
setTimeout(() => {
console.log(this);
/* obj,向外找到setTimeout,但是是一个箭头函数,
其中没有this,再向外寻找,aaa()的this,即obj */
})
})
}
}
var name = 'window'
var person1 = {
name: 'person1',
foo1: function () {
console.log(this.name)
},
foo2: () => console.log(this.name),
foo3: function () {
return function () {
console.log(this.name)
}
},
foo4: function () {
console.log(this.name);
return () => {
console.log(this.name)
}
}
}
var person2 = {
name: 'person2' }
var test = person1.foo4;
test()()//window,现在箭头函数的this是foo4函数的this，而最后执行test，这个给this指向window
person1.foo4()(); // person1(箭头函数不绑定this, 上层作用域this是person1)
person1.foo4.call(person2)(); // person2(上层作用域被显示的绑定了一个person2)
person1.foo4().call(person2); // person1(上层找到person1)
new题目
1.因为没有找到Foo.prototype,由于new产生的对象才会去找，但是它返回了一个对象
function Foo() {
this.a = 1;
return {
a: 4,
b: 5,
};
}
Foo.prototype.a = 6;
Foo.prototype.b = 7;
Foo.prototype.c = 8;
var o = new Foo();
console.log(o.a);//4
console.log(o.b);//5
console.log(o.c);//undefined
function Foo() {
Foo.a = function() {
console.log(1)
}
this.a = function() {
console.log(2)
}
}
Foo.prototype.a = function() {
console.log(3)
}
Foo.a = function() {
console.log(4)
}
Foo.a(); //4
let obj = new Foo();
obj.a(); //2
Foo.a(); //1
事件循环题目
1.看清楚有没有reslove
console.log(0);
setTimeout(() => {
console.log(1);
new Promise(resolve => {
console.log(2);
// resolve()
}).then(() => {
console.log(3);
})
})
new Promise(resolve => {
console.log(4);
for (let i = 0; i < 9; i++) {
i == 7
}
console.log(5);
}).then(() => {
console.log(6);
})
setTimeout(() => {
console.log(7);
new Promise(resolve => {
console.log(8);
resolve();
}).then(() => {
console.log(9);
})
})
console.log(10)
2.await async2()后面就是微任务了，promise2先进微任务队列
async function async1() {
await async2();
return 'async return';
}
async function async2() {
console.log("async2");
}
async1().then(function (message) {
console.log(message) });
new Promise(function (resolve) {
resolve();
}).then(function () {
console.log("promise2");
});
3.node的事件循环
先执行主线程，
然后执行nextTicks队列，
然后执行其他微任务队列，
然后执行timers队列，
然后执行io队列，
然后执行setimmedidate队列
async function async1() {
console.log('async1 start')
await async2()
console.log('async1 end')
}
async function async2() {
console.log('async2')
}
console.log('script start')
setTimeout(function () {
console.log('setTimeout0')
}, 0)
setTimeout(function () {
console.log('setTimeout2')
}, 300)
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick1'));
async1();
process.nextTick(() => console.log('nextTick2'));
new Promise(function (resolve) {
console.log('promise1')
resolve();
console.log('promise2')
}).then(function () {
console.log('promise3')
})
console.log('script end')
// script start
// async1 start
// async2
// promise1
// promise2
// script end
// nextTick1
// nextTick2
// async1 end
// promise3
// setTimeout0
// setImmediate
// setTimeout2
作用域题目
1.a中的count找的是window在一开始就确定了
var count = 10;
function a() {
return count + 10;
}
function b() {
var count = 20;
return a();
}
console.log(b());
2.变量提升
if (! "a" in window) {
var a=1
}
alert(a)//undefined
promise题目
1.await后面接的是promise，那么一定会把这个promise执行完才会执行await后面的代码
function a() {
return new Promise((resolve, reject) => {
resolve(1)
console.log(222);
}).then(res => {
console.log(res);
return 2
}).then(res => {
console.log(res);
})
}
//await后面接的是promise，那么一定会把这个promise执行完才会执行await后面的代码。
async function b() {
let v = await a();
console.log(111);
console.log(v);
}
b()
console.log(333);
原型重写题目
function Animal() {
}
const cat = new Animal()
const dog = new Animal()
Animal.prototype = {
bark: true }
console.log(cat.bark)
console.log(dog.bark)
new cat和dog时他俩的__proto__找的是老的原型
立即执行函数是个作用域
