¿Cuál es la diferencia entre llamar y aplicar?

¿Cuál es la diferencia entre usar call y los apply invocar una función?

var func = function() {
  alert('hello!');
};

func.apply(); vs func.call();

¿Existen diferencias de rendimiento entre los dos métodos mencionados anteriormente? Cuando es mejor usar call encima apply ¿y viceversa?

preguntado el 31 de diciembre de 09 a las 19:12

Piensa en a en solicitar una serie de argumentos y c en la convocatoria de columnas de argumentos. -

@LarryBattle Hago casi lo mismo, pero creo que una aplicación para una matriz y una c para una llamada (es decir, argumentos separados por comas). -

Estoy de acuerdo en que es una estupidez. Lo que es molesto es que de alguna manera esta pregunta se hace durante las entrevistas porque algún tonto influyente agregó la pregunta a su lista de preguntas js importantes. -

Usted aplicar para un trabajo una vez (un argumento), [teléfono] llámenos al la gente muchas veces (varios argumentos). Alternativa: hay [¿demasiado?] Muchos Llame al of Duty juegos. -

Cuando la intención es invocar una función variadic con una lista de valores de argumentos independientemente de "este" valor, utilice el operador de extensión ES6, p. Ej. fn(...input) donde input es una matriz. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… -

25 Respuestas

La diferencia es que apply te permite invocar la función con arguments como una matriz; call requiere que los parámetros se enumeren explícitamente. Un mnemónico útil es "A para array y C para comma ".

Consulte la documentación de MDN en aplicar y los llámenos al .

Pseudo sintaxis:

theFunction.apply(valueForThis, arrayOfArgs)

theFunction.call(valueForThis, arg1, arg2, ...)

También existe, a partir de ES6, la posibilidad de spread la matriz para usar con el call función, puedes ver las compatibilidades aquí.

Código de muestra:

function theFunction(name, profession) {
    console.log("My name is " + name + " and I am a " + profession +".");
}
theFunction("John", "fireman");
theFunction.apply(undefined, ["Susan", "school teacher"]);
theFunction.call(undefined, "Claude", "mathematician");
theFunction.call(undefined, ...["Matthew", "physicist"]); // used with the spread operator

Respondido el 26 de enero de 21 a las 14:01

Una cosa para agregar es que los argumentos deben ser una matriz numérica ([]). Las matrices asociativas ({}) no funcionarán. - Kevin Schroeder

@KevinSchroeder: en lenguaje javascript, [] se llama un matriz, {} se llama un objeto. - Martijn

A menudo solía olvidar cuál toma una matriz y cuál espera que enumeres los argumentos. Una técnica que solía recordar es si la primera letra del método comienza con a entonces se necesita una matriz, es decir a matriz de pply - aziz punjani

@SAM usando llámenos al en lugar de una llamada de función normal solo tiene sentido si necesita cambiar el valor de este para la llamada a la función. Un ejemplo (que convierte un objeto de argumentos de funciones en una matriz): Array.prototype.slice.call(arguments) or [].slice.call(arguments). aplicar tiene sentido si tiene los argumentos en una matriz, por ejemplo, en una función que llama a otra función con (casi) los mismos parámetros. Recomendación Usar una llamada de función normal funcname(arg1) si eso hace lo que necesitas, y ahorra llámenos al y los aplicar para esas ocasiones especiales en las que realmente las necesitas. - algo

@KunalSingh Ambos call y los apply toma dos parámetros. El primer argumento de apply' and La función call` debe ser el objeto propietario y el segundo parámetro serán parámetros separados por matrices o comas, respectivamente. Si pasa null or undefined como primer argumento, luego en modo no estricto se reemplazan con un objeto global, es decir window - AJ Qarshi

K. Scott Allen tiene una buena reseña sobre el asunto.

Básicamente, difieren en cómo manejan los argumentos de función.

El método apply () es idéntico a call (), excepto que apply () requiere una matriz como segundo parámetro. La matriz representa los argumentos del método de destino ".

De modo que:

// assuming you have f
function f(message) { ... }
f.call(receiver, "test");
f.apply(receiver, ["test"]);

Respondido 20 Jul 12, 00:07

el segundo parámetro de apply () y call () es opcional, no obligatorio. - kiwi enojado

El primer parámetro tampoco es necesario. - Ikrom

@Ikrom, el primer parámetro no es necesario para call pero un requisito para apply - iamcastelli

Para responder a la parte sobre cuándo usar cada función, use apply si no sabe la cantidad de argumentos que pasará, o si ya están en una matriz o en un objeto similar a una matriz (como el arguments objetar a reenviar sus propios argumentos. Usar call de lo contrario, ya que no es necesario envolver los argumentos en una matriz.

f.call(thisObject, a, b, c); // Fixed number of arguments

f.apply(thisObject, arguments); // Forward this function's arguments

var args = [];
while (...) {
    args.push(some_value());
}
f.apply(thisObject, args); // Unknown number of arguments

Cuando no paso ningún argumento (como su ejemplo), prefiero call desde que soy llamar la función. apply implicaría que eres aplicando la función a los argumentos (inexistentes).

No debería haber ninguna diferencia de rendimiento, excepto tal vez si usa apply y envuelve los argumentos en una matriz (p. ej. f.apply(thisObject, [a, b, c]) en lugar de f.call(thisObject, a, b, c)). No lo he probado, por lo que podría haber diferencias, pero sería muy específico del navegador. Es probable que call es más rápido si aún no tiene los argumentos en una matriz y apply es más rápido si lo hace.

Respondido el 01 de enero de 10 a las 00:01

Aquí tienes una buena mnemotécnica. Apply utiliza Arrays y ASiempre toma uno o dos argumentos. Cuando usas Ctodo lo que tiene que Ccuente el número de argumentos.

Respondido el 04 de Septiembre de 13 a las 22:09

¡Útil mnemónico allí mismo !. Cambiaré el 'uno o dos argumentos' para decir 'un máximo de dos argumentos' ya que ni el primer ni el segundo parámetro de apply se requiere. Aunque no estoy seguro de por qué uno llamará apply or call sin un parámetro. Parece que alguien está tratando de averiguar por qué aquí. stackoverflow.com/questions/15903782/… - dantheta

Si bien este es un tema antiguo, solo quería señalar que .call es un poco más rápido que .apply. No puedo decirte exactamente por qué.

Ver jsPerf, http://jsperf.com/test-call-vs-apply/3


[UPDATE!]

Douglas Crockford menciona brevemente la diferencia entre los dos, lo que puede ayudar a explicar la diferencia de rendimiento ... http://youtu.be/ya4UHuXNygM?t=15m52s

Apply toma una matriz de argumentos, mientras que Call toma cero o más parámetros individuales. ¡Ah, ja!

.apply(this, [...])

.call(this, param1, param2, param3, param4...)

Respondido el 18 de enero de 14 a las 21:01

Esto depende de lo que haga la función con los parámetros / matriz, si no necesita procesar la matriz, ¿lleva menos tiempo? - Eric Hodonsky

Curiosamente, incluso sin la matriz, la llamada sigue siendo mucho más rápida. jsperf.com/applyvscallvsfn2 - Josh Mc

@JoshMc Eso sería muy específico del navegador. En IE 11, solicito que vaya dos veces más rápido que una llamada. - Vincent McNabb

1. Crear una nueva matriz significa que el recolector de basura necesitará limpiarla en algún momento. 2. Acceder a los elementos de la matriz mediante la desreferenciación es menos eficaz que acceder a una variable (parámetro) directamente. (Creo que eso es lo que kmatheny quiso decir con "análisis", que en realidad es algo bastante diferente). Pero ninguno de mis argumentos explica el jsperf. Eso debe estar relacionado con la implementación del motor de las dos funciones, por ejemplo, quizás crean una matriz vacía de todos modos, si no se pasó ninguna. - joeytwiddle

Gracias por compartir la prueba y el video. Gary

Sigue un extracto de Cierre: La guía definitiva de Michael Bolin. Puede parecer un poco largo, pero está saturado de mucha información. Del "Apéndice B. Conceptos de JavaScript frecuentemente mal entendidos":


Lo que this Se refiere a cuando se llama a una función

Al llamar a una función de la forma foo.bar.baz(), el objeto foo.bar se conoce como el receptor. Cuando se llama a la función, es el receptor el que se utiliza como valor para this:

var obj = {};
obj.value = 10;
/** @param {...number} additionalValues */
obj.addValues = function(additionalValues) {
  for (var i = 0; i < arguments.length; i++) {
    this.value += arguments[i];
  }
  return this.value;
};
// Evaluates to 30 because obj is used as the value for 'this' when
// obj.addValues() is called, so obj.value becomes 10 + 20.
obj.addValues(20);

Si no hay un receptor explícito cuando se llama a una función, entonces el objeto global se convierte en el receptor. Como se explica en "goog.global" en la página 47, la ventana es el objeto global cuando se ejecuta JavaScript en un navegador web. Esto conduce a un comportamiento sorprendente:

var f = obj.addValues;
// Evaluates to NaN because window is used as the value for 'this' when
// f() is called. Because and window.value is undefined, adding a number to
// it results in NaN.
f(20);
// This also has the unintentional side effect of adding a value to window:
alert(window.value); // Alerts NaN

Aunque obj.addValues y los f se refieren a la misma función, se comportan de manera diferente cuando se llaman porque el valor del receptor es diferente en cada llamada. Por esta razón, al llamar a una función que hace referencia a this, es importante asegurarse de que this tendrá el valor correcto cuando se llame. Para ser claro, si this no fueron referenciados en el cuerpo de la función, entonces el comportamiento de f(20) y los obj.addValues(20) sería lo mismo.

Debido a que las funciones son objetos de primera clase en JavaScript, pueden tener sus propios métodos. Todas las funciones tienen los métodos call() y los apply() que permiten redefinir el receptor (es decir, el objeto que this se refiere) al llamar a la función. Las firmas del método son las siguientes:

/**
* @param {*=} receiver to substitute for 'this'
* @param {...} parameters to use as arguments to the function
*/
Function.prototype.call;
/**
* @param {*=} receiver to substitute for 'this'
* @param {Array} parameters to use as arguments to the function
*/
Function.prototype.apply;

Tenga en cuenta que la única diferencia entre call() y los apply() es que call() recibe los parámetros de la función como argumentos individuales, mientras que apply() los recibe como una única matriz:

// When f is called with obj as its receiver, it behaves the same as calling
// obj.addValues(). Both of the following increase obj.value by 60:
f.call(obj, 10, 20, 30);
f.apply(obj, [10, 20, 30]);

Las siguientes llamadas son equivalentes, ya que f y los obj.addValues referirse a la misma función:

obj.addValues.call(obj, 10, 20, 30);
obj.addValues.apply(obj, [10, 20, 30]);

Sin embargo, dado que ninguno de los dos call() ni apply() utiliza el valor de su propio receptor para sustituir el argumento del receptor cuando no está especificado, lo siguiente no funcionará:

// Both statements evaluate to NaN
obj.addValues.call(undefined, 10, 20, 30);
obj.addValues.apply(undefined, [10, 20, 30]);

El valor de this nunca puede ser null or undefined cuando se llama a una función. Cuándo null or undefined se suministra como receptor para call() or apply(), el objeto global se utiliza como valor para el receptor. Por lo tanto, el código anterior tiene el mismo efecto secundario indeseable de agregar una propiedad llamada value al objeto global.

Puede resultar útil pensar que una función no tiene conocimiento de la variable a la que está asignada. Esto ayuda a reforzar la idea de que el valor de esto estará vinculado cuando se llame a la función en lugar de cuando se defina.


Fin del extracto.

contestado el 24 de mayo de 14 a las 20:05

Solo para notar el hecho de que additionalValues no se hace referencia en el interior obj.addValues cuerpo - Viktor Stolbin

Sé que estaba respondiendo a la pregunta, pero le gustaría agregar: podría haber usado bind al definir f. var f = obj.addValues; se convierte en var f = obj.addValues.bind(obj) y ahora f (20) funcionaría sin tener que usar call o aplicar cada vez. - jhliberty

Sé que no lo escribiste, pero resaltaste el texto y los ejemplos del libro como relevantes, y estoy muy agradecido. Fueron muy útiles. - Fralcon

A veces es útil que un objeto tome prestada la función de otro objeto, lo que significa que el objeto prestado simplemente ejecuta la función prestada como si fuera propia.

Un pequeño ejemplo de código:

var friend = {
    car: false,
    lendCar: function ( canLend ){
      this.car = canLend;
 }

}; 

var me = {
    car: false,
    gotCar: function(){
      return this.car === true;
  }
};

console.log(me.gotCar()); // false

friend.lendCar.call(me, true); 

console.log(me.gotCar()); // true

friend.lendCar.apply(me, [false]);

console.log(me.gotCar()); // false

Estos métodos son muy útiles para dar a los objetos una funcionalidad temporal.

Respondido 25 Feb 14, 23:02

A la gente que quiere saber ver console.log verificar: ¿Qué es console.log y cómo lo uso? - Michel Ayres

Otro ejemplo con Llamar, Aplicar y Vincular. La diferencia entre Call y Apply es evidente, pero aglutinante funciona así:

  1. Bind devuelve una instancia de una función que se puede ejecutar
  2. El primer parámetro es 'este'
  3. El segundo parámetro es un Separado por comas lista de argumentos (como Llame al)

}

function Person(name) {
    this.name = name; 
}
Person.prototype.getName = function(a,b) { 
     return this.name + " " + a + " " + b; 
}

var reader = new Person('John Smith');

reader.getName = function() {
   // Apply and Call executes the function and returns value

   // Also notice the different ways of extracting 'getName' prototype
   var baseName = Object.getPrototypeOf(this).getName.apply(this,["is a", "boy"]);
   console.log("Apply: " + baseName);

   var baseName = Object.getPrototypeOf(reader).getName.call(this, "is a", "boy"); 
   console.log("Call: " + baseName);

   // Bind returns function which can be invoked
   var baseName = Person.prototype.getName.bind(this, "is a", "boy"); 
   console.log("Bind: " + baseName());
}

reader.getName();
/* Output
Apply: John Smith is a boy
Call: John Smith is a boy
Bind: John Smith is a boy
*/

Respondido 25 Oct 17, 21:10

Me gustaría mostrar un ejemplo, donde se usa el argumento 'valueForThis':

Array.prototype.push = function(element) {
   /*
   Native code*, that uses 'this'       
   this.put(element);
   */
}
var array = [];
array.push(1);
array.push.apply(array,[2,3]);
Array.prototype.push.apply(array,[4,5]);
array.push.call(array,6,7);
Array.prototype.push.call(array,8,9);
//[1, 2, 3, 4, 5, 6, 7, 8, 9] 

**detalles: http://es5.github.io/#x15.4.4.7*

Respondido el 16 de enero de 14 a las 16:01

Call () toma argumentos separados por comas, por ejemplo:

.call(scope, arg1, arg2, arg3)

y apply () toma una matriz de argumentos, por ejemplo:

.apply(scope, [arg1, arg2, arg3])

aquí hay algunos ejemplos de uso más: http://blog.i-evaluation.com/2012/08/15/javascript-call-and-apply/

Respondido el 25 de enero de 14 a las 20:01

`// llamar () === argumentos separados por comas (lista de argumentos). llamar (this, args1, args2, args3, ...) // aplicar () === matriz de argumentos (elementos de matriz). aplicar (esto, [arr0, arr1, arr2, ...]) `- xgqfrms

Desde los documentos de MDN en Function.prototype.apply () :

El método apply () llama a una función con una determinada this valor y argumentos proporcionados como una matriz (o un objeto similar a una matriz).

Sintaxis

fun.apply(thisArg, [argsArray])

Desde los documentos de MDN en Function.prototype.call () :

El método call () llama a una función con un determinado this valor y argumentos proporcionados individualmente.

Sintaxis

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

Desde Function.apply y Function.call en JavaScript :

El método apply () es idéntico a call (), excepto que apply () requiere una matriz como segundo parámetro. La matriz representa los argumentos del método de destino.


Ejemplo de código:

var doSomething = function() {
    var arr = [];
    for(i in arguments) {
        if(typeof this[arguments[i]] !== 'undefined') {
            arr.push(this[arguments[i]]);
        }
    }
    return arr;
}

var output = function(position, obj) {
    document.body.innerHTML += '<h3>output ' + position + '</h3>' + JSON.stringify(obj) + '\n<br>\n<br><hr>';
}

output(1, doSomething(
    'one',
    'two',
    'two',
    'one'
));

output(2, doSomething.apply({one : 'Steven', two : 'Jane'}, [
    'one',
    'two',
    'two',
    'one'
]));

output(3, doSomething.call({one : 'Steven', two : 'Jane'},
    'one',
    'two',
    'two',
    'one'
));

Véase también este violín.

Respondido el 20 de junio de 16 a las 20:06

La diferencia fundamental es que call() acepta un lista de argumentos, mientras apply() acepta un matriz única de argumentos.

Respondido 28 Feb 14, 08:02

Aquí hay una publicación pequeña, escribí sobre esto:

http://sizeableidea.com/call-versus-apply-javascript/

var obj1 = { which : "obj1" },
obj2 = { which : "obj2" };

function execute(arg1, arg2){
    console.log(this.which, arg1, arg2);
}

//using call
execute.call(obj1, "dan", "stanhope");
//output: obj1 dan stanhope

//using apply
execute.apply(obj2, ["dan", "stanhope"]);
//output: obj2 dan stanhope

//using old school
execute("dan", "stanhope");
//output: undefined "dan" "stanhope"

Respondido el 04 de diciembre de 13 a las 17:12

aquí hay otro: blog.i-evaluation.com/2012/08/15/javascript-call-and-apply pero básicamente es correcto: .call (alcance, arg1, arg2, arg3) - Mark Karwowski

La diferencia es que call() toma los argumentos de la función por separado, y apply() toma los argumentos de la función en una matriz.

respondido 28 nov., 17:09

Podemos diferenciar los métodos de llamada y aplicación de la siguiente manera

CALL: Una función con argumento proporcionar individualmente. Si conoce los argumentos que se deben pasar o no hay ningún argumento para pasar, puede usar call.

APLICAR: Llame a una función con un argumento proporcionado como una matriz. Puede usar aplicar si no sabe cuántos argumentos se van a pasar a la función.

Hay una ventaja de usar aplicar sobre llamada, no necesitamos cambiar el número de argumentos, solo podemos cambiar una matriz que se pasa.

No hay una gran diferencia en el rendimiento. Pero podemos decir que la llamada es un poco más rápida en comparación con la aplicación porque una matriz debe evaluarse en el método de aplicación.

respondido 06 nov., 13:15

La diferencia entre estos métodos es cómo desea pasar los parámetros.

“A para matriz y C para coma” es una práctica mnemotécnica.

Respondido 03 ago 15, 09:08

¿Qué proporciona esta respuesta que no esté bien proporcionada en otras respuestas? - Kyll

Llamar y aplicar ambos se utilizan para forzar la this valor cuando se ejecuta una función. La única diferencia es que call toma n+1 argumentos donde 1 es this y los 'n' arguments. apply toma solo dos argumentos, uno es this el otro es una matriz de argumentos.

La ventaja que veo en apply encima call es que podemos delegar fácilmente una llamada de función a otra función sin mucho esfuerzo;

function sayHello() {
  console.log(this, arguments);
}

function hello() {
  sayHello.apply(this, arguments);
}

var obj = {name: 'my name'}
hello.call(obj, 'some', 'arguments');

Observa la facilidad con la que delegamos hello a sayHello usar apply, pero con call esto es muy difícil de lograr.

respondido 24 nov., 15:11

Aunque call y los apply lograr lo mismo, creo que hay al menos un lugar donde no se puede usar call pero solo puedo usar apply. Ahí es cuando desea admitir la herencia y desea llamar al constructor.

Aquí hay una función que le permite crear clases que también admite la creación de clases ampliando otras clases.

function makeClass( properties ) {
    var ctor = properties['constructor'] || function(){}
    var Super = properties['extends'];
    var Class = function () {
                 // Here 'call' cannot work, only 'apply' can!!!
                 if(Super)
                    Super.apply(this,arguments);  
                 ctor.apply(this,arguments);
                }
     if(Super){
        Class.prototype = Object.create( Super.prototype );
        Class.prototype.constructor = Class;
     }
     Object.keys(properties).forEach( function(prop) {
           if(prop!=='constructor' && prop!=='extends')
            Class.prototype[prop] = properties[prop];
     });
   return Class; 
}

//Usage
var Car = makeClass({
             constructor: function(name){
                         this.name=name;
                        },
             yourName: function() {
                     return this.name;
                   }
          });
//We have a Car class now
 var carInstance=new Car('Fiat');
carInstance.youName();// ReturnsFiat

var SuperCar = makeClass({
               constructor: function(ignore,power){
                     this.power=power;
                  },
               extends:Car,
               yourPower: function() {
                    return this.power;
                  }
              });
//We have a SuperCar class now, which is subclass of Car
var superCar=new SuperCar('BMW xy',2.6);
superCar.yourName();//Returns BMW xy
superCar.yourPower();// Returns 2.6

Respondido 12 Feb 15, 21:02

Creo que la llamada funcionaría allí con el operador de propagación como se describe en la respuesta seleccionada. A menos que me esté perdiendo algo. - jhliberty

Resumen:

Ambos call() y los apply() son métodos que se encuentran en Function.prototype. Por lo tanto, están disponibles en todos los objetos de función a través de la cadena de prototipos. Ambas cosas call() y los apply() puede ejecutar una función con un valor especificado de la this.

La principal diferencia entre call() y los apply() es la forma en que tienes que pasarle argumentos. En ambos call() y los apply() pasas como primer argumento el objeto que quieres que sea el valor como this. Los otros argumentos difieren de la siguiente manera:

  • Con call() tienes que poner los argumentos normalmente (comenzando desde el segundo argumento)
  • Con apply() tienes que pasar una serie de argumentos.

Ejemplo:

let obj = {
  val1: 5,
  val2: 10
}

const summation = function (val3, val4) {
  return  this.val1 + this.val2 + val3 + val4;
}

console.log(summation.apply(obj, [2 ,3]));
// first we assign we value of this in the first arg
// with apply we have to pass in an array


console.log(summation.call(obj, 2, 3));
// with call we can pass in each arg individually

¿Por qué debería utilizar estas funciones?

El this El valor puede ser complicado a veces en javascript. El valor de this determina cuando se ejecuta una función, no cuando se define una función. Si nuestra función depende de un derecho this vinculante que podemos usar call() y los apply() para hacer cumplir este comportamiento. Por ejemplo:

var name = 'unwantedGlobalName';

const obj =  {
  name: 'Willem',
  sayName () { console.log(this.name);}
}


let copiedMethod = obj.sayName;
// we store the function in the copiedmethod variable



copiedMethod();
// this is now window, unwantedGlobalName gets logged

copiedMethod.call(obj);
// we enforce this to be obj, Willem gets logged

Respondido 29 ago 18, 18:08

La principal diferencia es que, al usar la llamada, podemos cambiar el alcance y pasar argumentos como de costumbre, pero aplicar le permite llamarlo usando argumentos como una matriz (pasarlos como una matriz). Pero en términos de lo que deben hacer en su código, son bastante similares.

Si bien la sintaxis de esta función es casi idéntica a la de apply (), la diferencia fundamental es que call () acepta una lista de argumentos, mientras que apply () acepta una única matriz de argumentos.

Entonces, como puede ver, no hay una gran diferencia, pero aún así, hay casos en los que preferimos usar call () o apply (). Por ejemplo, mire el código a continuación, que encuentra el número más pequeño y más grande en una matriz de MDN, usando el método de aplicación:

// min/max number in an array
var numbers = [5, 6, 2, 3, 7];

// using Math.min/Math.max apply
var max = Math.max.apply(null, numbers); 
// This about equal to Math.max(numbers[0], ...)
// or Math.max(5, 6, ...)

var min = Math.min.apply(null, numbers)

Entonces, la principal diferencia es la forma en que pasamos los argumentos:

Llame al:

function.call(thisArg, arg1, arg2, ...);

Solicita:

function.apply(thisArg, [argsArray]);

Respondido el 26 de enero de 19 a las 16:01

Permítanme agregar un pequeño detalle a esto.

estas dos llamadas son casi equivalentes:

func.call(context, ...args); // pass an array as list with spread operator

func.apply(context, args);   // is same as using apply

Solo hay una pequeña diferencia:

  • El spread operador ... permite pasar iterable args como la lista para llamar.
  • El apply acepta solo como una matriz argumentos.

Entonces, estas llamadas se complementan entre sí. Donde esperamos un iterable, call funciona, donde esperamos un como una matriz, apply obras.

Y para objetos que son a la vez iterable y los como una matriz, como una matriz real, técnicamente podríamos usar cualquiera de ellos, pero aplicar probablemente será Más rápida porque la mayoría de los motores de JavaScript lo optimizan mejor internamente.

Respondido el 12 de Septiembre de 19 a las 10:09

llamada() Es un método predefinido en javascript. Este método invoca un método (función) especificando el objeto propietario.

  function sayHello(){
  return "Hello " + this.name;
}
        
var obj = {name: "Sandy"};
        
sayHello.call(obj);
        
// Returns "Hello Sandy"

La llamada acepta argumento

function saySomething(message){
  return this.name + " is " + message;
}
        
var person4 = {name:  "John"};
        
saySomething.call(person4, "awesome");
// Returns "John is awesome"    

aplicar() El método de aplicación es similar al método call (). La única diferencia es que, el método call () toma los argumentos por separado, mientras que el método apply () toma los argumentos como una matriz.

ejemplo

function saySomething(message){
  return this.name + " is " + message;
}
        
var person4 = {name:  "John"};
        
saySomething.apply(person4, ["awesome"]);

Respondido el 26 de diciembre de 20 a las 17:12

Un bien explicado por flatline. Solo quiero agregar un ejemplo simple. lo que lo hace fácil de entender para los principiantes.

func.call(context, args1 , args2 ); // pass arguments as "," saprated value

func.apply(context, [args1 , args2 ]);   //  pass arguments as "Array"

también usamos el método "Llamar" y "Aplicar" para cambiar referencia como se define en el código a continuación

    let Emp1 = {
        name: 'X',
        getEmpDetail: function (age, department) {
            console.log('Name :', this.name, '  Age :', age, '  Department :', department)
        }
    }
    Emp1.getEmpDetail(23, 'Delivery')

    // 1st approch of chenging "this"
    let Emp2 = {
        name: 'Y',
        getEmpDetail: Emp1.getEmpDetail
    }
    Emp2.getEmpDetail(55, 'Finance')

    // 2nd approch of changing "this" using "Call" and "Apply"
    let Emp3 = {
        name: 'Z',
    }

    Emp1.getEmpDetail.call(Emp3, 30, 'Admin')        
// here we have change the ref from **Emp1 to Emp3**  object
// now this will print "Name =  X" because it is pointing to Emp3 object
    Emp1.getEmpDetail.apply(Emp3, [30, 'Admin']) //

Respondido el 11 de junio de 20 a las 13:06

El call() El método llama a una función con una determinada this valor y argumentos proporcionados individualmente.enter image description here

apply() - Similar a call() método, el primer parámetro en el apply() método establece el this valor que es el objeto sobre el que se invoca la función. En este caso, es el obj objeto de arriba. La única diferencia entre el apply() y los call() método es que el segundo parámetro del apply() El método acepta los argumentos de la función real como una matriz. enter image description here

Respondido el 26 de junio de 20 a las 00:06

Aunque agradecemos el esfuerzo realizado en la realización de imágenes, no son de mucha utilidad. Nadie puede copiar el código para usarlo, probarlo, mejorarlo ... El código debe pegarse como texto aquí - Expreso doble

Ambos llaman y aplican de la misma manera. Llama inmediatamente cuando usamos llamar y aplicar.

Tanto la llamada como la aplicación toman "este" parámetro como primer argumento y el segundo solo difiere.

la llamada toma los argumentos de las funciones como una lista (coma) Apply toma los argumentos de las funciones como una matriz.

Puede encontrar la diferencia completa entre vincular, llamar y aplicar en el siguiente video de YouTube.

https://www.youtube.com/watch?v=G-EfxnG0DtY&t=180s

Respondido 02 ago 20, 08:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.