Rekod dan Tuples: JavaScript ' s jenis data baru yang tidak berubah

rekod javascript dan tuple: masa depan struktur data yang tidak berubah

JavaScript akan membawa dua jenis data baru yang tidak berubah: rekod dan tuple. Mereka kini berada di Fasa 2 proses kelulusan standard TC39 dan masih diperbaiki dan tidak terdapat dalam mana -mana penyemak imbas atau persekitaran runtime, tetapi versi pelaksanaan dijangka tersedia dalam tahun depan. Mereka direka untuk menyelesaikan beberapa masalah yang sukar dihadapi oleh pemaju apabila menggunakan tatasusunan dan objek.

mata utama

Rekod dan tuple adalah jenis data baru yang tidak berubah di bawah pembangunan dalam JavaScript dan dijangka tersedia dalam tahun depan. Mereka direka untuk menyelesaikan cabaran yang dihadapi oleh pemaju, seperti memastikan fungsi tidak sengaja atau tidak sengaja mengubah nilai yang disimpan dalam tatasusunan atau objek.
tuple adalah struktur data seperti array dengan kedalaman yang tidak berubah. Mereka tidak boleh mempunyai nilai yang tidak jelas, mereka hanya boleh menetapkan jenis asas, tuples lain, atau rekod. Tuples adalah jenis primitif, jadi anda boleh membandingkan secara mendalam dengan tuple lain dengan nilai.
Rekod adalah struktur data yang serupa dengan objek dengan kedalaman yang tidak berubah. Mereka mesti menggunakan nama atribut rentetan dan hanya boleh menetapkan nilai dengan jenis primitif, tupel lain, atau rekod. Rekod boleh dibandingkan secara mendalam dengan rekod lain, dan perintah atribut tidak relevan.

Batasan Const

pemaju JavaScript yang berpengalaman tahu bahawa menggunakan

untuk mengisytiharkan pembolehubah adalah amalan terbaik. Ia menjadikan pembolehubah tidak berubah. Nilai tidak boleh diubah, jadi anda perlu menangani masalah yang lebih sedikit. const

Malangnya,

hanya boleh membuat nilai asas tidak berubah (rentetan, nombor, bigin, boolean, simbol, dan tidak ditentukan). Anda tidak boleh menetapkan semula susunan atau objek, tetapi nilai dan sifat yang mereka ada adalah const boleh diubah suai. Contohnya: Begitu juga dengan objek :

// 数组常量
const myArray = [1, 2, 3];

// 更改数组值
myArray[0] = 99;
myArray.push(42);

console.log(myArray); // [ 99, 2, 3, 42 ]

myArray = 'change'; // 错误！

Kaedah

boleh membantu, tetapi ia hanya memohon pembekuan cetek ke sifat anak langsung objek:

// 对象常量
const myObj = { a: 1, b: 2, c: 3 };

// 更改对象属性
myObj.a = 99;
myObj.d = 42;

console.log(myObj); // { a: 99, b: 2, c: 3, d: 42 }

myObj = 'change'; // 错误！

Oleh itu, sukar untuk memastikan fungsi tidak sengaja atau tidak sengaja mengubah nilai -nilai yang disimpan dalam tatasusunan atau objek. Pemaju sama ada meninggalkan perkara sahaja atau lulus versi pembolehubah yang diklonkan - (ini juga mempunyai cabaran tersendiri). Object.freeze()

Perbandingan tidak konsisten

const myObj = { a: 1, b: 2, c: { v: 3 } };
Object.freeze(myObj);

myObj.a = 99; // 静默忽略
myObj.c.v = 99; // 可以正常工作

console.log(myObj); // { a: 1, b: 2, c: { v: 99 } }

lebih banyak kekeliruan mungkin berlaku apabila pemaju cuba membuat objek atau perbandingan array yang munasabah:

Hanya jenis asas boleh dibandingkan dengan nilai. Objek dan tatasusunan diluluskan dan dibandingkan dengan rujukan

. Hanya apabila dua pembolehubah menunjuk kepada item yang sama dalam ingatan mereka sama:

const str = 'my string';
console.log(str === 'mystring');  // false

const num = 123;
console.log(num === 123);         // true

const arr = [1, 2, 3];
console.log(arr === [1, 2, 3]);   // false

const obj = { a: 1 };
console.log(obj === { a: 1 });    // false

Perbandingan mendalam dua objek atau tatasusunan memerlukan fungsi perbandingan rekursif untuk menilai setiap nilai pada gilirannya. Walaupun begitu, anda mungkin mempunyai masalah dengan jenis seperti tarikh atau fungsi yang mungkin disimpan dengan cara yang berbeza.

tuple: Struktur data seperti array yang tidak berubah

tuple adalah struktur data seperti array dengan kedalaman yang tidak berubah. Mereka sebenarnya adalah jenis primitif kompaun, yang dikenal pasti dengan pengubah # sebelum sintaks array normal:

// 数组常量
const myArray = [1, 2, 3];

// 更改数组值
myArray[0] = 99;
myArray.push(42);

console.log(myArray); // [ 99, 2, 3, 42 ]

myArray = 'change'; // 错误！

atau, kaedah Tuple.from() baru boleh membuat tuple dari array:

// 对象常量
const myObj = { a: 1, b: 2, c: 3 };

// 更改对象属性
myObj.a = 99;
myObj.d = 42;

console.log(myObj); // { a: 99, b: 2, c: 3, d: 42 }

myObj = 'change'; // 错误！

Tidak seperti array standard, tuple mesti memenuhi keperluan berikut:

1. mereka tidak boleh mempunyai ruang kosong dengan nilai undefined. Sebagai contoh, tidak sah. #[1,,,4]
Mereka hanya boleh menetapkan jenis asas, tuple lain, atau rekod. Array, objek, atau fungsi tidak dibenarkan digunakan:

const myObj = { a: 1, b: 2, c: { v: 3 } };
Object.freeze(myObj);

myObj.a = 99; // 静默忽略
myObj.c.v = 99; // 可以正常工作

console.log(myObj); // { a: 1, b: 2, c: { v: 99 } }

Oleh kerana tuple adalah jenis asas, anda boleh membandingkan kedalaman dengan tupel lain dengan nilai:

const str = 'my string';
console.log(str === 'mystring');  // false

const num = 123;
console.log(num === 123);         // true

const arr = [1, 2, 3];
console.log(arr === [1, 2, 3]);   // false

const obj = { a: 1 };
console.log(obj === { a: 1 });    // false

Perhatikan bahawa jika tuple mengandungi nilai tunggal, anda boleh menggunakan pengendali looser

untuk perbandingan. Contohnya: ==

Rekod: Struktur data seperti objek yang tidak berubah

const a = [1, 2];

const b = a;
b.push(3);

console.log(a === b); // true

// 原始数组已更改
console.log(a); // [1, 2, 3]

Rekod adalah struktur data yang serupa dengan objek dengan kedalaman yang tidak berubah. Sekali lagi, mereka adalah jenis primitif kompaun, yang dikenal pasti menggunakan pengubah

sebelum sintaks objek normal:

#

atau, pembina

// 新的元组
const t1 = #[1, 2, 3];
const t2 = #[1, 2, #[3, 4]];

baru boleh membuat rekod dari objek:

Record() Kaedah

atau

// 从数组创建新的元组
const t3 = Tuple.from([1, 2, 3]);

boleh mencipta rekod dari satu siri array atau tuple kunci nilai kunci:

Record.fromEntries()

Tidak seperti objek standard, rekod mesti memenuhi keperluan berikut:

const t4 = #[new Date()]; // 错误（设置一个对象）
const t5 = #[1, 2, [3, 4]]; // 错误（设置一个数组）

Mereka mesti menggunakan nama atribut rentetan. Sebagai contoh, tidak sah.

1. Mereka hanya boleh menetapkan nilai menggunakan jenis primitif, tuples lain, atau rekod. Array, objek, atau fungsi tidak dibenarkan digunakan: #{ Symbol(): 1 }
Rekod boleh dibandingkan secara mendalam dengan rekod lain, dan urutan atribut tidak relevan:

const t6 = #[1, 2];

console.log(t6 === #[1, 2]); // true

Rekod hanya boleh dibandingkan dengan rekod lain, jadi tidak ada perbezaan antara menggunakan pengendali

atau

const t7 = #[99];

console.log(t7 == #[99]); // true
console.log(t7 == 99);    // true
console.log(t7 == '99');  // true

// 元组不能与数组比较
console.log(t7 == [99]);  // false

. Walau bagaimanapun,

dan == boleh diekstrak untuk perbandingan tertentu. Contohnya: === Object.keys() Kemas kini yang tidak berubah Object.values()

tuples dan rekod bunyi seperti istilah sains komputer yang kompleks, tetapi akhirnya mereka membenarkan penyimpanan data yang kuat dan perbandingan dalam JavaScript.

// 新的记录
const r1 = #{ a: 1, b: 2 };
const r2 = #{
  a: 1,
  b: #{ c: 2 }, // 子记录
  d: #[3, 4]  // 子元组
};

Rekod dan tuples di JavaScript FAQ

Apakah rekod dalam JavaScript? Rekod dalam JavaScript adalah struktur seperti objek yang diperkenalkan dalam ECMAScript 2022 (ES12). Ia direka untuk mewakili data dengan sifat bernama dan tidak berubah secara lalai, jadi ia sesuai digunakan sebagai struktur data di mana nilai tidak berubah selepas penciptaan.

Bagaimana perbezaan antara rekod dan objek JavaScript biasa? Tidak seperti objek biasa, rekod dalam JavaScript tidak berubah secara lalai, dan sekali ditetapkan, sifat mereka tidak dapat diubah suai. Rekod juga lebih diramalkan dan mempunyai struktur yang lebih ketat, jadi ia sesuai untuk digunakan sebagai bekas data.

Apakah tuple dalam JavaScript? Tuples dalam JavaScript adalah koleksi elemen yang diperintahkan, di mana setiap elemen boleh menjadi jenis yang berbeza. Tuples tidak berubah dan diperbaiki panjang, menyediakan cara untuk mewakili dan memproses bilangan nilai tetap dalam urutan tertentu.

Bagaimana rekod dan tuple meningkatkan kebolehbacaan dan pemeliharaan kod anda? Rekod dan tupel dapat meningkatkan kebolehbacaan kod dengan menyediakan cara yang lebih deklaratif dan berstruktur untuk mewakili data. Aspek kebolehubahan juga membantu mencegah pengubahsuaian yang tidak disengajakan, dengan itu meningkatkan pemeliharaan kod.

Adakah terdapat pertimbangan prestasi apabila menggunakan rekod dan tuples? Rekod dan tupel bertindak sebagai struktur data yang tidak berubah, yang dapat meningkatkan prestasi dalam beberapa kes. Walau bagaimanapun, sokongan penyemak imbas dan kes penggunaan khusus mesti dipertimbangkan, kerana kesan prestasi mungkin berbeza -beza bergantung kepada butiran pelaksanaan runtime JavaScript.

Bagaimana untuk menyediakan polyfill untuk rekod dan tupel dalam persekitaran tanpa sokongan asli? Sebagai kemas kini terakhir saya, rekod dan tuple boleh disimulasikan dalam persekitaran tanpa sokongan asli menggunakan polyfill atau penterjemah. Walau bagaimanapun, adalah disyorkan untuk mengikuti perkembangan terkini dengan standard dan alat JavaScript apabila ekosistem terus berkembang.

Atas ialah kandungan terperinci Rekod dan Tuples: JavaScript ' s jenis data baru yang tidak berubah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!