Untuk jenis JavaScript, ini dapat dengan mudah dirangkum sebagai: dibandingkan dengan bahasa yang sangat diketik, itu adalah bahasa tipe yang lemah (longgar); Ada tipe dasar dan tipe referensi, dan mereka adalah perbedaannya adalah bahwa ruang tetap ada dalam memori tumpukan, dan pointer ke lokasi implementasi disimpan dalam memori tumpukan tanpa ruang tetap dan penunjuk ke lokasi implementasi disimpan dalam memori stack.
Banyak buku di pasar memiliki banyak ruang untuk dibicarakan. Artikel ini akan berbicara tentang beberapa aspek, yang mungkin mengharuskan Anda memiliki beberapa pemahaman sederhana tentang JavaScript, terutama jenis JavaScript. Jika Anda belum memahaminya, Anda dapat mengambil buku tentang JavaScript dan membacanya lagi.
1. Jenis Dasar dan Jenis Referensi
1. Tipe Dasar: tidak terdefinisi/nol/boolean/angka/string
2. Jenis Referensi: Objek/Array/Fungsi/Tanggal/Regexp/Kesalahan/Peta/Set…
Mengapa tipe referensi tidak disebutkan? Karena Anda hanya tahu banyak tentang itu, setidaknya dalam artikel saya membicarakannya sudah cukup. Yang lain mungkin jarang digunakan, dan bahkan yang seperti peta dan set tidak didukung oleh semua browser.
2. Penilaian Jenis Javascript
Ada dua operator dalam JavaScript yang dapat digunakan untuk menentukan jenis. Mereka adalah tipe dan contoh, tetapi lingkarannya sangat kecil, dan mereka tidak begitu baik dalam hal itu, dan mereka terkenal tidak dapat diandalkan. Beberapa situasi juga benar, tetapi dalam banyak kasus mereka tidak dapat diandalkan. Lihat saja dan Anda akan tahu:
Salinan kode adalah sebagai berikut:
// Saat andal:
typeof 'sofish' // string
new string ('sofish') instanceof string // true
// Saat itu tidak dapat diandalkan:
typeof [] // objek
typeof null // objek
instance 'sofish' dari string // false
Uh ~ banyak pemula pemula JavaScript dapat bersumpah. Kebanyakan orang sudah memiliki perpustakaan seperti jQuery ketika mereka perlu menggunakan JS. Mereka semua telah merangkumnya sehingga Anda dapat dengan mudah mendeteksi jenis. Tentu saja, pada kenyataannya, tidak merepotkan untuk mendeteksi, karena kalimat "dalam JavaScript, semuanya adalah objek", tentu saja, seperti yang disebutkan dalam banyak dokumen, tidak ditentukan sebenarnya hanyalah atribut global dengan Nan dan Infinity. Anda mungkin tahu. Tetapi "objek" dapat membantu kami:
Salinan kode adalah sebagai berikut:
/* Mendeteksi jenis objek
* @param: obj {objek javascript}
* @param: type {string} js js name dimulai dengan huruf besar
* @return: {boolean}
*/
fungsi adalah (obj, type) {
return object.prototype.tostring.call (obj) .slice (8, -1) === Jenis;
}
Dengan cara ini, kita dapat menggunakan fungsi IS untuk membantu kita menyelesaikan penilaian tipe, dan fungsi sederhana ini memiliki kompatibilitas yang baik dan dapat digunakan dalam proyek Anda. Situasi itu seperti:
Salinan kode adalah sebagai berikut:
adalah ('sofish', 'string') // true
adalah (null, 'null') // true
adalah (set baru (), 'set') // true
3. JavaScript Jenis Konversi
Dalam JavaScript, jenis variabel (properti) dapat diubah. Hal paling umum yang Anda lihat adalah konversi antara string dan angka. Bagaimana cara mengubah 1 + '2' menjadi 12? Penting untuk memahami + operator di sini, yang merupakan operator matematika dan juga tanda hubung di JavaScript. Oleh karena itu, pemula akan sering melihat fenomena yang menarik. Saat menggunakan tanda +, kadang -kadang perhitungannya tidak seperti yang mereka inginkan, tetapi menggunakan tanda - selalu bisa mendapatkan jawaban yang "benar".
Salinan kode adalah sebagai berikut:
1 + '2' // '12'
1 + ( + '2') // 3
1 - '2' // -1
Ini sebenarnya disebabkan oleh peran ganda +. Dalam kode di atas, Anda dapat melihat bahwa ekspresi kedua menggunakan tanda + di depan string, memaksa kelasnya untuk dikonversi menjadi angka. Adapun pemahaman konversi tipe JavaScript, dalam kebanyakan kasus, cukup untuk memahami + memiliki peran ganda. Kelas lain yang dapat dimengerti, yang serupa dapat dimodifikasi dengan tugas/kelebihan beban, dan bahkan termasuk kesalahan:
Salinan kode adalah sebagai berikut:
var err = kesalahan baru ();
console.log (kesalahan instance dari kesalahan); // BENAR
err = 'sofish';
console.log (err); // 'Sofish'
4. Jenis Referensi JavaScript
Ini adalah poin yang sulit dalam artikel ini. Dibandingkan dengan tipe dasar, referensi dapat menambah sifat dan metode ke dalamnya; Referensi adalah nilai serupa yang merupakan referensi, menetapkan nilai jenis referensi ke variabel, dan menunjuk pada nilai yang sama yang disimpan dalam memori heap. Variabel (properti) dapat kelebihan beban, tetapi menyalin akan menjadi hal yang sangat menarik, kami akan membicarakannya secara rinci nanti.
1. Tambahkan Properti dan Metode
Kami akan melihat dalam kode berikut bahwa dengan asumsi kami tidak akan melaporkan kesalahan ke tugas dasar yang serupa, tetapi akan tidak valid saat mengambil:
Salinan kode adalah sebagai berikut:
var arr = [1,2,3];
arr.hello = 'dunia';
console.log (arr.hello); // 'dunia'
var str = 'sofish';
str.hello = 'dunia';
console.log (str.hello); // belum diartikan
2. Operasi merujuk pada nilai jenis
Karena jenis referensi disimpan dalam memori tumpukan adalah referensi, ketika kita menunjuk ke nilai asli yang sama, operasi pada nilai akan mempengaruhi semua referensi; Contoh di sini adalah bahwa penugasan kembali (bukan operasi langsung pada nilai) akan membuat ulang objek dan tidak akan mengubah nilai asli. Misalnya:
Salinan kode adalah sebagai berikut:
var arr = [1,2,3], sofish = arr;
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3, 'halo dunia']
// tipe non-same
sofish = ['bukan ikan']; // Saat Sofish Perubahan Demikian pula, nilai asli tidak akan diubah
Console.log (arr); // [1, 2, 3, 'Hello World']
3. Menyalin nilai jenis referensi
Operasi pada nilai asli akan mempengaruhi semua referensi, yang belum tentu seperti yang kita inginkan. Terkadang kita perlu menyalin objek baru tanpa mempengaruhi referensi lain saat beroperasi. Secara umum, ada beberapa operasi spesifik seperti tanggal / fungsi / regexp ..., terutama karena array dan objek memiliki item tambahan, atribut, dll. Jadi yang perlu kita pahami adalah cara menyalin array dan objek objek.
3.1 Menyalin array
Pada objek array, metode SLICE ada untuk mengembalikan array yang dicegat, dan dalam filter ES5, dll. Juga mengembalikan array baru, jadi kami dapat menggunakan metode ini untuk menyalin.
Salinan kode adalah sebagai berikut:
var arr = [1, 2, 3];
var sofish = arr.slice ();
// Operasi pada array baru tidak akan mempengaruhi array asli
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3]
3.2 Menyalin objek
Dalam menyalin array, kami menggunakan metode Slice. Bahkan, untuk array dan objek, kita dapat menggunakan untuk ... di loop untuk melintasi dan menetapkan nilai untuk disalin.
Salinan kode adalah sebagai berikut:
var obj = {name: 'sofish'}, sofish = {}, p;
untuk (p dalam obj) sofish [p] = obj [p];
// Operasi pada objek baru tidak akan mempengaruhi nilai asli
sofish.say = function () {};
Console.log (OBJ); // {name: 'sofish'}
3.3 Bayangan/Salinan Dalam
Seperti operasi di atas, itulah yang sering kita sebut salinan bayangan. Namun, baik array dan objek dapat memiliki banyak lapisan (dimensi). Salin seperti ini hanya memperhitungkan nilai lapisan atas. Array dan objek dalam nilai yang mungkin masih menunjuk ke objek asli. Misalnya:
Salinan kode adalah sebagai berikut:
var arr = [1, {bio: 'bukan ikan'}], sofish = [], p;
untuk (p in arr) {
Sofish [p] = arr [p];
}
// Operasi pada objek `cat` yang terkandung dalam` Sofish` mempengaruhi nilai asli
Sofish [1] .bio = 'hackable';
console.log (arr); // [1, cat: {bio: 'hackable'}]
Jadi bagaimana melakukannya? Mari kita gunakan fungsi copy () untuk menyelesaikan masalah ini:
Salinan kode adalah sebagai berikut:
/* Salin objek
* @param: obj {objek javascript} objek asli
* @param: isdeep {boolean} adalah salinan yang dalam
* @return: {JavaScript Object} mengembalikan objek baru
*/
function copy (obj, isDeep) {
var ret = obj.slice? []: {}, p, prop;
// Gunakan dengan fungsi IS
if (! isDeep && is (obj, 'array')) mengembalikan obj.slice ();
untuk (p dalam obj) {
if (! obj.hasownproperty (p)) melanjutkan;
prop = obj [p];
ret [p] = (apakah (prop, 'objek') || adalah (prop, 'array'))?
Salin (prop, isDeep): prop;
}
kembali kembali;
}
Dengan cara ini, kita dapat menyalin array atau objek melalui fungsi salinan (OBJ, ISDEEP). Anda bisa mengujinya:
Salinan kode adalah sebagai berikut:
var arr = [1, {bio: 'bukan ikan'}];
var sofish = copy (arr);
// Salinan dangkal tidak mempengaruhi nilai asli untuk pengoperasian lapisan pertama, tetapi mempengaruhi lapisan kedua
sofish.push ('cat');
console.log (arr); // [1, {bio: 'bukan ikan'}]
Sofish [1] .bio = 'Hello World';
console.log (arr) // [1, {bio: 'hello world'}]
// salinan dalam tidak akan mempengaruhi nilai aslinya
sofish = salin (arr, 1);
Sofish [1] .bio = 'foo atau bar';
console.log (arr); // [1, {bio: 'halo dunia'}]
Itu saja. Anda pada dasarnya harus memahami poin yang lebih sulit tentang jenis. Tentu saja, replikasi adalah titik yang paling merepotkan. Selain array dan objek yang sering membutuhkan operasi, ada juga replikasi tanggal/fungsi/regexp.