Kemas kini terakhir: 04/08/2018

Pengaturcaraan berorientasikan objek ialah salah satu paradigma yang dominan dalam pembangunan aplikasi hari ini, dan dalam JavaScript kita juga boleh memanfaatkan sepenuhnya OOP. Pada masa yang sama, berhubung dengan JavaScript, pengaturcaraan berorientasikan objek mempunyai beberapa ciri.

Objek

Dalam topik sebelumnya, kami bekerja dengan data primitif - nombor, rentetan, tetapi data tidak selalu mewakili jenis primitif. Sebagai contoh, jika dalam program kita perlu menggambarkan intipati seseorang yang mempunyai nama, umur, jantina, dan sebagainya, maka secara semula jadi kita tidak akan dapat mewakili intipati seseorang sebagai nombor atau rentetan. Kami memerlukan beberapa baris atau nombor untuk menerangkan orang itu dengan betul. Dalam hal ini, seseorang akan bertindak sebagai struktur kompleks yang kompleks, yang akan mempunyai sifat individu - umur, ketinggian, nama pertama, nama keluarga, dll.

Untuk bekerja dengan struktur sedemikian, JavaScript menggunakan . Setiap objek boleh menyimpan sifat yang menerangkan keadaannya dan kaedah yang menerangkan tingkah lakunya

Mencipta objek baharu

Terdapat beberapa cara untuk mencipta objek baharu.

Cara pertama ialah menggunakan pembina Objek:

Pengguna Var = Objek baru();

Dalam kes ini, objek dipanggil pengguna. Ia ditakrifkan dengan cara yang sama seperti mana-mana pembolehubah biasa menggunakan kata kunci var.

Ungkapan new Object() mewakili panggilan kepada pembina - fungsi yang mencipta objek baru. Operator baru digunakan untuk memanggil pembina. Memanggil pembina pada asasnya seperti memanggil fungsi biasa.

Cara kedua untuk mencipta objek adalah dengan menggunakan pendakap kerinting:

Pengguna Var = ();

Hari ini, kaedah kedua lebih biasa.

Sifat objek

Selepas mencipta objek, kita boleh menentukan sifat padanya. Untuk mentakrifkan harta, anda perlu menentukan nama harta itu selepas nama objek, dipisahkan dengan titik dan memberikan nilai kepadanya:

Pengguna Var = (); user.name = "Tom"; pengguna.umur = 26;

Dalam kes ini, dua nama dan umur sifat diisytiharkan dan diberikan nilai yang sepadan. Selepas itu, kita boleh menggunakan sifat ini, sebagai contoh, memaparkan nilainya dalam konsol:

Console.log(user.name); console.log(user.age);

Anda juga boleh menentukan sifat apabila menentukan objek:

Pengguna Var = ( nama: "Tom", umur: 26 );

Dalam kes ini, aksara bertindih digunakan untuk menetapkan nilai kepada harta dan koma (bukannya koma bernoktah) diletakkan selepas definisi sifat.

Di samping itu, terdapat cara pintasan untuk menentukan sifat:

Nama Var = "Tom"; var umur = 34; var pengguna = (nama, umur); console.log(nama pengguna); // Tom console.log(user.age); // 34

Dalam kes ini, nama pembolehubah juga merupakan nama bagi sifat objek. Dan dengan cara ini anda boleh membuat reka bentuk yang lebih kompleks:

Nama Var = "Tom"; var umur = 34; var pengguna = (nama, umur); var teacher = (pengguna, kursus: "JavaScript"); console.log(guru.pengguna); // (nama: "Tom", umur: 34) console.log(teacher.course); // JavaScript

Kaedah Objek

Kaedah objek menentukan kelakuannya, atau tindakan yang dilakukannya. Kaedah adalah fungsi. Sebagai contoh, mari kita tentukan kaedah yang akan memaparkan nama dan umur seseorang:

Pengguna Var = (); user.name = "Tom"; pengguna.umur = 26; user.display = function())( console.log(user.name); console.log(user.age); ); // method call user.display();

Seperti fungsi, kaedah pertama kali ditakrifkan dan kemudian dipanggil.

Kaedah juga boleh ditakrifkan secara langsung apabila mentakrifkan objek:

Pengguna Var = ( nama: "Tom", umur: 26, paparan: function())( console.log(this.name); console.log(this.age); ) );

Seperti sifat, kaedah diberikan rujukan fungsi menggunakan titik bertindih.

Untuk mengakses sifat atau kaedah objek dalam objek itu, gunakan kata kunci ini. Ia bermaksud rujukan kepada objek semasa.

Anda juga boleh menggunakan cara ringkas untuk menentukan kaedah dengan menghilangkan kolon dan fungsi:

Pengguna Var = ( nama: "Tom", umur: 26, display())( console.log(this.name, this.age); ), move(place)( console.log(this.name, "goes to " , tempat); ) ); user.display(); // Tom 26 user.move("the shop"); //Tom pergi ke kedai

Sintaks tatasusunan

Terdapat juga cara alternatif untuk menentukan sifat dan kaedah menggunakan sintaks tatasusunan:

Pengguna Var = (); pengguna["nama"] = "Tom"; pengguna["umur"] = 26; pengguna["paparan"] = function())( console.log(user.name); console.log(user.age); ); // memanggil pengguna kaedah ["paparan"]();

Nama setiap sifat atau kaedah disertakan dalam tanda petikan dan kurungan segi empat sama, kemudian ia juga diberikan nilai. Contohnya, pengguna["umur"] = 26 .

Apabila mengakses sifat dan kaedah ini, anda boleh sama ada menggunakan notasi titik (user.name) atau gunakan: user["name"]

Rentetan sebagai Sifat dan Kaedah

Ia juga harus diperhatikan bahawa nama sifat dan kaedah objek sentiasa rentetan. Iaitu, kita boleh menulis semula definisi objek sebelumnya seperti ini:

Var pengguna = ( "nama": "Tom", "umur": 26, "paparan": function())( console.log(user.name); console.log(user.age); ) ); // method call user.display();

Di satu pihak, tidak ada perbezaan antara kedua-dua definisi. Sebaliknya, terdapat kes di mana melampirkan tajuk dalam baris boleh membantu. Contohnya, jika nama harta terdiri daripada dua perkataan yang dipisahkan oleh ruang:

Pengguna Var = ( nama: "Tom", umur: 26, "nama penuh": "Tom Johns", "maklumat paparan": function())( console.log(user.name); console.log(user.age ) ; ) ); console.log(pengguna["nama penuh"]); pengguna["maklumat paparan"]();

Hanya dalam kes ini, kita mesti menggunakan sintaks tatasusunan untuk mengakses sifat dan kaedah tersebut.

Mengalih keluar sifat

Di atas kita melihat bagaimana kita boleh menambah sifat baharu secara dinamik pada objek. Walau bagaimanapun, kami juga boleh memadam sifat dan kaedah menggunakan pengendali padam. Dan sama seperti dengan menambah, kita boleh mengalih keluar sifat dalam dua cara. Cara pertama ialah menggunakan notasi titik:

Padam objek.harta

Atau gunakan sintaks tatasusunan:

Padam objek["property"]

Sebagai contoh, mari kita keluarkan harta:

Pengguna Var = (); user.name = "Tom"; pengguna.umur = 26; user.display = function())( console.log(user.name); console.log(user.age); ); console.log(nama pengguna); // Tom delete user.name; // padam harta // alternatif // padam pengguna ["nama"]; console.log(nama pengguna); // tidak ditentukan

Selepas pemadaman, harta itu akan menjadi tidak ditentukan, jadi apabila anda cuba mengaksesnya, program akan mengembalikan nilai yang tidak ditentukan.

Salam sejahtera kepada semua yang membaca penerbitan ini. Hari ini saya ingin membimbing anda melalui alat utama bahasa - objek JavaScript. Biar saya ingatkan anda bahawa js ialah penyemak imbas silang dan berfungsi pada semua sistem pengendalian (tetingkap, mac os, dll.). Tidak seperti bahasa pengaturcaraan berorientasikan objek, pelaksanaan objek dalam js berbeza dengan ketara daripada fungsi biasa dan variasi dalam penggunaan contoh, contohnya, dalam C#.

Oleh itu, selepas membaca artikel semasa, anda akan mempelajari ciri membezakan utama objek skrip, belajar bagaimana ia boleh dibuat, dikemas kini dan dipadamkan. Saya juga akan menyentuh topik sifat, kaedah dan pembina, dan bercakap tentang perintah yang berguna dan tentunya serba sedikit tentang harta pusaka. Saya rasa sudah tiba masanya untuk mula belajar!

Apakah objek dalam JavaScript dan apakah keupayaan yang ada padanya?

Dalam js, objek ialah tatasusunan bersekutu mudah (ia juga dipanggil cincang).

Apakah tatasusunan bersekutu?

Ini ialah struktur data yang menyimpan sejumlah maklumat yang berkaitan dengan dan menerangkan elemen tertentu. Semua data berstruktur dan saling berkaitan sebagai "nilai => kunci".

Sebagai contoh, anda perlu menerangkan kereta. Kemudian anda mencipta objek auto dan menerangkan ciri-cirinya dalam tatasusunan. Saya memutuskan untuk menerangkan jenama kereta (nama), warna (warna) dan kos (harga). Di bawah saya telah melampirkan kod untuk melaksanakan tugas yang diterangkan.

1 2 3 4 5

var avto = ( nama: "BMW 116i", warna: "hitam", harga: 588000 );

var avto = ( nama: "BMW 116i", warna: "hitam", harga: 588000 );

Di sini anda melihat satu cara untuk mencipta objek yang dipanggil "avto". Nama, warna dan harga adalah kunci yang boleh digunakan semasa menulis permohonan.

Saya mendahului diri saya dengan contoh ini, jadi sekarang mari kita lihat semuanya mengikut urutan.

Anda boleh mencipta objek dalam beberapa cara:

var auto = (); atau var auto = new Object();

Dalam kedua-dua kes, objek kosong dicipta dengan nama terkenal, tetapi pilihan pertama digunakan lebih kerap, kerana ia lebih pendek dan lebih mudah untuk ditulis.

Semua tentang hartanah

Sekarang anda perlu mengisi objek kosong dengan parameter. Untuk melakukan ini, anda perlu menambah sifat, yang saya juga panggil kunci di atas. Sekali lagi, terdapat dua cara untuk mengisytiharkan harta.

Saya ingin ambil perhatian bahawa JavaScript tidak mempunyai rangka kerja yang ketat untuk mencipta dan memulakan parameter tersebut. Sifat baharu boleh muncul di seluruh kod, sama seperti ia boleh dipadamkan dan dikemas kini.

Oleh itu, anda boleh mencipta semua kunci sekaligus atau mengisytiharkannya apabila ia tersedia. Dan walaupun, semasa menulis program, anda merujuk kepada kunci yang tidak wujud, tidak akan ada ralat. Dalam kes ini, "undefined" akan dikembalikan.

Cara pertama.

Mencipta dan mengakses sifat menggunakan titik. Untuk melaksanakan pilihan ini, anda perlu menulis nama objek, dan kemudian menambah nama kunci kepadanya melalui titik dan kemudian menetapkan beberapa nilai melalui tanda yang sama:

avto.name = “BMW 116i”

Tetapi dalam kaedah ini anda akan menambah satu lagi elemen pada kunci sedia ada:

Kaedah ini digunakan apabila nama harta itu sudah diketahui dan anda perlu melakukan tindakan tertentu dengan nilai.

Cara kedua.

Tidak berbeza dengan yang pertama, jika anda membandingkan tujuan mereka. Walau bagaimanapun, kaedah ini mempunyai sedikit kelebihan. Untuk pilihan ini, kurungan segi empat sama digunakan:

avto[“nama”] = “BMW 116i”

Tambahan yang bagus ialah keupayaan untuk mencipta nama harta dalam bentuk sebarang rentetan. Cth,

avto[“nama kereta”] = “BMW 116i”

Bekerja dengan kekunci melalui kurungan segi empat sama digunakan apabila beberapa parameter dimasukkan oleh pengguna dan disimpan dalam pembolehubah atau apabila nama sifat tidak diketahui terlebih dahulu. Sebagai contoh, pengguna meminta harga kereta yang dipilih. Elemen yang dipanggil ditulis kepada pembolehubah, dan harga dihantar sebagai tindak balas:

var auto = (); avto.name = "BMW_116i"; avto.price = 588000; kunci var = "harga"; // harga kereta diminta alert(avto);

Sekarang mari kita beralih kepada memadam sifat. Semuanya sangat mudah di sini. Untuk mengalih keluar, gunakan arahan padam. Jadi, jika anda menambah 2 baris berikut pada contoh terakhir di bawah:

padamkan auto.price;

makluman(auto);

Kemudian, apabila memanggil amaran untuk kali kedua, kotak dialog akan memaparkan "tidak ditentukan".

Beberapa perkataan tentang kekompakan

Pada peringkat semasa, saya memberitahu anda cara membuat objek dan menerangkan sifatnya. Saya telah melampirkan kes ujian untuk ini, tetapi yang paling prihatin daripada anda, pembaca yang dihormati, telah menyedari bahawa kod program pertama agak berbeza daripada semua yang lain.

Dan semuanya kerana ia menggunakan perwakilan data padat. Ini adalah kaedah yang sangat popular untuk mengisytiharkan kunci kerana ia lebih pendek untuk ditulis dan lebih mudah difahami secara visual.

Mari kita pergi melalui hartanah kami

Dalam JavaScript, anda boleh lelaran dengan cepat melalui sifat yang dicipta. Untuk tujuan ini, mekanisme khas telah disediakan, lebih dikenali sebagai kitaran.

Jika anda biasa dengan bahasa pengaturcaraan lain, anda tahu bahawa selalunya gelung dibuat menggunakan perkataan itu untuk, maka syarat untuk menghitung unsur ditulis dalam kurungan.

Dalam js ia mengingatkannya penampilan kitaran untuk setiap daripada bahasa C#. Semak reka bentuk umum:

untuk (var obj dalam objek) ( // melakukan carian)

di mana obj bertanggungjawab untuk nama kunci yang disenaraikan,

objek - untuk nilai mereka.

Dan sekarang inilah contoh konkrit untuk anda.

1 2 3 4 5 6 7 8

var avto = ( nama: "BMW 116i", warna: "hitam", harga: 588000 ); for (var obj in object) ( alert(obj + ":" + object) )

var avto = ( nama: "BMW 116i", warna: "hitam", harga: 588000 ); for (var obj in object) ( alert(obj + ":" + object) )

Sudah tiba masanya untuk membiasakan diri dengan kaedah

Bahasa skrip menyediakan untuk penciptaan kaedah. Ini adalah mekanisme yang sangat mudah yang pada bila-bila masa anda boleh menambah kaedah atau kaedah pada mana-mana objek yang mengembangkan keupayaan tatasusunan bersekutu yang dicipta. Mereka juga dipanggil sifat fungsi.

Js sendiri sangat dinamik dan menakjubkan sedikit sebanyak. Ini adalah bagaimana elemen boleh dicipta jenis yang berbeza. Apabila mempelajari bahasa ini, anda tidak perlu menghafal struktur yang kompleks, kerana banyak pengisytiharan sangat serupa antara satu sama lain.

Jadi, untuk mencipta kaedah, anda perlu mengisytiharkan objek, dan kemudian mula menulis arahan yang sama seperti mencipta sifat. Bagaimanapun, selepas “=” bukan lagi nilai yang ditulis, tetapi fungsi kata kunci (pembolehubah). Dan kemudian tindakan disenaraikan dalam kurungan kerinting.

Berikut adalah pelaksanaan mekanisme ini:

var avto =() avto.name = “BMV” avto.year = 1999 avto.drive = function(k) ( alert(“Kereta telah berlalu”+n+“ km.”)) avto.drive(300) avto. memandu ( 450)

Seperti yang anda lihat, contoh ini mengandungi sifat dan kaedah yang panggilannya pada mulanya serupa.

Adakah JS juga mempunyai pembina?

Baik tuan! Dalam bahasa ini, semua yang menggunakan kata kunci " baru", secara automatik menjadi pembina. Jadi, di atas anda melihat pengisytiharan objek kosong dalam bentuk: avto = new Object ();. Ini adalah pembina.

Untuk kejelasan, pertimbangkan baris di bawah.

var bob = Objek baru();

bob.name = "Bob Smith";

Walau bagaimanapun, ini bukan keseluruhan senjata kemungkinan. Dalam js, anda boleh mencipta pembina anda sendiri dan kemudian menggunakannya untuk mengisytiharkan objek baharu.

Jadi, saya ingin "membuat" pembina tersuai untuk kereta sedia ada. Sila ambil perhatian bahawa nama mesti ditulis dengan huruf besar. Ini adalah ciri fungsi. Untuk melakukan ini, saya menulis pelaksanaan perisian berikut:

fungsi Auto (nama, harga) (

ini.nama = nama;

ini.harga = harga;

Sekarang, apabila anda mencipta objek tanpa had dan menggunakan pembina ini padanya, semuanya akan tergolong dalam kelas yang sama. Sebagai contoh:

var car1 = new Avto("BMW", 650000);

var car2 = new Avto("Audi", 520000);

Di samping itu, anda boleh membuat kaedah di dalam pembina.

Ciri-ciri warisan dalam JavaScript

Biasanya, dalam banyak bahasa, warisan adalah berdasarkan kelas yang boleh mewarisi antara satu sama lain. Kemudian anda boleh mendengar ungkapan seperti "kelas nenek moyang", "kelas kanak-kanak", dsb.

Walau bagaimanapun, dalam js semuanya berbeza. Di sinilah objek diwarisi.

Semua pewarisan adalah berdasarkan pautan dalaman antara objek, yang dikenali sebagai "prototaip". Jika anda menambah ".prototype" pada kaedah menggunakan titik, dan kemudian masukkan nama prototaip, maka semua objek kaedah yang dipilih akan diwarisi daripada prototaip ini.

Mari kita beralih kepada contoh.

fungsi Transport (nama) ( this.name = name this.canDrive = true ) var transport = new Transport ("avto") // mencipta fungsi objek pengangkutan Bike (nama) ( this.name = name ) Bike.prototype = transport / / nyatakan bahawa semua objek baharu kelas ini akan menggunakan transport bike1 = new Bike ("for_sport") bike2= new Bike ("for_child") console.log(bike1.name) console.log(bike2.name) console .log (basikal1.canDrive)

Saya rasa saya akan berakhir di sini. Saya telah memberitahu anda tentang aspek asas bahasa skrip. Namun, ini hanyalah ilmu yang dangkal. Seterusnya kita akan pergi lebih dalam. Sementara itu, jangan lupa untuk menyertai barisan pelanggan saya dan kongsikan pautan ke artikel itu dengan rakan anda. Semoga berjaya!

Selamat tinggal!

Salam sejahtera, Roman Chueshov

Baca: 97 kali

Objek adalah asas JavaScript. Banyak jenis data terbina dalam diwakili sebagai objek. Akan menjadi pemaju yang berjaya JavaScript, anda perlu mempunyai pemahaman yang jelas tentang cara ia berfungsi. Blok binaan objek dipanggil medannya atau sifat objek JavaScript. Ia digunakan untuk menerangkan mana-mana aspek objek. Harta ini boleh menerangkan panjang senarai, warna langit atau tarikh lahir seseorang. Mencipta objek adalah proses yang mudah. Bahasa ini menyediakan sintaks yang dikenali sebagai literal objek, yang dilambangkan dengan pendakap kerinting.

Mengakses Hartanah

Bahasa ini menyediakan dua entri untuk mengakses sifat. Yang pertama dan paling biasa dikenali sebagai notasi titik. Dalam notasi titik, sumber boleh diakses dengan menyatakan nama objek hos, diikuti dengan noktah dan nama harta tersebut. Sebagai contoh, apabila object.foo pada mulanya ditetapkan kepada satu, maka nilainya akan menjadi 2 selepas pernyataan objek JavaScript dilaksanakan.

Sintaks akses alternatif dikenali sebagai notasi kurungan. Dalam tatatanda, nama objek diikuti oleh satu set kurungan segi empat sama. Di dalamnya, nama sifat ditentukan sebagai rentetan:

objek["foo"] = objek["foo"] + 1.

Ia lebih ekspresif daripada notasi titik kerana ia membenarkan pembolehubah untuk menentukan semua atau sebahagian daripada nama sifat. Ini mungkin kerana penterjemah objek JavaScript secara automatik menukar ungkapan ini kepada rentetan dan kemudian memperoleh sifat yang sepadan. Nama harta dibuat dengan cepat dengan menggabungkan kandungan pembolehubah f dengan rentetan "oo":

objek = "bar".

Notasi kurungan membenarkan nama sifat mengandungi aksara yang dilarang dalam tatatanda titik. Sebagai contoh, pernyataan berikut adalah sah sepenuhnya dalam kurungan. Walau bagaimanapun, jika pengguna cuba mencipta nama sifat yang sama dalam tatatanda titik, mereka akan menghadapi ralat sintaks:

objek["!@#$% &*()."] = benar.

Sifat objek JavaScript bersarang boleh diakses dengan merantai titik dan/atau kurungan. Sebagai contoh, objek berikut mengandungi objek bersarang bernama baz yang mengandungi objek lain bernama foo yang mempunyai sifat bernama bar yang mengandungi nilai lima:

objek var = ( baz: ( foo: ( bar: 5 ) ) ).

Ungkapan berikut mengakses harta yang dilampirkan bar. Ungkapan pertama menggunakan tatatanda titik, manakala ungkapan kedua menggunakan tatatanda segi empat sama. Ungkapan ketiga menggabungkan kedua-dua entri untuk mencapai hasil yang sama:

• object.baz.foo.bar;
• objek["baz"]["foo"]["bar"];
• objek["baz"].foo["bar"].

Ungkapan seperti yang ditunjukkan dalam contoh sebelumnya boleh menyebabkan kemerosotan prestasi apabila salah guna dan menjadikan objek JavaScript tidak boleh digunakan. Menilai setiap ungkapan titik atau kurungan memerlukan masa. Jika harta yang sama digunakan beberapa kali, maka masuk akal untuk mengakses harta itu sekali dan kemudian menyimpan nilai dalam pembolehubah tempatan untuk semua kegunaan masa hadapan.

Berfungsi sebagai kaedah

Apabila fungsi digunakan sebagai sifat objek, ia dipanggil kaedah. Seperti sifat, ia dinyatakan dalam notasi literal objek. Sebagai contoh:

var object = ( sum: function(foo, bar) ( return foo + bar; ) ).

Kaedah objek JavaScript boleh dipanggil menggunakan tanda dan kurungan. Contoh berikut memanggil kaedah sum() daripada contoh sebelumnya menggunakan kedua-dua entri:

• object.sum(1, 2);
• objek["jumlah"](1, 2).

Notasi literal objek berguna untuk mencipta objek baharu, tetapi ia tidak boleh menambah sifat atau kaedah kepada yang sedia ada. Nasib baik, menambah data baharu semudah membuat pernyataan tugasan. Objek kosong dibuat. Kemudian, menggunakan pengendali tugasan, kami menambah dua sifat, foo, dan bar, dan kaedah baz:

• objek var = ();
• object.foo = 1;
• object.bar = null;
• object.baz = function() ( kembalikan "hello from baz()"; ).

Enkapsulasi Program

Idea asas pengaturcaraan berorientasikan objek adalah untuk membahagikan program kepada bahagian yang lebih kecil dan menjadikan setiap bahagian bertanggungjawab untuk menguruskan keadaannya sendiri. Oleh itu, beberapa pengetahuan tentang cara sebahagian daripada program berfungsi mungkin setempat kepada bahagian tersebut. Seseorang yang bekerja pada seluruh program tidak sepatutnya mengingati atau mengetahuinya. Apabila data setempat ini berubah, hanya kod di sekelilingnya sahaja yang perlu dikemas kini.

Pelbagai bahagian program sedemikian berkomunikasi antara satu sama lain melalui antara muka, set fungsi atau pengikatan terhad yang menyediakan fungsi berguna pada tahap yang lebih abstrak sambil menyembunyikan pelaksanaan tepatnya. Bahagian program sedemikian dimodelkan menggunakan objek. Antara muka mereka terdiri daripada satu set kaedah dan sifat tertentu. Sifat yang merupakan sebahagian daripada antara muka dipanggil awam. Selebihnya, yang tidak boleh menyentuh kod luaran, dipanggil peribadi.

Banyak bahasa menyediakan keupayaan untuk membezakan antara harta awam dan swasta dan tidak membenarkan kod luaran untuk mengakses yang peribadi. JavaScript, sekali lagi mengambil pendekatan minimalis, belum ada lagi. Kerja sedang dijalankan untuk menambah bahasa ini. Oleh itu, pengaturcara JavaScript akan berjaya menggunakan idea ini. Biasanya, antara muka yang boleh diakses diterangkan dalam dokumentasi atau ulasan. Ia juga merupakan amalan biasa untuk meletakkan garis bawah (_) pada permulaan nama harta untuk menunjukkan bahawa harta tersebut adalah peribadi. Memisahkan antara muka daripada pelaksanaan - idea bernas. Ini biasanya dipanggil enkapsulasi.

Hartanah

Objek dengan kurungan (...) dipanggil objek literal. Anda boleh segera meletakkan beberapa sifat dalam kurungan tersebut (...). Sebagai contoh, pasangkan "kunci: nilai dan seterusnya":

biarkan pengguna = ( // nama objek: "John", // dengan kunci "nama" menyimpan nilai "John" age: 30 // by key "age" store value 30 }.!}

Sifat mempunyai kunci (juga dikenali sebagai "nama" atau "pengecam") sebelum titik bertindih ":" dan nilai di sebelah kanannya. Objek pengguna mempunyai dua sifat. Objek pengguna JavaScript yang terhasil dengan dua fail yang ditandatangani berlabel "nama" dan "umur". Anda boleh menambah, memadam dan membaca fail daripadanya pada bila-bila masa. Nilai sifat diakses menggunakan notasi titik. Ia boleh daripada apa-apa jenis. Anda boleh menambah nilai boolean. Untuk mengalih keluar harta, gunakan padam pada kes Ralat objek JavaScript.

Semua objek ralat JavaScript adalah turunan daripada objek Ralat atau objek yang diwarisi:

1. Objek Ralat Sintaks mewarisi daripada objek Ralat.
2. Ralat Parse JSON jenis objek Ralat Sintaks tertentu.

Untuk menyelam lebih mendalam untuk memahami cara aplikasi menangani ralat JavaScript, lihat lebih dekat pada Airbrake JavaScript, alat penjejakan ralat untuk makluman masa nyata dan cerapan segera tentang perkara yang salah dengan kod JavaScript anda.

Mesej ralat yang mungkin diterima pengguna sebelum memadamkan objek JavaScript:

1. Watak kawalan buruk dalam rentetan literal.
2. Watak buruk dalam rentetan literal.
3. Output Unicode yang lemah.
4. Watak melarikan diri yang buruk.
5. Rentetan yang tidak ditamatkan.
6. Kod bukan angka yang tidak dijangka.
7. Tiada nombor selepas titik perpuluhan.
8. Nombor pecahan tidak ditamatkan.
9. Tiada nombor selepas penunjuk darjah.
10. Tiada nombor selepas tanda eksponen.
11. Bahagian eksponen tidak mempunyai nombor.
12. Penghujung data yang tidak dijangka.
13. Kata kunci yang tidak dijangka.
14. Simbol yang tidak dijangka.
15. Tamat data apabila membaca kandungan objek.
16. Nama harta yang dijangkakan atau ")".

Sifat pengiraan

Anda boleh menggunakan kurungan segi empat sama dalam literal objek. Ini dipanggil sifat dikira. Contoh diberikan di bawah.

Maksud harta yang dikira adalah mudah: ini bermakna nama harta mesti diambil daripada buah. Jadi jika pelawat memasuki "epal", beg akan menjadi (epal: 5). Boleh digunakan lebih ungkapan yang kompleks dalam kurungan segi empat sama:

biarkan buah = "epal";

: 5 // bag.appleComputers = 5

Tanda kurung persegi jauh lebih berkuasa daripada tatatanda titik. Mereka membenarkan nama dan pembolehubah harta. Tetapi mereka juga lebih menyusahkan untuk menulis. Oleh itu, kebanyakan masa, apabila nama harta diketahui dan mudah, titik digunakan. Dan jika anda memerlukan sesuatu yang lebih kompleks, kemudian beralih kepada kurungan segi empat sama.

Tempahan perkataan

Pembolehubah tidak boleh mempunyai nama yang sama dengan salah satu perkataan yang dikhaskan seperti "untuk", "biar", "kembali", dll. Tetapi apabila mengisih objek JavaScript, tiada sekatan sedemikian.

Pada dasarnya, sebarang nama dibenarkan, tetapi ada nama yang istimewa: ia "__proto__" mendapat layanan istimewa atas sebab sejarah. Sebagai contoh, anda tidak boleh menetapkannya kepada nilai selain daripada objek:

obj.__proto__ = 5;

alert(obj.__proto__); // tidak berfungsi seperti yang dimaksudkan

Seperti yang anda lihat dari kod, tujuan primitif 5 diabaikan. Ini boleh menjadi punca ralat dan juga kelemahan jika pengendali berhasrat untuk menyimpan pasangan nilai kunci sewenang-wenangnya dalam objek dan membenarkan pelawat menentukan kunci. Dalam kes ini, pelawat boleh memilih "proto" sebagai kunci dan menambah JavaScript pada objek. Terdapat cara untuk menjadikan objek dirawat dengan __proto__ sebagai harta biasa. Terdapat juga satu lagi peta struktur data yang menyokong kunci sewenang-wenangnya.

Sifat Integer

Istilah "sifat integer" di sini bermaksud rentetan yang boleh ditukar daripada integer tanpa pengubahsuaian. Jadi, sebagai contoh, "49" ialah nama sifat integer kerana apabila ia ditukar kepada integer dan kembali semula, ia masih sama. Tetapi "+49" dan "1.2" tidak seperti itu. Sebaliknya, jika kunci bukan integer, maka ia disenaraikan dalam susunan ia dicipta. Contoh di bawah.

Untuk menyelesaikan masalah dengan kod dail, anda boleh "menipu" dengan membuat kod tidak lengkap. Menambah "+" (tanda tambah) sebelum setiap kod adalah mencukupi. Sekarang ia akan berfungsi seperti yang dimaksudkan.

Perbezaan antara objek dan primitif ialah ia disimpan dan disalin "dengan rujukan". Nilai primitif diberikan dan disalin "sebagai nilai integer". Pembolehubah menyimpan "alamat dalam ingatan" dan bukannya objek itu sendiri atau "rujukan" kepadanya. Anda boleh menggunakan mana-mana pembolehubah untuk mengakses dan menukar kandungannya.

Contoh di atas menunjukkan bahawa hanya ada satu objek dan pentadbir untuk log masuk ke dalamnya. Kemudian, jika kunci lain (pengguna) digunakan kemudian, pengguna akan melihat perubahan.

Pengendali kesamaan == dan kesamaan ketat === untuk objek berfungsi dengan cara yang sama. Dua objek adalah sama hanya jika ia adalah objek yang sama. Untuk perbandingan seperti obj1 > obj2 atau perbandingan dengan obj primitif == 5, objek ditukar kepada primitif. Sejujurnya, perbandingan sedemikian sangat jarang diperlukan dan biasanya hasil daripada ralat pengekodan.

Pengesahan Objek JavaScript

Objek mempunyai akses kepada mana-mana harta. Walau bagaimanapun, jika ia tidak wujud sama sekali, ia tidak akan menjadi ralat. Hanya mengakses harta yang tidak wujud mengembalikan tidak ditentukan. Ia menyediakan cara yang sangat biasa untuk menguji harta dan membandingkannya dengan yang tidak ditentukan. Di bawah adalah contoh.

Menggunakan "dalam" untuk sifat yang menyimpan tidak ditentukan. Biasanya pemeriksaan perbandingan "=== undefined" yang ketat berfungsi dengan baik. Terdapat kes khas di mana ia gagal dan "dalam" berfungsi dengan betul. Ini adalah apabila sifat objek wujud tetapi kekal tidak ditentukan.

Dalam kod di atas, sifat obj.test wujud secara teknikal. Oleh itu operator dalam berfungsi dengan betul. Situasi seperti ini sangat jarang berlaku kerana undefined biasanya tidak ditetapkan. Kebanyakan nilai nol "tidak diketahui" atau "kosong" digunakan. Oleh itu, pengendali dalam secara berkesan adalah tetamu dalam kod.

gelung "untuk..dalam".

Untuk bergerak melalui semua kekunci dari objek ke objek, terdapat bentuk gelung khas: for..in. Ini adalah perkara yang sama sekali berbeza daripada binaan for(;;).

Di bawah adalah contoh.

Sila ambil perhatian bahawa semua pembina "untuk" membenarkan anda mengisytiharkan pembolehubah gelung di dalam gelung sebagai kunci biarkan. Sebagai alternatif, anda boleh menggunakan nama pembolehubah yang berbeza, kunci, sebaliknya.

Contohnya, for(let prop in obj) juga digunakan secara meluas.

Terdapat alternatif "kurungan persegi" yang berfungsi dengan mana-mana rentetan.

Perkara di sini memerlukan kunci objek JavaScript menjadi pengecam pembolehubah yang sah, bermakna tiada ruang atau sekatan lain. Penjagaan mesti diambil untuk memastikan bahawa garisan di dalam kurungan dipetik dengan betul. Tanda kurung segi empat sama juga menyediakan cara untuk mendapatkan nama harta daripada hasil sebarang ungkapan, berbanding rentetan literal daripada pembolehubah:

let key = "suka burung";

// sama seperti pengguna["suka burung"] = benar;

pengguna = benar.

Di sini pembolehubah utama boleh dikira pada masa jalan dan bergantung pada input pengguna dan kemudian digunakan untuk mengakses harta tersebut. Ini memberikan pengaturcara lebih fleksibiliti. Notasi titik tidak boleh digunakan dengan cara yang sama, kerana ia akan berulang pada objek JavaScript. Di bawah adalah contoh.

Objek const

Objek const yang diisytiharkan boleh diubah suai. Contoh diberikan di bawah.

Ia mungkin kelihatan seperti objek JavaScript dalam baris (*) akan melemparkan ralat, tetapi itu tidak berlaku. Ini kerana const menangkap nilai pengguna itu sendiri. Dan di sini pengguna menyimpan rujukan kepada objek yang sama sepanjang masa. Baris (*) masuk ke dalam objek, ia tidak ditetapkan semula kepada pengguna. Const akan memberikan ralat jika anda cuba menetapkan pengguna dan sesuatu yang lain. Pengklonan dan penggabungan, Object.assign mencipta rujukan lain kepada objek yang sama jika ia perlu diduplikasi. Ini juga boleh dilakukan, tetapi sedikit lebih sukar kerana JavaScript tidak mempunyai kaedah terbina dalam. Malah, ini jarang diperlukan. Menyalin melalui rujukan digunakan dalam kebanyakan kes. Tetapi jika anda benar-benar memerlukan ini, maka anda perlu mencipta objek JavaScript dan meniru struktur yang sedia ada, menyalin sifatnya pada tahap primitif. Di bawah adalah contoh.

Dan anda juga boleh menggunakan kaedah Object.assign untuk ini. Argumen dest dan src1, ..., srcN ialah objek. Ia menyalin sifat semua objek src1, ..., srcNINTO dest. Dalam erti kata lain, sifat semua hujah, bermula dari yang kedua, disalin ke yang pertama. Kemudian ia kembali ke destinasi. Sebagai contoh, anda boleh menggunakannya untuk menggabungkan beberapa objek menjadi satu.

Dan juga anda boleh menggunakan Object.assign untuk menggantikan gelung pengklonan mudah. Ia menyalin semua sifat pengguna ke objek kosong dan mengembalikannya, sama seperti gelung, tetapi lebih pendek. Sehingga kini, telah diandaikan bahawa semua sifat pengguna adalah primitif. Tetapi sifat boleh menjadi rujukan kepada objek lain.

Untuk membetulkannya, anda perlu menggunakan gelung klon yang menyemak setiap nilai pengguna dan, jika ia adalah objek, kemudian mereplikasi strukturnya. Ini dipanggil "pengklonan mendalam."

wujud algoritma piawai pengklonan dalam, yang mengendalikan kes di atas dan kes yang lebih kompleks dipanggil algoritma pengklonan Berstruktur. Untuk mengelakkan mencipta semula roda, anda boleh menggunakan pelaksanaan yang berfungsi daripada perpustakaan JavaScript lodash, kaedah itu dipanggil _.cloneDeep(obj).

Kaedah Lanjutan

Jika pengaturcara menggelungkan objek dan ingin mendapatkan semua sifat dalam susunan yang sama ia telah ditambahkan, dia boleh bergantung pada "pesanan khas", di mana sifat integer diisih dan lain-lain dibentuk mengikut susunan objek JavaScript dicipta. .

Kaedah objek lanjutan berurusan dengan konsep yang jarang digunakan dalam JavaScript. Ini kerana dalam senario biasa ciri berkuasa ini tidak diperlukan. Sesetengah kaedah ini mungkin tidak berfungsi dalam pelayar lama, seperti keluaran awal Netscape 4.

Prototaip boleh digunakan untuk mencipta objek JavaScript dan semua kaedah mycircle, bukan hanya yang baharu. Ini mempunyai kesan prestasi yang bercampur-campur. Mereka tidak perlu menyimpan salinan kaedah yang berasingan untuk setiap contoh objek, jadi mereka mungkin memerlukan kurang memori untuk beroperasi, tetapi penyemak imbas mesti mencari skop semasa dan induk untuk mencarinya. Ini boleh mengakibatkan kependaman yang melampau. Secara amnya, pengguna harus menggunakan apa yang sesuai untuk kod dan bukannya berdasarkan keputusan itu pada prestasi, melainkan mereka berurusan dengan persekitaran terkawal yang sangat khusus.

Kembali benar

Dalam sesetengah kes, harta objek mungkin perlu diikat pada objek itu sendiri atau di suatu tempat dalam rantai prototaip. Dalam JavaScript, semua objek menggunakan kaedah hasOwnProperty, yang mengembalikan benar jika sifat itu terikat pada contoh objek individu. Dalam kes ini, ia menjadi mungkin untuk menyemak sama ada pembina objek mempunyai sifat yang sama dengan nilai yang sama dengan contoh objek itu sendiri. Ini mungkin memberikan hasil yang salah jika terdapat sifat objek JavaScript yang berasingan dengan nilai yang sama untuk kedua-dua contoh objek dan prototaip litar. Kaedah hasOwnProperty mengambil satu parameter - nama harta sebagai rentetan.

Anda boleh membuat kaedah peribadi dengan cara yang sama. Ia hanyalah fungsi yang dicipta di dalam fungsi pembina. Ini mungkin kelihatan mengelirukan bagi sesetengah orang, tetapi itulah cara ia berfungsi. Fungsi peribadi hanya boleh dipanggil oleh pembina itu sendiri atau dengan kaedah yang ditakrifkan pada baris. Ia boleh digunakan sebagai kaedah awam jika diberikan kepada pembina awam dan diakses menggunakan kaedah awam objek Javascript.

function myob() ( function cantBeSeen() ( alert(secretValue);

) var secretValue = "";

this.method1 = function () ( secretValue = "tiada kejutan";!}

this.method2 = cantBeSeen;

) var oneOb = myob baru();

oneOb.method1();

//alerts "no surprises" oneOb.method2();

//memberi isyarat "tiada kejutan".

Templat Perintah

Objek perintah membenarkan sistem gandingan longgar dengan memisahkan mereka yang mengeluarkan permintaan daripada objek dan yang benar-benar memproses permintaan itu. Permintaan ini dipanggil peristiwa, dan kod yang memproses permintaan dipanggil pengendali acara.

Katakan anda mencipta aplikasi yang menyokong tindakan papan keratan Potong, Salin dan Tampal. Tindakan ini boleh dicetuskan dengan cara yang berbeza sepanjang aplikasi: oleh sistem menu, oleh menu konteks, contohnya dengan mengklik butang kanan tetikus oleh medan teks atau pintasan papan kekunci. Objek perintah membolehkan anda memusatkan pemprosesan tindakan ini, satu untuk setiap operasi, apabila hanya satu perintah diperlukan untuk memproses semua permintaan Potong, satu untuk semua permintaan Salin dan satu untuk semua permintaan Tampal.

Oleh kerana pasukan memusatkan semua pemprosesan, mereka juga sering terlibat dalam mengendalikan fungsi buat asal untuk keseluruhan aplikasi. Penambahbaikan yang ketara boleh dicapai dengan menggunakan teknik JavaScript moden, menghasilkan aplikasi yang lebih cekap, boleh dipercayai dan boleh diselenggara.

Untuk mengetahui cara melakukannya, anda boleh menggunakan templat JavaScript + jQuery. Pakej unik ini termasuk JavaScript yang dioptimumkan untuk semua templat GoF menggunakan ciri yang lebih maju seperti ruang nama, prototaip, modul, objek fungsi, penutupan, fungsi tanpa nama dan banyak lagi. Jika pengguna memerlukan alat dan teknik terkini untuk templat JavaScript, templat jQuery dan seni bina templat, maka ini adalah kes penggunaan terbaik. Pakej ini mengandungi yang berharga, maklumat terkini untuk pembangun JavaScript. Inilah yang disertakan:

1. Templat GoF yang dioptimumkan JavaScript.
2. Corak Reka Bentuk JavaScript Moden.
3. Corak Reka Bentuk Pandangan Model.
4. templat reka bentuk jQuery.
5. Corak seni bina simpulan bahasa JavaScript.
6. Contoh aplikasi (MVC, SPA, dll.)

Asas sintaks objek JavaScript yang dicadangkan adalah sangat penting untuk pengaturcara permulaan. Seseorang mesti terlebih dahulu memahami objek, maka akan ada pengetahuan tentang pengaturcaraan berorientasikan objek. Adalah penting untuk mempunyai pemahaman yang mendalam tentang bahan ini kerana ia berfungsi sebagai asas untuk seluruh bahasa JavaScript.

Objek

Objek ialah jenis data asas dalam bahasa JavaScript. Sebuah objek ialah nilai komposit: ia menggabungkan satu set nilai (nilai mudah atau objek lain) dan membenarkan nilai tersebut disimpan dan diambil dengan nama.

Objek ialah koleksi sifat tidak tertib, setiap satunya mempunyai nama dan nilai. Nama harta ialah rentetan, jadi objek boleh dikatakan memetakan rentetan kepada nilai. Pemetaan rentetan kepada nilai ini boleh menggunakan banyak nama: Anda mungkin sudah biasa dengan struktur data asas seperti cincang, kamus atau tatasusunan bersekutu. Walau bagaimanapun, terdapat lebih kepada objek daripada pemetaan mudah rentetan kepada nilai.

Selain sifatnya sendiri, objek JavaScript juga boleh mewarisi sifat daripada objek lain, yang dikenali sebagai prototaip. Kaedah objek ialah wakil tipikal bagi sifat yang diwarisi, dan " pewarisan melalui prototaip" ialah ciri utama bahasa JavaScript.

Objek dalam JavaScript adalah dinamik—ia biasanya membenarkan anda menambah dan mengalih keluar sifat—tetapi ia juga boleh digunakan untuk meniru objek statik dan "struktur" yang terdapat dalam bahasa pengaturcaraan yang ditaip secara statik. Ia juga boleh digunakan (jika anda mengabaikan objek itu memetakan rentetan kepada nilai) untuk mewakili set rentetan.

Sebarang nilai dalam JavaScript yang bukan rentetan, nombor, benar, palsu, batal atau tidak ditentukan ialah objek. Malah rentetan, nombor dan boolean yang bukan objek boleh berkelakuan seperti objek tidak berubah (mempunyai objek pembungkus String, Nombor, dsb.).

Objek ialah nilai boleh ubah dan operasi padanya dilakukan dengan rujukan, bukan dengan nilai. Jika pembolehubah x merujuk kepada objek dan pernyataan var y = x; , pembolehubah y akan mengandungi rujukan kepada objek yang sama, bukan salinannya. Sebarang perubahan yang dibuat pada objek oleh pembolehubah y juga akan dicerminkan dalam pembolehubah x.

Harta mempunyai nama dan nilai. Nama sifat boleh berupa sebarang rentetan, termasuk rentetan kosong, tetapi objek tidak boleh mempunyai dua sifat dengan nama yang sama. Nilai sifat boleh menjadi sebarang nilai yang dibenarkan dalam bahasa JavaScript, atau (dalam ECMAScript 5) fungsi baca atau tulis (atau kedua-duanya).

Sebagai tambahan kepada nama dan nilai, setiap harta mempunyai beberapa nilai yang dikaitkan dengannya, dipanggil sifat-sifat harta :

Atribut boleh ditulis menentukan sama ada nilai harta boleh ditulis.

Atribut terbilang menentukan sama ada nama harta itu tersedia untuk penghitungan dalam gelung untuk/dalam.

Atribut boleh dikonfigurasikan menentukan kemungkinan penyesuaian, i.e. memadamkan harta dan menukar atributnya.

Sebelum kemunculan standard ECMAScript 5, semua sifat dalam objek dicipta oleh program tersebut, tersedia untuk rakaman, penyenaraian dan penyesuaian. ECMAScript 5 menyediakan keupayaan untuk menyesuaikan atribut sifat anda.

Selain sifat, setiap objek mempunyai tiga atribut objek :

Atribut kelas mengandungi rentetan dengan nama kelas objek dan menentukan jenis objek.

Bendera boleh dipanjangkan(dalam ECMAScript 5) menunjukkan keupayaan untuk menambah sifat baharu pada objek.

Akhir sekali, di bawah ialah perihalan beberapa istilah yang akan membantu kami membezakan antara tiga kategori luas objek dalam JavaScript dan dua jenis sifat:

Sebuah objek bahasa asas

Ia ialah objek atau kelas objek yang ditakrifkan oleh spesifikasi ECMAScript. Tatasusunan, fungsi, tarikh dan ungkapan biasa (contohnya) ialah objek bahasa teras.

Objek masa jalan

Ini ialah objek yang ditakrifkan oleh persekitaran masa jalan (seperti pelayar web) di mana penterjemah JavaScript dibenamkan. Objek HTMLElement, yang mewakili struktur halaman web dalam JavaScript sisi klien, ialah objek masa jalan. Objek masa jalan juga boleh menjadi objek bahasa asas, contohnya apabila masa jalan mentakrifkan kaedah yang merupakan objek Fungsi biasa bahasa JavaScript asas.

Objek tersuai

Sebarang objek yang dibuat dengan melaksanakan kod JavaScript.

Harta sendiri

Ini ialah sifat yang ditakrifkan secara langsung pada objek tertentu.

Harta yang diwarisi

Ini adalah sifat yang ditakrifkan oleh prototaip objek.

Mencipta Objek

Objek boleh dibuat menggunakan literal objek, kata kunci baharu dan (dalam ECMAScript 5) fungsi Object.create().

Tersurat objek

Cara paling mudah untuk mencipta objek adalah dengan memasukkan objek literal dalam program anda. Objek literal ialah objek yang disertakan pendakap gigi senarai sifat (pasangan nama/nilai) yang dipisahkan dengan koma. Nama sifat boleh menjadi pengecam atau rentetan literal (rentetan kosong boleh diterima). Nilai harta boleh menjadi sebarang ungkapan yang dibenarkan dalam JavaScript - nilai ungkapan (ini boleh menjadi nilai mudah atau objek) akan menjadi nilai harta itu.

Di bawah ialah beberapa contoh mencipta objek:

Var kosong = (); // Objek tanpa sifat var point = ( x:0, y:0 ); // Dua sifat var point2 = ( x:point.x, y:point.y+1 ); // Nilai yang lebih kompleks var tapak = ( "tapak url": "www..NET Framework", // dan tanda sempang, jadi gunakan pengarang petikan: ( // Nilai sifat ini ialah nama pertama: "Alexandr", / / objek Sila ambil perhatian bahawa nama keluarga: "Frolov" // nama-nama hartanah ini tanpa petikan. ) );

ECMAScript 5 (dan beberapa pelaksanaan ECMAScript 3) membenarkan perkataan terpelihara untuk digunakan sebagai nama sifat tanpa petikan. Walau bagaimanapun, secara umum, nama harta yang sepadan perkataan terpelihara, dalam ECMA-Script 3 mesti disertakan dalam tanda petikan. Dalam ECMAScript 5, koma terakhir mengikuti sifat terakhir dalam literal objek diabaikan. Kebanyakan pelaksanaan ECMAScript 3 juga mengabaikan koma mengekor, tetapi IE mentafsir kehadirannya sebagai ralat.

Objek literal ialah ungkapan yang mencipta dan memulakan objek baharu apabila ungkapan itu dinilai. Nilai setiap sifat dikira semula apabila nilai literal dinilai. Ini bermakna bahawa satu objek literal boleh mencipta banyak objek baharu jika literal diletakkan dalam badan gelung atau fungsi yang akan dipanggil berulang kali, dan nilai sifat objek ini boleh berbeza antara satu sama lain.

Mencipta Objek Menggunakan Operator Baharu

Operator baharu mencipta dan memulakan objek baharu. Pernyataan ini mesti diikuti dengan nama fungsi. Fungsi yang digunakan dengan cara ini dipanggil pembina dan digunakan untuk memulakan objek yang baru dibuat. JavaScript asas termasuk banyak pembina terbina dalam untuk mencipta objek bahasa asas. Sebagai contoh:

Var o = Objek baru(); // Cipta objek kosong baharu: sama seperti () var a = new Array(); // Cipta tatasusunan kosong: sama seperti var d = new Date(); // Cipta objek Tarikh yang mewakili masa semasa var r = new RegExp("js"); // Cipta objek RegExp untuk operasi padanan corak

Sebagai tambahan kepada pembina terbina dalam ini, adalah mungkin untuk menentukan fungsi pembina anda sendiri untuk memulakan objek yang baru dibuat. Bagaimana ini dilakukan diterangkan dalam artikel seterusnya.

Object.create()

Piawaian ECMAScript 5 mentakrifkan kaedah Object.create(), yang mencipta objek baharu dan menggunakan hujah pertamanya sebagai prototaip objek tersebut. Selain itu, Object.create() boleh mengambil hujah pilihan kedua yang menerangkan sifat objek baharu.

Object.create() ialah fungsi statik, bukan kaedah yang dipanggil pada beberapa objek tertentu. Untuk memanggil fungsi ini, hanya berikan objek prototaip yang dikehendaki:

// obj mewarisi sifat x dan y var obj = Object.create((x:1, y:2));

Untuk mencipta objek yang tidak mempunyai prototaip, anda boleh lulus null, tetapi dalam kes ini objek yang baru dibuat tidak akan mewarisi sebarang sifat atau kaedah asas, seperti toString() (yang bermaksud objek ini tidak boleh digunakan dalam ungkapan dengan operator +):

// obj2 tidak mewarisi sebarang sifat atau kaedah var obj2 = Object.create(null);

Jika program anda perlu mencipta objek kosong biasa (seperti yang dikembalikan oleh literal() atau ungkapan Object() baharu), lulus Object.prototype sebagai hujah pertama:

// obj3 adalah seperti objek yang dicipta // menggunakan () atau new Object() var obj3 = Object.create(Object.prototype);

Keupayaan untuk mencipta objek baharu dengan prototaip sewenang-wenangnya (katakan dengan cara lain: keupayaan untuk mencipta "waris" daripada sebarang objek) ialah alat yang berkuasa, kesannya boleh disimulasikan dalam ECMAScript 3 menggunakan fungsi yang dibentangkan dalam contoh di bawah:

// inherit() mengembalikan objek yang baru dicipta yang mewarisi sifat // objek prototaip p. Menggunakan fungsi ECMAScript 5 Object.create() // jika ditakrifkan, sebaliknya menggunakan teknik yang lebih lama. function inherit(p) ( if (p == null) throw TypeError(); // p tidak boleh null if (Object.create) // If Object.create() ditakrifkan... return Object.create(p ) ; // gunakannya. var t = typeof p; // Jika tidak, ketahui jenisnya dan semak jika (t !== "objek" && t !== "function") throw TypeError(); function f() () ; // Tentukan pembina kosong. f.prototype = p; // Tetapkan sifat prototaipnya // kepada rujukan kepada objek p. return new f(); // Gunakan f() untuk mencipta // " pengganti" objek p. )

Pelaksanaan fungsi inherit() akan lebih masuk akal setelah kita mengenali pembina dalam artikel seterusnya. Buat masa ini, anggap sahaja ia mengembalikan objek baharu yang mewarisi sifat objek dalam hujah. Ambil perhatian bahawa inherit() bukanlah pengganti lengkap untuk Object.create(): ia tidak membenarkan anda mencipta objek tanpa prototaip, dan ia tidak memerlukan hujah kedua pilihan seperti Object.create() lakukan.

Mendapat dan menukar sifat

Anda boleh mendapatkan nilai harta menggunakan pengendali titik (.) dan kurungan segi empat sama (). Di sebelah kiri pengendali mesti ada ungkapan yang mengembalikan objek. Apabila menggunakan pengendali titik, harus ada pengecam mudah di sebelah kanan yang sepadan dengan nama sifat. Apabila menggunakan kurungan segi empat sama, kurungan segi empat sama mesti mengandungi ungkapan yang mengembalikan rentetan yang mengandungi nama sifat yang dikehendaki:

// Simple object var user = ( log masuk:"kot86", nama:"Alexandr", umur:26 ); var log masuk = pengguna.log masuk; // Dapatkan sifat "log masuk" objek pengguna var name = user.name; // Dapatkan sifat "nama" objek pengguna var age = user["age"]; // Dapatkan sifat "umur" objek pengguna

Untuk mencipta sifat baharu atau menukar nilai harta sedia ada, pengendali kurungan titik dan segi empat sama juga digunakan, seperti dalam operasi membaca nilai sifat, tetapi ungkapan itu sendiri diletakkan di sebelah kiri pengendali tugasan:

Pengguna.umur = 28; // Tukar nilai pengguna harta "umur"["log masuk"] = "kot84"; // Change the value of the "login" property user["surname"] = "Frolov"; // Buat harta baharu "nama keluarga"

Dalam ECMAScript 3, pengecam mengikut titik tidak boleh menjadi perkataan simpanan: anda tidak boleh menulis panggilan sifat kepada o.for atau o.class kerana for ialah kata kunci dan kelas ialah perkataan yang dikhaskan untuk kegunaan masa hadapan.

Jika objek mempunyai sifat yang namanya sepadan dengan perkataan terpelihara, anda mesti menggunakan notasi kurungan segi empat untuk mengaksesnya: o["for"] dan o["class"]. Piawaian ECMAScript 5 melonggarkan keperluan ini (seperti yang telah dilakukan oleh beberapa pelaksanaan ECMAScript 3) dan membenarkan penggunaan perkataan terpelihara selepas pengendali titik.

Prototaip

Setiap objek dalam JavaScript mempunyai objek kedua (atau nol, tetapi lebih jarang) dikaitkan dengannya. Objek kedua ini dipanggil prototaip, dan objek pertama mewarisi sifatnya daripada prototaip.

Semua objek yang dibuat menggunakan literal objek mempunyai objek prototaip yang sama, yang boleh dirujuk dalam program JavaScript sebagai Object.prototype .

Objek yang dicipta menggunakan kata kunci baharu dan panggilan pembina menerima nilai sifat prototaip fungsi pembina sebagai prototaipnya. Oleh itu, objek yang dicipta oleh Object() baharu mewarisi sifat Object.prototype seolah-olah ia dicipta menggunakan literal pendakap (). Begitu juga, prototaip objek yang dicipta oleh Array() baharu ialah Array.prototype, dan prototaip objek yang dicipta oleh Date() baharu ialah Date.prototype.

Object.prototype ialah salah satu daripada beberapa objek yang tidak mempunyai prototaip: ia tidak mempunyai sifat yang diwarisi. Objek prototaip lain hanyalah objek biasa yang mempunyai prototaip sendiri.

Semua pembina terbina dalam (dan kebanyakan pembina tersuai) mewarisi prototaip Object.prototype. Contohnya, Date.prototype mewarisi sifat daripada Object.prototype, jadi objek Date yang dicipta oleh Date() baharu mewarisi sifat daripada Date.prototype dan Object.prototype. Urutan objek prototaip yang disambungkan sedemikian dipanggil rantai prototaip.

Warisan

Objek dalam JavaScript mempunyai banyak "sifat sendiri" dan juga boleh mewarisi banyak sifat daripada objek prototaipnya. Untuk memahami perkara ini, anda perlu mengkaji dengan teliti mekanisme akses harta benda. Contoh dalam bahagian ini menggunakan fungsi inherit() yang ditunjukkan di atas untuk mencipta objek dengan prototaip tertentu.

Katakan program mengakses sifat x objek obj. Jika obj tidak mempunyai harta sendiri dengan nama itu, percubaan dibuat untuk mencari harta x dalam prototaip obj. Jika objek prototaip tidak mempunyai harta sendiri dengan nama itu, tetapi mempunyai prototaip sendiri, percubaan dibuat untuk mencari harta dalam prototaip prototaip. Ini berterusan sehingga harta x ditemui atau objek yang tidak mempunyai prototaip dicapai. Seperti yang anda lihat, atribut prototaip objek mencipta rantaian, atau senarai terpaut, objek dari mana sifat diwarisi.

Var obj = (); // obj mewarisi kaedah objek Object.prototype obj.x = 1; // dan mempunyai harta sendiri x. var p = inherit(obj); // p mewarisi sifat objek obj dan Object.prototype p.y = 2; // dan mempunyai harta sendiri y. var q = mewarisi(p); // q mewarisi sifat objek p, obj dan Object.prototype q.z = 3; // dan mempunyai harta sendiri z. var s = q.toString(); // toString mewarisi daripada Object.prototype var d = q.x + q.y // Keputusan 3: x dan y mewarisi daripada obj dan p

Sekarang andaikan bahawa program memberikan beberapa nilai kepada sifat x bagi obj. Jika obj sudah mempunyai harta sendiri (tidak diwarisi) bernama x, maka operasi tugasan hanya akan menukar nilai harta sedia ada. Jika tidak, sifat baharu bernama x akan dibuat dalam obj. Jika obj mewarisi harta x sebelum ini, harta yang diwarisi kini akan disembunyikan oleh harta yang baru dicipta sendiri dengan nama yang sama.

Operasi memberikan nilai kepada harta akan menyemak kehadiran harta itu dalam rantaian prototaip untuk memastikan bahawa tugasan itu sah. Sebagai contoh, jika objek obj mewarisi sifat baca sahaja x, maka tugasan tidak akan berlaku. Walau bagaimanapun, jika tugasan adalah sah, sifat itu sentiasa dicipta atau diubah dalam objek asal dan tidak sekali-kali dalam rantaian prototaip. Hakikat bahawa mekanisme pewarisan berfungsi apabila membaca sifat, tetapi tidak berfungsi apabila menulis nilai baharu, ialah ciri utama bahasa JavaScript kerana ia membolehkan anda secara selektif mengatasi sifat yang diwarisi:

Bulatan unit Var = ( r:1 ); // Objek dari mana harta itu diwarisi var c = inherit(unitcircle); // c mewarisi harta r c.x = 1; c.y = 1; // c mentakrifkan dua sifatnya sendiri c.r = 2; // c mengatasi console.log harta warisan yang diwarisi(unitcircle.r); // => 1: objek prototaip tidak berubah

Terdapat satu pengecualian kepada peraturan ini, apabila operasi penetapan harta gagal atau mengakibatkan harta dicipta/diubah suai pada objek asal. Jika obj mewarisi harta x dan harta itu diakses melalui pengakses, maka bukannya mencipta harta x baharu pada obj, kaedah untuk menulis nilai baharu dipanggil. Walau bagaimanapun, ambil perhatian bahawa kaedah tulis dipanggil pada obj, bukan pada prototaip di mana sifat itu ditakrifkan, jadi jika kaedah tulis mentakrifkan sebarang sifat, ia akan dijadikan instantiated pada obj dan rantaian prototaip sekali lagi akan kekal tidak berubah.

Ralat capaian harta

Ungkapan akses harta tidak selalu mengembalikan atau mengubah nilai harta benda. Bahagian ini menerangkan situasi apabila operasi baca atau tulis harta gagal.

Percubaan untuk mengakses harta yang tidak wujud tidak dianggap sebagai ralat. Jika harta x tidak ditemui di kalangan obj sendiri atau harta warisan, ungkapan akses harta obj.x akan kembali tidak ditentukan.

Walau bagaimanapun, percubaan untuk mengakses sifat objek yang tidak wujud dianggap sebagai ralat. Nilai null dan undefined tidak mempunyai sifat, dan percubaan untuk mengakses sifat nilai ini dianggap sebagai ralat:

// Simple object var user = ( log masuk:"kot86", nama:"Alexandr", umur:26 ); var a = pengguna.kata laluan; // undefined: property is missing // Menimbulkan pengecualian TypeError. // Nilai yang tidak ditentukan tidak mempunyai sifat panjang var len = user.password.length;

Jika anda tidak pasti bahawa pengguna dan kata laluan pengguna ialah objek (atau berkelakuan seperti objek), anda tidak seharusnya menggunakan ungkapan user.password.length kerana ia mungkin mengeluarkan pengecualian. Berikut menunjukkan dua cara untuk melindungi daripada jenis pengecualian ini:

// Cara yang lebih visual dan mudah var len = undefined; if (user) ( if (user.password) len = user.password.length; ) // Alternatif khusus JavaScript yang lebih ringkas // ​​untuk mendapatkan panjang nilai sifat kata laluan var len = pengguna && pengguna. kata laluan && pengguna.kata laluan.panjang ;

Percubaan untuk menetapkan nilai harta kepada nilai lain tidak selalu berjaya: sesetengah sifat adalah baca sahaja dan tidak membenarkan nilainya diubah. Di samping itu, sesetengah objek tidak membenarkan anda menambah sifat baharu padanya. Walau bagaimanapun, perkara yang paling menarik ialah kegagalan sedemikian, sebagai peraturan, tidak membawa kepada pengecualian yang dibangkitkan:

// Sifat prototaip pembina terbina dalam ialah Object.prototype baca sahaja = 0; // Tugasan tidak akan menimbulkan pengecualian; // nilai Object.prototype tidak akan berubah

Cacat JavaScript sejarah ini diperbetulkan dalam mod ketat, seperti yang ditakrifkan oleh standard ECMAScript 5. Semua percubaan yang tidak berjaya untuk menukar nilai harta dalam mod ketat mengakibatkan pengecualian TypeError.

Peraturan untuk menentukan bila percubaan untuk melaksanakan operasi tugasan akan berjaya dan bila ia akan gagal adalah mudah dan mudah, tetapi sukar untuk dinyatakan dengan cara yang cukup ringkas. Percubaan untuk memberikan nilai kepada sifat p bagi obj akan gagal dalam kes berikut:

Objek obj mempunyai sifat baca sahaja p: anda tidak boleh menukar nilai harta baca sahaja. (Namun, ambil perhatian bahawa kaedah defineProperty() ialah pengecualian yang membolehkan anda menukar nilai sifat tersuai baca sahaja.)

Objek obj mempunyai sifat diwarisi baca sahaja p: sifat baca sahaja yang diwarisi tidak boleh ditindih oleh sifat anda sendiri dengan nama yang sama.

Objek obj tidak mempunyai harta sendiri p; obj tidak mewarisi harta p dengan kaedah pengakses, dan atribut boleh diperluaskan obj adalah palsu. Jika harta p tidak hadir dalam obj dan tiada kaedah tulis yang ditentukan untuknya, maka operasi penugasan akan cuba menambah harta p pada obj. Tetapi oleh kerana obj tidak boleh diperluaskan, percubaan untuk menambah sifat baharu padanya akan gagal.

Mengalih keluar sifat

Operator padam mengeluarkan harta daripada objek. Satu-satunya operannya mestilah ungkapan akses harta benda. Ia mungkin kelihatan mengejutkan, tetapi padam operator tidak menjejaskan nilai harta - ia beroperasi pada harta itu sendiri:

// Simple object var user = ( log masuk:"kot86", nama:"Alexandr", umur:26 ); padam pengguna.log masuk; // Sekarang objek pengguna tidak mempunyai sifat log masuk padam pengguna["nama"]; // Sekarang objek pengguna tidak mempunyai sifat nama

Pengendali padam hanya memadamkan sifatnya sendiri dan tidak memadamkan yang diwarisi. (Untuk mengalih keluar harta yang diwarisi, anda mesti mengalih keluarnya daripada objek prototaip yang ditakrifkan. Operasi ini akan menjejaskan semua objek yang mewarisi prototaip itu.)

Ungkapan padam kembali benar apabila harta itu berjaya dipadamkan atau apabila operasi padam tidak mengubah objek (contohnya, apabila cuba memadamkan harta yang tidak wujud). Ungkapan padam juga kembali benar apabila lulus ungkapan yang bukan ungkapan akses harta:

Obj = (x:1); // obj mempunyai hartanya sendiri x dan mewarisi toString padam obj.x; //Memadam x dan mengembalikan obj.x padam benar; //Tidak melakukan apa-apa (x tidak wujud) dan mengembalikan true delete obj.toString; // Tidak akan melakukan apa-apa (toString bukan miliknya sendiri) dan mengembalikan true delete 1; // Tiada guna, tetapi akan kembali benar

Pengendali padam tidak memadam sifat tidak boleh dikonfigurasikan, atribut boleh dikonfigurasikan yang mempunyai nilai palsu. (Walau bagaimanapun, ia boleh mengalih keluar sifat tersuai bagi objek tidak boleh dilanjutkan.) Sifat tidak boleh dikonfigurasikan ialah sifat objek terbina dalam, serta sifat objek global yang dibuat menggunakan pernyataan pengisytiharan pembolehubah dan fungsi. Cuba untuk mengalih keluar harta yang tidak boleh dikonfigurasikan dalam mod ketat menimbulkan TypeError. Dalam mod tidak ketat (dan dalam pelaksanaan ECMAScript 3), pengendali padam hanya mengembalikan palsu dalam kes sedemikian:

Padam Object.prototype; // Pembuangan tidak boleh dilakukan - sifat tidak boleh dikonfigurasikan var x = 1; // Pengisytiharan pembolehubah global padam this.x; // Sifat ini tidak boleh dipadamkan fungsi f() () // Perisytiharan fungsi global padam ini.f; // Harta ini tidak boleh dipadam sama ada

Memeriksa kewujudan hartanah

Objek dalam JavaScript boleh dianggap sebagai set sifat, dan selalunya berguna untuk dapat menguji keahlian dalam set - untuk menyemak sama ada objek mempunyai sifat dengan nama tertentu. Anda boleh melakukan semakan sedemikian menggunakan operator dalam, menggunakan kaedah hasOwnProperty() Dan propertyIsEnumerable() atau hanya dengan mengakses harta itu.

Operator in memerlukan ia diberi nama sifat (sebagai rentetan) sebagai operan kirinya dan objek sebagai operan kanannya. Ia kembali benar jika objek mempunyai harta sendiri atau diwarisi dengan nama itu:

Var obj = ( x:1 ) "x" dalam obj; // true: obj mempunyai sifat sendiri "x" "y" dalam obj; // false: obj tidak mempunyai sifat "y" "toString" dalam obj; // true: obj mewarisi sifat toString

Kaedah hasOwnProperty() bagi objek menyemak sama ada objek itu mempunyai hartanya sendiri dengan nama yang ditentukan. Untuk sifat yang diwarisi ia mengembalikan palsu:

Var obj = ( x:1 ) obj.hasOwnProperty("x"); // true: obj mempunyai sifatnya sendiri "x" obj.hasOwnProperty("y"); // false: obj tidak mempunyai harta "y" obj.hasOwnProperty("toString"); // false: toString - harta warisan

Kaedah propertyIsEnumerable() mengenakan sekatan tambahan berbanding hasOwnProperty(). Ia mengembalikan benar hanya jika sifat yang ditentukan ialah sifat asli yang atribut terhitungnya ditetapkan kepada benar. Sifat objek terbina dalam tidak boleh dikira. Sifat yang dicipta oleh program JavaScript biasa boleh dikira melainkan salah satu daripada kaedah ECMAScript 5 di bawah telah digunakan untuk menjadikan sifat itu tidak boleh dikira.

Selalunya, bukannya operator dalam, cukup untuk menggunakan ungkapan akses harta mudah dan menggunakan operator !== untuk menyemak ketidaksamaan dengan nilai yang tidak ditentukan:

Var obj = ( x:1 ) obj.x !== undefined; // true: obj mempunyai sifat "x" obj.y !== undefined; // false: obj tidak mempunyai sifat "y" obj.toString !== undefined; // true: obj mewarisi sifat toString

Walau bagaimanapun, operator dalam membezakan situasi yang tidak dapat dibezakan menggunakan teknik berasaskan harta yang dibentangkan di atas. Operator dalam membezakan ketiadaan harta daripada harta yang mempunyai nilai yang tidak ditentukan.

Menghitung Harta

Daripada menyemak ketersediaan sifat individu Kadangkala adalah perlu untuk mengulangi semua sifat sedia ada atau untuk mendapatkan senarai semua sifat sesuatu objek. Ini biasanya dilakukan menggunakan gelung untuk/dalam, tetapi standard ECMAScript 5 menyediakan dua alternatif yang mudah.

Pernyataan gelung untuk/dalam melaksanakan badan gelung untuk setiap harta terhitung (sama ada miliknya sendiri atau diwarisi) bagi objek yang ditentukan, memberikan nama sifat kepada pembolehubah gelung. Kaedah terbina dalam yang diwarisi oleh objek tidak boleh dikira dan sifat yang ditambahkan pada objek oleh program anda boleh dikira (melainkan anda menggunakan fungsi yang diterangkan di bawah untuk menjadikan sifat tidak boleh dikira). Sebagai contoh:

// Objek ringkas dengan tiga sifat terhitung var user = ( login:"kot86", name:"Alexandr", umur:26 ); user.propertyIsEnumerable("toString"); // false, toString - kaedah terbina dalam untuk (n dalam pengguna) console.log(n);

Sesetengah perpustakaan menambah kaedah baharu (atau sifat lain) pada objek Object.prototype supaya ia boleh diwarisi dan disediakan kepada semua objek. Walau bagaimanapun, sehingga kemunculan piawaian ECMAScript 5, ia tidak dapat dilakukan kaedah tambahan tidak boleh dikira, jadi ia tersedia untuk penghitungan dalam gelung untuk/dalam. Untuk menyelesaikan isu ini, anda mungkin perlu menapis sifat yang dikembalikan oleh gelung untuk/dalam. Di bawah ialah dua contoh pelaksanaan penapisan sedemikian:

Untuk (n dalam pengguna) ( jika (!user.hasOwnProperty(n)) teruskan; console.log(n); ) untuk (n dalam pengguna) ( jika (jenis pengguna[n] === "fungsi") teruskan; console.log(n); )

Sebagai tambahan kepada gelung untuk/dalam, standard ECMAScript 5 mentakrifkan dua fungsi yang menghitung nama sifat. Yang pertama daripada mereka, Object.keys(), mengembalikan tatasusunan nama bagi sifat terhitung objek itu sendiri.

Fungsi ECMAScript 5 kedua yang melaksanakan penghitungan harta ialah Object.getOwnPropertyNames(). Ia bertindak seperti fungsi Object.keys(), tetapi mengembalikan nama semua sifat objek yang ditentukan sendiri, bukan hanya yang boleh dikira. Pelaksanaan ECMAScript 3 tidak mempunyai keupayaan untuk melaksanakan fungsi tersebut kerana ECMAScript 3 tidak menyediakan keupayaan untuk mendapatkan sifat objek yang tidak boleh dikira.

Kaedah untuk sifat membaca dan menulis

Telah dikatakan di atas bahawa harta objek mempunyai nama, nilai dan satu set atribut. Dalam ECMAScript 5, nilai boleh digantikan dengan satu atau dua kaedah, dikenali sebagai kaedah membaca (getter) Dan rekod (setter). Sifat yang kaedah baca dan tulis ditakrifkan kadangkala dipanggil hartanah dengan kaedah capaian untuk membezakannya daripada sifat data yang mewakili nilai mudah.

Apabila program cuba mendapatkan nilai harta dengan kaedah pengakses, jurubahasa memanggil kaedah baca (tanpa hujah). Nilai yang dikembalikan oleh kaedah ini menjadi nilai ungkapan akses harta benda. Apabila atur cara cuba menulis nilai pada harta, penterjemah memanggil kaedah tulis, menghantar nilai ke kanan pengendali tugasan. Kaedah ini bertanggungjawab untuk "menetapkan" nilai harta tersebut. Nilai yang dikembalikan oleh kaedah tulis diabaikan.

Tidak seperti sifat data, sifat pengakses tidak mempunyai atribut boleh tulis. Jika harta mempunyai kedua-dua kaedah baca dan tulis, ia adalah baca/tulis. Jika harta hanya mempunyai kaedah baca, ia adalah baca sahaja. Dan jika harta hanya mempunyai kaedah tulis, ia adalah tulis sahaja (ini tidak mungkin untuk sifat data) dan percubaan untuk membaca nilai harta sedemikian akan sentiasa kembali tidak ditentukan.

Cara paling mudah untuk menentukan harta dengan kaedah pengakses ialah menggunakan sintaks definisi literal objek lanjutan:

Var obj = ( // Normal data property data_prop: value, // Sifat dengan kaedah capaian ditakrifkan sebagai sepasang fungsi mendapatkan accessor_prop() ( /* function body */ ), set accessor_prop(value) ( ​​​​ /* badan fungsi */ ) );

Sifat dengan kaedah pengakses ditakrifkan sebagai satu atau dua fungsi yang namanya sama dengan nama harta dan dengan kata kunci fungsi digantikan dengan get dan/atau set.

Ambil perhatian bahawa anda tidak perlu menggunakan titik bertindih untuk memisahkan nama sifat daripada fungsi yang mengawal akses kepada harta tersebut, tetapi anda masih perlu menggunakan koma selepas badan fungsi untuk memisahkan kaedah daripada kaedah atau sifat data lain.

Sebagai contoh, pertimbangkan objek berikut yang mewakili Koordinat Cartesan mata di atas kapal terbang. Ia mempunyai sifat data biasa untuk mewakili koordinat X dan Y, serta sifat dengan kaedah pengakses untuk mendapatkan koordinat kutub yang setara bagi suatu titik:

Var p = ( // x dan y ialah sifat data biasa, baca/tulis x: 1.0, y: 1.0, // r ialah sifat baca/tulis dengan dua kaedah akses. // Jangan lupa tambah koma selepas akses kaedah dapatkan r() ( kembalikan Math.sqrt(this.x*this.x + this.y*this.y); ), set r(newvalue) ( ​​​​var oldvalue = Math.sqrt(this.x* this.x + this.y*this.y); var ratio = newvalue/oldvalue; this.x *= ratio; this.y *= ratio; ), // theta ialah sifat baca sahaja dengan satu-satunya kaedah reads get theta() ( return Math.atan2(this.y, this.x); ) );

Perhatikan penggunaan kata kunci ini dalam kaedah baca dan tulis di atas. Jurubahasa akan memanggil fungsi ini sebagai kaedah objek di mana ia ditakrifkan, i.e. dalam badan fungsi ini akan merujuk kepada objek titik. Ini membolehkan kaedah baca sifat r merujuk sifat x dan y, seperti ini.x dan ini.y.

Sifat dengan kaedah pengakses diwarisi sama seperti sifat data biasa, jadi objek p yang ditakrifkan di atas boleh digunakan sebagai prototaip untuk objek titik lain. Objek baharu boleh menentukan sifat x dan y mereka sendiri, dan mereka akan mewarisi sifat r dan theta.

Atribut Objek

Semua objek mempunyai prototaip, kelas dan atribut boleh diperluaskan. Semua atribut ini diterangkan dalam subseksyen di bawah.

atribut prototaip

Atribut prototaip objek menentukan objek dari mana sifat diwarisi. Adalah penting untuk memahami bahawa apabila rujukan prototaip berlaku dalam kod program, ia menandakan sifat biasa objek, bukan atribut prototaip.

Atribut prototaip ditetapkan apabila objek dibuat. Untuk objek yang dibuat menggunakan literal, prototaip ialah Object.prototype. Prototaip objek yang dibuat menggunakan operator baharu ialah nilai sifat prototaip pembina. Dan prototaip objek yang dicipta menggunakan Object.create() menjadi hujah pertama bagi fungsi ini (yang boleh menjadi nol).

Piawaian ECMAScript 5 menyediakan keupayaan untuk menentukan prototaip mana-mana objek dengan menghantarnya kepada kaedah Object.getPrototypeOf(). ECMAScript 3 tidak mempunyai fungsi yang setara, tetapi anda selalunya boleh mentakrifkan prototaip obj menggunakan ungkapan obj.constructor.prototype.

Objek yang dibuat menggunakan operator baharu biasanya mewarisi harta tersebut pembina Rujukan kepada fungsi pembina yang digunakan untuk mencipta objek. Dan seperti yang dinyatakan di atas, fungsi pembina mempunyai sifat prototaip, yang mentakrifkan prototaip objek yang dibuat menggunakan pembina ini.

Ambil perhatian bahawa objek yang dicipta menggunakan literal objek atau Object.create() menerima sifat pembina yang merujuk kepada pembina Object(). Oleh itu, constructor.prototype merujuk kepada prototaip sebenar untuk literal objek, tetapi ini biasanya tidak berlaku untuk objek yang dicipta dengan memanggil Object.create().

Untuk menentukan sama ada satu objek ialah prototaip (atau pautan dalam rantaian prototaip) objek lain, gunakan kaedah isPrototypeOf(). Untuk mengetahui sama ada p ialah prototaip obj, anda perlu menulis ungkapan p.isPrototypeOf(obj). Sebagai contoh:

Var p = (x:1); // Tentukan objek prototaip. var obj = Object.create(p); // Cipta objek dengan prototaip ini. p.isPrototypeOf(obj); // => true: obj mewarisi p Object.prototype.isPrototypeOf(p); // => true: p mewarisi Object.prototype

atribut kelas

atribut kelas objek ialah rentetan yang mengandungi maklumat tentang jenis objek. ECMAScript 3 mahupun ECMAScript 5 tidak menyediakan keupayaan untuk menukar atribut ini dan hanya menyediakan cara tidak langsung untuk menentukan nilainya. Secara lalai, kaedah toString() (diwarisi daripada Object.prototype) mengembalikan rentetan seperti:

Oleh itu, untuk menentukan kelas objek, anda boleh cuba memanggil kaedah toString() objek ini dan mengekstrak subrentetan daripada aksara kelapan kepada aksara kedua daripada hasil carian. Bahagian yang sukar ialah banyak kaedah mewarisi daripada pelaksanaan toString() yang lain yang lebih berguna dan untuk memanggil versi toString() yang betul anda perlu membuat panggilan tidak langsung menggunakan kaedah Function.call().

Contoh di bawah mentakrifkan fungsi yang mengembalikan kelas mana-mana objek yang dihantar kepadanya:

// Nama fungsi kelas objek classof(obj) ( if (obj === null) kembalikan "Null"; if (obj === undefined) kembalikan "Undefined"; kembalikan Object.prototype.toString.call(obj) .slice (8,-1); )

Fungsi classof() ini boleh menghantar sebarang nilai yang dibenarkan dalam JavaScript. Nombor, rentetan dan boolean bertindak seperti objek apabila toString() dipanggil padanya, tetapi nilai nol dan tidak ditentukan dilayan secara berbeza.

atribut boleh diperluaskan

Atribut yang boleh diperluaskan bagi objek menentukan sama ada sifat baharu boleh ditambah pada objek. Dalam ECMAScript 3, semua objek terbina dalam dan ditentukan pengguna boleh dilanjutkan secara tersirat, dan kebolehlanjutan objek masa jalan adalah khusus pelaksanaan. Dalam ECMAScript 5, semua objek terbina dalam dan ditakrifkan pengguna boleh dilanjutkan melainkan ia telah ditukar kepada objek tidak boleh dilanjutkan, dan kebolehlanjutan objek masa jalan masih khusus pelaksanaan.

Piawaian ECMAScript 5 mentakrifkan fungsi untuk mendapatkan dan menukar atribut kebolehlanjutan sesuatu objek. Untuk menentukan sama ada objek boleh dilanjutkan, anda mesti menyerahkannya kepada kaedah Object.isExtensible(). Untuk menjadikan objek tidak boleh dipanjangkan, anda perlu menghantarnya ke kaedah Object.preventExtensions(). Ambil perhatian bahawa apabila objek dibuat tidak boleh dipanjangkan, ia tidak boleh dipanjangkan lagi. Ambil perhatian juga bahawa panggilan untuk preventExtensions() hanya mempengaruhi kebolehlanjutan objek itu sendiri. Jika sifat baharu ditambahkan pada prototaip objek tidak boleh dipanjangkan, objek tidak boleh dipanjangkan akan mewarisi sifat baharu tersebut.

Tujuan atribut boleh diperluaskan adalah untuk membolehkan objek "membetulkan" dalam keadaan tertentu, melarang perubahan. Atribut objek yang boleh diperluaskan sering digunakan bersama dengan atribut sifat boleh dikonfigurasikan dan boleh ditulis, jadi ECMAScript 5 mentakrifkan fungsi yang memudahkan untuk menetapkan atribut ini pada masa yang sama.

Kaedah Object.seal() bertindak seperti kaedah Object.preventExtensions(), tetapi ia bukan sahaja menjadikan objek tidak boleh dilanjutkan, ia juga menjadikan semua sifat objek itu tidak boleh dikonfigurasikan. Iaitu, sifat baharu tidak boleh ditambahkan pada objek, dan sifat sedia ada tidak boleh dipadam atau dikonfigurasikan. Walau bagaimanapun, sifat boleh tulis sedia ada masih boleh diubah.

Setelah Object.seal() dipanggil, objek tidak boleh dikembalikan ke keadaan sebelumnya. Untuk menentukan sama ada kaedah Object.seal() telah dipanggil pada objek, anda boleh memanggil kaedah tersebut Object.isSealed().

Kaedah Object.freeze() menyediakan penetapan objek yang lebih tegar. Selain menjadikan objek tidak boleh dilanjutkan dan sifatnya tidak boleh dikonfigurasikan, ia juga menjadikan semua sifat data asli baca sahaja. (Ini tidak terpakai pada sifat objek dengan kaedah pengakses yang mempunyai kaedah tulis; kaedah tersebut masih akan dipanggil oleh pernyataan tugasan.) Untuk menentukan sama ada kaedah Object.freeze() objek telah dipanggil, anda boleh memanggil Object.isFrozen().

Adalah penting untuk memahami bahawa Object.seal() dan Object.freeze() hanya mempengaruhi objek yang dihantar kepada mereka: mereka tidak menjejaskan prototaip objek itu. Jika program anda perlu melakukan sepenuhnya objek, anda mungkin juga perlu menangkap objek dalam rantai prototaip.

Pensirian Objek

Pensirian objek ialah proses menukar objek kepada bentuk perwakilan rentetan, yang kemudiannya boleh digunakan untuk memulihkannya. ECMAScript 5 menyediakan fungsi terbina dalam untuk mensiri dan memulihkan objek JavaScript JSON.stringify() Dan JSON.parse(). Fungsi ini menggunakan format pertukaran data JSON. Nama JSON berasal daripada "Notasi Objek JavaScript" (satu bentuk tatatanda objek JavaScript), dan sintaks tatatanda ini serupa dengan sintaks objek dan literal tatasusunan dalam JavaScript:

Var obj = (x:1, y:(z:)); // Tentukan objek ujian var s = JSON.stringify(obj); // s == "("x":1,"y":("z":))" var p = JSON.parse(s); // p - salinan objek obj

Sintaks format JSON hanyalah subset sintaks JavaScript dan tidak boleh digunakan untuk mewakili semua kemungkinan nilai yang dibenarkan dalam JavaScript. Disokong dan boleh disiri dan dipulihkan: objek, tatasusunan, rentetan, nilai angka terhingga, benar, palsu dan nol. Nilai NaN, Infinity dan -Infinity diserikan kepada null. Objek tarikh disiri ke dalam rentetan tarikh format ISO, tetapi JSON.parse() meninggalkannya dalam perwakilan rentetan dan tidak memulihkan objek Tarikh asal.

Objek Fungsi, RegExp dan Ralat dan nilai yang tidak ditentukan tidak boleh disiri atau dipulihkan. Fungsi JSON.stringify() hanya mensiri sifat asli objek yang boleh dikira. Jika nilai harta tidak boleh bersiri, harta itu hanya dikecualikan daripada perwakilan rentetan. Kedua-dua JSON.stringify() dan JSON.parse() mengambil hujah kedua pilihan yang boleh digunakan untuk menyesuaikan proses bersiri dan/atau pemulihan, contohnya dengan mentakrifkan senarai sifat untuk disirikan atau fungsi untuk mengubah nilai semasa bersiri.

Lawatan ke sumber web ialah URI khusus dalam bar alamat pelayar. Pelawat menentukan alamat halaman dan ia dihuraikan oleh penyemak imbas ke dalam elemen pepohon DOM - Model Objek Dokumen. Mana-mana pautan pada halaman ini memberitahu pelayar untuk menghuraikan halaman lain dan membina pepohon objek lain.

Pelayar membenarkan pelawat untuk kembali atau ke hadapan melalui rangkaian halaman yang telah dilihat dalam sesi semasa.

Malah, tindakan pengguna adalah pergerakan antara sistem objek yang terbentuk dalam proses melawat halaman. Setiap halaman ialah pepohon DOM sendiri dan, sebagai tambahan, objek JavaScript ialah objek sintaks bahasa itu sendiri dan penerangan pengguna.

DOM: memuatkan, mengemas kini dan menukar

Terdapat tiga pilihan utama yang membentuk objek halaman sumber web, kedua-duanya pada tahap DOM dan bahasa JavaScript itu sendiri, yang melaksanakan binaan penciptaan pembolehubah dan berdasarkan huraian yang dibuat oleh pembangun:

• memuatkan - pelawat datang ke halaman tapak;
• kemas kini - pelawat (butang pelayar atau Ctrl-F5);
• menukar elemen halaman, contohnya (AJAX, skrip, acara, ...).

Ketiga-tiga proses pada asasnya berbeza, tetapi membezakan ciri-ciri dua yang pertama adalah sangat penting. Sukar untuk menghalang pelawat daripada menyegarkan halaman - ini adalah tabiat pelawat "buruk" yang tidak boleh dihapuskan yang perlu diingat oleh pembangun.

Navigasi pada halaman dan seterusnya harus terletak semata-mata pada kefungsian halaman itu sendiri, dan bukan pada sejarah penyemak imbas dan fungsi butangnya. Banyak tapak mengisytiharkan keperluan penting ini, tetapi pelawat secara tradisinya melanggarnya.

Menukar halaman tanpa memuatkannya semula pada tahap elemen individunya (contohnya, AJAX) adalah penyelesaian biasa untuk halaman dinamik. Sebagai peraturan, ini digunakan untuk menavigasi elemen halaman, menukar objeknya dan mengurus dialog dengan pelawat.

Objek JavaScript Asas

JavaScript adalah berasaskan objek. Hampir semuanya pembolehubah bahasa- ini adalah objek. Pembangun boleh merumus penerangan sendiri objek menggunakan pelbagai pilihan sintaks.

Apa-apa sahaja yang bukan "rentetan", "nombor", benar, palsu, batal atau tidak ditentukan ialah objek. Dalam rangka kerja sintaks bahasa, ini boleh diabaikan, bermakna objek hanyalah elemen DOM dan mereka sendiri Penerangan JavaScript Objek. Struktur asas bahasa dalam kebanyakan kes tidak mempunyai kepentingan praktikal yang ketara untuk pembangun.

Sebagai contoh, fungsi matematik diwakili oleh objek Matematik. Ini mudah dalam rangka konsep bahasa, tetapi bagi pembangun ia hanyalah sintaks yang mudah untuk menggunakan senjata operasi matematik yang diperlukan.

Adalah penting untuk bekerja dengan betul dengan DOM dan menerangkan objek anda sendiri dengan betul. Sintaks fungsi dan ungkapan objek JavaScript untuk kegunaannya ialah satu bentuk merekodkan logik algoritma yang diperlukan.

Rentetan, Tatasusunan dan Objek

Semua objek JavaScript adalah berdasarkan peraturan: "property" = "value" dan konsep tatasusunan bersekutu. Dalam sangat kes mudah Objek JavaScript ialah koleksi harta = pasangan nilai. Walau bagaimanapun, "nilai" mungkin tidak selalunya nombor, dan harta itu tidak selalu ditulis tanpa petikan.

Anda tidak seharusnya terlalu menggunakan penamaan harta. Ideal apabila nama harta hanya mengandungi aksara abjad Latin, memenuhi keperluan untuk menamakan pembolehubah dan bukan kata kunci (termasuk dikhaskan) bahasa.

Tiada susunan sifat dijangka, tetapi apabila mencipta atau memulakan tatasusunan bersekutu, agak boleh diterima untuk mengetahui cara elemennya disusun. Ia tidak disyorkan untuk menggunakan keadaan ini, tetapi adalah mungkin untuk mengingatinya.

Memulakan tatasusunan sifat bermakna serentak:

• mencipta tatasusunan;
• penciptaan objek.

Dalam konteks aplikasi tertentu, anda boleh menganggap objek JavaScript sebagai tatasusunan bersekutu, dan di tempat lain dalam algoritma sebagai objek, tetapkan kaedah yang diperlukan kepadanya, tukar nilai elemennya.

Oleh kerana nama harta dan nilainya mesti dinyatakan dalam format rentetan apabila dibuat atau diubah suai, adalah disyorkan untuk menggunakan tatatanda rentetan dan tanda petikan.

Mengakses Sifat Objek

Anda boleh mendapatkan dan menukar nilai sifat objek menggunakan pembinaan Object.keys: JavaScript menjana tatasusunan semua sifat objek. Apabila objek dicipta secara dinamik, pembinaan ini sangat mudah, kerana ia secara automatik menjana senarai semua sifat yang terdapat dalam objek.

Dalam contoh ini, dua tatasusunan diterangkan dalam cara yang berbeza. Dalam aplikasi, kedua-dua tatasusunan adalah setara, kerana ia mengandungi sifat nama yang sama dan nilainya. Gelung berulang melalui semua sifat tatasusunan kedua dan menjana rentetan semua nilai.

Kesan yang serupa boleh dicapai dalam notasi titik atau kurungan:

• x1_Obj.NameLast;
• x1_Obj ["Nama Pertama" ].

Kedua-dua pembinaan adalah sah dan memberikan hasil yang diingini. Dalam contoh di atas, apabila menentukan tatasusunan melalui pendakap kerinting "()", ralat mungkin dibuat dalam bentuk simbol "," pada penghujung penghitungan (ditandakan dalam contoh dengan bulatan merah). Penyemak imbas biasanya mengabaikan aksara tambahan dalam penghitungan, tetapi lebih baik jangan lakukan ini.

Mengalih keluar sifat objek

Oleh kerana objek adalah tatasusunan bersekutu, operasi Objek padam JavaScript dilaksanakan pada tahap objek semasa (apabila mewarisi - ini penting) dan dipertimbangkan pada pengumpulan sifat objek ini.

Dalam konteks contoh di atas, anda boleh menggunakan binaan berikut:

• padam x1_Obj .NameLast ;
• padam x2_Obj ["Nama Pertama" ];

Pembinaan pertama membuang elemen kedua objek pertama, pembinaan kedua membuang elemen pertama objek kedua. Operator padam tidak berfungsi pada sifat prototaip dan mengembalikan palsu jika harta itu tidak boleh dipadamkan.

Sifat dan kaedah objek

Sintaks sifat dan fungsi objek JavaScript (kaedah) adalah serupa dengan kanun umum sintaks dan semantik bahasa. Malah, sebaliknya adalah benar.

Sifat dan kaedah sesuatu objek ialah variasi menerangkan maklumat dan tindakan yang dibenarkan dengannya melalui paradigma JavaScript berorientasikan objek.

Contoh ini menerangkan objek x3_Obj yang hanya mempunyai dua sifat: item dan pos. Kemudian kaedah hello() telah ditambahkan sebagai fungsi. Akibatnya, nilai objek JavaScript akan mentafsirkan perihalan ini dalam konteks nilai harta seperti yang ditunjukkan dalam tetingkap hasil, iaitu, ia akan meletakkan badan fungsi (1) sebagai nilai.

Apabila memanggil sifat Hello() secara langsung, ia ditafsirkan sebagai kaedah (fungsi) dan hasil (2) ialah pelaksanaan kod kaedah ini.

Kata kunci ini dalam objek

Untuk menavigasi ruang harta objek, pembangun boleh menggunakan kata kunci ini dan merujuknya kepada sifat yang diterangkan untuk mendapatkan atau menukar nilainya.

Ini hanyalah permulaan untuk menerangkan objek dengan hanya badan pembina. Contoh ini menerangkan objek untuk bekerja dengan kuki. Objek dimulakan apabila halaman dimuatkan oleh binaan berikut:

• var oCookie = scCookies baharu(cOwnerCode);
• oCookie.Init();

Dalam contoh ini, coOwnerCode ialah kod pelawat unik. Jika ia tidak ada, maka kod baharu akan dibuat dalam pembina objek oCookie. Tidak kira apa yang dimaksudkan oleh pembangun objek ini dengan kebenaran pelawat, yang penting ialah cara kata kunci ini digunakan di sini untuk menerangkan kaedah objek dan cara ia dipanggil daripada kaedah objek lain:

• ini .GetCookie = function (cName) ( ... );
• ini .SetCookie = fungsi (cName, cValue) ( ​​​​... ).

Ini menerangkan kaedah objek untuk membaca kuki dengan namanya dan menulis nilai kuki dengan nama tertentu.

• ini .GetCookie("cOwner");
• this .SetCookie ( "cowner" , cOwner );

Ini adalah bagaimana ia digunakan, jika sebagai hasil daripada pembinaan pertama nilai tidak diwakili, maka pembinaan kedua menetapkannya.

Contoh objek untuk bekerja dengan kuki

Anda boleh membincangkan Objek dan paradigma pendekatan berorientasikan objek bagi bahasa yang beroperasi dalam persekitaran pelayar. Ia menarik, tetapi pada hakikatnya ia memerlukan latihan, bukan teori. Layan halaman DOM, Menyediakan alat untuk memanipulasi objek dan bergerak melalui sistem objek adalah kekuatan JavaScript.

Dalam amalan berorientasikan objek, sesuatu yang lain adalah penting. Bekerja dengan kuki pada hampir semua sumber web adalah setara untuk kursus. Melaksanakan ini dalam format objek adalah idea yang bagus. Dalam konteks ini, pemulaan objek berlaku pada saat halaman dibuka: halaman dimuatkan = objek kuki wujud dan semuanya telah dibaca, dan apa yang tidak ada dicipta.

Semasa bekerja dengan halaman, pelawat melakukan tindakan tertentu dan penyemak imbas mesti menukar atau membuat kuki. Terdapat dua kaedah objek (dilabelkan di atas) yang melakukan ini.

Malah, objek kuki muncul serta-merta selepas penyemak imbas membina DOM dan menambah fungsi baharu pada sistem objek JavaScript: membaca dan mencipta (mengubah suai) kuki.

Mengenai ini contoh mudah dianggap sebagai prosedur untuk mencipta objek sebenar yang mempunyai sifat dan fungsi (kaedah) mereka sendiri secara eksklusif. Setiap objek melakukan tugasnya sendiri dan tidak mengambil bahagian dalam algoritma umum, tidak mengubah data objek lain atau ruang bersama nama

Dengan pendekatan ini, pembangun memastikan penciptaan sistem objek unik yang mencukupi untuk menerangkan dan memberi perkhidmatan kepada masalah yang sedang diselesaikan.

Peristiwa halaman dan objek

Elemen penting bagi fungsi DOM dan JavaScript: acara objek "s - yang membolehkan anda mendapatkan maklumat tentang acara dalam pengendalinya. Hampir setiap elemen halaman boleh diberikan pengendalinya sendiri untuk satu atau lebih acara.

Sebenarnya, pembangun JavaScript tidak mencipta satu "kepingan" kod yang besar, tetapi banyak perihalan fungsi, objek, struktur data dan serah hak elemen tertentu halaman pengendali acara.

Peristiwa objek ialah maklumat tentang peristiwa yang menyebabkan pengendali dan keupayaan pengendali ini melakukan tindak balas yang mencukupi terhadap peristiwa ini. Setiap peristiwa berbeza bukan sahaja dalam nama dan tempat kejadian, tetapi juga dalam banyak parameter lain.

Khususnya, acara papan kekunci ialah satu set parameter, acara tetikus ialah julat data yang sama sekali berbeza, dan tindak balas pelayan melalui AJAX dirancang sepenuhnya oleh pembangun sendiri.

Dalam setiap kes tertentu, gambar peristiwa yang boleh berlaku pada halaman diubah menjadi julat pengendali yang didayakan; di luar pilihan yang disediakan untuk memproses set acara tertentu, halaman tidak mengambil sebarang tindakan.

Penciptaan dan pengendalian objek

Penyemak imbas "mengubah" URI, alamat sumber web yang ditentukan oleh pelawat, ke dalam pepohon DOM - sistem objek halaman sumber web ini. Apabila pelawat mengikuti pautan pada halaman, penyemak imbas pergi ke pepohon halaman lain yang sepadan.

Keadaan ini membolehkan pembangun membina sistem objeknya sebagai asas sumber web yang bertindak balas secukupnya kepada gelagat pelawat. Jika anda mengasingkan fungsi umum, contohnya:

• bekerja dengan kuki;
• menerima/menghantar data (AJAX);
• petua alat;
• mesej dalaman (sembang laman web);
• tugas lain;

maka, setelah dibuat, sistem objek boleh digunakan apabila membangunkan tapak lain. Ini adalah kelebihan ketara pendekatan objek berbanding penggunaan biasa JavaScript sebagai bahasa penyemak imbas yang memastikan halaman berfungsi dan tindak balas kepada peristiwa.

Objek ialah komponen lengkap yang boleh diformatkan sebagai fail berasingan dan digunakan pada masa hadapan. Ciri ciri pendekatan ini ialah kemungkinan maklum balas, apabila objek yang dikemas kini dan dipertingkatkan boleh digunakan dalam pembangunan sebelumnya, mengemas kini fungsinya secara automatik tanpa mengubah suai tapak.