El métodobind() crea una nueva función, que cuando es llamada, asigna a su operadorthis el valor entregado, con una secuencia de argumentos dados precediendo a cualquiera entregados cuando la función es llamada.

El valor dethis es ignorado cuando la función es llamada con el operadornew.

fun.bind(thisArg[, arg1[, arg2[, ...]]])

thisArg

Es un valor que será enviado a la función destino cuando se llame a la función de enlace. Este valor será ignorado si la función de enlace es construida usando el operadornew.

arg1, arg2, ...

Son los argumentos que se enviarán además de los provistos a la función de enlace cuando se invoque la función destino.

Una copia de la función entregada con el valor especificadothis y los argumentos iniciales.

La funciónbind() crea una nueva función (función ligada) con el mismo cuerpo (propiedad internacall en términos de ECMAScript 5) como la función que será llamada (lafunción objetivo de la función ligada) con la referenciathis asociada al primer argumento debind(), el cual no podrá ser sobreescrito.bind() también acepta parámetros predeterminados que antecederán al resto de los parámetros específicos cuando la función objetivo sea llamada. Una función ligada también puede ser construída utilizando el operadornew: al hacerlo, actuará como si en su lugar hubiera sido construída la función objetivo.

En este último caso, el parámetro correspondiente parathis será ignorado, aunque los parámetros predeterminados que antecederán al resto sí serán provistos para la función emulada.

El uso más simple debind() es hacer que una función que, sin importar cómo es llamada, siempre apunte al mismo objeto con la referenciathis. Un error común para nuevos programadores de JavaScript es que obtienen una referencia a un método de un objeto, posteriormente ejecutan ese método desde la referencia externa y esperan que la referencia dethis siga apuntando al objeto original de donde se obtuvo el método (v.g. cuando se usa ese método en un callback). Sin el debido cuidado, el objeto original es comúnmente perdido. Creando una función ligada desde la función empleando el objeto original, resuelve limpiamente este problema:

this.x = 9;var module = {  x: 81,  getX: function () {    return this.x;  },};module.getX(); // 81var getX = module.getX;getX(); // 9, porque en este caso, "this" apunta al objeto global// Crear una nueva función con 'this' asociado al objeto original 'module'var boundGetX = getX.bind(module);boundGetX(); // 81

El siguiente uso simple debind() es definir una función con argumentos predeterminados que precederán a los argumentos finales de la función ligada. Estos argumentos iniciales (en caso de haberlos) se definen a continuación de lo que será la referencia dethis y son entonces enviados como argumentos de la función objetivo, seguidos por los argumentos enviados a la función ligada cada vez que dicha función sea llamada.

function list() {  return Array.prototype.slice.call(arguments);}var list1 = list(1, 2, 3); // [1, 2, 3]// Crear funcion (sin referencia this) con argumento inicial predeterminadovar leadingThirtysevenList = list.bind(undefined, 37);var list2 = leadingThirtysevenList(); // [37]var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

De manera predeterminada, dentro dewindow.setTimeout(), la palabra reservadathis será setteada al objetowindow (o a global). Cuando se esté trabajando con métodos de clase que requieran quethis se refiera a instancias de clase, usted puede explícitamente ligarthis a la función callback para mantener la referencia de la instancia.

function LateBloomer() {  this.petalCount = Math.ceil(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!");};

Las funciones ligadas son automáticamente adecuadas para usarse con el operadornew para construir nuevas instancias creadas por la función objetivo. Cuando una función ligada es utilizada para construir un valor, el parámetro enviado para reemplazar la referenciathis es ignorado. De cualquier forma, los argumentos iniciales sí son tomados en consideración y antecederán a los parámetros que se envíen al constructor:

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'var emptyObj = {};var YAxisPoint = Point.bind(emptyObj, 0 /*x*/);// not supported in the polyfill below,// works fine with native bind:var YAxisPoint = Point.bind(null, 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 que no necesita hacer nada especial para crear una función ligada para usarse connew. El razonamiento es que usted no necesita hacer nada especial para crear una función ligada para ser llamada planamente, aún si usted prefiriera requerir que la función ligada sea llamada únicamente utilizandonew.

// Ejemplo que puede ser ejecutado directamente en tu consola JavaScript// ...continúa de arriba// Aún puede ser invocada como una función normal// (aunque es usualmente indeseable)YAxisPoint(13);emptyObj.x + "," + emptyObj.y;// >  '0,13'

Si desea utilizar una función ligada únicamente usandonew, o únicamente mediante una llamada directa, la función objetivo debe forzar esa restricción.

bind() también es útil en casos en los que desea crear un atajo para una función que requiere una referencia específica parathis.

TomandoArray.prototype.slice, por ejemplo, el cual se desearía utilizar para convertir un objeto tipo array a un arreglo real. Podría crear un atajo como el siguiente:

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

Conbind(), esto puede ser simplificado. En el siguiente fragmento de código,slice es una función ligada a la funcióncall() deFunction.prototype, con la referenciathis setteada a la funciónslice() deArray.prototype. Esto significa que llamadas adicionales acall() pueden omitirse:

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

La funciónbind() fue añadida a la especificación ECMA-262, 5a edición; por lo tanto podría no estar presente en todos los navegadores. Usted puede parcialmente simularla al insertar el siguiente código al inicio de sus scripts, permitiendo emplear muchas de las funcionalidades debind() en implementaciones que no la soportan nativamente.

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 && oThis ? this : oThis,          aArgs.concat(Array.prototype.slice.call(arguments)),        );      };    fNOP.prototype = this.prototype;    fBound.prototype = new fNOP();    return fBound;  };}

Algunas de las muchas diferencias (bien podría haber otras, en tanto la siguiente lista no intenta ser exhaustiva) entre este algoritmo y el algoritmo de la especificación son:

• La implementación parcial se basa enArray.prototype.slice(),Array.prototype.concat(),Function.prototype.call() yFunction.prototype.apply(), métodos incorporados para tener sus valores originales.
• La implementación parcial crea funciones que no tienen "poison pills" inmutablescaller y las propiedades de losargumentos que lanzan unaTypeError sobre get, set, o deletion. (Esto podría ser añadido si la implementación soportaraObject.defineProperty, o parcialmente implementada [sin el comportamiento throw-on-delete] si la implementación soportara las extensionesObject.prototype.__defineGetter__() yObject.prototype.__defineSetter__() ).
• La implementación parcial crea funciones que tienen una propiedadprototype. (Las funciones ligadas no tienen ninguna).
• La implementación parcial crea funciones ligadas cuya propiedadlength no coincide con la indicada por ECMA-262: ésta crea funciones con longitud 0, mientras que la implementación completa, dependiendo de la longitud de la función objetivo y del número de argumentos pre-especificados, podría regresar una longitud mayor a zero.

Si elige usar esta implementación parcial,no debe de utilizarla en los casos en los que el comportamiento es distinto al de la especificación ECMA-262, 5th edition! Con un poco de cuidado, de cualquier manera (y tal vez con algunas modificaciones adicionales para adecuarse a sus necesidades específicas), esta implementación parcial podría ser un puente razonable al momento en quebind() sea ampliamente implementada acorde a a la especificación.

Por favor checahttps://github.com/Raynos/function-bind para ver una solución más profunda.

• Function.prototype.apply()
• Function.prototype.call()
• Functions and function scope