Ketika kita berbicara tentang orientasi objek, kita dapat memikirkan kelas, objek, pengemasan, warisan, polimorfisme. Dalam buku "Javascript Advanced Program Design" (People's Post dan Telecommunications Press, Cao Li, Zhang Xin. Nama bahasa Inggris adalah: JavaScript profesional untuk pengembang web) dijelaskan dalam buku ini. Mari kita lihat berbagai metode yang ditentukan dalam JavaScript.
1. Metode pabrik
Buat kelas dan objek kita sendiri di JavaScript, kita harus menguasai.
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
var ocar = objek baru ();
ocar.color = "merah";
ocar.doors = 4;
ocar.showcolor = function () {
Waspada (this.color);
}
// Panggilan
ocar.showcolor ();
</script>
Kami mudah menggunakan objek OCAR, tetapi kami membuat beberapa instance mobil. Kita dapat menggunakan fungsi untuk merangkum kode di atas untuk diimplementasikan:
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
fungsi createCar () {
var ocar = objek baru ();
ocar.color = "merah";
ocar.doors = 4;
ocar.showcolor = function () {
Waspada (this.color);
}
Mengembalikan ocar;
}
// Panggilan
var ocar1 = createCar ();
var ocar2 = createCar ();
ocar1.color = "hitam";
ocar1.showcolor ();
ocar2.showcolor ();
</script>
Ngomong -ngomong, atribut keanggotaan default dari objek JavaScript bersifat publik. Dengan cara ini, kami menyebutnya metode pabrik, dan kami telah membuat pabrik yang dapat membuat dan mengembalikan jenis objek tertentu.
Ini sedikit menarik, tetapi dalam objek yang berorientasi objek, metode membuat objek adalah:
Mobil mobil = mobil baru ();
Penggunaan kata kunci baru telah berakar dalam hati orang -orang, jadi kami menggunakan metode di atas untuk mendefinisikannya. . Mari kita lihat definisi bentuk konstruktor.
2. Konstruktor
Metode ini terlihat seperti fungsi pabrik. Kinerja spesifik adalah sebagai berikut:
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
Function Car (Color, Doors) {
this.color = warna;
this.doors = pintu;
this.showcolor = function () {
Waspada (this.color);
};
}
// Panggilan
var car1 = mobil baru ("merah", 4);
var car2 = mobil baru ("biru", 4);
car1.showcolor ();
car2.showcolor ();
</script>
Terlihat jelas, ada perbedaan. Rasanya agak menarik. Buat objek di dalam fungsi pembuatan menggunakan kata kunci ini, dan rasanya sangat baik untuk membuat objek menggunakan simbol komputasi baru. Tetapi ada juga beberapa masalah: setiap kali objek baru dibuat, semua atribut, termasuk penciptaan fungsi, yaitu bahwa banyak objek sepenuhnya independen. Objek CAR1 dan objek CAR2 keduanya. Ini adalah keuntungan dari bentuk aslinya.
3. Prototipe
Menggunakan atribut prototipe objek, Anda dapat melihat prototipe yang bergantung pada objek baru. Metode ini adalah sebagai berikut:
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
fuintict car () {
};
Car.prototype.color = "merah";
Car.prototype.doors = 4;
Car.prototype.drivers = array baru ("tom", "jerry");
Car.prototype.showcolor = function () {
Waspada (this.color);
}
// Panggilan:
var car1 = mobil baru ();
var car2 = mobil baru ();
car1.showcolor ();
car2.showcolor ();
peringatan (car1.drivers);
car1.drivers.push ("Stephen");
peringatan (car1.drivers);
peringatan (car2.drivers);
// Anda dapat menggunakan JSON untuk menyederhanakan definisi prototipe:
Car.prototype =
{{
Warna: "Merah",
Pintu: 4,
Pengemudi: ["Tom", "Jerry", 'Safdad'],
showColor: function () {
Waspada (this.color);
}
}
</script>
Pertama -tama, konstruktor kode ini, tidak ada kode, dan kemudian menambahkan atribut objek untuk menentukan atribut objek mobil melalui atribut prototipe objek. Metode ini sangat bagus, tetapi masalahnya adalah bahwa objek mobil menunjuk ke pointer array. Car2 juga pada saat yang sama, ini tidak diperbolehkan.
Pada saat yang sama, masalahnya juga dimanifestasikan dalam prototipe yang tidak dapat membawa parameter inisialisasi, yang membuat konstruktor tidak dapat menginisialisasi secara normal. Ini membutuhkan cara lain untuk menyelesaikan: yaitu mode konstruktor/prototipe campuran.
4. Mode Konstruktor/Prototipe Campuran
Kombinasi konstruktor dan prototipe sangat nyaman untuk menentukan kelas.
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
Fungsi mobil (warna, pintu)
{{
this.color = warna;
this.doors = pintu;
this.drivers = array baru ("tom", "jerry");
}
Car.prototype.showcolor = function () {
Waspada (this.color);
}
// Panggilan:
var car1 = mobil baru ('merah', 4);
var car2 = mobil baru ('biru', 4);
car1.showcolor ();
car2.showcolor ();
peringatan (car1.drivers);
car1.drivers.push ("Stephen");
peringatan (car1.drivers);
peringatan (car2.driver); // Hasil: Tom, Jerry
Peringatan (car1 instance dari mobil);
</script>
Metode ini adalah untuk menentukan atribut di dalam, dan menggunakan prototipe untuk mendefinisikannya di luar. Masalah menyelesaikan metode ketiga.
Metode ini seharusnya sangat ramah, tetapi dibandingkan dengan tata bahasa Java, harus ada beberapa ketidakharmonisan, dan rasanya lebih berantakan. Untuk personel R&D J2EE, metode ini selalu canggung. Itu selalu merasa bahwa itu bukan kemasan yang ramah , dianggap lebih merepotkan. Itu adalah prototipe dinamis.
5. Prototipe dinamis
Untuk pengembang yang terbiasa menggunakan bahasa lain, penggunaan konstruktor/prototipe campuran tidak terlalu harmonis. Bagaimanapun, ketika mendefinisikan kategori, sebagian besar bahasa berorientasi objek dikemas secara visual pada atribut dan metode. Pertimbangkan kelas C#berikut:
Salin kode kode sebagai berikut:
Kelas Mobil // Kelas
{{
warna string publik = "merah";
Pintu int publik = 4;
Publik int mpg = 23;
mobil publik (warna string, pintu int, int mpg) // konstruktor
{{
this.color = warna;
this.doors = pintu;
this.mpg = mpg;
}
public void showcolor () // medhod
{{
Console.WriteLine (this.color);
}
}
C#dikemas dengan baik semua atribut dan metode kelas mobil, jadi ketika Anda melihat kode ini, Anda tahu fungsi apa yang harus dicapai, dan mendefinisikan informasi objek. Orang yang mengkritik konstruktor/prototipe konstruktor campuran percaya bahwa metode menemukan atribut dalam memori konstruktor, dan metode menemukan metode di luarnya tidak logis. Oleh karena itu, mereka merancang prototipe dinamis untuk memberikan gaya pengkodean yang lebih ramah.
Gagasan dasar metode prototipe dinamis sama dengan konstruktor/prototipe dari struktur campuran, yaitu, mendefinisikan atribut non -fungsi dalam konstruktor, dan atribut fungsi didefinisikan menggunakan atribut prototipe. Satu -satunya perbedaan adalah posisi metode objek. Berikut ini adalah kelas mobil yang ditulis ulang dengan prototipe dinamis:
Salin kode kode sebagai berikut:
<type skrip = "Teks/JavaScript">
//definisi
fuintict car () {
this.color = "merah";
this.doors = 4;
this.drivers = array baru ("tom", "jerry");
ifof car._initialized == "tidak terdefinisi") {{
Car.prototype.showcolor = function () {
Waspada (this.color);
}
// ............
}
// definisi terakhir
Car._initialized = true;
}
</script>
Sampai memeriksa tipe car._inisialisasi setara yang sama dengan "tidak ditentukan", konstruktor ini tidak berubah. Baris kode ini adalah bagian terpenting dari metode prototipe dinamis. Jika nilai ini tidak didefinisikan, konstruktor akan terus menentukan metode objek dengan prototipe, dan kemudian atur car._initialized ke true. Jika nilai ini didefinisikan (ketika nilainya benar, nilai tipeof adalah boolean), maka metode ini tidak akan dibuat. Singkatnya, metode ini menggunakan logo (_initialized) untuk menentukan apakah telah memberikan metode apa pun pada prototipe. Metode ini hanya dibuat dan ditugaskan sekali.
6 Metode Pabrik Hibrida
Metode ini biasanya merupakan cara untuk mengubah cara ketika metode sebelumnya tidak dapat diterapkan. Tujuannya adalah untuk membuat konstruktor palsu dan hanya mengembalikan contoh baru dari objek lain. Kode ini tampaknya sangat mirip dengan fungsi pabrik:
Salin kode kode sebagai berikut:
fuintict car () {
var ompcar = objek baru ();
ionmpcar.color = "merah";
ionmpcar.doors = 4;
ionmpcar.mpg = 23;
ionmpcar.showcolor = function () {
Waspada (this.color);
}
Mengembalikan otempcar;
}
Berbeda dari metode klasik, metode ini menggunakan operator baru agar terlihat seperti fungsi struktur nyata:
var ocar = mobil baru ();
Karena operator baru dipanggil di dalam konstruktor mobil (), operator baru kedua akan diabaikan (terletak di luar konstruktor). Objek yang dibuat dalam konstruktor diteruskan kembali ke variabel var. Metode ini memiliki masalah yang sama dengan metode klasik dari metode objek. Sangat disarankan: kecuali Anda harus (lihat Bab 15), Anda masih menghindari metode ini.
Ringkasan: (metode mana yang digunakan)
Saat ini, yang paling banyak digunakan adalah konstruktor/prototipe campuran. Selain itu, prototipe dinamis juga sangat populer, dan setara dengan fungsi fungsional/prototipe fungsi. Anda dapat menggunakan salah satu dari dua metode ini. Namun, jangan gunakan konstruktor atau prototipe klasik, karena ini akan memperkenalkan kode untuk masalah tersebut.
Salin kode kode sebagai berikut:
// PS
// kelas statis (1: fungsi)
varcollection = function baru () {
var _carcollection = array baru (); // global, pribadi
this.add = function (objcar) {
peringatan ('tambahkan');
}
this.get = function (carid) {
waspada ('dapatkan');
}
}
// Kelas Statis (2: JSON)
var mobil = {
Warna: 'merah',
Pintu: 4,
showColor: function () {waspada (this.color);}
}
Car.showcolor ();