Function.prototype.bind()

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

El valor de this es ignorado cuando la función es llamada con el operador new.

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 operador new.

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 especificado this y los argumentos iniciales.

La función bind() crea una nueva función (función ligada) con el mismo cuerpo (propiedad interna call en términos de ECMAScript 5) como la función que será llamada (la función objetivo de la función ligada) con la referencia this asociada al primer argumento de bind(), 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 operador new: al hacerlo, actuará como si en su lugar hubiera sido construída la función objetivo.

En este último caso, el parámetro correspondiente para this 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 de bind() es hacer que una función que, sin importar cómo es llamada, siempre apunte al mismo objeto con la referencia this. 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 de this 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(); // 81

var 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 de bind() 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 de this 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 predeterminado
var leadingThirtysevenList = list.bind(undefined, 37);

var list2 = leadingThirtysevenList(); // [37]
var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

De manera predeterminada, dentro de window.setTimeout(), la palabra reservada this será setteada al objeto window (o a global). Cuando se esté trabajando con métodos de clase que requieran que this se refiera a instancias de clase, usted puede explícitamente ligar this 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 second
LateBloomer.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 operador new 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 referencia this 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; // true
axisPoint instanceof YAxisPoint; // true
new Point(17, 42) instanceof YAxisPoint; // true

Note que no necesita hacer nada especial para crear una función ligada para usarse con new. 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 utilizando new.

// 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 usando new, 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 para this.

Tomando Array.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);

Con bind(), esto puede ser simplificado. En el siguiente fragmento de código, slice es una función ligada a la función call() de Function.prototype, con la referencia this setteada a la función slice() de Array.prototype. Esto significa que llamadas adicionales a call() pueden omitirse:

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

// ...

slice(arguments);

La función bind() 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 de bind() 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 en Array.prototype.slice(), Array.prototype.concat(), Function.prototype.call() y Function.prototype.apply(), métodos incorporados para tener sus valores originales.
• La implementación parcial crea funciones que no tienen "poison pills" inmutables caller y las propiedades de los argumentos que lanzan una TypeError sobre get, set, o deletion. (Esto podría ser añadido si la implementación soportara Object.defineProperty, o parcialmente implementada [sin el comportamiento throw-on-delete] si la implementación soportara las extensiones Object.prototype.__defineGetter__() y Object.prototype.__defineSetter__() ).
• La implementación parcial crea funciones que tienen una propiedad prototype. (Las funciones ligadas no tienen ninguna).
• La implementación parcial crea funciones ligadas cuya propiedad length 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 que bind() sea ampliamente implementada acorde a a la especificación.

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

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