Bagaimana untuk melaksanakan parameter panjang berubah-ubah dalam fungsi javascript

Fungsi JavaScript ialah salah satu bahagian pembangunan program yang paling banyak digunakan kerana ia membolehkan kami melaksanakan tugas berulang dan melaksanakan blok kod. Fungsi JavaScript boleh menerima sifar atau lebih parameter (iaitu input). Dalam sesetengah kes, kita perlu melaksanakan fungsi yang menerima bilangan argumen yang berubah-ubah. Ini ialah kepentingan bilangan parameter yang berubah-ubah dalam JavaScript.

Dalam JavaScript, bilangan parameter boleh ditentukan secara eksplisit atau tidak semasa mentakrifkan fungsi. Bermula dari versi ES6, kita boleh menggunakan parameter selebihnya untuk menunjukkan bahawa fungsi menerima berbilang parameter. Dalam artikel ini, kita akan membincangkan konsep bilangan pembolehubah parameter dalam JavaScript dan cara melaksanakannya.

Parameter tak tentu

Kaedah dalam JavaScript yang membolehkan kami mentakrifkan nombor pembolehubah parameter dipanggil parameter tak tentu (juga dipanggil parameter pembolehubah). Apakah parameter tidak tentu? Ringkasnya, parameter berubah bermakna bahawa fungsi boleh mempunyai bilangan parameter input yang tidak ditentukan pada masa jalan. Dalam JavaScript, kami menggunakan awalan elipsis (...) untuk menentukan parameter pembolehubah. Sebagai contoh, pengisytiharan fungsi berikut menerima bilangan argumen yang tidak ditentukan:

function sum(...args) {
  let result = 0;
  for (let i = 0; i < args.length; i++) {
    result += args[i];
  }
  return result;
}

console.log(sum(1, 2)); // 3
console.log(sum(1, 2, 3, 4)); // 10

Dalam contoh ini, fungsi sum() mentakrifkan bilangan argumen yang tidak ditentukan, args. Semasa pelaksanaan fungsi, kita boleh menghantar sebarang bilangan argumen kepada fungsi dan menambahnya melalui gelung.

objek hujah

Sebelum pengenalan parameter tak tentu dalam ES6, JavaScript menyediakan ciri lain yang serupa dengan parameter tak tentu yang dipanggil objek argumen. Apabila fungsi dipanggil, objek argumen menyediakan senarai argumen fungsi. Objek argumen membolehkan kita mengakses dalam fungsi semua argumen yang sebenarnya diluluskan semasa panggilan fungsi. Berikut ialah contoh mudah menggunakan objek argumen:

function multiply() {
  let result = 1;
  for (let i = 0; i < arguments.length; i++) {
    result *= arguments[i];
  }
  return result;
}

console.log(multiply(2, 3)); // 6
console.log(multiply(2, 3, 4)); // 24

Dalam contoh ini, fungsi multiply() tidak menerima sebarang parameter, tetapi ia boleh mengakses setiap parameter yang dihantar kepadanya melalui objek argumen. Dalam kes ini, kami menggunakan gelung for untuk mengulangi parameter dan mengira produknya.

Perbandingan parameter tak tentu dan objek argumen

Dalam JavaScript, kedua-dua parameter tak tentu dan objek argumen boleh mengendalikan bilangan parameter yang berubah-ubah. Walau bagaimanapun, terdapat beberapa perbezaan penting antara mereka.

• Jenis: Parameter pembolehubah ialah tatasusunan sebenar, dan objek argumen sebenarnya ialah objek tatasusunan.
• Fleksibiliti: Parameter tidak tentu adalah lebih fleksibel daripada objek argumen kerana ia boleh ditakrifkan di mana-mana dan boleh digunakan dengan parameter lain pada masa yang sama.
• Prestasi: Menggunakan parameter pembolehubah cenderung untuk melaksanakan lebih cepat daripada menggunakan objek argumen kerana ia adalah tatasusunan sebenar.

Jadi secara ringkasnya, parameter pembolehubah ialah kaedah pemprosesan parameter yang lebih berkuasa dan fleksibel yang diperkenalkan dalam ES6 Berbanding dengan objek argumen, ia lebih disyorkan untuk digunakan dalam pembangunan JavaScript.

Kesimpulan

Dalam JavaScript, memandangkan fungsi merupakan bahagian penting dalam pembangunan program, adalah perkara biasa untuk mengendalikan bilangan parameter yang berubah-ubah. Argumen tidak tentu ialah ciri yang sangat berguna yang membenarkan fungsi mengendalikan sebarang bilangan argumen input. Menggunakan parameter rehat ES6 dan definisi parameter berubah-ubah, kami boleh mengendalikan berbilang parameter dengan mudah, menjadikan kod lebih ringkas dan boleh dibaca.

Dalam pembangunan harian, kita perlu memilih parameter yang berbeza (parameter tidak tentu atau objek argumen) mengikut situasi sebenar untuk menyelesaikan tugas pengaturcaraan dengan lebih baik. Walau bagaimanapun, sebagai pengaturcara yang bekerja dalam JavaScript, memahami perbezaan antara kedua-dua teknologi dan cara menggunakannya boleh sangat membantu.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan parameter panjang berubah-ubah dalam fungsi javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!