thisArg

The value to be passed as thethis parameter to the target function when the bound function is called. The value is ignored if the bound function is constructed using thenew operator.

arg1, arg2, ...

Arguments to prepend to arguments provided to the bound function when invoking the target function.

A copy of the given function with the specifiedthis value and initial arguments.

bind() 函式建立了一個新的綁定函式（BF）。BF 是個包裝了原有函式物件的exotic function object（ECMAScript 2015 的術語）。通常，呼叫BF 會執行該wrapped function。BF 含有以下內部屬性：

• [[BoundTargetFunction]] - the wrapped function object;
• [[BoundThis]] - the value that is always passed asthis value when calling the wrapped function.
• [[BoundArguments]] - a list of values whose elements are used as the first arguments to any call to the wrapped function.
• [[Call]] - executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are athis value and a list containing the arguments passed to the function by a call expression.

When bound function is called, it calls internal method[[Call]] on[[BoundTargetFunction]], with following argumentsCall(boundThis,args). Where,boundThis is[[BoundThis]],args is[[BoundArguments]] followed by the arguments passed by the function call.

A bound function may also be constructed using thenew operator: doing so acts as though the target function had instead been constructed. The providedthis value is ignored, while prepended arguments are provided to the emulated function.

The simplest use ofbind() is to make a function that, no matter how it is called, is called with a particularthis value. A common mistake for new JavaScript programmers is to extract a method from an object, then to later call that function and expect it to use the original object as itsthis (e.g. by using that method in callback-based code). Without special care, however, the original object is usually lost. Creating a bound function from the function, using the original object, neatly solves this problem:

this.x = 9; // this refers to global "window" object here in the browservar module = {  x: 81,  getX: function () {    return this.x;  },};module.getX(); // 81var retrieveX = module.getX;retrieveX();// returns 9 - The function gets invoked at the global scope// Create a new function with 'this' bound to module// New programmers might confuse the// global var x with module's property xvar boundGetX = retrieveX.bind(module);boundGetX(); // 81

The next simplest use ofbind() is to make a function with pre-specified initial arguments. These arguments (if any) follow the providedthis value and are then inserted at the start of the arguments passed to the target function, followed by the arguments passed to the bound function, whenever the bound function is called.

function list() {  return Array.prototype.slice.call(arguments);}var list1 = list(1, 2, 3); // [1, 2, 3]// Create a function with a preset leading argumentvar leadingThirtysevenList = list.bind(null, 37);var list2 = leadingThirtysevenList();// [37]var list3 = leadingThirtysevenList(1, 2, 3);// [37, 1, 2, 3]

By default withinwindow.setTimeout(), thethis keyword will be set to thewindow (orglobal) object. When working with class methods that requirethis to refer to class instances, you may explicitly bindthis to the callback function, in order to maintain the instance.

function LateBloomer() {  this.petalCount = Math.floor(Math.random() * 12) + 1;}// Declare bloom after a delay of 1 secondLateBloomer.prototype.bloom = function () {  window.setTimeout(this.declare.bind(this), 1000);};LateBloomer.prototype.declare = function () {  console.log("I am a beautiful flower with " + this.petalCount + " petals!");};var flower = new LateBloomer();flower.bloom();// after 1 second, triggers the 'declare' method

Bound functions are automatically suitable for use with thenew operator to construct new instances created by the target function. When a bound function is used to construct a value, the providedthis is ignored. However, provided arguments are still prepended to the constructor call:

function Point(x, y) {  this.x = x;  this.y = y;}Point.prototype.toString = function () {  return this.x + "," + this.y;};var p = new Point(1, 2);p.toString(); // '1,2'// not supported in the polyfill below,// works fine with native bind:var YAxisPoint = Point.bind(null, 0 /*x*/);var emptyObj = {};var YAxisPoint = Point.bind(emptyObj, 0 /*x*/);var axisPoint = new YAxisPoint(5);axisPoint.toString(); // '0,5'axisPoint instanceof Point; // trueaxisPoint instanceof YAxisPoint; // truenew Point(17, 42) instanceof YAxisPoint; // true

Note that you need do nothing special to create a bound function for use withnew. The corollary is that you need do nothing special to create a bound function to be called plainly, even if you would rather require the bound function to only be called usingnew.

// Example can be run directly in your JavaScript console// ...continuing from above// Can still be called as a normal function// (although usually this is undesired)YAxisPoint(13);emptyObj.x + "," + emptyObj.y;// >  '0,13'

If you wish to support the use of a bound function only usingnew, or only by calling it, the target function must enforce that restriction.

bind() is also helpful in cases where you want to create a shortcut to a function which requires a specificthis value.

TakeArray.prototype.slice, for example, which you want to use for converting an array-like object to a real array. You could create a shortcut like this:

var slice = Array.prototype.slice;// ...slice.apply(arguments);

Withbind(), this can be simplified. In the following piece of code,slice is a bound function to theapply() function ofFunction.prototype, with thethis value set to theslice() function ofArray.prototype. This means that additionalapply() calls can be eliminated:

// same as "slice" in the previous examplevar unboundSlice = Array.prototype.slice;var slice = Function.prototype.apply.bind(unboundSlice);// ...slice(arguments);

You can partially work around this by inserting the following code at the beginning of your scripts, allowing use of much of the functionality ofbind() in implementations that do not natively support it.

if (!Function.prototype.bind) {  Function.prototype.bind = function (oThis) {    if (typeof this !== "function") {      // closest thing possible to the ECMAScript 5      // internal IsCallable 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 () {        return fToBind.apply(          this instanceof fNOP ? this : oThis,          aArgs.concat(Array.prototype.slice.call(arguments)),        );      };    if (this.prototype) {      // Function.prototype doesn't have a prototype property      fNOP.prototype = this.prototype;    }    fBound.prototype = new fNOP();    return fBound;  };}

Some of the many differences (there may well be others, as this list does not seriously attempt to be exhaustive) between this algorithm and the specified algorithm are:

• The partial implementation relies onArray.prototype.slice(),Array.prototype.concat(),Function.prototype.call() andFunction.prototype.apply(), built-in methods to have their original values.
• The partial implementation creates functions that do not have immutable "poison pill"caller andarguments properties that throw aTypeError upon get, set, or deletion. (This could be added if the implementation supportsObject.defineProperty, or partially implemented [without throw-on-delete behavior] if the implementation supports theObject.prototype.__defineGetter__() andObject.prototype.__defineSetter__() extensions.)
• The partial implementation creates functions that have aprototype property. (Proper bound functions have none.)
• The partial implementation creates bound functions whoselength property does not agree with that mandated by ECMA-262: it creates functions with length 0, while a full implementation, depending on the length of the target function and the number of pre-specified arguments, may return a non-zero length.

If you choose to use this partial implementation,you must not rely on those cases where behavior deviates from ECMA-262, 5th edition! With some care, however (and perhaps with additional modification to suit specific needs), this partial implementation may be a reasonable bridge to the time whenbind() is widely implemented according to the specification.

Please checkhttps://github.com/Raynos/function-bind for a more thorough solution!

• Function.prototype.apply()
• Function.prototype.call()
• Functions