1. 创建函数的方式与区别
- 函数声明
- 函数声明提升
// 变量提升 function add(){}
console.log(add(1, 2)) // 3
function add(a, b) {
return a + b
}
- 函数表达式
// 变量提升 var add (var add = undefined)
console.log(add(1, 2)) // add is not a function
var add = function (a, b) {
return a + b
}
- Function构造器
- 作用域为局部作用域
var f1 = new Function('var a = 1; return a;')
console.log(f1()) //1
console.log(a) //a is not defined 创建的变量是局部变量
2. this
- 全局作用域
this指向window
this.a = 1
window.a //1
console.log(this === window) //true
- 一般函数声明的
this指向window; 严格模式下，this等于undefined
function f1() {
return this;
}
f1() === window //true
function f1() {
'use strict';
return this;
}
f1() === undefined //true
- 作为对象方法的
this指向调用这个方法的对象（如： 对象o）
var o = {
prop: 3,
f: function() {
return this.prop;
}
};
console.log(o.f()) //3
- 原型链上的
this指向对象
var o = {
f: function() {
return this.a + this.b
}
}
var p = Object.create(o);
p.a = 1;
p.b = 2;
p.f() //3 o是p的原型。o上的this指向p
- get、set方法的
this指向调用它的对象
var o = {
a: 1,
b: 3
}
function f() {
return this.a + this.b
}
Object.defineProperty(o, 'c', {
get: f, enumerable: true, configurable: true
});
console.log(o.c) //4
- 构造器中的
this
-
new操作符执行的事情- 创建一个新对象
- 构造函数作用域指向新对象（this指向新对象,该新对象的原型指向构造函数的prototype属性）
- 执行构造函数代码（为新对象设置属性）
- 返回新对象（若构造函数返回新对象则为该对象，若返回为空。返回this对象）
function My() {
this.a = 37;
}
var o = new My();
console.log(o.a) //37
function My1() {
this.a = 37;
return {a: 38};
}
var o = new My1();
console.log(o.a) //38
-
call/apply中的this指向call/apply方法第一个参数
function add(a, b) {
return a + b + this.c
}
var o = {c: 3}
add.call(o, 1, 2) //6
function add(a, b) {
return a + b + this.c
}
var o = {c: 3}
add.apply(o, [1, 2]) //6
-
bind中的this指向参数对象
function f() {
return this.a;
}
var g = f.bind({a: 'test'});
console.log(g()) //test
var o = {a: 37, f: f, g: g};
console.log(o.f(), o.g()) //37 test
3. 闭包
闭包就是能够读取其他函数内部变量的函数（如：函数对象fun,可以取到函数outer内的变量local）
function outer() {
var local = 30;
return function(){
return local;
};
}
var fun = outer();
fun() //30
