Memahami Parameter Lalai dalam Fungsi JavaScript

Parameter Lalai dalam Fungsi JavaScript

Parameter lalai dalam JavaScript membolehkan anda menentukan nilai lalai untuk parameter fungsi. Jika fungsi dipanggil tanpa nilai untuk parameter tertentu, nilai lalai digunakan sebaliknya.

Ciri ini telah diperkenalkan dalam ES6 (ECMAScript 2015) dan membantu mengendalikan kes di mana parameter mungkin tidak disediakan, mengelakkan tingkah laku yang tidak ditentukan dan menjadikan kod anda lebih mantap.

1. Sintaks Asas Parameter Lalai

Dalam contoh berikut, jika tiada hujah yang diluluskan untuk b, ia akan lalai kepada 10:

function sum(a, b = 10) {
  return a + b;
}

console.log(sum(5, 3));  // Output: 8
console.log(sum(5));     // Output: 15 (b defaults to 10)

Dalam kes ini:

• Apabila jumlah(5, 3) dipanggil, hasilnya ialah 8 kerana b secara eksplisit diluluskan sebagai 3.
• Apabila jumlah(5) dipanggil, hasilnya ialah 15 kerana b tidak diluluskan, jadi ia mengambil nilai lalai 10.

2. Menggunakan Parameter Lalai dengan Ungkapan

Anda juga boleh menetapkan nilai lalai yang merupakan hasil ungkapan, seperti memanggil fungsi atau melakukan pengiraan.

function greet(name = "Guest") {
  console.log(`Hello, ${name}!`);
}

greet();          // Output: Hello, Guest!
greet("John");    // Output: Hello, John!

Di sini, "Tetamu" ialah nilai lalai untuk nama jika tiada nilai dihantar ke fungsi.

3. Parameter Lalai dengan Pemusnahan

Parameter lalai juga berfungsi dengan penstrukturan. Jika anda menggunakan penstrukturan objek atau tatasusunan dalam parameter fungsi, anda boleh menetapkan nilai lalai untuk sifat atau item tertentu.

Nilai Lalai dalam Pemusnahan Objek

function printInfo({ name = "Anonymous", age = 18 } = {}) {
  console.log(`Name: ${name}, Age: ${age}`);
}

printInfo({ name: "Alice", age: 25 });  // Output: Name: Alice, Age: 25
printInfo({});                          // Output: Name: Anonymous, Age: 18
printInfo();                            // Output: Name: Anonymous, Age: 18

Dalam kes ini:

• Jika objek dilalui, fungsi menggunakan sifat objek itu.
• Jika tiada objek dilalui atau objek tiada sifat, nilai lalai akan digunakan.

Nilai Lalai dalam Pemusnahan Tatasusunan

function printNumbers([a = 1, b = 2] = []) {
  console.log(`a: ${a}, b: ${b}`);
}

printNumbers([5, 10]);  // Output: a: 5, b: 10
printNumbers([7]);      // Output: a: 7, b: 2
printNumbers();         // Output: a: 1, b: 2

Dalam kes ini:

• Fungsi berfungsi dengan tatasusunan dan menyediakan nilai lalai untuk a dan b jika tiada nilai yang diluluskan.

4. Parameter Lalai dan Argumen Fungsi

Anda juga boleh menggunakan parameter lalai bersama-sama dengan argumen untuk mengendalikan kes di mana bilangan argumen adalah dinamik.

function multiply(a, b = 2) {
  console.log(a * b);
}

multiply(3, 4);  // Output: 12
multiply(3);     // Output: 6 (b defaults to 2)

Dalam contoh ini:

• Fungsi mendarab a dengan b, dan jika b tidak disediakan, ia lalai kepada 2.

5. Parameter Lalai dengan Fungsi yang Mengembalikan Lalai

Anda boleh menggunakan fungsi sebagai nilai lalai, yang boleh membantu dalam senario di mana anda memerlukan nilai lalai dinamik atau kompleks.

function getUser(id, name = getDefaultName()) {
  console.log(`User ID: ${id}, Name: ${name}`);
}

function getDefaultName() {
  return "John Doe";
}

getUser(1);          // Output: User ID: 1, Name: John Doe
getUser(2, "Alice"); // Output: User ID: 2, Name: Alice

Dalam contoh ini:

• Jika nama tidak diberikan, fungsi getDefaultName() dipanggil dan hasilnya digunakan sebagai nilai lalai.

6. Parameter Lalai dengan Parameter Rehat

Anda boleh menggabungkan parameter lalai dengan parameter rehat (...args) untuk mengendalikan senario yang anda tidak tahu berapa banyak argumen yang mungkin diterima oleh fungsi.

function sum(a, b = 10) {
  return a + b;
}

console.log(sum(5, 3));  // Output: 8
console.log(sum(5));     // Output: 15 (b defaults to 10)

Dalam kes ini:

• Parameter pemisah mempunyai nilai lalai , jika tidak disediakan dan rentetan akan mengumpulkan semua argumen tambahan yang dihantar ke fungsi.

Kesimpulan

Parameter lalai dalam JavaScript menjadikan fungsi lebih fleksibel dengan membenarkan anda menentukan nilai lalai untuk parameter yang tiada atau tidak ditentukan. Ciri ini meningkatkan kebolehbacaan kod dan membantu mengelakkan ralat yang disebabkan oleh argumen yang tiada.

Ia boleh digabungkan dengan ciri lain seperti penstrukturan, parameter rehat dan juga panggilan fungsi untuk mencipta fungsi dinamik, ringkas dan boleh diselenggara.

---

Hai, saya Abhay Singh Kathayat!
Saya seorang pembangun timbunan penuh dengan kepakaran dalam kedua-dua teknologi hadapan dan belakang. Saya bekerja dengan pelbagai bahasa pengaturcaraan dan rangka kerja untuk membina aplikasi yang cekap, berskala dan mesra pengguna.
Jangan ragu untuk menghubungi saya melalui e-mel perniagaan saya: kaashshorts28@gmail.com.

Atas ialah kandungan terperinci Memahami Parameter Lalai dalam Fungsi JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!