Pemahaman mendalam tentang perbezaan antara kaedah apply() dan call() dalam kemahiran javascript_javascript

Jika anda tidak pernah didedahkan dengan bahasa dinamik, ia akan menjadi perasaan ajaib dan pelik untuk memahami JavaScript dengan cara pemikiran bahasa yang disusun, kerana perkara yang secara sedar mustahil sering berlaku, malah berasa tidak munasabah pembelajaran Apabila anda menghadapi perasaan ini dalam proses JavaScript, bahasa yang bebas dan sentiasa berubah-ubah, maka mulai sekarang, sila hilangkan "prasangka" anda, kerana ini sudah pasti benua baru untuk anda, dan biarkan JavaScript perlahan-lahan hilang dari masa lalu. Tetapkan kesedaran pengaturcaraan yang kukuh dan suntikan tenaga baharu!

Baiklah, mari kita beralih kepada perniagaan Mula-mula, fahami ciri konteks masa jalan yang berubah secara dinamik bagi JavaScrtipt. Ciri ini ditunjukkan terutamanya dalam penggunaan kaedah memohon dan memanggil

Perbezaan antara apply dan call hanyalah satu ayat, foo.call(this, arg1,arg2,arg3) == foo.apply(this, arguments)==this.foo(arg1, arg2, arg3)

call dan apply ialah kedua-dua kaedah Function.prototype, yang dilaksanakan secara dalaman oleh enjin JavaScript Kerana ia tergolong dalam Function.prototype, setiap contoh objek Function, iaitu, setiap kaedah mempunyai atribut panggilan dan gunakan kaedah , maka penggunaannya sudah tentu disasarkan kepada kaedah ini mudah dikelirukan, kerana ia mempunyai fungsi yang sama, tetapi ia digunakan dalam cara yang berbeza

Mata yang sama: Kedua-dua kaedah mempunyai kesan yang sama

Perbezaan: Parameter yang diluluskan oleh kaedah adalah berbeza

Kemudian apakah fungsi kaedah dan apakah parameter yang diluluskan oleh kaedah?

Mari kita analisis foo.call di atas(ini, arg1, arg2, arg3).

foo ialah kaedah, ini ialah objek sensitif konteks apabila kaedah dilaksanakan, arg1, arg2, arg3 ialah parameter yang dihantar kepada kaedah foo Apa yang dipanggil objek sensitif konteks apabila kaedah dilaksanakan di sini, jika anda mempunyai asas pengaturcaraan berorientasikan objek, ia adalah sangat Mudah untuk difahami, ini ini.

dalam objek selepas kelas diwujudkan.

Dalam JavaScript, kod sentiasa mempunyai objek konteks dan kod memproses objek ini Objek konteks diwakili oleh pembolehubah ini, dan pembolehubah ini sentiasa menunjuk ke objek di mana kod semasa berada.

Untuk lebih memahami apa ini, mari kita berikan contoh.

Dapat dilihat bahawa kelas A dan B kedua-duanya mempunyai atribut mesej (ahli dalam istilah berorientasikan objek A mempunyai kaedah getMessage untuk mendapatkan mesej, dan B mempunyai kaedah setMessage untuk menetapkan kuasa). panggilan ditunjukkan di bawah.

/创建一个A类
function A(){
//类实例化时将运行以下代码
//此时的执行上下文对象就是this,就是当前实例对象
this.message = “message of a”;
this.getMessage = function(){
<SPAN style="WHITE-SPACE: pre">	</SPAN>return this.message;
<SPAN style="WHITE-SPACE: pre">	</SPAN>}
}
//创建一个A类实例对象
var a = new A();
//调用类实例getMessage方法获得message值
alert(a.getMessage());
//创建一个B类
function B(){
this.message = ”message of b”;
this.setMessage = function(msg){
<SPAN style="WHITE-SPACE: pre">	</SPAN>this.message = msg;
<SPAN style="WHITE-SPACE: pre">	</SPAN>}
}
//创建一个B类实例对象
var a = new B();

Ini adalah kuasa panggilan JavaScript bahasa dinamik!

//给对象a动态指派b的setMessage方法,注意,a本身是没有这方法的!
b.setMessage.call(a, “a的消息”);
//下面将显示”a的消息”
alert(a.getMessage());
//给对象b动态指派a的getMessage方法,注意,b本身也是没有这方法的!

Ia hanya "diperbuat daripada tiada". Kaedah objek boleh ditetapkan sewenang-wenangnya, tetapi objek itu sendiri tidak pernah mempunyai kaedah sedemikian objek untuk menyelesaikan tugasan. Pada dasarnya Objek konteks berubah apabila kaedah dilaksanakan.

Jadi b.setMessage.call(a, "a's message"); adalah bersamaan dengan menggunakan a sebagai objek konteks pelaksanaan untuk memanggil kaedah setMessage bagi objek b, dan proses ini tiada kaitan dengan b, dan kesan adalah bersamaan dengan a.setMessage(“mesej a”);

Sebab apply dan call sama kesannya, boleh dikatakan

Fungsi panggilan dan permohonan adalah untuk meminjam kaedah orang lain untuk membuat panggilan, sama seperti memanggil anda sendiri.

Baiklah, selepas memahami persamaan antara panggilan dan apply--selepas fungsinya, mari kita lihat perbezaannya Selepas membaca contoh di atas, saya percaya anda mungkin tahu.

Daripada b.setMessage.call(a, "mesej a") adalah bersamaan dengan a.setMessage("mesej a"), dapat dilihat bahawa "mesej a" dihantar sebagai parameter dalam panggilan,

Jadi, bagaimanakah ia dinyatakan dalam permohonan? Tidak jelas untuk diterangkan secara langsung perlu digabungkan dengan senario aplikasi untuk menjadikannya jelas sekali imbas:

Dalam senario ini, dalam kaedah contoh, a, b, c, d digunakan sebagai parameter yang dilalui oleh kaedah Kaedah menggunakan guna dan panggil masing-masing untuk meminjam kaedah cetakan untuk memanggil,

function print(a, b, c, d){
alert(a + b + c + d);
}
function example(a, b , c , d){
//用call方式借用print,参数显式打散传递
print.call(this, a, b, c, d);
//用apply方式借用print, 参数作为一个数组传递,
//这里直接用JavaScript方法内本身有的arguments数组
print.apply(this, arguments);
//或者封装成数组
print.apply(this, [a, b, c, d]);
}
//下面将显示”背光脚本”
example(”背” , “光” , “脚”, “本”);

Ayat terakhir adalah kerana kaedah contoh dipanggil terus, jadi objek konteks ini dalam kaedah ini ialah objek tetingkap.

Jadi, kecuali untuk parameter pertama kaedah panggilan dan gunakan, iaitu objek konteks semasa pelaksanaan, parameter lain kaedah panggilan akan dihantar kepada kaedah yang dipinjam sebagai parameter secara bergilir, manakala apply hanya mempunyai dua parameter , parameter kedua Lulus sebagai tatasusunan Jadi ia boleh dikatakan sebagai

Perbezaan antara kaedah panggilan dan gunakan ialah bermula dari parameter kedua, parameter kaedah panggilan akan dihantar kepada kaedah yang dipinjam sebagai parameter secara bergilir-gilir, manakala apply terus meletakkan parameter ini ke dalam tatasusunan dan kemudian menghantarnya, dan akhirnya senarai parameter kaedah yang dipinjam Ia adalah sama.

Senario aplikasi:
Apabila parameter jelas, anda boleh menggunakan panggilan Apabila parameter tidak jelas, anda boleh menggunakan aplikasi untuk menggabungkan argumen

Artikel di atas memberikan pemahaman yang mendalam tentang perbezaan antara kaedah apply() dan call() dalam JavaScript Ini semua kandungan yang dikongsi oleh editor saya harap ia boleh memberi rujukan kepada anda anda akan menyokong Script Home.

//例
print.call(window, “背” , “光” , “脚”, “本”);
//foo参数可能为多个
function foo(){
<SPAN style="WHITE-SPACE: pre">	</SPAN>print.apply(window, arguments);
}