Membaca artikel ini membutuhkan pengalaman pemrograman dalam bahasa lain.
Jenis sederhana dalam JavaScript meliputi:
1. Angka
2. String
3. Boolean (Benar dan Salah)
4.Null
5. Dipahami
Tipe lain adalah objek (kita tidak boleh bingung dengan nilai pengembalian operator tipe dari), misalnya:
1. Fungsi
2.array
3. Ekspresi reguler
4. Objek (objek adalah objek alami)
Dasar Objek
Dalam JavaScript, objek adalah koleksi properti (objek adalah array asosiatif), setiap properti termasuk:
1. Nama atribut harus berupa string
2. Nilai atribut dapat berupa nilai apa pun selain tidak ditentukan
Buat objek melalui objek literal:
Salinan kode adalah sebagai berikut:
// Buat objek kosong melalui objek literal {}
var kosong_object = {};
Nama atribut dan nilai atribut objek:
Salinan kode adalah sebagai berikut:
var stande = {
// "nama depan" adalah nama atribut, dan "Jerome" adalah nilai atribut
"Nama depan": "Jerome",
// "Name Terakhir" adalah nama atribut, dan "Howard" adalah nilai atribut
"Nama terakhir": "Howard"
};
Jika nama atribut adalah pengidentifikasi hukum, tanda kutip dapat dihilangkan:
Salinan kode adalah sebagai berikut:
var flight = {
Maskapai: "Oceanic",
Nomor: 815,
departemen: {
Iata: "Syd",
Waktu: "2004-09-22 14:55",
Kota: "Sydney"
},
kedatangan: {
Iata: "longgar",
Waktu: "2004-09-23 10:42",
Kota: "Los Angeles"
}
};
Mari kita lihat contoh akses properti:
Salinan kode adalah sebagai berikut:
var pemilik = {name: "name5566"};
pemilik.name; // "name5566"
pemilik ["name"]; // "name5566"
pemilik.job; // belum diartikan
pemilik.job = "coder"; // atau pemilik ["job"] = "coder";
Jika nama atribut bukan pengidentifikasi hukum, itu perlu dibungkus dengan kutipan. Nilai properti yang tidak ada tidak terdefinisi. Objek dilewatkan dengan referensi daripada berdasarkan nilai:
Salinan kode adalah sebagai berikut:
var x = {};
var pemilik = x;
pemilik.name = "name5566";
x.name; // x.name === "name5566"
Di sini X dan pemilik merujuk ke objek yang sama.
Atribut suatu objek dapat dihapus menggunakan operator hapus:
Salinan kode adalah sebagai berikut:
hapus obj.x; // hapus atribut x objek obj
Prototipe objek
Setiap objek ditautkan ke objek prototipe, dan objek dapat mewarisi atribut dari objek prototipe. Kami membuat objek melalui objek literal, yang objek prototipenya adalah objek.prototype objek (objek.prototype objek itu sendiri tidak memiliki objek prototipe). Saat kami membuat objek, kami dapat mengatur objek prototipe objek (dan kemudian membahas metode pengaturan spesifik). Saat mencoba untuk mendapatkan (tidak memodifikasi) atribut suatu objek, jika objek tidak ada, JavaScript mencoba untuk mendapatkan atribut dari objek prototipe objek ini, jika tidak ada atribut tersebut dalam objek prototipe, kemudian lihat dari objek prototipe objek prototipe ini, dan sebagainya hingga objek. Objek prototype prototype. Dibandingkan dengan mendapatkan atribut, ketika kami memodifikasi atribut objek, itu tidak akan mempengaruhi objek prototipe.
Dasar -dasar fungsional
Fungsi juga merupakan objek dalam JavaScript, yang ditautkan ke objek prototipe function.prototype (tautan Function.prototype ke objek.prototype). Fungsi ini memiliki properti bernama prototipe, dan nilainya adalah objek. Objek ini memiliki konstruktor properti, dan nilai konstruktor adalah fungsi ini:
Salinan kode adalah sebagai berikut:
var f = function () {}
tipe f.prototype; // 'objek'
typeof f.prototype.constructor; // 'fungsi'
f === f.prototype.constructor; // BENAR
Fungsi adalah objek, Anda dapat menggunakan fungsi seperti menggunakan objek, yaitu, fungsi dapat disimpan dalam variabel dan array, dan dapat dilewatkan sebagai parameter untuk fungsi, dan fungsi dapat didefinisikan dalam fungsi. Sebagai catatan tambahan, fungsi memiliki dua properti tersembunyi:
1. Konteks fungsi
2. Kode fungsi
Fungsi dibuat sebagai berikut:
Salinan kode adalah sebagai berikut:
var f = fungsi add (a, b) {
mengembalikan A + B;
}
console.log (f); // output [fungsi: tambahkan]
Nama fungsi setelah fungsi kata kunci adalah opsional. Kami merumuskan nama fungsi terutama untuk beberapa tujuan:
1. Untuk panggilan rekursif
2. Debuggers, alat pengembangan, dll digunakan untuk mengidentifikasi fungsi
Berkali -kali kita tidak memerlukan nama fungsi, dan fungsi tanpa nama fungsi disebut fungsi anonim. Daftar parameter dibungkus dengan tanda kurung. JavaScript tidak memerlukan pencocokan parameter nyata dan parameter formal, misalnya:
Salinan kode adalah sebagai berikut:
var add = function (a, b) {
mengembalikan A + B;
}
Tambahkan (1, 2, 3); // parameter aktual dan parameter formal tidak cocok
Jika ada terlalu banyak parameter nyata, maka parameter nyata kelebihan akan diabaikan. Jika ada terlalu sedikit parameter nyata, maka nilai parameter formal yang belum ditugaskan tidak terdefinisi. Fungsi harus memiliki nilai pengembalian. Jika nilai pengembalian tidak ditentukan melalui pernyataan pengembalian, nilai fungsi pengembalian tidak terdefinisi.
Fungsi dan variabel eksternal yang diaksesnya membentuk penutupan. Ini adalah pesona utama JavaScript.
Panggilan Fungsi
Ketika setiap fungsi dipanggil, dua parameter tambahan diterima:
1. ini
2.Argumen
Nilai ini terkait dengan pola panggilan spesifik. Ada empat pola panggilan di JavaScript:
1. Mode panggilan metode. Jika properti objek adalah fungsi, itu disebut metode. Jika metode dipanggil melalui OM (args), ini adalah objek O (yang dapat dilihat bahwa ini dan O terikat hanya jika dipanggil), misalnya:
Salinan kode adalah sebagai berikut:
var obj = {
Nilai: 0,
increment: function (v) {
this.value += (typeof v === 'Number'? V: 1);
}
};
obj.increment (); // ini === OBJ
2. Mode Panggilan Fungsi. Jika suatu fungsi bukan properti objek, itu akan disebut sebagai fungsi, dan ini terikat pada objek global, misalnya:
Salinan kode adalah sebagai berikut:
pesan = 'halo dunia';
var p = function () {
console.log (this.message);
}
P(); // output 'hello world'
Perilaku ini terkadang membingungkan, lihat sebuah contoh:
Salinan kode adalah sebagai berikut:
obj = {
Nilai: 0,
increment: function () {
var helper = function () {
// Tambahkan 1 ke nilai dalam objek global
this.value += 1;
}
// helper disebut sebagai fungsi
// Oleh karena itu ini adalah objek global
pembantu();
}
};
obj.increment (); // obj.value === 0
Hasil yang kami harapkan harus:
Salinan kode adalah sebagai berikut:
obj = {
Nilai: 0,
increment: function () {
var itu = ini;
var helper = function () {
itu.value += 1;
}
pembantu();
}
};
obj.increment (); // obj.value === 1
3. Mode Panggilan Konstruktor. Fungsi yang bermaksud menggunakan awalan baru disebut konstruktor, misalnya:
Salinan kode adalah sebagai berikut:
// tes disebut konstruktor
var test = function (string) {
this.message = string;
}
var mytest = tes baru ("halo dunia");
Fungsi dapat dipanggil dengan baru (fungsi seperti itu biasanya dimulai dengan kapitalisasi). Setelah menambahkan yang baru, objek yang ditautkan ke properti prototipe fungsi ini akan dibuat, dan objek ini dalam konstruktor adalah objek ini.
4. Terapkan mode panggilan. Metode aplikasi dari fungsi digunakan untuk memanggil fungsi, yang memiliki dua parameter, yang pertama adalah ini dan yang kedua adalah array parameter, misalnya:
Salinan kode adalah sebagai berikut:
var add = function (a, b) {
mengembalikan A + B;
}
var ret = add.Apply (null, [3, 4]); // ret === 7
Saat memanggil fungsi, kita dapat mengakses array kelas yang disebut argumen (array javascript non-real) yang berisi semua argumen, sehingga kita dapat menerapkan parameter panjang variabel:
Salinan kode adalah sebagai berikut:
var add = function () {
var sum = 0;
untuk (var i = 0; i <arguments.length; ++ i) {
jumlah += argumen [i];
}
jumlah pengembalian;
}
Tambahkan (1, 2, 3, 4);
abnormal
Sekarang mari kita bicara tentang mekanisme penanganan pengecualian JavaScript. Kami menggunakan pernyataan lemparan untuk melempar pengecualian, dan pernyataan try-cache untuk menangkap dan menangani pengecualian:
Salinan kode adalah sebagai berikut:
var add = function (a, b) {
if (typeof a! == 'number' || typeof b! == 'nomor') {
// Lemparkan pengecualian
melemparkan {
Nama: 'TypeError',
Pesan: 'Tambahkan Nomor Kebutuhan'
};
}
mengembalikan A + B;
}
// Tangkap dan tangani pengecualian
mencoba {
tambahkan ("tujuh");
// E adalah objek pengecualian yang dilemparkan
} catch (e) {
console.log (e.name + ':' + e.message);
}
Tambahkan properti ke jenis JavaScript
Konstruktor ada di sebagian besar jenis di JavaScript:
1. Konstruktor objek adalah objek
2. Konstruktor array adalah array
3. Konstruktor fungsi adalah fungsi
4. Konstruktor string adalah string
5. Konstruktor nomornya adalah nomor
6. Konstruktor Boolean adalah Boolean
7. Konstruktor ekspresi reguler adalah RegExp
Kami dapat menambahkan properti (sering menambahkan metode) ke prototipe konstruktor sehingga properti ini tersedia untuk variabel terkait:
Salinan kode adalah sebagai berikut:
Number.prototype.integer = function () {
mengembalikan matematika [ini <0? 'ceil': 'floor'] (this);
}
(1.1) .Integer (); // 1
Cakupan
JavaScript perlu membangun lingkup melalui fungsi:
Salinan kode adalah sebagai berikut:
fungsi() {
// ...
} ();
Fungsi anonim dibuat dan dieksekusi di sini. Ruang lingkup untuk menyembunyikan variabel yang tidak ingin Anda ungkapkan:
Salinan kode adalah sebagai berikut:
var obj = function () {
// Sembunyikan nilai, tidak dapat diakses secara eksternal
nilai var = 0;
kembali {
// Hanya metode ini yang dapat memodifikasi nilainya
increment: function () {
nilai += 1;
},
// Hanya metode ini yang dapat membaca nilai
getValue: function () {
nilai pengembalian;
}
};
} ();
obj.increment ();
obj.getValue () === 1;
mewarisi
Ada banyak cara untuk menerapkan warisan dalam JavaScript.
Saat membuat objek, kita dapat mengatur objek prototipe yang terkait dengan objek, dan kita lakukan:
Salinan kode adalah sebagai berikut:
// Buat objek o dengan objek prototipe {x: 1, y: 2}
var o = object.create ({x: 1, y: 2});
Metode Object.Create didefinisikan dalam ecmascript 5. Jika Anda menggunakan ecmascript 3, Anda dapat menerapkan metode Buat sendiri:
Salinan kode adalah sebagai berikut:
// Jika metode objek.Create tidak didefinisikan
if (typeof object.create! == 'function') {
// buat metode objek.create
Objek.create = function (o) {
var f = function () {};
F.prototype = o;
// Buat objek baru, objek prototipe dari objek ini adalah o
mengembalikan f baru ();
};
}
Melalui metode Object.Create, kami melakukan pewarisan berbasis prototipe: Objek baru secara langsung mewarisi sifat-sifat objek lama (relatif terhadap pewarisan berbasis kelas, tidak perlu untuk keberadaan kelas di sini, dan objek secara langsung mewarisi objek). contoh:
Salinan kode adalah sebagai berikut:
var mymammal = {
Nama: 'Ramuan Mamalia',
get_name: function () {
kembalikan nama ini;
},
mengatakan: function () {
kembalikan ini.saying || '';
}
};
// mewarisi mymammal
var mycat = object.create (myMammal);
mycat.name = 'Henrietta';
mycat.saying = 'meow';
mycat.purr = function (n) {
var i, s = '';
untuk (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
kembali S;
};
mycat.get_name = function () {
kembalikan this.says () + '' + this.name + '' + this.says ();
};
Kode di atas sederhana, tetapi tidak dapat melindungi anggota pribadi. Kita dapat menggunakan mode modul. Dalam mode modul, jenis objek tertentu dihasilkan oleh fungsi dan menggunakan ruang lingkup fungsi untuk melindungi anggota pribadi dari akses eksternal:
Salinan kode adalah sebagai berikut:
// fungsi mamalia, digunakan untuk membangun objek mamalia
var mammal = function (spec) {
// Itu adalah objek yang dibangun
var that = {};
// metode publik get_name dapat diakses secara eksternal
that.get_name = function () {
// spec.name tidak dapat diakses langsung dari luar
return spec.name;
};
// Metode publik mengatakan dapat diakses secara eksternal
itu.says = function () {
// spec.saying Tidak ada akses langsung ke eksternal
return spec.saying || '';
};
kembalikan itu;
};
// Buat objek mamalia
var mymammal = mammal ({name: 'herb'});
// fungsi kucing, digunakan untuk membuat objek kucing
var cat = function (spec) {
spec.saying = spec.saying || 'Meow';
// Cat mewarisi dari mamalia, jadi pertama -tama buat objek mamalia
var that = mamalia (spec);
// Tambahkan metode publik Purr
itu.purr = function (n) {
var i, s = '';
untuk (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
kembali S;
};
// Ubah metode publik get_name
that.get_name = function () {
return that.says () + '' + spec.name +
'' + that.says ();
kembalikan itu;
};
};
// Buat objek kucing
var mycat = cat ({name: 'henrietta'});
Dalam mode modul, warisan dicapai dengan memanggil konstruktor. Selain itu, kami juga dapat mengakses metode kelas induk di subclass:
Salinan kode adalah sebagai berikut:
Object.prototype.superior = function (name) {
var that = this, method = itu [nama];
return function () {
return method.Apply (itu, argumen);
};
};
var coolcat = function (spec) {
// Dapatkan metode get_name dari subkelas
var that = cat (spec), super_get_name = that.superior ('get_name');
itu.get_name = function (n) {
return 'like' + super_get_name () + 'baby';
};
kembalikan itu;
};