new

function Person(name) {
  this.name = name
}
let p  = new Person(‘name‘)
function New() {
  let obj = {  }
  obj.__proto__ = Person.prototype
  Person.apply(obj,Array.prototype.slice.call(arguments, 1))
  return typeof obj === ‘object‘ ? obj : {}
}
let p1 = New(Person,‘name‘)
console.log(p1)
//Person {name: "name"}
//name: "name"
//__proto__:
//constructor: ƒ Person(name)
//__proto__: Object
function New1(f) {
  //返回一个func
  return function () {
      var o = {"__proto__": f.prototype};
      f.apply(o, arguments);//继承父类的属性
      return o; //返回一个Object
  }
}
var p2 = New1(Person)("Jack",25);
console.log(p2)

// 判断Test 是否是被new执行的
function Test() {
  console.log(new.target)
}
Test() // undefined
new Test() // [Function: Test] 也就是 new.target === Test

intanceof


function Instanceof(obj,fn) {
  if(typeof fn !== ‘function‘){
    throw new Error(‘instance error‘)
  }
  if (!obj || (typeof obj !== ‘object‘ && typeof obj !== ‘function‘)) {
    return false
  }
  let type = fn.prototype  //原型对象
  while (obj.__proto__) { //对象原型
    if (obj.__proto__ === type) {
      return true
    }
    obj = obj.__proto__
  }
  return false
}
console.log(Instanceof([],Array))//true
console.log(Instanceof([],Function))//false
console.log([] instanceof Function)//false

//call apply

Function.prototype.Call(context) {
  if (typeof context === ‘undefined‘ || context === null) {
    context = window
  }
  context.fn = this //调用Call的那个函数
  let args = [...argments].slice(1)
  context.fn(...agrs) //apply就直接参数数组参数
  delete context.fn
}
//例子
Function.prototype.Call = function (context) {
  console.log(context) //{ name: ‘Tom1‘ }
  if (typeof context === ‘undefined‘ || context === null) {
    context = window
  }
  console.log(context) //{ name: ‘Tom1‘ }
  context.fn = this
  console.log(this,context.fn) //[Function: say] [Function: say]
  let args = [...arguments].splice(1)
  context.fn(...args)
  console.log(args) //[ 1 ]
  delete context.fn
}
let Person1 = {
  name: ‘Tom‘,
  say(age) {
      //console.log(this)
      console.log(`我叫${this.name}+${age}`)
  }
}
// 先看代码执行效果
Person1.say() //我叫Tom 
Person2 = {
  name: ‘Tom1‘
}
Person1.say.call(Person2) //我叫Tom1
Person1.say.Call(Person2,1)

//例2扩展用法
function Doctor(name){
  this.name = name;
  this.say = function(){
      console.log(this.name)
  }
}
function Stephen(name){
  //当前函数内的this指向函数Son的实例化对象
  //在执行Stephen时执行Doctor，同时将Doctor内的this改变成Stephen的this
  Doctor.Call(this,name)
}
 var doctor = new Doctor("Doctor")
 doctor.say();       //Doctor
 var stephen = new Stephen("Stephen Strange")
// // 在Stephen中并没有say方法，但是因为在new Stephen时，执行了Doctor，
// // 并将Doctor中的this指向Stephen的this，
// // 那么在new Stephen后，得到的实例，也具有了Doctor内的属性和方法
 stephen.say();      //Stephen Strange



//bind

//高阶函数
//JavaScript的函数其实都指向某个变量。既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
function add(x, y, f) {
    return f(x) + f(y);
}
console.log(add(-5, 6, Math.abs)) //11
//偏函数
//固定一个或者几个参数，返回一个新的函数，接收剩下的参数
function add(a,b){ //固定参数
  return a + b;
}
//生产偏函数的工厂
function partial(fn,a){
  return function(b){
      return fn(a,b);
  }
}
var parAdd = partial(add,1);//变量parAdd接受返回的新函数
console.log(parAdd(2));//在调用的时候传入剩余的参数
console.log(parAdd(3));//在调用的时候传入剩余的参数
console.log(parAdd(4));//在调用的时候传入剩余的参数
//柯里化sum(1)(2)(3)...
//把接收多个参数的函数转换成多个接收一个参数的函数----可以延迟执行 ，bind也是
//因为没满足原参数个数就不会返回结果
//辅助函数
function sub_curry(fn) {
  let args = [...arguments].slice(1)
  return function () {
    return fn.apply(this.args.concat([...arguments]))
  }
}
function curry(fn,length){
   length = length || fn.length//Function.prototype.length 属性，就是为了告诉你这个函数定义了几个参数。
  return function() {
    if(arguments.length < length) {
      let next = [fn].concat(...arguments) //包含fn,因为重复调辅助函数
    return length - arguments.length > 0 
      ? curry(sub_curry.apply(this, combined), length - arguments.length)
      : sub_curry.call(this, combined );
      
    }else {
       return fn.apply(this,arguments) //拿到了原函数的所有参数
    }
  }
}
var fn = function(a, b, c) { return [a, b, c]; };
 curry(fn)(‘a‘)(‘a‘,‘a‘)
console.log( curry(fn)(‘a‘,‘a‘)(‘a‘))