20 Pertanyaan: Apa perbedaan antara panggilan dan melamar?

pertanyaan dibuat di Wed, Jul 11, 2018 12:00 AM

Apa perbedaan antara menggunakan call dan apply untuk menjalankan fungsi?

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

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

Apakah ada perbedaan kinerja antara kedua metode yang disebutkan di atas? Kapan sebaiknya menggunakan call lebih dari apply dan sebaliknya?

    
2923
  1. Pikirkan a untuk melamar array args dan c untuk kolom args.
    2012-06-12 06: 17: 46Z
  2. @ LarryBattle Saya melakukan hal yang hampir sama, tetapi saya pikir a berlaku untuk array dan c di panggil untuk koma (mis. argumen yang dipisahkan koma).
    2013-12-06 16: 20: 03Z
  3. Saya setuju itu bodoh. Yang menjengkelkan adalah bahwa entah bagaimana pertanyaan ini ditanyakan selama wawancara karena beberapa orang berpengaruh menambahkan pertanyaan ke daftar pertanyaan penting mereka.
    2014-03-10 22: 55: 26Z
  4. Anda melamar sekali saja (satu argumen), Anda [telepon] menelepon orang berkali-kali (beberapa argumen). Alternatif: ada [juga?] Banyak Panggilan dari game Duty.
    2014-12-04 03: 27: 09Z
  5. Ketika maksudnya adalah untuk memanggil fungsi variad dengan daftar nilai argumen terlepas dari nilai "ini", kemudian gunakan operator spread ES6, mis. fn(...input) di mana input adalah sebuah array. developer.mozilla.org/en-US/docs/Web /JavaScript /Referensi /...
    2014-12-18 01: 22: 07Z
20 Jawaban                              20                         

Perbedaannya adalah apply memungkinkan Anda menjalankan fungsi dengan arguments sebagai array; call mengharuskan parameter terdaftar secara eksplisit. Mnemonic yang berguna adalah " A untuk a rray dan C untuk c omma."

Lihat dokumentasi MDN di berlaku dan panggilan .

Sintaks semu:

theFunction.apply(valueForThis, arrayOfArgs)

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

Ada juga, pada ES6, kemungkinan untuk spread array untuk digunakan dengan fungsi call, Anda dapat melihat kompatibilitasnya di sini .

Kode sampel:

 
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
    
3488
2017-12-19 16: 10: 20Z
  1. Satu hal yang harus ditambahkan adalah argumen harus berupa array numerik ([]). Array asosiatif ({}) tidak akan berfungsi.
    2012-07-28 16: 18: 38Z
  2. @ KevinSchroeder: Dalam bahasa javascript, [] disebut array , {} disebut sebagai objek .
    2013-01-10 15: 19: 59Z
  3. Saya sering lupa lupa mana yang mengambil array, dan yang mengharapkan Anda untuk membuat daftar argumen. Teknik yang saya ingat adalah jika huruf pertama dari metode dimulai dengan a maka dibutuhkan sebuah array i.e a pply array
    2013-10-06 20: 43: 02Z
  4. @ SAM Menggunakan panggilan alih-alih panggilan fungsi normal hanya masuk akal jika Anda perlu mengubah nilai ini untuk panggilan fungsi. Contoh (yang mengonversi objek argumen-fungsi ke array): Array.prototype.slice.call(arguments) atau [].slice.call(arguments). berlaku masuk akal jika Anda memiliki argumen dalam array, misalnya dalam suatu fungsi yang memanggil fungsi lain dengan (hampir) parameter yang sama. Rekomendasi Gunakan panggilan fungsi normal funcname(arg1) jika itu sesuai dengan yang Anda butuhkan, dan simpan panggil dan terapkan untuk acara-acara khusus ketika Anda benar-benar membutuhkannya.
    2014-07-16 05: 04: 43Z
  5. @ KunalSingh Baik call dan apply mengambil dua parameter. Argumen pertama dari fungsi panggilan apply' and harus menjadi objek pemilik dan parameter kedua akan menjadi parameter array atau dipisahkan koma masing-masing. Jika Anda melewati null atau undefined sebagai argumen pertama, maka dalam mode non-ketat mereka diganti dengan objek global yaitu window
    2016-02-24 12: 42: 44Z

K. Scott Allen memiliki Langgan yang bagus tentang masalah ini.

Pada dasarnya, mereka berbeda tentang bagaimana mereka menangani argumen fungsi.

  

Metode apply () identik dengan panggilan (), kecuali apply () membutuhkan array sebagai parameter kedua. Array mewakili argumen untuk metode target. "

Jadi:

 
// assuming you have f
function f(message) { ... }
f.call(receiver, "test");
f.apply(receiver, ["test"]);
    
218
2012-07-19 20: 53: 50Z
  1. parameter kedua dari apply () dan call () adalah opsional, tidak wajib.
    2011-07-29 04: 01: 11Z
  2. Parameter pertama tidak diperlukan juga.
    2013-06-05 05: 33: 59Z

Untuk menjawab bagian tentang kapan harus menggunakan setiap fungsi, gunakan apply jika Anda tidak tahu jumlah argumen yang akan Anda lewati, atau jika sudah ada dalam array atau objek mirip array (seperti objek arguments untuk teruskan argumen Anda sendiri. Gunakan call sebaliknya, karena tidak perlu membungkus argumen dalam sebuah array.

 
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

Saat saya tidak memberikan argumen apa pun (seperti contoh Anda), saya lebih suka call karena saya memanggil fungsinya. apply akan menyiratkan Anda menerapkan fungsi ke argumen (tidak ada).

Seharusnya tidak ada perbedaan kinerja, kecuali mungkin jika Anda menggunakan apply dan membungkus argumen dalam array (mis. f.apply(thisObject, [a, b, c]) alih-alih f.call(thisObject, a, b, c)). Saya belum mengujinya, jadi mungkin ada perbedaan, tetapi akan sangat spesifik browser. Kemungkinan call lebih cepat jika Anda belum memiliki argumen dalam sebuah array dan apply lebih cepat jika Anda melakukannya.

    
152
2009-12-31 21: 56: 01Z

Ini mnemonik yang bagus. A pply menggunakan A sinar dan A lways membutuhkan satu atau dua argumen. Saat Anda menggunakan C semua yang Anda miliki untuk C menghantui jumlah argumen.

    
105
2013-09-04 18: 21: 25Z
  1. Mnemonic yang berguna di sana !. Saya akan mengubah 'satu atau dua Argumen' untuk mengatakan 'maksimum dua Argumen' karena tidak diperlukan parameter pertama atau kedua dari apply. Saya tidak yakin mengapa seseorang akan menelepon apply atau call tanpa parameter. Sepertinya seseorang sedang mencari tahu mengapa di sini stackoverflow.com/questions /15903782 /...
    2013-11-03 11: 40: 14Z
  2. Jadi, kapan harus menggunakan Call () dan kapan harus menggunakan Apply () ....
    2017-04-06 07: 54: 19Z

Walaupun ini adalah topik lama, saya hanya ingin menunjukkan bahwa .call sedikit lebih cepat dari .apply. Saya tidak bisa memberi tahu Anda alasannya.

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


[UPDATE!]

Douglas Crockford menyebutkan secara singkat perbedaan antara keduanya, yang dapat membantu menjelaskan perbedaan kinerja ... http: //youtu.be/ya4UHuXNygM?t=15m52s

Terapkan membutuhkan array argumen, sementara Panggilan mengambil nol atau lebih parameter individual! Ah hah!

.apply(this, [...])

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

    
91
2014-01-18 17: 44: 50Z
  1. Ini tergantung pada apa fungsinya dengan parameter /array, jika tidak perlu memproses array, apakah ini membutuhkan waktu lebih sedikit?
    2012-03-01 20: 30: 04Z
  2. Menariknya bahkan tanpa array, panggilan masih jauh lebih cepat. jsperf.com/applyvscallvsfn2
    2012-05-11 01: 42: 30Z
  3. @ JoshMc Itu akan sangat spesifik browser. Di IE 11, saya mulai berlaku dua kali lebih cepat dari panggilan.
    2013-10-08 01: 10: 55Z
  4. 1. Membuat array baru berarti pengumpul sampah perlu membersihkannya di beberapa titik. 2. Mengakses item dalam array menggunakan dereference kurang efisien daripada mengakses variabel (parameter) secara langsung. (Saya percaya itulah yang dimaksud kmatheny dengan "parsing", yang sebenarnya merupakan sesuatu yang sangat berbeda.) Tetapi tidak satu pun dari argumen saya yang menjelaskan jsperf. Itu harus terkait dengan implementasi mesin dari dua fungsi, mis. mungkin mereka tetap membuat array kosong, jika tidak ada yang lulus.
    2013-11-23 16: 41: 20Z
  5. Terima kasih telah berbagi tes dan video
    2017-07-23 11: 22: 23Z

Mengikuti ekstrak dari Penutupan: Panduan Definitif oleh Michael Bolin . Ini mungkin terlihat agak panjang, tetapi penuh dengan banyak wawasan. Dari "Lampiran B. Konsep JavaScript yang Sering Disalahpahami":


Apa yang this Rujuk Ketika Suatu Fungsi Dipanggil

Saat memanggil fungsi formulir foo.bar.baz(), objek foo.bar disebut sebagai penerima. Ketika fungsi dipanggil, itu adalah penerima yang digunakan sebagai nilai untuk 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);

Jika tidak ada penerima eksplisit saat fungsi dipanggil, maka objek global menjadi penerima. Seperti yang dijelaskan dalam "goog.global" di halaman 47, jendela adalah objek global ketika JavaScript dieksekusi di browser web. Ini mengarah ke beberapa perilaku mengejutkan:

 
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

Meskipun obj.addValues dan f merujuk ke fungsi yang sama, mereka berperilaku berbeda ketika dipanggil karena nilai penerima berbeda dalam setiap panggilan. Untuk alasan ini, ketika memanggil fungsi yang merujuk ke this, penting untuk memastikan bahwa this akan memiliki nilai yang benar ketika dipanggil. Untuk menjadi jelas, jika this tidak direferensikan di badan fungsi, maka perilaku f(20) dan obj.addValues(20) akan sama.

Karena fungsiion adalah objek kelas pertama dalam JavaScript, mereka dapat memiliki metode mereka sendiri. Semua fungsi memiliki metode call() dan apply() yang memungkinkan untuk mendefinisikan ulang penerima (mis., Objek yang merujuk this) saat memanggil fungsi. Tanda tangan metode adalah sebagai berikut:

 
/**
* @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;

Perhatikan bahwa satu-satunya perbedaan antara call() dan apply() adalah bahwa call() menerima parameter fungsi sebagai argumen individual, sedangkan apply() menerimanya sebagai array tunggal:

 
// 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]);

Panggilan berikut ini setara, seperti f dan obj.addValues merujuk ke fungsi yang sama:

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

Namun, karena call() atau apply() tidak menggunakan nilai receivernya sendiri untuk menggantikan argumen penerima saat tidak ditentukan, hal berikut ini tidak akan berfungsi:

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

Nilai this tidak pernah bisa menjadi null atau undefined saat sebuah fungsi dipanggil. Ketika null atau undefined dipasok sebagai penerima ke call() atau apply(), objek global digunakan sebagai nilai untuk penerima sebagai gantinya. Oleh karena itu, kode sebelumnya memiliki efek samping yang tidak diinginkan yang sama dengan menambahkan properti bernama value ke objek global.

Mungkin bermanfaat untuk memikirkan fungsi yang tidak memiliki pengetahuan tentang variabel yang ditugaskan padanya. Ini membantu memperkuat gagasan bahwa nilai ini akan diikat ketika fungsi dipanggil daripada ketika didefinisikan.


Akhir ekstrak.

    
75
2014-05-24 16: 15: 33Z
  1. Hanya untuk mencatat fakta, bahwa additionalValues tidak direferensikan di dalam obj.addValues body
    2015-10-27 12: 12: 23Z
  2. Saya tahu Anda menjawab pertanyaan tetapi ingin menambahkan: Anda bisa menggunakan bind saat mendefinisikan f. var f = obj.addValues; menjadi var f = obj.addValues.bind(obj) dan sekarang f (20) akan berfungsi tanpa harus menggunakan panggilan atau melamar setiap saat.
    2017-10-25 19: 15: 42Z

Terkadang berguna bagi satu objek untuk meminjam fungsi objek lain, artinya objek pinjaman hanya menjalankan fungsi yang dipinjamkan seolah-olah itu adalah miliknya sendiri.

Contoh kode kecil:

 
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

Metode ini sangat berguna untuk memberikan fungsionalitas sementara objek.

    
33
2014-02-25 19: 31: 51Z
  1. Untuk orang-orang yang ingin tahu cara melihat console.log periksa: Apa itu console.log dan bagaimana cara menggunakannya?
    2014-02-25 19: 50: 40Z

Contoh lain dengan Panggilan, Terapkan, dan Bind. Perbedaan antara Panggilan dan Terapkan jelas, tetapi Binding berfungsi seperti ini:

  1. Bind mengembalikan instance fungsi yang dapat dieksekusi
  2. Parameter Pertama adalah ' ini '
  3. Parameter kedua adalah daftar argumen yang dipisahkan koma (seperti Panggilan )

}

 
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
*/
    
25
2017-10-25 18: 50: 04Z

Saya ingin menunjukkan contoh, di mana argumen 'valueForThis' digunakan:

 
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] 

** detail: http://es5.github.io/#x15.4.4. 7 *

    
23
2014-01-16 12: 47: 13Z

Panggilan () mengambil argumen yang dipisahkan koma, mis:

.call(scope, arg1, arg2, arg3)

dan apply () mengambil array arguments, mis:

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

berikut beberapa contoh penggunaan lainnya: http://blog.i-evaluation.com/2012/08/15 /javascript-panggilan-dan-terapkan /

    
20
2014-01-25 16: 40: 32Z
  1. `//call () === argumen yang dipisahkan koma (daftar argumen) .call (this, args1, args2, args3, ...) //apply () === array argumen (array-items) .apply (this, [arr0, arr1, arr2, ...]) `
    2016-12-25 13: 52: 53Z

Dari dokumen MDN di Function.prototype.apply () :

  

Metode apply () memanggil fungsi dengan nilai this yang diberikan dan   argumen disediakan sebagai array (atau objek mirip array).

     

Sintaks

 
fun.apply(thisArg, [argsArray])

Dari dokumen MDN di Function.prototype.call () :

  

Metode panggilan () memanggil fungsi dengan nilai this dan argumen yang diberikan secara individual.

     

Sintaks

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

Dari Function.apply dan Function.call di JavaScript :

  

Metode apply () identik dengan panggilan (), kecuali apply () membutuhkan   array sebagai parameter kedua. Array mewakili argumen untuk   metode target.


Contoh kode:

 
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'
));

Lihat juga Biola ini .

    
19
2016-06-20 17: 06: 56Z

Perbedaan mendasar adalah bahwa call() menerima daftar argumen , sedangkan apply() menerima array argumen tunggal .

    
11
2014-02-28 04: 57: 48Z
  1. 2014-03-13 18: 52: 51Z

Ini postingan kecil, saya menulis ini:

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"
    
10
2013-12-04 13: 58: 29Z
  1. di sini ada satu lagi: blog.i-evaluation.com/2012/08/15/javascript-call-and-apply tetapi pada dasarnya itu benar: .call (lingkup, arg1, arg2, arg3 )
    2014-01-21 18: 07: 40Z

Perbedaannya adalah bahwa call() mengambil argumen fungsi secara terpisah, dan apply() mengambil argumen fungsi dalam sebuah array.

    
7
2017-11-28 06: 41: 37Z

Kami dapat membedakan metode panggilan dan menerapkan seperti di bawah ini

PANGGILAN: Fungsi dengan argumen yang disediakan secara individual. Jika Anda tahu argumen yang harus diteruskan atau tidak ada argumen untuk dilewati, Anda dapat menggunakan panggilan.

BERLAKU: Memanggil fungsi dengan argumen yang disediakan sebagai larik. Anda dapat menggunakan berlaku jika Anda tidak tahu berapa banyak argumen yang akan diteruskan ke fungsi.

Ada keuntungan menggunakan apply over call, kami tidak perlu mengubah jumlah argumen, kami hanya dapat mengubah array yang diteruskan.

Tidak ada perbedaan besar dalam kinerja. Tetapi kita dapat mengatakan panggilan sedikit lebih cepat dibandingkan dengan menerapkan karena array perlu mengevaluasi dalam metode yang berlaku.

    
6
2013-11-06 11: 50: 46Z

Perbedaan antara metode ini adalah, bagaimana Anda ingin memberikan parameter.

"A untuk larik dan C untuk koma" adalah mnemonik yang praktis.

    
5
2015-08-03 06: 15: 16Z
  1. Apa yang disediakan jawaban ini yang belum disediakan dengan baik dalam jawaban lain?
    2015-09-07 10: 38: 27Z

Panggilan dan terapkan keduanya digunakan untuk memaksa nilai this saat fungsi dijalankan. Satu-satunya perbedaan adalah bahwa call mengambil n+1 argumen di mana 1 adalah this dan 'n' arguments. apply hanya mengambil dua argumen, satu adalah this lainnya adalah array argumen.

Keuntungan yang saya lihat di apply dibandingkan call adalah kita dapat dengan mudah mendelegasikan pemanggilan fungsi ke fungsi lain tanpa banyak usaha;

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

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

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

Perhatikan betapa mudahnya kami mendelegasikan hello ke sayHello menggunakan apply, tetapi dengan call ini sangat sulit dicapai.

    
5
2015-11-24 08: 36: 02Z

Meskipun call dan apply mencapai hal yang sama, saya pikir ada setidaknya satu tempat di mana Anda tidak dapat menggunakan call tetapi hanya bisa menggunakan apply. Saat itulah Anda ingin mendukung warisan dan ingin memanggil konstruktor.

Ini adalah fungsi yang memungkinkan Anda membuat kelas yang juga mendukung pembuatan kelas dengan memperluas kelas lain.

 
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
    
4
2015-02-12 18: 10: 05Z
  1. Saya percaya panggilan akan bekerja di sana dengan operator spread seperti yang dijelaskan dalam jawaban yang dipilih. Kecuali saya melewatkan sesuatu.
    2017-10-25 19: 10: 00Z

Perbedaan utamanya adalah, menggunakan panggilan, kita dapat mengubah cakupan dan meneruskan argumen seperti biasa, tetapi menerapkan memungkinkan Anda menyebutnya menggunakan argumen sebagai Array (meneruskannya sebagai array). Tetapi dalam hal apa yang harus mereka lakukan dalam kode Anda, mereka sangat mirip.

  

Meskipun sintaks fungsi ini hampir identik dengan   berlaku (), perbedaan mendasar adalah panggilan itu () menerima argumen   daftar, sambil menerapkan () menerima satu array argumen.

Jadi seperti yang Anda lihat, tidak ada perbedaan besar, tapi tetap saja, ada beberapa kasus yang kami sukai menggunakan panggilan () atau menerapkan (). Misalnya, lihat kode di bawah ini, yang menemukan angka terkecil dan terbesar dalam array dari MDN, menggunakan metode yang berlaku:

 
// 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)

Jadi perbedaan utama adalah cara kita menyampaikan argumen:

Panggil:

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

Terapkan:

 
function.apply(thisArg, [argsArray]);
    
4
2019-01-26 13: 13: 01Z

Ringkasan:

call() dan apply() adalah metode yang ada di Function.prototype. Oleh karena itu mereka tersedia pada setiap objek fungsi melalui rantai prototipe. Baik call() dan apply() dapat menjalankan fungsi dengan nilai yang ditentukan dari this.

Perbedaan utama antara call() dan apply() adalah cara Anda harus memasukkan argumen ke dalamnya. Dalam call() dan apply() Anda lulus sebagai argumen pertama objek yang Anda inginkan nilainya sebagai this. Argumen lain berbeda dengan cara berikut:

  • Dengan call() Anda harus memasukkan argumen secara normal (mulai dari argumen kedua)
  • Dengan apply() Anda harus memberikan beragam argumen.

Contoh:

 
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

Mengapa saya harus menggunakan fungsi-fungsi ini?

Nilai this terkadang rumit di javascript. Nilai this ditentukan ketika suatu fungsi dieksekusi bukan ketika suatu fungsi didefinisikan. Jika fungsi kita bergantung pada ikatan this yang tepat, kita dapat menggunakan call() dan apply() untuk menegakkan perilaku ini. Misalnya:

 
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
    
3
2018-08-29 15: 29: 42Z
sumber ditempatkan sini
Pertanyaan Lain