从Function.pr原型.bind（）上的MDN文档中：

bind（）方法创建一个新函数，当调用该函数时此关键字设置为提供的值，具有给定的序列调用新函数时提供的任何参数之前的参数。

那是什么意思？！

好吧，让我们来做一个如下的函数：

var logProp = function(prop) {
    console.log(this[prop]);
};

现在，让我们看一个像这样的对象：

var Obj = {
    x : 5,
    y : 10
};

我们可以像这样将函数绑定到对象：

Obj.log = logProp.bind(Obj);

现在，我们可以在代码中的任何位置运行Obj.log：

Obj.log('x'); // Output : 5
Obj.log('y'); // Output : 10

这是有效的，因为我们将其值绑定到对象Obj。

它真正有趣的地方是，当你不仅为它绑定一个值，而且为它的参数属性绑定一个：

Obj.logX = logProp.bind(Obj, 'x');
Obj.logY = logProp.bind(Obj, 'y');

我们现在可以这样做：

Obj.logX(); // Output : 5
Obj.logY(); // Output : 10

与Obj.log不同，我们不必传递x或y，因为我们在绑定时传递了这些值。

简单解释：

bind（）创建一个新函数，即它返回给您的函数的新引用。

在该关键字后面的parameter中，传递要预配置的参数。实际上，它不会立即执行，只是准备执行。

您可以根据需要预配置任意多个参数。

理解绑定的简单示例：

function calculate(operation) {
  if (operation === 'ADD') {
   alert('The Operation is Addition');
  } else if (operation === 'SUBTRACT') {
   alert('The Operation is Subtraction');
  }
}

addBtn.addEventListener('click', calculate.bind(this, 'ADD'));
subtractBtn.addEventListener('click', calculate.bind(this, 'SUBTRACT'));

bind（）方法创建一个新函数，当调用该函数时，将其this关键字设置为所提供的值，并在调用新函数时提供的任何参数之前设置一个给定的参数序列。

第一部分的示例

使用St8从反应包中抓取

import { useState } from "react"

function st8() {
    switch(arguments.length) {
        case 0: return this[0]
        case 1: return void this[1](arguments[0])
        default: throw new Error("Expected 0 or 1 arguments")
    }
}


function useSt8(initial) {
    // this in st8 will be something like [state, setSatate]
    return st8.bind(useState(initial))
}

// usage
function Counter() {
  const count = useSt8(0);
  return (
    <>
      Count: {count()}
      <button onClick={() => count(0)}>Reset</button>
      <button onClick={() => count(prevCount => prevCount + 1)}>inc</button>
    </>
  );
}

第二部分的示例

const add = (a, b) => a+b

someThis = this
// new function with this value equal to someThis
add5 = add.bind(someThis, 5) 
add5(10) // 15

// we don't use this in add decelartion so this will work too.
add10 = add.bind(null, 10) 
add10(5) // 15

bind函数创建了一个新函数，其函数体和它所调用的函数相同。它是用这个参数调用的。为什么我们使用bind fun？：当每次创建一个新实例时，我们必须使用第一个初始实例，然后使用bind fun。我们不能重写bind fun.暗示它存储类的初始对象。

setInterval(this.animate_to.bind(this), 1000/this.difference);

Bind创建一个新函数，该函数将强制函数内部的this作为传递给Bind（）的参数。

下面是一个示例，展示了如何使用bind传递具有正确this的成员方法：

var myButton = {
  content: 'OK',
  click() {
    console.log(this.content + ' clicked');
  }
};

myButton.click();

var looseClick = myButton.click;
looseClick(); // not bound, 'this' is not myButton - it is the globalThis

var boundClick = myButton.click.bind(myButton);
boundClick(); // bound, 'this' is myButton

打印结果：

OK clicked
undefined clicked
OK clicked

您还可以在第一个（this）参数之后添加额外的参数，bind将把这些值传递给原始函数。稍后传递给绑定函数的任何其他参数将在绑定参数之后传递：

// Example showing binding some parameters
var sum = function(a, b) {
  return a + b;
};

var add5 = sum.bind(null, 5);
console.log(add5(10));

打印结果：

15

查看JavaScript函数绑定以获取更多信息和交互式示例。

更新：ECMAScript 2015增加了对=>函数的支持。=>函数更紧凑，不会从其定义范围更改this指针，因此您可能不需要经常使用bind（）。例如，如果您希望第一个示例中Button上的一个函数将单击回调连接到DOM事件，以下都是实现这一点的有效方法：

var myButton = {
  ... // As above
  hookEvent(element) {
    // Use bind() to ensure 'this' is the 'this' inside click()
    element.addEventListener('click', this.click.bind(this));
  }
};

Or:

var myButton = {
  ... // As above
  hookEvent(element) {
    // Use a new variable for 'this' since 'this' inside the function
    // will not be the 'this' inside hookEvent()
    var me = this;
    element.addEventListener('click', function() { me.click() });
  }
};    

Or:

var myButton = {
  ... // As above
  hookEvent(element) {
    // => functions do not change 'this', so you can use it directly
    element.addEventListener('click', () => this.click());
  }
};

考虑下面列出的简单程序，

//we create object user
let User = { name: 'Justin' };

//a Hello Function is created to Alert the object User 
function Hello() {
  alert(this.name);
}

//since there the value of this is lost we need to bind user to use this keyword
let user = Hello.bind(User);
user();

//we create an instance to refer the this keyword (this.name);