JavaScript de llamada () y apply () vs bind ()?

Ya sé que apply y call son funciones similares que configuran this (contexto de función).

La diferencia está en cómo enviamos los argumentos (manual array vs)

Pregunta:

Pero, ¿cuándo debo usar el método bind() ?

 var obj = { x: 81, getX: function() { return this.x; } }; alert(obj.getX.bind(obj)()); alert(obj.getX.call(obj)); alert(obj.getX.apply(obj)); 

jsbin

684
17 марта '13 в 0:40 2013-03-17 00:40 Royi Namir preguntó el 17 de marzo de 2013 a las 0:40 2013-03-17 00:40
@ 19 respuestas

Use .bind() cuando desee que esta función se llame más tarde con un contexto específico, útil en eventos. Use .call() o .apply() cuando quiera llamar inmediatamente a una función y cambiar el contexto.

Llamada / aplicación Llama a la función inmediatamente, mientras que bind devuelve una función que, cuando se ejecuta de nuevo, tendrá el contexto adecuado para llamar a la función original. De esta manera, puede mantener el contexto en devoluciones de llamada y eventos asíncronos.

Hago esto mucho

 function MyObject(element) { this.elm = element; element.addEventListener('click', this.onClick.bind(this), false); }; MyObject.prototype.onClick = function(e) { var t=this; //do something with [t]... //without bind the context of this function wouldn't be a MyObject //instance as you would normally expect. }; 

Lo uso ampliamente en Node.js para devoluciones de llamada asíncronas para las que quiero pasar un método miembro, pero aún quiero que el contexto sea la instancia que inició la acción asíncrona.

Una implementación simple de enlace naive se vería así:

 Function.prototype.bind = function(ctx) { var fn = this; return function() { fn.apply(ctx, arguments); }; }; 

Hay más en él (por ejemplo, pasar otros argumentos), pero puede aprender más sobre él y ver la implementación real en MDN .

Espero que esto ayude.

716
17 марта '13 в 0:44 2013-03-17 00:44 Chad respondió el 17 de marzo, 13 a las 0:44 2013-03-17 00:44

Todos adjuntan esto a una función (u objeto), y la diferencia está en la llamada a la función (ver más abajo).

La llamada adjunta esto a la función e inmediatamente realiza la función:

 var person = { name: "James Smith", hello: function(thing) { console.log(this.name + " says hello " + thing); } } person.hello("world"); // output: "James Smith says hello world" person.hello.call({ name: "Jim Smith" }, "world"); // output: "Jim Smith says hello world" 

bind adjunta esto a una función, y debe llamarse por separado de la siguiente manera:

 var person = { name: "James Smith", hello: function(thing) { console.log(this.name + " says hello " + thing); } } person.hello("world"); // output: "James Smith says hello world" var helloFunc = person.hello.bind({ name: "Jim Smith" }); helloFunc("world"); // output: Jim Smith says hello world" 

o así:

 ... var helloFunc = person.hello.bind({ name: "Jim Smith" }, "world"); helloFunc(); // output: Jim Smith says hello world" 

La aplicación es similar a una llamada , excepto que toma un objeto como una matriz, en lugar de especificar los argumentos de uno en uno:

 function personContainer() { var person = { name: "James Smith", hello: function() { console.log(this.name + " says hello " + arguments[1]); } } person.hello.apply(person, arguments); } personContainer("world", "mars"); // output: "James Smith says hello mars", note: arguments[0] = "world" , arguments[1] = "mars" 
397
10 авг. La respuesta la da CuriousSuperhero 10 ago. 2015-08-10 17:50 '15 a las 17:50 2015-08-10 17:50

La respuesta más simple

  • La llamada llama a la función y le permite pasar argumentos uno por uno.
  • Aplicar llama a una función y le permite pasar argumentos como una matriz.
  • Bind devuelve una nueva función que le permite pasar esta matriz y cualquier número de argumentos.

Aplicar vs. Ejemplos de desafío vs unión

Llamar

 var person1 = {firstName: 'Jon', lastName: 'Kuperman'}; var person2 = {firstName: 'Kelly', lastName: 'King'}; function say(greeting) { console.log(greeting + ' ' + this.firstName + ' ' + this.lastName); } say.call(person1, 'Hello'); // Hello Jon Kuperman say.call(person2, 'Hello'); // Hello Kelly King 

Aplicar

 var person1 = {firstName: 'Jon', lastName: 'Kuperman'}; var person2 = {firstName: 'Kelly', lastName: 'King'}; function say(greeting) { console.log(greeting + ' ' + this.firstName + ' ' + this.lastName); } say.apply(person1, ['Hello']); // Hello Jon Kuperman say.apply(person2, ['Hello']); // Hello Kelly King 

Atar

 var person1 = {firstName: 'Jon', lastName: 'Kuperman'}; var person2 = {firstName: 'Kelly', lastName: 'King'}; function say() { console.log('Hello ' + this.firstName + ' ' + this.lastName); } var sayHelloJon = say.bind(person1); var sayHelloKelly = say.bind(person2); sayHelloJon(); // Hello Jon Kuperman sayHelloKelly(); // Hello Kelly King 

Cuándo usar cada

El reto y la aplicación son bastante intercambiables. Simplemente decida si es más fácil enviarlo a una matriz o a una lista de argumentos separados por comas.

Siempre recuerdo cuál recuerda que la llamada es para una coma (una lista dividida), y Aplicar es para una matriz.

La encuadernación es un poco diferente. Devuelve una nueva función. Llama y Aplica inmediatamente realiza la función actual.

Snap es ideal para muchas cosas. Podemos usarlo para realizar funciones similares a las anteriores. Podemos tomar una simple función de saludo y convertirla en helloJon o helloKelly. También podemos usarlo para eventos como onClick, donde no sabemos cuándo serán despedidos, pero sabemos qué contexto queremos tener.

Enlace: codeplanet.io

106
12 окт. Responder Amit Shah 12 de octubre 2017-10-12 05:47 '17 a las 5:47 2017-10-12 05:47

Le permite establecer el valor de this independientemente de cómo se llame la función. Esto es muy útil cuando se trata de devoluciones de llamada:

  function sayHello(){ alert(this.message); } var obj = { message : "hello" }; setTimeout(sayHello.bind(obj), 1000); 

Para lograr el mismo resultado, el uso de la call se verá así:

  function sayHello(){ alert(this.message); } var obj = { message : "hello" }; setTimeout(function(){sayHello.call(obj)}, 1000); 
50
17 марта '13 в 0:45 2013-03-17 00:45 la respuesta la da jantimon el 17 de marzo de 2013 a las 0:45 2013-03-17 00:45

Supongamos que la función de multiplication

 function multiplication(a,b){ console.log(a*b); } 

Le permite crear algunas funciones estándar con bind

var multiby2 = multiplication.bind(this,2);

Ahora multiby2 (b) es igual a la multiplicación (2, b);

 multiby2(3); //6 multiby2(4); //8 

¿Qué pasa si paso ambos parámetros para enlazar?

 var getSixAlways = multiplication.bind(this,3,2); 

Ahora getSixAlways () es igual a la multiplicación (3,2);

 getSixAlways();//6 

incluso pasando parámetros de retorno 6; getSixAlways(12); //6

 var magicMultiplication = multiplication.bind(this); 

Crear una nueva función de multiplicación y asignarla a magicMultiplication.

No, escondemos la funcionalidad de multiplicación en magicMultiplication.

call magicMultiplication devuelve una function b() vacía function b()

cuando se ejecuta, funciona bien magicMultiplication(6,5); //30 magicMultiplication(6,5); //30

¿Qué hay de llamar y aplicar?

magicMultiplication.call(this,3,2); //6

magicMultiplication.apply(this,[5,2]); //10

En palabras simples, bind crea una función, call y apply ejecuta la función, mientras que apply espera los parámetros en una matriz.

40
10 июня '15 в 21:04 2015-06-10 21:04 la respuesta se da tk120404 10 de junio de 15 a 21:04 2015-06-10 21:04

Tanto Function.prototype.call() como Function.prototype.apply() llaman a una función con el valor dado de this y devuelven el valor de retorno de esta función.

Function.prototype.bind() , por otro lado, crea una nueva función con el valor dado de this y devuelve esta función sin ejecutarla.

Entonces, toma una función que se parece a esto:

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

Ahora toma un objeto que se ve así:

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

Podemos unir nuestra función a nuestro objeto de la siguiente manera:

 Obj.log = logProp.bind(Obj); 

Ahora podemos ejecutar Obj.log en cualquier lugar de nuestro código:

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

Si esto es realmente interesante, esto es cuando no solo unes el valor para this , sino también para el argumento prop :

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

Ahora podemos hacer esto:

 Obj.logX(); // Output : 5 Obj.logY(); // Output : 10 
28
18 янв. Respuesta dada por John Slegers el 18 de enero. 2016-01-18 06:59 '16 a las 6:59 2016-01-18 06:59

bind : enlaza una función con el valor y el contexto proporcionados, pero no realiza esa función. Para ejecutar una función, necesita llamar a una función.

llamada : realiza la función con el contexto y parámetro proporcionados.

aplicar : ejecuta la función con el contexto provisto y como una matriz .

18
22 нояб. La respuesta la da Siddhartha el 22 de noviembre. 2017-11-22 20:31 '17 a las 8:31 pm 2017-11-22 20:31

Aquí hay un buen artículo para ilustrar la diferencia entre bind() , apply() y call() , resúmalo como se muestra a continuación.

  • bind() nos permite determinar fácilmente qué objeto en particular se asociará con esto al llamar a una función o método.

     // This data variable is a global variable​ var data = [ {name:"Samantha", age:12}, {name:"Alexis", age:14} ] var user = { // local data variable​ data :[ {name:"T. Woods", age:37}, {name:"P. Mickelson", age:43} ], showData:function (event) { var randomNum = ((Math.random () * 2 | 0) + 1) - 1; // random number between 0 and 1​ console.log (this.data[randomNum].name + " " + this.data[randomNum].age); } } // Assign the showData method of the user object to a variable​ var showDataVar = user.showData; showDataVar (); // Samantha 12 (from the global data array, not from the local data array)​  // Bind the showData method to the user object​ var showDataVar = user.showData.bind (user); // Now the we get the value from the user object because the this keyword is bound to the user object​ showDataVar (); // P. Mickelson 43​ 
  • bind() nos permite tomar métodos

     // Here we have a cars object that does not have a method to print its data to the console​ var cars = { data:[ {name:"Honda Accord", age:14}, {name:"Tesla Model S", age:2} ] } // We can borrow the showData () method from the user object we defined in the last example.​ // Here we bind the user.showData method to the cars object we just created.​ cars.showData = user.showData.bind (cars); cars.showData (); // Honda Accord 14​ 

    Un problema con este ejemplo es que agregamos un nuevo método showData al objeto cars y es posible que no queramos hacerlo simplemente para tomar prestado el método, ya que el objeto cars ya puede tener una propiedad o el nombre del método showData . No queremos sobrescribirlo por casualidad. Como veremos en nuestra discusión de Apply y Call continuación, es mejor tomar prestado el método utilizando el método Apply o Call .

  • bind() nos permite realizar una función

    La función de Currying , también conocida como una aplicación de función parcial, es el uso de la función (que toma uno o más argumentos), que devuelve una nueva función con algunos argumentos ya establecidos.

     function greet (gender, age, name) { // if a male, use Mr., else use Ms.​ var salutation = gender === "male" ? "Mr. " : "Ms. "; if (age > 25) { return "Hello, " + salutation + name + "."; }else { return "Hey, " + name + "."; } } 

    Podemos usar bind() para ejecutar esta función de greet .

     // So we are passing null because we are not using the "this" keyword in our greet function. var greetAnAdultMale = greet.bind (null, "male", 45); greetAnAdultMale ("John Hartlove"); // "Hello, Mr. John Hartlove." var greetAYoungster = greet.bind (null, "", 16); greetAYoungster ("Alex"); // "Hey, Alex."​ greetAYoungster ("Emma Waterloo"); // "Hey, Emma Waterloo." 
  • apply() o call() para establecer este valor

    Los métodos Apply , Call y bind se utilizan para establecer este valor al llamar a un método, y lo hacen de maneras ligeramente diferentes para permitir el control directo y la versatilidad que se utilizará en nuestro código JavaScript.

    Los métodos de Apply y Call son casi idénticos al configurar este valor, excepto que pasa los parámetros de la función a apply () como una matriz, mientras que debe enumerar individualmente los parámetros para pasarlos al método call () .

    Este es un ejemplo del uso de Call o Apply para configurar esto en una función de devolución de llamada.

     // Define an object with some properties and a method​ // We will later pass the method as a callback function to another function​ var clientData = { id: 094545, fullName: "Not Set", // setUserName is a method on the clientData object​ setUserName: function (firstName, lastName) { // this refers to the fullName property in this object​ this.fullName = firstName + " " + lastName; } }; function getUserInput (firstName, lastName, callback, callbackObj) { // The use of the Apply method below will set the "this" value to callbackObj​ callback.apply (callbackObj, [firstName, lastName]); } // The clientData object will be used by the Apply method to set the "this" value​ getUserInput ("Barack", "Obama", clientData.setUserName, clientData); // the fullName property on the clientData was correctly set​ console.log (clientData.fullName); // Barack Obama 
  • Prestaciones prestadas usando Apply o Call

    • Utilizar métodos de matriz

      Le permite crear un objeto array-like una array-like y tomar prestados algunos métodos de matriz para trabajar con nuestro objeto, como una matriz.

       // An array-like object: note the non-negative integers used as keys​ var anArrayLikeObj = {0:"Martin", 1:78, 2:67, 3:["Letta", "Marieta", "Pauline"], length:4 }; // Make a quick copy and save the results in a real array: // First parameter sets the "this" value​ var newArray = Array.prototype.slice.call (anArrayLikeObj, 0); console.log (newArray); // ["Martin", 78, 67, Array[3]]​ // Search for "Martin" in the array-like object​ console.log (Array.prototype.indexOf.call (anArrayLikeObj, "Martin") === -1 ? false : true); // true​ 

      Otro caso común es convertir los arguments a una matriz de la siguiente manera.

        // We do not define the function with any parameters, yet we can get all the arguments passed to it​ function doSomething () { var args = Array.prototype.slice.call (arguments); console.log (args); } doSomething ("Water", "Salt", "Glue"); // ["Water", "Salt", "Glue"] 
    • Pedir prestado otros metodos

       var gameController = { scores :[20, 34, 55, 46, 77], avgScore:null, players :[ {name:"Tommy", playerID:987, age:23}, {name:"Pau", playerID:87, age:33} ] } var appController = { scores :[900, 845, 809, 950], avgScore:null, avg :function () { var sumOfScores = this.scores.reduce (function (prev, cur, index, array) { return prev + cur; }); this.avgScore = sumOfScores / this.scores.length; } } // Note that we are using the apply () method, so the 2nd argument has to be an array​ appController.avg.apply (gameController); console.log (gameController.avgScore); // 46.4​ // appController.avgScore is still null; it was not updated, only gameController.avgScore was updated​ console.log (appController.avgScore); // null​ 
  • Use apply() para ejecutar la función de variable de aridad.

Math.max es un ejemplo de la función variable-arity,

 // We can pass any number of arguments to the Math.max () method​ console.log (Math.max (23, 11, 34, 56)); // 56 

¿Pero qué pasa si tenemos una serie de números para ir a Math.max ? No podemos hacer esto:

 var allNumbers = [23, 11, 34, 56]; // We cannot pass an array of numbers to the the Math.max method like this​ console.log (Math.max (allNumbers)); // NaN 

Aquí, el método apply () nos ayuda a realizar funciones variacionales. En lugar de lo anterior, debemos pasar una matriz de números usando apply ( ), por lo tanto:

 var allNumbers = [23, 11, 34, 56]; // Using the apply () method, we can pass the array of numbers: console.log (Math.max.apply (null, allNumbers)); // 56 
16
08 апр. La respuesta se da zangw 08 de abril. 2016-04-08 09:45 '16 a las 9:45 AM 2016-04-08 09:45

La llamada / aplicación realiza inmediatamente la función:

 func.call(context, arguments); func.apply(context, [argument1,argument2,..]); 

el enlace no ejecuta la función inmediatamente, pero devuelve la función envuelta de apply (para ejecución posterior):

 function bind(func, context) { return function() { return func.apply(context, arguments); }; } 
7
07 февр. La respuesta la da Eldiyar Talantbek el 7 de febrero. 2017-02-07 22:34 '17 a las 10:34 pm 2017-02-07 22:34
  • La llamada llama a la función y le permite pasar argumentos uno por uno.
  • Aplicar llama a una función y le permite pasar argumentos como una matriz.
  • Bind devuelve una nueva función que le permite pasar esta matriz y cualquier número de argumentos.
5
01 янв. La respuesta se da Khalid Azam 01 de enero 2017-01-01 01:01 '17 a la 1:01 2017-01-01 01:01

Aplicar y snap. y como difieren.

Le permite estudiar el desafío y aplicar utilizando cualquier terminología diaria.

Tienes tres autos: your_scooter , your_car and your_jet , que comienzan con el mismo mecanismo (método). Creamos un automobile utilizando el método push_button_engineStart .

 var your_scooter, your_car, your_jet; var automobile = { push_button_engineStart: function (runtime){ console.log(this.name + "'s" + ' engine_started, buckle up for the ride for ' + runtime + " minutes"); } } 

Le permite comprender cuándo se está utilizando y aplicando una llamada. Supongamos que usted es un ingeniero y que tiene your_scooter , your_car y your_jet , que no vienen con push_button_engine_start, y desea utilizar un push_button_engineStart terceros.

Si ejecuta las siguientes líneas de código, le darán un mensaje de error. Por que

 //your_scooter.push_button_engineStart(); //your_car.push_button_engineStart(); //your_jet.push_button_engineStart(); automobile.push_button_engineStart.apply(your_scooter,[20]); automobile.push_button_engineStart.call(your_jet,10); automobile.push_button_engineStart.call(your_car,40); 

Por lo tanto, el ejemplo anterior le da a your_scooter, your_car, your_jet una función desde un objeto de automóvil.

Vamos a profundizar. Aquí dividimos la línea de código anterior. automobile.push_button_engineStart nos ayuda a usar el método.

Luego usamos la aplicación o llamamos usando notación de puntos. automobile.push_button_engineStart.apply()

Ahora aplica y llama a dos parámetros.

  • Contexto
  • argumentos

Así que aquí establecemos el contexto en la última línea del código.

automobile.push_button_engineStart.apply(your_scooter,[20])

La diferencia entre una llamada y una aplicación es que se aplican los parámetros de toma en forma de una matriz, mientras que una llamada puede simplemente tomar una lista de argumentos, separados por comas.

¿Qué es la función JS Bind?

La función de enlace básicamente vincula el contexto de algo y luego lo almacena en una variable para su ejecución en una etapa posterior.

Hagamos nuestro ejemplo anterior aún mejor. Anteriormente, utilizamos un método que pertenece a un objeto de automóvil y lo usamos para equipar your_car, your_jet and your_scooter . Ahora imagine que queremos separar el push_button_engineStart separado para comenzar nuestros autos individualmente en cualquier etapa posterior del rendimiento que deseemos.

 var scooty_engineStart = automobile.push_button_engineStart.bind(your_scooter); var car_engineStart = automobile.push_button_engineStart.bind(your_car); var jet_engineStart = automobile.push_button_engineStart.bind(your_jet); setTimeout(scooty_engineStart,5000,30); setTimeout(car_engineStart,10000,40); setTimeout(jet_engineStart,15000,5); 

todavia no esta satisfecho?

Que quede claro como una lágrima. Tiempo para experimentar. Volveremos a llamar y aplicaremos la aplicación a la aplicación e intentaremos guardar el valor de la función como referencia.

El experimento descrito a continuación no se pudo realizar porque la llamada y la aplicación se llaman de inmediato, por lo que nunca llegamos a la etapa de almacenar la referencia en una variable donde la función de enlace roba el espectáculo.

var test_function = automobile.push_button_engineStart.apply(your_scooter);

4
27 марта '17 в 20:21 2017-03-27 20:21 La respuesta la da Sagar Munjal el 27 de marzo de 17 a las 20:21 2017-03-27 20:21
 function printBye(message1, message2){ console.log(message1 + " " + this.name + " "+ message2); } var par01 = { name:"John" }; var msgArray = ["Bye", "Never come again..."]; printBye.call(par01, "Bye", "Never come again...");//Bye John Never come again... printBye.call(par01, msgArray);//Bye,Never come again... John undefined //so call() doesn't work with array and better with comma seperated parameters //printBye.apply(par01, "Bye", "Never come again...");//Error printBye.apply(par01, msgArray);//Bye John Never come again... var func1 = printBye.bind(par01, "Bye", "Never come again..."); func1();//Bye John Never come again... var func2 = printBye.bind(par01, msgArray); func2();//Bye,Never come again... John undefined //so bind() doesn't work with array and better with comma seperated parameters 
2
16 июня '17 в 17:19 2017-06-16 17:19 Shiljo dio la respuesta el 16 de junio de 17 a las 17:19 2017-06-16 17:19

Creé esta comparación entre objetos de función, llamadas de función, call/apply y bind algún tiempo:

2019

06 февр. La respuesta la da Félix Kling el 6 de febrero. 2019-02-06 23:42 '19 a las 11:42 pm 2019-02-06 23:42

Imagina que el enlace no está disponible. Fácilmente puedes construirlo así:

 var someFunction=... var objToBind=.... var bindHelper = function (someFunction, objToBind) { return function() { someFunction.apply( objToBind, arguments ); }; } bindHelper(arguments); 
1
20 авг. Respuesta dada por Philippe Oceangermanique el 20 de agosto. 2016-08-20 13:42 '16 a la 1:42 pm 2016-08-20 13:42

Considerando la impresionante cantidad de conocimientos sobre aspectos específicos, aplicaciones y fundamentos léxicos con respecto a la disciplina en estas publicaciones, noté un patrón que vale la pena mencionar: La aplicación call () / bind () rastrea un paralelo con el efecto final de asignar una variable a la función original, que no devuelve explícitamente un valor.

  function A(arg){ alert(arg); } // side effects only, no return function B(arg){ return arg; } // it does return a value var checkA = A("A_alert"); // left assignment won't be performed var checkB = B("B_return"); // left assignment as expected alert(checkA) // undefined --> no value was returned alert(checkB) // B_return --> as expected *using call()* checkA = function(){ return A("A_alert"); }; // left assignment requires explicitly function checkA(); // A_alert **using bind()** checkA = A("A_alert").bind(window); // left assignment don't checkA(); // A_alert 

La función bind () 'prepackages' y devuelve esta función, la llamada () solo realiza la llamada,

0
04 нояб. La respuesta se da Wnog 04 Nov. 2017-11-04 19:46 '17 a las 7:46 2017-11-04 19:46

Llamar: llama a una función y le permite pasar argumentos uno por uno.

Aplicar: Aplicar llama a la función y le permite pasar argumentos como una matriz.

Bind: Bind devuelve una nueva función que le permite pasar una matriz de este y cualquier número de argumentos.

  function sayHello() { //alert(this.message); return this.message; } var obj = { message: "Hello" }; function x(country) { var z = sayHello.bind(obj); setTimeout(y = function(w) { //'this' reference not lost return z() + ' ' + country + ' ' + w; }, 1000); return y; } var t = x('India')('World'); document.getElementById("demo").innerHTML = t; 
0
15 дек. La respuesta se da pandhari 15 dic. 2017-12-15 12:49 '17 a las 12:49 2017-12-15 12:49

Creo que los mismos lugares de ellos: todos pueden cambiar el valor de esta función. Diferencias entre ellos: la función de vinculación devolverá una nueva función como resultado; los métodos de llamada y aplicación ejecutarán inmediatamente esta función, pero se puede aceptar una matriz como parámetros, y analizará la matriz seleccionada. Y también la función de vinculación puede ser Currying.

-1
15 апр. La respuesta se da Xin Tao 15 de abril. 2016-04-15 12:36 '16 a las 12:36 PM 2016-04-15 12:36

La función de enlace debe utilizarse si queremos asignar una función con un contexto específico, por ejemplo.

 var demo = { getValue : function(){ console.log('demo object get value function') } setValue : function(){ setTimeout(this.getValue.bind(this),1000) } } 

en el ejemplo anterior, si llamamos a la función demo.setValue () y pasamos la función this.getValue directamente, no llamamos a la función demo.setValue directamente, porque en el setTimeout se refiere al objeto de la ventana, por lo que necesitamos pasar el contexto del objeto de muestra this.getValue utilizando bind. esto significa que estamos pasando solo la función con el contexto del objeto de demostración, y no la función de llamada de la llamada.

Espero que lo entiendas.

для получения дополнительной информации см. функция связывания javascript знает подробно

-3
ответ дан user7339156 25 дек. '16 в 9:52 2016-12-25 09:52

Другие вопросы по меткам или Задайте вопрос