JavaScript mempunyai ciri yang dipanggil penstrukturan yang membolehkan anda mengekstrak nilai dengan mudah daripada tatasusunan atau sifat daripada objek dan menetapkannya kepada pembolehubah. Pemusnahan menjadikannya lebih mudah untuk bekerja dengan data dan ia merupakan alat penting untuk pemula yang mempelajari JavaScript.
Dalam siaran ini, kami akan memecahkan penstrukturan dengan contoh yang sangat mudah supaya anda boleh memahaminya dalam masa yang singkat.
Bayangkan anda mempunyai kotak yang penuh dengan mainan, dan anda ingin mengeluarkan beberapa mainan daripada kotak dan bermain dengannya. Daripada mengambil setiap mainan secara individu, memusnahkan membolehkan anda merebut mainan tertentu (atau data) yang anda perlukan sekali gus!
Dalam JavaScript, penstrukturan membolehkan anda membongkar nilai daripada tatasusunan atau mengekstrak sifat daripada objek ke dalam pembolehubah. Ia merupakan cara yang bersih dan mudah untuk mengendalikan data, terutamanya apabila bekerja dengan tatasusunan atau objek yang kompleks.
Mari mulakan dengan pemusnahan tatasusunan. Tatasusunan adalah seperti senarai yang memegang berbilang nilai dan penstrukturan membolehkan anda mengambil nilai daripada tatasusunan dan menetapkannya kepada pembolehubah dalam satu baris kod.
Contoh 1: Pemusnahan Tatasusunan Asas
let fruits = ['apple', 'banana', 'orange']; // Destructuring the array let [fruit1, fruit2, fruit3] = fruits; console.log(fruit1); // Output: apple console.log(fruit2); // Output: banana console.log(fruit3); // Output: orange
Dalam contoh ini, kami mempunyai tatasusunan yang dipanggil buah-buahan, dan kami menggunakan penstrukturan untuk menetapkan nilai kepada fruit1, fruit2 dan fruit3. Daripada mengakses setiap elemen secara manual, memusnahkan membolehkan kami melakukannya sekaligus!
Contoh 2: Melangkau Elemen Tatasusunan
Anda juga boleh melangkau elemen dalam tatasusunan menggunakan penstrukturan. Katakan anda hanya mahukan buah pertama dan ketiga daripada susunan buah-buahan.
let fruits = ['apple', 'banana', 'orange']; // Skipping the second element let [fruit1, , fruit3] = fruits; console.log(fruit1); // Output: apple console.log(fruit3); // Output: orange
Di sini, dengan meninggalkan ruang kosong (hanya koma) dalam corak pemusnahan, kami melangkau elemen kedua (pisang) dan terus ke oren.
Contoh 3: Nilai Lalai dalam Pemusnahan Tatasusunan
Bagaimana jika tatasusunan tidak mempunyai elemen yang mencukupi? Anda boleh menetapkan nilai lalai untuk mengelakkan daripada tidak ditentukan.
let colors = ['red']; // Setting a default value for the second color let [color1, color2 = 'blue'] = colors; console.log(color1); // Output: red console.log(color2); // Output: blue
Memandangkan warna hanya mempunyai satu elemen (merah), pembolehubah kedua (warna2) mendapat nilai lalai 'biru'.
Sekarang, mari kita beralih kepada pemusnahan objek. Objek adalah seperti bekas yang menyimpan pasangan nilai kunci dan penstrukturan membantu anda mengeluarkan sifat tertentu dengan mudah.
Contoh 4: Pemusnahan Objek Asas
let person = { name: 'John', age: 30, job: 'developer' }; // Destructuring the object let { name, age, job } = person; console.log(name); // Output: John console.log(age); // Output: 30 console.log(job); // Output: developer
Di sini, objek orang mempunyai tiga sifat: nama, umur dan pekerjaan. Pemusnahan membolehkan kami mengekstrak sifat ini ke dalam pembolehubah berasingan dengan nama yang sama.
Contoh 5: Menetapkan kepada Nama Pembolehubah Baharu
Bagaimana jika anda ingin menetapkan sifat ini kepada pembolehubah dengan nama yang berbeza? Anda boleh melakukannya dengan mudah dengan memusnahkan objek.
let car = { brand: 'Toyota', model: 'Corolla', year: 2020 }; // Assigning to new variable names let { brand: carBrand, model: carModel, year: carYear } = car; console.log(carBrand); // Output: Toyota console.log(carModel); // Output: Corolla console.log(carYear); // Output: 2020
Dalam contoh ini, kami menggunakan jenama: carBrand untuk menetapkan sifat jenama kepada pembolehubah baharu yang dipanggil carBrand, dan begitu juga untuk model dan tahun.
Contoh 6: Nilai Lalai dalam Pemusnahan Objek
Sama seperti tatasusunan, anda boleh menetapkan nilai lalai apabila memusnahkan objek.
let student = { name: 'Alice' }; // Setting default value for age let { name, age = 18 } = student; console.log(name); // Output: Alice console.log(age); // Output: 18 (since age wasn't in the object)
Memandangkan objek pelajar tidak mempunyai sifat umur, ia lalai kepada 18.
Contoh 7: Pemusnahan Bersarang
Kadangkala, objek boleh mempunyai objek lain di dalamnya. Di sinilah pemusnahan bersarang berguna.
let user = { name: 'Bob', address: { city: 'New York', zip: 10001 } }; // Destructuring nested object let { name, address: { city, zip } } = user; console.log(name); // Output: Bob console.log(city); // Output: New York console.log(zip); // Output: 10001
Dalam contoh ini, kami bukan sahaja memusnahkan sifat nama tetapi juga bandar dan zip daripada objek alamat bersarang.
Memusnahkan ialah ciri yang berkuasa dan mudah dalam JavaScript yang menjadikan kerja dengan tatasusunan dan objek lebih mudah. Dengan menggunakan penstrukturan, anda boleh menulis kod yang lebih bersih, lebih cekap sambil menjimatkan masa dan mengurangkan ralat. Sama ada anda seorang pemula atau baru belajar JavaScript, penstrukturan ialah sesuatu yang anda akan kerap gunakan dalam perjalanan pengekodan anda.
Mula bereksperimen dengan pemusnahan, dan lihat bagaimana ia boleh memudahkan kod anda! Selamat mengekod!
Atas ialah kandungan terperinci Panduan Mudah untuk Memusnahkan JavaScript: Belajar dengan Contoh Mudah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!