第二章 this全面解析

在使用call、apply的时候，如果传入了一个原始值，那么会被转会成它的对象形式，例如字符串会被转换成字符串形式

硬绑定

不管是隐式绑定还是显示绑定，都会出现this绑定丢失的问题, 硬绑定就是用来解决this丢失绑定的问题，它是显示绑定的一个变种

var obj = {
	a: 2
}
function foo () {

}
function bar () {
	foo.call(obj)
}
bar()

这样无论如何都不会改变foo绑定的this

辅助函数

function foo (something) {
	return this.a + something
}
var obj = {
	a: 2
}
function bind (fc, obj) {
	return function () {
		return fc.apply(obj, arguments)
	}
}
var bar = bind(foo, obj)

this优先级

• 如果使用了new那么始终this始终指向新的对象
• 如果使用了显示绑定call、apply或者硬式绑定，那么this指向绑定的对象
• 是否是使用了隐式绑定，如是this指向调用它的对象
• 如果都不是，在非严格模式下this指向window在严格模式下为undefined

例外

如果把null、undefined作为this的绑定对象传入call、apply、bind，那么会被忽略，会采用默认的绑定方式

bind实现

		Function.prototype.bind = function (oThis) {
			if (typeof this !== 'function') {
				throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable')
			}
			var aArgs = Array.prototype.slice.call(arguments, 1),
				fToBind = this,
				fNOP = function () {},
				fBound = function() { <= 注意这里的this指向这个函数
					return fToBind.apply(this instanceof fNOP 
					? this
					: oThis,
					aArgs.concat(Array.prototype.slice.call(arguments)))
				}
				// 使新函数的的原型和需要绑定的函数的原型保持一致
			if (fToBind .prototype) {
				fNOP.prototype = fToBind .prototype
			}
			fBound.prototype = new fNOP() 
			return fBound
		}

像上面这种硬绑定的this只能指向给定的对象(除了使用new时), 所以还有一种软绑定，软绑定实现了除了我们给定的obj对象以外，还可以使用call、apply来改变上下文，只不过这个时候使用new时，不再指向新的对象，而是仍然指向给定的obj，代码实现如下

		Function.prototype.softBind = function (obj) {
			var aArgs = Array.prototype.slice.call(arguments, 1),
				fToBind = this,
				fBound = function() {
					return fToBind.apply((!this || this === (window || global)) 
					? obj
					: this,
					aArgs.concat(Array.prototype.slice.call(arguments)))
				}
			fBound.prototype = fToBind.prototype
			return fBound
		}
		//   可以这样使用
		function foo () {
			console.log(this)
			console.log(arguments)
		}
		var obj1 = { name: 'obj1'},
			obj2 = { name: 'obj2'}
		var bar = foo.softBind(obj1)
		bar.call(obj2)