Jenis data dan pembolehubah

Jenis data

Komputer, seperti namanya, ialah mesin yang boleh melakukan pengiraan matematik Oleh itu, program komputer secara semula jadi boleh mengendalikan pelbagai nilai berangka. Walau bagaimanapun, komputer boleh memproses lebih daripada sekadar nilai berangka Mereka juga boleh memproses pelbagai data seperti teks, grafik, audio, video, halaman web, dll. Data yang berbeza memerlukan definisi jenis data yang berbeza. Jenis data berikut ditakrifkan dalam JavaScript:

Nombor

JavaScript tidak membezakan antara integer dan nombor titik terapung, dan diwakili secara seragam oleh Nombor Jenis nombor ：

123; // Integer 1230.456; // Nombor titik terapung 0.4561.2345e3; // Notasi saintifik mewakili 1.2345x1000, yang bersamaan dengan 1234.5-99; mewakili Bukan Nombor, Apabila hasilnya tidak boleh dikira, gunakan NaN untuk mewakili Infiniti; // Infiniti mewakili infiniti Apabila nilai melebihi nilai maksimum yang boleh diwakili oleh Nombor JavaScript, ia diwakili sebagai Infiniti

<🎜. > Memandangkan komputer menggunakan perduaan, Oleh itu, kadangkala adalah lebih mudah untuk menggunakan perenambelasan untuk mewakili integer diwakili oleh awalan 0x dan 0-9, a-f, contohnya: 0xff00, 0xa5b4c3d2, dsb. Mereka betul-betul sama dengan. nilai yang diwakili oleh perpuluhan.

Nombor boleh secara langsung melakukan empat operasi aritmetik Peraturannya konsisten dengan matematik:

1 + 2; // 3(1 + 2) * 5 / 2; // 7.52 / 0; // Infinity0 / 0; // NaN10 % 3; // 110.5 % 3; // 1.5

Perhatikan bahawa % ialah operasi selebihnya.

Rentetan

Rentetan ialah sebarang teks yang disertakan dalam petikan tunggal ' atau petikan berganda ", seperti 'abc', "xyz", dll. Sila ambil perhatian , ' ' atau "" itu sendiri hanyalah perwakilan, bukan sebahagian daripada rentetan itu, rentetan 'abc' hanya mempunyai 3 aksara: a, b, c

Nilai Boolean<🎜 🎜>Perwakilan nilai Boolean dan algebra Boolean adalah betul-betul sama Nilai Boolean hanya mempunyai dua nilai: benar dan salah, sama ada benar atau salah Anda boleh terus menggunakan benar atau salah untuk mewakili nilai Boolean. atau anda boleh menggunakan Boolean Operasi dikira:

benar // Ini adalah nilai palsu 2 > 3; // Ini ialah Nilai palsu

&& operasi DAN hanya jika semuanya benar, hasil operasi && adalah benar:

benar && /; / Hasil pernyataan && ini adalah benar && salah; // Pernyataan && ini dinilai salah && benar && salah // Pernyataan && ini dinilai salah

|| operasi, asalkan salah satu daripadanya adalah benar, |. |Hasil operasi adalah benar:

salah || pernyataan menilai kepada benar ||. // Kenyataan ini menilai kepada benar

! Operasi ini adalah satu operator yang bertukar menjadi benar dan salah menjadi benar: // Hasilnya adalah palsu benar! (2 > 5); // Hasilnya adalah benar

Nilai Boolean sering digunakan dalam pertimbangan bersyarat, seperti:

var age = 15;if (age >= 18) {
    alert('adult');
} else {
    alert('teenager');
}

Operator perbandingan

Apabila kita membandingkan Nombor, kita boleh mendapatkan nilai Boolean melalui pengendali perbandingan:

2 > 5; // false5 >= 2; // true7 == 7; // true

Malah, JavaScript membenarkan perbandingan mana-mana jenis data:

false == 0; // truefalse === 0; // false

Jadilah istimewa Perhatikan pengendali kesamarataan ==. Apabila JavaScript direka, terdapat dua operator perbandingan:

Yang pertama ialah == perbandingan, yang akan menukar jenis data secara automatik dan kemudian membandingkannya Dalam banyak kes, hasil yang sangat pelik akan diperolehi >

Jenis kedua ialah === perbandingan, yang tidak menukar jenis data secara automatik Jika jenis data tidak konsisten, palsu akan dikembalikan.

Disebabkan kecacatan reka bentuk ini dalam JavaScript, jangan gunakan == perbandingan dan sentiasa berpegang pada === perbandingan.

Satu lagi pengecualian ialah NaN Nombor istimewa ini tidak sama dengan semua nilai lain, termasuk dirinya sendiri:

NaN === NaN; // false

The satu-satunya cara untuk menentukan NaN adalah melalui fungsi isNaN():

isNaN(NaN); // true

Akhir sekali, perhatikan perbandingan kesamaan nombor titik terapung:

1 / 3 === (1 - 2 / 3); // palsu

Ini bukan kecacatan reka bentuk dalam JavaScript. Nombor titik terapung menghasilkan ralat semasa operasi kerana komputer tidak dapat mewakili perpuluhan berulang tak terhingga dengan tepat. Untuk membandingkan sama ada dua nombor titik terapung adalah sama, anda hanya boleh mengira nilai mutlak perbezaannya untuk melihat sama ada ia kurang daripada ambang tertentu:

Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // benar

null dan undefined

null mewakili nilai "kosong", yang berbeza daripada 0 dan kosong string'', 0 Merupakan nilai berangka, '' mewakili rentetan panjang 0, dan null mewakili "kosong".

Dalam bahasa lain, terdapat juga perwakilan null yang serupa dengan JavaScript Contohnya, Java juga menggunakan null, Swift menggunakan nil, dan Python menggunakan None. Walau bagaimanapun, dalam JavaScript, terdapat juga undefined, yang serupa dengan null, yang bermaksud "undefined".

Pereka JavaScript ingin menggunakan null untuk mewakili nilai kosong dan undefined untuk mewakili nilai yang tidak ditentukan. Fakta telah membuktikan bahawa ini tidak berguna, dan perbezaan antara kedua-duanya tidak begitu penting. Dalam kebanyakan kes, kita harus menggunakan null. undefined hanya berguna apabila menentukan sama ada parameter fungsi diluluskan.

Array

Array ialah koleksi yang disusun mengikut tertib, dan setiap nilai koleksi dipanggil elemen. Tatasusunan JavaScript boleh mengandungi sebarang jenis data. Contohnya:

[1, 2, 3.14, 'Hello', null, true];

Tatasusunan di atas mengandungi 6 elemen. Tatasusunan diwakili oleh [], dan elemen dipisahkan dengan ,.

Cara lain untuk mencipta tatasusunan ialah melalui fungsi Array():

new Array(1, 2, 3); // Array tercipta [1, 2, 3]

Walau bagaimanapun, demi kebolehbacaan kod, amat disyorkan untuk menggunakan [] secara langsung.

Elemen tatasusunan boleh diakses melalui indeks. Sila ambil perhatian bahawa nilai permulaan indeks ialah 0:

var arr = [1, 2, 3.14, 'Hello', null, true];
arr[0]; // 返回索引为0的元素，即1arr[5]; // 返回索引为5的元素，即truearr[6]; // 索引超出了范围，返回undefined

Objek

Objek JavaScript ialah koleksi nilai kunci yang tidak tertib, contohnya:

var person = {
    name: 'Bob',
    age: 20,
    tags: ['js', 'web', 'mobile'],
    city: 'Beijing',
    hasCar: true,
    zipcode: null};

Kunci objek JavaScript adalah semua jenis rentetan, dan nilainya boleh daripada sebarang jenis data. Objek orang di atas mentakrifkan sejumlah 6 pasangan nilai kunci, setiap satu daripadanya juga dipanggil atribut objek Sebagai contoh, atribut nama orang ialah 'Bob' dan atribut kod zip adalah nol.

Untuk mendapatkan atribut objek, kami menggunakan pembolehubah objek. Nama atribut:

person.name; // 'Bob'person.zipcode; >

Pembolehubah

Konsep pembolehubah pada asasnya adalah sama dengan pembolehubah persamaan dalam algebra sekolah menengah rendah, kecuali dalam program komputer, pembolehubah bukan sahaja boleh menjadi nombor, tetapi juga boleh menjadi sebarang jenis data.

Pembolehubah diwakili oleh nama pembolehubah dalam JavaScript Nama pembolehubah ialah gabungan huruf besar dan huruf kecil Inggeris, nombor, $ dan _, dan tidak boleh bermula dengan nombor. Nama pembolehubah tidak boleh menjadi kata kunci JavaScript, seperti if, while, dsb. Untuk mengisytiharkan pembolehubah, gunakan penyataan var, contohnya:

var a; // Pembolehubah a diisytiharkan, dan nilai a tidak ditentukanvar $b = 1; dan nilai diberikan kepada $b , pada masa ini nilai $b ialah 1var s_007 = '007' // s_007 ialah rentetan var Jawapan = benar // Jawapan ialah nilai Boolean t = null; Nilai t adalah batal

Nama pembolehubah juga boleh dalam bahasa Cina, tetapi tolong jangan menimbulkan masalah untuk diri sendiri.

Dalam JavaScript, gunakan tanda sama = untuk menetapkan nilai kepada pembolehubah. Sebarang jenis data boleh ditugaskan kepada pembolehubah yang sama boleh ditetapkan berulang kali, dan ia boleh menjadi pembolehubah jenis yang berbeza Walau bagaimanapun, perlu diingatkan bahawa ia hanya boleh diisytiharkan dengan var, contohnya:

var a = 123; // a的值是整数123a = 'ABC'; // a变为字符串

Jenis pembolehubah ini sendiri tidak tetap Bahasa ini dipanggil bahasa dinamik, dan rakan sejawatannya ialah bahasa statik. Dalam bahasa statik, jenis pembolehubah mesti ditentukan semasa mentakrifkan pembolehubah Jika jenis tidak sepadan semasa memberikan nilai, ralat akan dilaporkan. Contohnya, Java ialah bahasa statik, dan pernyataan tugasan adalah seperti berikut:

int a = 123; // a ialah pembolehubah jenis integer, dan jenisnya diisytiharkan dengan int a = "ABC"; // Ralat: Tidak boleh menetapkan rentetan kepada integer Jenis pembolehubah

Berbanding dengan bahasa statik, bahasa dinamik adalah lebih fleksibel atas sebab ini.

Sila jangan samakan tanda sama dengan pernyataan tugasan dengan tanda sama matematik. Contohnya, kod berikut:

var x = 10;
x = x + 2;

Jika anda faham x = x + 2 secara matematik, ia tidak benar dalam atur cara, penyataan tugasan terlebih dahulu mengira ungkapan x + 2 di sebelah kanan dan mendapat keputusan 12. Kemudian berikan kepada pembolehubah x. Oleh kerana nilai x sebelumnya ialah 10, selepas penugasan semula, nilai x menjadi 12.

mod ketat

Pada permulaan reka bentuk JavaScript, untuk memudahkan pemula belajar, adalah tidak wajib untuk menggunakan var untuk mengisytiharkan pembolehubah. Ralat reka bentuk ini mempunyai akibat yang serius: jika pembolehubah digunakan tanpa pengisytiharan var, maka pembolehubah diisytiharkan secara automatik sebagai pembolehubah global:

i = 10; // i现在是全局变量

Dalam fail JavaScript yang berbeza pada halaman yang sama, Jika tiada perisytiharan var digunakan dan kedua-dua pembolehubah i kebetulan digunakan, pembolehubah i akan mempengaruhi satu sama lain dan menghasilkan keputusan yang salah yang sukar untuk nyahpepijat.

Pembolehubah yang diisytiharkan menggunakan var bukan pembolehubah global Skopnya terhad kepada badan fungsi di mana pembolehubah itu diisytiharkan (konsep fungsi akan diterangkan kemudian). antara satu sama lain dalam badan fungsi yang berbeza.

Untuk membetulkan kecacatan reka bentuk yang serius ini dalam JavaScript, ECMA memperkenalkan mod ketat dalam spesifikasi berikutnya yang dijalankan dalam mod ketat terpaksa mengisytiharkan pembolehubah melalui var. Jika pembolehubah digunakan tanpa menggunakan var, ia akan menyebabkan ralat berjalan .

Cara untuk mendayakan mod ketat adalah dengan menulis dalam baris pertama kod JavaScript:

'gunakan ketat';

Ini ialah rentetan, tidak disokong Penyemak imbas dalam mod ketat akan melaksanakannya sebagai pernyataan rentetan, dan penyemak imbas yang menyokong mod ketat akan membolehkan mod ketat menjalankan JavaScript.

Untuk menguji sama ada penyemak imbas anda boleh menyokong mod ketat:

'gunakan ketat';
// Jika penyemak imbas menyokong mod ketat,
// Kod ReferenceError berikut akan dilaporkan:

abc = 'Hello, world';
alert(abc);

rrree