JavaScript mempunyai beberapa jenis data primitif: nombor, rentetan, boolean, undefined, null, simbol, dan jenis besar, dan bukan primitif seperti objek dan array. Memahami ini adalah penting untuk menulis kod yang cekap, bebas bug: 1) Nombor menggunakan format 64-bit, yang membawa kepada isu-isu terapung seperti 0.1 0.2 = 0.3000000000000000004. 2) Rentetan tidak berubah, dengan literasi templat untuk rentetan multiline. 3) Boolean mempunyai nilai yang benar dan palsu. 4) Undefined menunjukkan tiada nilai yang diberikan, Null menandakan ketiadaan yang disengajakan. 5) Simbol digunakan untuk kunci objek yang unik. 6) Bigint mengendalikan bilangan bulat besar. 7) Objek adalah pasangan nilai utama, tatasusunan diindeks secara numerik. Penaipan dinamik membolehkan perubahan jenis runtime, tetapi boleh menyebabkan pepijat jika tidak diuruskan.

Mari kita menyelam ke dalam dunia data data JavaScript yang menarik. Anda mungkin tertanya -tanya, mengapa saya perlu mengambil berat tentang jenis data dalam JavaScript? Nah, pemahaman jenis data adalah penting untuk menulis kod yang cekap dan bebas. Ia seperti mengetahui bahan -bahan sebelum anda mula memasak; Ia membantu anda membuat makanan yang lazat, atau dalam kes ini, aplikasi yang mantap.

JavaScript, yang menjadi bahasa yang dinamik, kadang-kadang boleh merasakan seperti barat jenis data. Tetapi jangan takut, ketika kami meneroka nuansa jenis data JavaScript, anda akan mendapat pandangan yang akan menjadikan anda pemaju yang lebih yakin dan berkesan.

Mari kita mulakan dengan asas -asas. JavaScript mempunyai beberapa jenis data primitif: Number , String , Boolean , Undefined , Null , Symbol , dan BigInt . Setiap jenis ini berfungsi dengan tujuan yang unik dan mempunyai set tingkah laku dan kebiasaannya sendiri.

Sebagai contoh, Number dalam JavaScript adalah format binari 64-bit ketepatan dua kali ganda IEEE 754 nilai. Ini bermakna anda boleh mewakili bilangan bilangan bulat dan terapung, tetapi menyedari batasannya. Pernah mencuba 0.1 0.2 dalam JavaScript? Anda mungkin terkejut melihat 0.30000000000000004 sebagai hasilnya. Ini disebabkan oleh cara nombor terapung disimpan, dan ia adalah gotcha biasa yang perlu anda ketahui.

 Console.log (0.1 0.2); // output: 0.3000000000000000004

Sekarang, mari kita bercakap mengenai String . String JavaScript tidak berubah, yang bermaksud sekali rentetan dibuat, ia tidak boleh diubah. Ini boleh menjadi berkat dan kutukan. Ia bagus untuk prestasi kerana ia membolehkan pengoptimuman, tetapi ia boleh mengecewakan apabila anda cuba memanipulasi rentetan. Berikut adalah fakta yang menyeronokkan: anda boleh menggunakan literasi templat untuk membuat rentetan multiline, yang sangat berguna.

 const multilinestring = `Ini adalah
rentetan multiline`;
console.log (multilinestring);

Boolean adalah mudah, tetapi ada titik halus untuk dipertimbangkan: JavaScript mempunyai nilai yang benar dan palsu. Sebagai contoh, 0 , '' , null , undefined , dan NaN adalah semua palsu, sementara segala -galanya adalah kebenaran. Ini boleh membawa kepada tingkah laku yang tidak dijangka jika anda tidak berhati -hati.

 jika ('') {
    Console.log ('Ini tidak akan dicetak');
}

jika ('hello') {
    console.log ('Ini akan dicetak');
}

Undefined dan Null sering dikelirukan, tetapi mereka berbeza. Undefined bermaksud pembolehubah telah diisytiharkan tetapi tidak mempunyai nilai yang diberikan kepadanya, sementara Null adalah ketiadaan yang disengajakan dari sebarang nilai objek. Inilah cara cepat untuk memeriksa perbezaannya:

 biarkan a;
Console.log (A); // output: Undefined

biarkan b = null;
Console.log (b); // output: null

Symbol adalah jenis data yang unik dan tidak berubah yang digunakan sebagai kunci untuk sifat objek. Ia amat berguna untuk mewujudkan sifat peribadi dalam objek. Inilah cara anda boleh menggunakannya:

 const id = simbol ('id');
const user = {
    [Id]: '12345',
    Nama: 'John Doe'
};

console.log (pengguna [id]); // output: 12345
console.log (user.name); // output: John Doe

Akhirnya, BigInt adalah tambahan yang agak baru kepada JavaScript, yang diperkenalkan untuk mewakili integer yang lebih besar daripada jenis Number yang boleh dikendalikan. Ia sesuai untuk senario di mana anda perlu bekerja dengan jumlah yang sangat besar.

 const bignumber = 9007199254740991N;
console.log (bignumber); // output: 9007199254740991N

Sekarang, mari kita bincangkan beberapa konsep lanjutan. JavaScript juga mempunyai jenis data yang tidak primitif, terutamanya Object dan Array . Objek adalah koleksi pasangan nilai utama, dan tatasusunan adalah jenis objek khas yang menyimpan nilai dalam senarai yang diindeks secara berangka.

 const orang = {
    Nama: 'Alice',
    Umur: 30
};

const buah = ['epal', 'pisang', 'oren'];

Salah satu ciri yang paling kuat dari JavaScript ialah keupayaannya untuk mengendalikan menaip dinamik. Ini bermakna anda boleh menukar jenis pembolehubah pada masa runtime. Walaupun fleksibiliti ini hebat, ia juga boleh menyebabkan pepijat jika tidak diuruskan dengan betul. Inilah contoh:

 Biarkan Dynamicvar = 'Hello'; // String
DynamicVar = 42; // sekarang ini nombor
console.log (typeof dynamicvar); // output: nombor

Apabila bekerja dengan jenis data, penting untuk mempertimbangkan prestasi. Sebagai contoh, menggunakan typeof untuk memeriksa jenis pembolehubah biasanya lebih cepat daripada menggunakan instanceof untuk objek. Walau bagaimanapun, instanceof lebih tepat untuk memeriksa sama ada objek adalah contoh kelas tertentu.

 Console.log (Typeof 'Hello'); // output: String
console.log ('hello' instanceof string); // output: palsu

const str = rentetan baru ('hello');
console.log (typeof str); // output: objek
console.log (stretsof string); // output: benar

Dari segi amalan terbaik, sentiasa berhati -hati dengan paksaan jenis. JavaScript sering cuba menukar nilai kepada jenis biasa apabila melakukan operasi, yang boleh membawa kepada hasil yang tidak dijangka. Contohnya:

 Console.log ('5' 5); // output: 55 (penyebaran rentetan)
Console.log ('5' - 5); // output: 0 (pengurangan angka)

Untuk mengelakkan isu -isu ini, gunakan === untuk pemeriksaan kesamaan yang ketat, yang membandingkan kedua -dua nilai dan jenis, bukannya == , yang boleh menyebabkan taipkan paksaan.

 Console.log ('5' == 5); // output: benar
Console.log ('5' === 5); // output: palsu

Kesimpulannya, pemahaman jenis data JavaScript adalah penting untuk menulis kod yang mantap dan cekap. Dengan menguasai konsep -konsep ini, anda akan dilengkapi dengan lebih baik untuk mengendalikan kerumitan JavaScript dan mengelakkan perangkap biasa. Ingat, kunci untuk menjadi pemaju JavaScript yang mahir bukan hanya mengetahui sintaks tetapi memahami mekanik bahasa yang mendasari bahasa tersebut. Terus bereksperimen, dan jangan takut untuk menyelam jauh ke dalam nuansa jenis data JavaScript.

Atas ialah kandungan terperinci Jenis Data JavaScript: menyelam yang mendalam. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!