Pembolehubah JavaScript: Memahami Jenis Primitif dan Rujukan

Dua jenis asas data disimpan dalam pembolehubah dalam JavaScript: primitif dan jenis rujukan. Memahami perbezaan antara kedua-dua jenis ini adalah penting untuk pengurusan memori dan untuk mengawal selia perkongsian, penyimpanan dan pengubahan data. Artikel ini menyelidiki perbezaan, menyediakan contoh dunia sebenar dan mengkaji kaedah untuk mengendalikan kedua-dua jenis dengan cekap.

---

1. Primitif vs Jenis Rujukan

Primitif

Jenis data yang paling mudah dipanggil primitif. Mereka secara langsung menyimpan data yang tidak boleh diubah dalam pembolehubah. Jenis primitif yang disokong JavaScript adalah seperti berikut:

• rentetan: "hello"
• nombor: 42
• boolean: benar atau salah
• null
• tidak ditentukan
• simbol
• besar

Ciri-ciri utama:

• Tidak boleh ubah: Nilainya tidak boleh diubah secara langsung.
• Disimpan mengikut nilai.

Jenis Rujukan

Sebaliknya, jenis rujukan menyimpan lokasi memori objek. Daripada menyimpan nilai sebenar, pembolehubah menyimpan rujukan kepada alamat memori. Antara contohnya ialah:

• objek: { nama: 'Alice' }
• tatasusunan: [1, 2, 3]
• function: function() { console.log('hello'); }
• Tarikh: new Date()

Ciri-ciri utama:

• Mutable: Kandungannya boleh diubah suai.
• Disimpan dengan rujukan.

---

2. Jenis Primitif dan Rujukan dalam Tindakan

// Primitive Example
let a = 10;
let b = a;
b = 20;
console.log(a); // Output: 10

// Reference Example
let obj1 = { name: 'Alice' };
let obj2 = obj1;
obj2.name = 'Bob';
console.log(obj1.name); // Output: 'Bob'

Penjelasan:

• Primitif: Menugaskan a kepada b mencipta salinan nilai. Menukar b tidak menjejaskan a kerana mereka bebas.
• Jenis Rujukan: Kedua-dua obj1 dan obj2 menghala ke lokasi memori yang sama. Menukar kandungan melalui obj2 turut mengemas kini obj1.

---

3. Menggambarkan Konsep

• Primitif: Bayangkan setiap pembolehubah sebagai kotaknya sendiri yang mengandungi nilai. Menyalin mencipta kotak baharu dengan nilai bebas.
• Jenis Rujukan: Fikirkan pembolehubah sebagai label yang menunjuk ke bekas kongsi. Semua label yang merujuk bekas yang sama dipengaruhi oleh perubahan yang dibuat pada kandungannya.

---

4. Mutasi lwn Tugasan

Memahami perbezaan antara mutasi dan tugasan adalah kunci apabila bekerja dengan jenis rujukan.

Mutasi: Mengubah suai kandungan objek sedia ada.

// Primitive Example
let a = 10;
let b = a;
b = 20;
console.log(a); // Output: 10

// Reference Example
let obj1 = { name: 'Alice' };
let obj2 = obj1;
obj2.name = 'Bob';
console.log(obj1.name); // Output: 'Bob'

Tugasan: Menukar rujukan kepada objek baharu.

let arr = [1, 2, 3];
let arr2 = arr;
arr2.push(4);
console.log(arr); // Output: [1, 2, 3, 4]

---

5. Menyalin Objek dan Tatasusunan

Salinan Cetek:

Untuk membuat salinan berasingan objek atau tatasusunan, gunakan operator hamparan (...) atau Object.assign().

let arr = [1, 2, 3];
let arr2 = arr;
arr2 = [4, 5, 6];
console.log(arr); // Output: [1, 2, 3]

Salinan Dalam:

Untuk objek bersarang, salinan dalam diperlukan. Pendekatan biasa ialah menggunakan JSON.parse(JSON.stringify()).

let original = { name: 'Alice' };
let copy = { ...original };
copy.name = 'Bob';
console.log(original.name); // Output: 'Alice'

---

6. Lulus Nilai vs Lulus Rujukan

Primitif (Lulus Mengikut Nilai):

Apabila menghantar primitif kepada fungsi, salinan nilai dihantar.

let nested = { person: { name: 'Alice' } };
let deepCopy = JSON.parse(JSON.stringify(nested));
deepCopy.person.name = 'Bob';
console.log(nested.person.name); // Output: 'Alice'

Jenis Rujukan (Lulus Rujukan):

Apabila menghantar jenis rujukan, rujukan kepada lokasi memori dihantar.

function modifyValue(x) {
  x = 20;
}
let num = 10;
modifyValue(num);
console.log(num); // Output: 10

---

7. Jenis Pembungkus Primitif

Walaupun primitif tidak boleh diubah, JavaScript membungkusnya buat sementara waktu dalam objek untuk membenarkan akses kepada kaedah dan sifat.

function modifyObject(obj) {
  obj.name = 'Bob';
}
let person = { name: 'Alice' };
modifyObject(person);
console.log(person.name); // Output: 'Bob'

Penjelasan:

Rentetan primitif 'hello' dibalut buat sementara waktu dalam objek String untuk mengakses sifat panjang. Pembalut dibuang selepas pembedahan.

---

8. Amalan Terbaik

1. Gunakan const untuk Jenis Rujukan: Mengisytiharkan objek dan tatasusunan dengan const menghalang penugasan semula tetapi membenarkan mutasi kandungan.

let str = 'hello';
console.log(str.length); // Output: 5

1. Elakkan Mutasi Yang Tidak Diingini:
   Jika anda memerlukan salinan bebas, pastikan anda menciptanya menggunakan operator spread atau teknik salinan dalam.

2. Tahu Bila Perlu Menggunakan Salinan Dalam:
   Untuk objek cetek, operator hamparan adalah mencukupi, tetapi struktur bersarang memerlukan salinan dalam untuk mengelakkan isu rujukan.

3. Memanfaatkan Ketidakbolehubah:
   Gunakan perpustakaan seperti Immutable.js atau gunakan teknik pengaturcaraan berfungsi untuk meminimumkan pepijat yang disebabkan oleh mutasi yang tidak diingini.

---

9. Perangkap Biasa

1. Tugasan Mengelirukan dengan Mutasi:
   Berhati-hati sama ada anda mengubah suai objek atau menetapkan semula rujukan.

2. Mengubah suai Rujukan Dikongsi:
   Perubahan pada objek kongsi boleh menyebabkan akibat yang tidak diingini jika bahagian lain program turut menggunakannya.

3. Andaikan Semua Salinan Adalah Bebas:
   Ingat bahawa salinan cetek tidak melindungi daripada perubahan dalam struktur bersarang.

---

Kesimpulan

Salah satu idea teras JavaScript ialah perbezaan antara primitif dan jenis rujukan. Ia mempengaruhi cara anda menghantar data ke fungsi, mengurus pembolehubah dan menghalang kesan sampingan yang tidak dijangka dalam kod anda. Anda boleh membina kod JavaScript yang lebih boleh dipercayai dan boleh diselenggara dengan memahami idea ini dan menggunakan amalan terbaik.

Ikuti saya di : Github Linkedin

Atas ialah kandungan terperinci Pembolehubah JavaScript: Memahami Jenis Primitif dan Rujukan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!