你不知道的JavaScript:this和对象原型

2017-01-09 14:07:56来源:open-open作者:网络转载人点击

this在调用时绑定,完全取决于函数的调用位置。


绑定规则

默认绑定(独立函数调用,绑定到全局对象,但严格模式下this会绑定到undefined)
function foo() {
console.log(this.a);
}
var a = 2;
foo(); // 2
隐式绑定:当函数引用有上下文对象时,this绑定在这个上下文对象上,最后一层调用位置起作用
function foo() {
console.log(this.a);
}
var obj = {
a: 2,
foo: foo
}
var a = "hello";
obj.foo(); // 2 隐式丢失
function foo() {
console.log(this.a);
}
var obj = {
a: 2,
foo: foo
}
var bar = obj.foo; //实际上指向foo本身,独立函数调用
var a = "hello world";
bar(); // hello world
显示绑定,call和apply,第一个参数是对象,函数调用时将this绑定到这个对象上 硬绑定
function foo() {
console.log(this.a);
}
var obj = {
a: 2
}
var bar = function() {
foo.call(obj);
}
bar(); // 2
setTimeout(bar, 1000); // 2
var a = "hello world";
bar.call(window); // 2
new绑定:用new调用函数时,会创建一个新对象,并将这个新对象绑定到函数调用的this上。
function foo(a) {
this.a = a;
}
var bar = new foo(2); //将返回的对象bar绑定在foo的this上
console.log(bar.a); //2

绑定规则优先级

显示绑定高于隐式绑定
function foo() {
console.log(this.a);
}
var obj1 = {
a: 2,
foo: foo
}
var obj2 = {
a: 3,
foo: foo
}
obj1.foo();//2
obj2.foo();//3
obj1.foo.call(obj2);//3,先将foo中的this绑定到obj2,在被obj1调用
obj2.foo.call(obj1);//2
new绑定高于隐式绑定
function foo(something) {
this.a = something;
}
var obj1 = {
foo:foo
};
var obj2 = {};
obj1.foo(2);
console.log(obj1.a); //2
obj1.foo.call(obj2,3);
console.log(obj2.a); //3
var bar = new obj1.foo(4);
console.log(bar.a);//4
console.log(obj1.a);//2
new绑定高于硬绑定(new 和call或者apply不能同时使用)
function foo(something) {
this.a = something;
}
var obj1 = {};
var bar = foo.bind(obj1);
bar(2);
console.log(obj1.a); //2
var baz = new bar(3);
console.log(obj1.a); //2
console.log(baz.a);//3 new中使用硬绑定,可以预先设置一些参数,使用new初始化时只需传入其他的参数,柯里化的一种
function foo(p1, p2) {
this.val = p1 + p2;
}
var bar = foo.bind(null, "p1"); //不关心硬绑定到哪里,this会被new修改
var baz = new bar("p2");
console.log(baz.val);//p1p2

绑定例外


把null或者undefined传入call,apply,bind等,忽略this

function foo() {
console.log(this.a);
}
var a = 2;
foo.call(null);//2,实际使用默认绑定

间接引用

function foo() {
console.log(this.a);
}
var a = 2;
var o = {a:3, foo:foo};
var p = {a:4};
o.foo();//3
(p.foo = o.foo)();//2,返回值是目标函数的引用,所以是默认绑定

软绑定

function foo() {
console.log("name: " + this.name);
}
var obj = {name:obj},
obj2 = {name:obj2},
obj3 = {name:obj2};
var fooOBJ = foo.softBind(obj);
fooOBJ(); //name:obj
obj2.foo = foo.softBind(obj);
obj2.foo();//name:obj2
fooOBJ.call(obj3);//name:obj3
setTimeout(obj2.foo, 10);//name:obj

箭头函数:根据外层作用域来决定this,箭头函数的绑定无法修改

function foo() {
return (a) => {
//this继承自foo()
console.log(this.a);
}
}
var obj1 = {a:2};
var obj2 = {a:3};
var bar = foo.call(obj1);
bar.call(obj2);//2

数组,添加数字类属性,数组长度增加

var myArray = ["foo", 42, "bar"];
myArray.baz = "baz";
console.log(myArray.length);
myArray["3"] = "baz";
console.log(myArray.length);

属性描述符:writable,是否可以修改属性的值;configurable,属性描述符是否可修改,为false的话禁止删除这个属性;Enumerable,可枚举


getter / setter

var myObject = {
get a() {
return this._a_;
},
set a(val) {
this._a_ = val * 2;
}
};
myObject.a = 2;
console.log(myObject.a);

属性的存在性,值为undefined或者不存在都返回

undefined
var myObject = {
a:2
};
"a" in myObject; // true, 会检查原型链
"b" in myObject; //false
myObject.hasOwnProperty("a");//true,只检查对象本身
myObject.hasOwnProperty("b");//false

混入


1、 显示混入

function mixin(sourceObj, targetObj) {
for(var key in sourceObj) {
if(!(key in targetObj)) {
targetObj[key] = sourceObj[key];
}
}
return targetObj;
}
var Vehicle = {
engine: 1,
ignition: function() {
console.log("turning on my engine.");
},
drive: function() {
this.ignition();
console.log("steering and moving forward!");
}
};
var Car = mixin(Vehicle, {
wheels: 4,
drive: function() {
Vehicle.drive.call(this);
console.log("rolling on all" + this.wheels + "wheels!");
}
});

2、混合混入,先进行复制,之后再特殊化,效率低,不常用

function mixin(sourceObj, targetObj) {
for(var key in sourceObj) {
targetObj[key] = sourceObj[key];
}
return targetObj;
}
var Vehicle = {
//...
};
var Car = mixin(Vehicle, {});
mixin({
wheels: 4,
drive:function(){
//...
}
}, car);

3、寄生继承

function Vehicle() {
this.engine = 1;
}
Vehicle.prototype.ignition = function() {
console.log("turning on my engine.");
};
Vehicle.prototype.drive = function() {
this.ignition();
console.log("steering and move forward!");
};
function Car() {
var car = new Vehicle();
car.wheels = 4;
var vehDrive = car.drive;
car.drive = function() {
vehDrive.call(this);
console.log("rolling on all" + this.wheels + "wheels!");
}
return car;
}
var mycar = new Car();
mycar.drive();

4、 隐式混入

var Something = {
cool: function() {
this.greetng = "hello world";
this.count = this.count ? this.count + 1 : 1;
}
};
Something.cool();
Something.greetng; // hello world
Something.count; // 1
var Another = {
cool: function() {
Something.cool.call(this);
}
};
Another.cool();
Another.greetng; //hello world
Another.count; // 1, count 不是共享状态

隐式屏蔽

var anotherObject = {
a: 2
};
var myObject = Object.create(anotherObject);
anotherObject.a; // 2
myObject.a; //2
anotherObject.hasOwnProperty("a"); //true
myObject.hasOwnProperty("a"); //false
myObject.a++; //隐式屏蔽
anotherObject.a; //2
myObject.a;//3
myObject.hasOwnProperty("a");//true

构造函数 || 调用

function nosp() {
console.log("don't mind me!");
}
var a = new nosp(); //don't mind me!
a; // {}

委托模式

Task = {
setID: function(ID) {this.id = ID;},
outputID: function() {console.log(this.id);}
};
//让XYZ委托Task
XYZ = Object.create(Task);
XYZ.prepareTask = function(ID, Lable) {
this.setID(ID);
this.Lable = Lable;
};
XYZ.outputTaskDetails = function() {
this.outputID();
console.log(this.Lable);
};

时间有点急,这篇可能有些格式上的问题,以后再看。

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台