Aplikasi Kekal dalam kemahiran JavaScript_javascript

Objek boleh ubah
Dalam JavaScript, objek adalah data jenis rujukan Kelebihannya ialah apabila objek sering diubah suai, ia diubah suai berdasarkan objek asal dan tidak perlu dicipta semula Ini boleh menggunakan memori dengan berkesan dan tidak akan menyebabkan pembaziran memori ruang. Objek Ciri ini boleh dipanggil Mutable, yang bermaksud "pembolehubah" dalam bahasa Cina.
Untuk objek boleh ubah, kelebihannya sebagai fleksibel dan boleh diubah kadangkala menjadi kelemahannya Lebih fleksibel dan boleh diubah, lebih sukar untuk dikawal Untuk objek dengan struktur yang kompleks, ia mungkin diubah suai secara tidak sengaja di suatu tempat. jika objek digunakan dalam berbilang skop, sukar untuk meramalkan sama ada dan bila data akan berubah.

var obj = { /* 一个复杂结构的对象 */ };
doSomething(obj);
// 上面的函数之行完后，此时的 obj 还是最初的那个 obj 吗？

Untuk menangani masalah ini, penyelesaian konvensional ialah menyalin objek ke objek baharu dalam bentuk salinan dalam, dan kemudian melakukan operasi pengubahsuaian pada objek baharu Ini boleh memastikan kebolehkawalan data, tetapi Penyalinan yang kerap boleh menyebabkan banyak pembaziran ruang ingatan.

var obj = { /* 一个复杂结构的对象 */ };
// copy 出一个新的 obj2
// 但是 copy 操作会浪费内存空间
var obj2 = deepClone(obj);
doSomething(obj2);
// 上面的函数之行完后，无论 obj2 是否变化，obj 肯定还是原来那个 obj

Objek tidak berubah
Untuk menyelesaikan masalah di atas dengan lebih baik, objek Kekal muncul secara literal diterjemahkan ke dalam bahasa Cina sebagai "tidak berubah". Setiap kali objek tidak berubah diubah suai, objek tidak berubah baharu dicipta dan operasi pada objek baharu tidak akan menjejaskan data objek asal. Objek istimewa ini bukanlah ciri baharu JavaScript, tetapi satu set penyelesaian yang disediakan oleh industri untuk menyelesaikan masalah ini, dan beberapa perpustakaan sumber terbuka yang sangat baik telah muncul, yang paling terkenal ialah sumber terbuka Lee Byron Facebook tidak berubah. js. Sudah tentu, penyelesaian Immutable tidak asli, tetapi datang dari Clojure dan Scala.
Perbandingan prestasi antara Boleh Berubah dan Tidak Berubah
Operasi yang tidak cekap pada objek Boleh Berubah terutamanya dicerminkan dalam penyalinan dan perbandingan, dan objek Tidak Boleh ubah menyelesaikan dua titik kesakitan yang tidak cekap ini.
Operasi penyalinan mendalam bagi objek Boleh Ubah biasa akan menyalin keseluruhan data, tetapi objek Tidak Boleh ubah tidak akan menyalin keseluruhan data apabila mengubah suai data, tetapi akan memindahkan hubungan ibu bapa-anak antara nod yang diubah dan nod yang tidak berubah nod, struktur yang serupa dengan senarai terpaut. Dari perspektif "menyalin", penyalinan minimum dicapai, dan bahagian yang tidak berubah dikongsi "jumlah penuh", manakala salinan tidak berubah "kenaikan" Mengenai penggunaan ruang memori Penghakiman akan dibuat berdasarkan perbandingan kadar.
Dan berdasarkan ciri bahawa objek Tidak Berubah baharu dicipta setiap kali objek Tidak Berubah diubah suai, status pengubahsuaian data boleh disimpan sebagai satu set syot kilat, yang juga sangat mudah.
Mari bercakap tentang operasi perbandingan. Untuk objek Boleh ubah, jika anda ingin membandingkan sama ada dua objek adalah sama, anda mesti melintasi setiap nod objek untuk perbandingan Untuk objek dengan struktur yang kompleks, kecekapan pastinya tidak jauh lebih tinggi. Untuk objek tidak boleh ubah, immutable.js menyediakan API untuk menentukan secara langsung sama ada "nilai" dua objek tidak berubah adalah sama.

var map1 = Immutable.Map({a:1, b:1, c:1});
var map2 = Immutable.Map({a:1, b:1, c:1});
assert(map1 !== map2); // 不同的 Immutable 实例，此时比较的是引用地址
assert(Immutable.is(map1, map2)); // map1 和 map2 的值相等，比较的是值
assert(map1.equals(map2)); // 与 Immutable.is 的作用一样

Dalam aplikasi pembangunan sebenar, prestasi tidak selalunya yang paling kritikal dan penting Untuk projek JavaScript biasa, kebolehkawalan data yang dibawa oleh ciri-ciri Immutable adalah lebih berfaedah daripada prestasi , Objek boleh ubah sesuai untuk digunakan dalam julat yang kecil daripada skop tertutup, manakala objek tidak boleh ubah sesuai untuk digunakan apabila data perlu dihantar merentasi berbilang skop.

Perbezaan penggunaan antara Mutable dan Immutable

immutable.js menyediakan pelbagai struktur data tidak boleh ubah: termasuk Senarai Stack Map OrderedMap Set OrderedSet Record Struktur data ini secara kasarnya sepadan dengan struktur data Mutable asli.
Penggunaan setiap struktur data tidak akan diterangkan secara terperinci di sini Mari kita bincangkan tentang perbezaan penggunaan antara objek Tidak boleh ubah dan objek Boleh Berubah.
Objek Mutable Asli sangat mudah untuk "membaca" dan "menulis".

var mutableObj = {};
// 写入数据
mutableObj.foo = 'bar';
// 读取数据
console.log(mutableObj.foo);

Objek Tidak boleh ubah perlu "membaca" dan "menulis" data melalui set dan dapatkan.

var immutableObj1 = Immutable.Map();
// 写入数据
var immutableObj2 = immutableObj1.set('foo', 'bar');
// 读取数据
console.log(immutableObj2.get('foo')); // => 'bar'

Contoh di atas hanya mencipta objek kosong pada permulaan untuk menggambarkan penggunaan kaedah set Malah, nilai awal boleh dihantar semasa instantiasi.

var immutableObj = Immutable.Map({'foo', 'bar'});

Untuk data peringkat dalam, antara muka akses yang disediakan oleh immutable.js adalah sangat mudah.

var immutableObj1 = Immutable.fromJS({
 a: {
  b: 'c'
 },
 d: [1, 2, 3]
});
// 读取深层级的数据
console.log(immutableObj1.getIn(['a', 'b'])); // => 'c'
console.log(immutableObj1.getIn(['d', 1])); // => 2
// 修改深层级的数据
var immutableObj2 = immutableObj1.setIn(['a', 'b'], 'd');
console.log(immutableObj2.getIn(['a', 'b'])); // => 'd'

Jika ia adalah objek Boleh ubah asli, ralat tidak ditentukan objek mungkin dilaporkan apabila merantai akses kepada data peringkat dalam Walau bagaimanapun, objek Tidak Boleh ubah tidak akan melaporkan ralat apabila menghadapi situasi ini dan mengembalikan tidak ditentukan.
Apabila menyahpepijat, jika anda ingin melihat struktur dalaman objek Tidak Boleh Ubah, adalah disyorkan untuk menggunakan toJSON() untuk menukarnya kepada objek Boleh Ubah biasa terlebih dahulu.