js的this、call、apply、bind、继承、原型链0.前言1.this2.call、apply、bind3.从call到继承

function F() {
        this.name = 1
}
var f = new F()
复制代码

 var obj = {
                value: 5,
                printThis: function () {
                    console.log(this);
                }
            };
复制代码

 var obj = {
                value: 5,
                printThis: function () {
                    console.log(this);
                }
            };
var f = obj.printThis
f()
复制代码

var obj = {
                value: 5,
                printThis: function () {
                        return function(){ console.log(this)}
                   }
            };
obj.printThis()//window

 var obj = {
                value: 5,
                printThis: function () {
                                      return () => console.log(this)
                                 }
            };
obj.printThis()()//obj

复制代码

Function.prototype.mycall = function(){
	var ctx = arguments[0]||window||global//获取上下文，call的第一个参数
	var len = arguments.length
	var hash = new Date().getTime()//避免名字重复
	ctx[hash] = this//将this缓存，this就是那个想在另一个上下文利用的函数
	var result
	if(len === 1){
		result = ctx[hash]()//如果后面没有其他参数直接运行
	} else{
		var i = 1
		var args = []
		for(;i<len;i++){
			args.push(arguments[i])
		}
		args = args.join(',')
		result = eval('ctx[hash](' + args + ')')//将参数传递进去调用
	}
	delete ctx[hash]//删除临时增加的属性
	return result
}
复制代码

Function.prototype.mybind = function(){
	var ctx = arguments[0]||window||global
	var f = this
	var args1 = []
	if(arguments.length>1){//预先填入的参数
		var i = 1
		for(;i < arguments.length;i++){
			args1.push(arguments[i])
		}
	}
	return function(){
		var args2 = Array.prototype.slice.call(arguments)//call和apply我们都可以实现，这里就不再重复
		return f.apply(ctx,args1.concat(args2))//将预先填入的参数和执行时的参数合并
	}
}
复制代码

function F(name,age){
  this.name = name 
  this.age = age
}
function G(name,age,a) {
  F.call(this,...arguments)
  this.a = a
}
var g = new G('a',12,1) //G {name: "a", age: 12, a: 1}
复制代码

function F(){
  this.a = [1,2,3,4]
  this.b = 2
}
var f = new F()
function G(){}
G.prototype = f
var g = new G()
var h = new G()
g.a //[1,2,3,4]
g.b //2
//对于引用类型，如果我们修改g.a（不是用=赋值，用=不会操作到原型链）
g.a.push(123)
g.a//[1,2,3,4,123]
//而且其他的实例也会变化
h.a //[1,2,3,4,123]
g.b = 666 //只是在实例里面对b属性进行改写，不会影响原形链
复制代码

function A() {}  
function B() {}  
A.prototype = Object.create(B.prototype,{father:{value:[1,2,3]}});

//Object.create的hack
Object.create =Object.create|| function (o) {
    var F = function () {};
    F.prototype = o;
    return new F();
}
//其实create函数内部的原理就是这样子，看回去上面的A和B，这些操作相当于
var F = function () {};
F.prototype = B.prototype;//原型被重写，a.__proto__.constructor是B而不是F
A.prototype = new F()

//create方法，第二个参数类似于defineProperty，而且定义的属性可以自行配置，默认是不可以重新赋值
var a = new A()
a.father //[1,2,3]
a.father = 1
a.father //[1,2,3]
复制代码

function createobj (obj) {
	var temp = Object.create(obj)
	temp.f = function () {
		console.log('this is father')
	}
	return temp
}
function B() {}  
var b = createobj (B.prototype)
b.f() //this is father
复制代码

function A() {}  
function B() {}  
var prototype = Object.create(B.prototype)//创建
prototype.constructor = A//增强
A.prototype = prototype//指定，这下a.__proto__.constructor 就是A了
var a = new A()
复制代码