Nota Kajian Javascript - Fungsi (4): arguments object_basic knowledge

Setiap fungsi Javascript boleh mengakses pembolehubah khas dalam skopnya sendiri - argumen. Pembolehubah ini mengandungi senarai semua argumen yang dihantar ke fungsi.
Objek argumen bukan tatasusunan. Walaupun secara sintaksis ia mempunyai ciri yang sama seperti tatasusunan, contohnya ia mempunyai sifat panjang. Tetapi ia tidak mewarisi daripada Array.prototype, sebenarnya, ia adalah objek.
Oleh itu, kita tidak boleh terus menggunakan beberapa kaedah tatasusunan seperti push, pop atau slice pada argumen. Jadi untuk menggunakan kaedah ini, kita perlu menukarnya kepada tatasusunan sebenar.

Tukar kepada tatasusunan

Kod berikut akan mengembalikan tatasusunan yang mengandungi semua elemen objek argumen.

Array.prototype.slice.call(arguments);
Oleh kerana penukaran adalah sangat perlahan, ini tidak disyorkan dalam program kritikal prestasi.

Pas parameter

Berikut ialah cara yang disyorkan untuk menghantar objek argumen dari satu fungsi ke fungsi yang lain.

Salin kod Kod adalah seperti berikut:

fungsi foo() {
bar.apply(null, arguments);
}
bar fungsi(a, b, c) {
// buat perkara di sini
}

Kaedah pintar lain ialah menggunakan panggilan dan memohon pada masa yang sama untuk mencipta kaedah luar yang tidak terikat dengan cepat.

Salin kod Kod adalah seperti berikut:

fungsi Foo() {}
Foo.prototype.method = fungsi(a, b, c) {
console.log(ini, a, b, c);
};
// Cipta versi "kaedah" yang tidak terikat
// Ia mengambil parameter: ini, arg1, arg2...argN
Foo.method = function() {
// Keputusan: Foo.prototype.method.call(this, arg1, arg2... argN)
Function.call.apply(Foo.prototype.method, arguments);
};

Hubungan antara parameter fungsi dan atribut argumen

Objek

argumen mencipta kaedah pengambil dan penetap untuk kedua-dua sifatnya sendiri dan parameter formal fungsinya.
Oleh itu, mengubah suai parameter formal fungsi akan mempengaruhi nilai sifat objek argumen yang sepadan, dan sebaliknya.

Salin kod Kod adalah seperti berikut:

fungsi foo(a, b, c) {
hujah[0] = 2;
a; // 2
b = 4;
hujah[1]; // 4
var d = c;
d = 9;
c; // 3
}
foo(1, 2, 3);

Isu prestasi

argumen tidak akan dibuat dalam dua situasi sahaja, satu diisytiharkan sebagai pembolehubah tempatan di dalam fungsi, dan satu lagi digunakan sebagai parameter formal fungsi. Jika tidak, objek argumen sentiasa dicipta.
Memandangkan kaedah getter dan setter sentiasa dicipta dengan objek argumen, menggunakan argumen itu sendiri mempunyai sedikit kesan ke atas prestasi.
Walau bagaimanapun, terdapat satu situasi yang menjejaskan prestasi Javascript secara serius, iaitu penggunaan arguments.callee.

Salin kod Kod adalah seperti berikut:

fungsi foo() {
arguments.callee; // lakukan sesuatu dengan objek fungsi ini
arguments.callee.caller; // dan objek fungsi memanggil
}
fungsi bigLoop() {
untuk(var i = 0; i < 100000; i ) {
foo(); // Lazimnya akan sebaris...
}
}

Dalam kod di atas, fungsi foo bukan lagi sambungan sebaris yang mudah, kerana ia perlu mengetahui dirinya sendiri dan pemanggilnya. Ini bukan sahaja menafikan keuntungan prestasi yang dibawa oleh pengembangan sebaris, tetapi juga memusnahkan enkapsulasi fungsi, kerana fungsi itu sendiri mungkin perlu bergantung pada konteks panggilan tertentu.
Oleh itu, adalah disyorkan agar anda cuba untuk tidak menggunakan arguments.callee.

Yang di atas adalah mengenai objek hujah Javascript Adakah anda memahaminya dengan teliti

argumen merujuk kepada objek parameter fungsi (merujuk kepada parameter sebenar yang diluluskan)
arguments.length merujuk kepada panjang objek parameter fungsi
argumen[i] merujuk kepada nilai parameter ke-i (yang pertama ialah 0)