另一种用法是，可以将绑定函数作为参数传递给在另一个执行上下文下运行的另一个函数。

var name = "sample";
function sample(){
  console.log(this.name);
}
var cb = sample.bind(this);

function somefunction(cb){
  //other code
  cb();
}
somefunction.call({}, cb);

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());
  }
};

简单的例子

function lol(second, third) {
    console.log(this.first, second, third);
}

lol(); // undefined, undefined, undefined
lol('1'); // undefined, "1", undefined
lol('1', '2'); // undefined, "1", "2"

lol.call({first: '1'}); // "1", undefined, undefined
lol.call({first: '1'}, '2'); // "1", "2", undefined
lol.call({first: '1'}, '2', '3'); // "1", "2", "3"

lol.apply({first: '1'}); // "1", undefined, undefined
lol.apply({first: '1'}, ['2', '3']); // "1", "2", "3"

const newLol = lol.bind({first: '1'}); 
newLol(); // "1", undefined, undefined
newLol('2'); // "1", "2", undefined
newLol('2', '3'); // "1", "2", "3"

const newOmg = lol.bind({first: '1'}, '2');
newOmg(); // "1", "2", undefined
newOmg('3'); // "1", "2", "3"

const newWtf = lol.bind({first: '1'}, '2', '3');
newWtf(); // "1", "2", "3"

function.prototype.bind（）接受Object。它将调用函数绑定到传递的Object，并返回相同的。当对象绑定到函数时，这意味着您将能够使用“this”关键字。

也可以说，

function.prototype.bind（）用于提供/更改作用

让powerOfNumber=函数（数字）{设乘积=1；for（设i=1；i<=this.power；i++）{产品*=数量；}退货产品；}让powerOfTwo=powerOfNumber.bind（｛power:2｝）；警报（powerOfTwo（2））；让powerOfThree=powerOfNumber.bind（{power:3}）；警报（powerOfThree（2））；让powerOfFour=powerOfNumber.bind（{power:4}）；警报（powerOfFour（2））；

让我们试着理解这一点。

    let powerOfNumber = function(number) {
      let product = 1;
      for (let i = 1; i <= this.power; i++) {
        product *= number;
      }
      return product;
    }

这里，在这个函数中，这对应于绑定到函数powerOfNumber的对象。目前，我们没有任何函数绑定到此函数。

让我们创建一个函数powerOfTwo，它将使用上面的函数查找数字的二次幂。

  let powerOfTwo = powerOfNumber.bind({power:2});
  alert(powerOfTwo(2));

这里使用bind将对象｛power:2｝传递给powerOfNumber函数。

bind函数将此对象绑定到powerOfNumber（），并将以下函数返回给powerOfTwo。现在，powerOfTwo看起来，

    let powerOfNumber = function(number) {
      let product = 1;
        for(let i=1; i<=2; i++) {
          product*=number;
      }
      return product;
    }

因此，powerOfTwo将找到第二个电源。

请随意查看。

Javascript中的bind（）函数

bind（）方法创建一个新的函数实例，该实例的值与传递到bind（的值绑定。例如：

   window.color = "red"; 
   var o = { color: "blue" }; 
   function sayColor(){ 
       alert(this.color); 
   } 
   var objectSayColor = sayColor.bind(o); 
   objectSayColor(); //blue 

在这里，通过调用bind（）并传入对象o，从sayColor（）创建了一个名为objectSayColor）的新函数。objectSayCcolor（）函数的这个值相当于o，因此即使作为全局调用调用该函数，也会显示字符串“blue”。

参考资料：Nicholas C.Zakas-面向WEB开发人员的专业JAVASCRIPT®

我将从理论上和实践上解释bind

javascript中的bind是一种方法--Function.prototype.bind.bind是一个方法。它是在函数原型上调用的。此方法创建一个函数，其主体与调用该函数的函数相似，但“This”引用传递给绑定方法的第一个参数。其语法为

     var bindedFunc = Func.bind(thisObj,optionsArg1,optionalArg2,optionalArg3,...);

示例：--

  var checkRange = function(value){
      if(typeof value !== "number"){
              return false;
      }
      else {
         return value >= this.minimum && value <= this.maximum;
      }
  }

  var range = {minimum:10,maximum:20};

  var boundedFunc = checkRange.bind(range); //bounded Function. this refers to range
  var result = boundedFunc(15); //passing value
  console.log(result) // will give true;