Javascript Object: paglikha ng mga bagay at nagtatrabaho sa kanila. Mga katangian at pamamaraan ng mga bagay. Paglikha ng bagong bagay

Huling na-update: 04/08/2018

Ang Object-oriented na programming ay isa sa mga nangingibabaw na paradigms sa pagbuo ng application ngayon, at sa JavaScript ay maaari rin nating lubos na mapakinabangan ang OOP. Kasabay nito, may kaugnayan sa JavaScript, ang object-oriented na programming ay may ilang mga tampok.

Mga bagay

Sa mga nakaraang paksa, nagtrabaho kami gamit ang primitive na data - mga numero, string, ngunit hindi palaging kinakatawan ng data ang mga primitive na uri. Halimbawa, kung sa ating programa kailangan nating ilarawan ang kakanyahan ng isang tao na may pangalan, edad, kasarian, at iba pa, natural na hindi natin magagawang ilarawan ang kakanyahan ng isang tao bilang isang numero o string. Kakailanganin natin ng ilang linya o numero para maayos na mailarawan ang tao. Kaugnay nito, ang isang tao ay kikilos bilang isang kumplikadong kumplikadong istraktura, na magkakaroon ng mga indibidwal na katangian - edad, taas, unang pangalan, apelyido, atbp.

Upang gumana sa gayong mga istruktura, ginagamit ng JavaScript ang . Ang bawat bagay ay maaaring mag-imbak ng mga katangian na naglalarawan sa estado nito at mga pamamaraan na naglalarawan sa pag-uugali nito

Paglikha ng bagong bagay

Mayroong ilang mga paraan upang lumikha ng isang bagong bagay.

Ang unang paraan ay ang paggamit ng Object constructor:

Var user = bagong Bagay();

Sa kasong ito, ang bagay ay tinatawag na user. Ito ay tinukoy sa parehong paraan tulad ng anumang regular na variable gamit ang var keyword.

Ang expression na new Object() ay kumakatawan sa isang tawag sa isang constructor - isang function na lumilikha bagong bagay. Ang bagong operator ay ginagamit upang tawagan ang constructor. Ang pagtawag sa isang constructor ay mahalagang tulad ng pagtawag sa isang regular na function.

Ang pangalawang paraan upang lumikha ng isang bagay ay sa pamamagitan ng paggamit ng mga kulot na braces:

Var user = ();

Ngayon, ang pangalawang paraan ay mas karaniwan.

Mga katangian ng bagay

Pagkatapos lumikha ng isang bagay, maaari naming tukuyin ang mga katangian dito. Upang tukuyin ang isang property, kailangan mong tukuyin ang pangalan ng property pagkatapos ng pangalan ng object, na pinaghihiwalay ng isang tuldok, at magtalaga ng value dito:

Var user = (); user.name = "Tom"; user.age = 26;

Sa kasong ito, dalawang pangalan ng property at edad ang idineklara at itinalaga ang mga katumbas na halaga. Pagkatapos nito, maaari naming gamitin ang mga katangiang ito, halimbawa, ipakita ang kanilang mga halaga sa console:

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

Maaari mo ring tukuyin ang mga katangian kapag tinutukoy ang isang bagay:

Var user = ( pangalan: "Tom", edad: 26 );

Sa kasong ito, ginagamit ang isang colon na character upang magtalaga ng isang halaga sa property, at isang kuwit (sa halip na isang semicolon) ay inilalagay pagkatapos ng kahulugan ng property.

Bilang karagdagan, mayroong isang shortcut na paraan upang tukuyin ang mga katangian:

Var name = "Tom"; var edad = 34; var user = (pangalan, edad); console.log(user.name); // Tom console.log(user.age); // 34

Sa kasong ito, ang mga pangalan ng mga variable ay ang mga pangalan din ng mga katangian ng bagay. At sa ganitong paraan maaari kang lumikha ng mas kumplikadong mga disenyo:

Var name = "Tom"; var edad = 34; var user = (pangalan, edad); var teacher = (gumagamit, kurso: "JavaScript"); console.log(teacher.user); // (pangalan: "Tom", edad: 34) console.log(teacher.course); // JavaScript

Mga Paraan ng Bagay

Tinutukoy ng mga pamamaraan ng isang bagay ang pag-uugali nito, o ang mga aksyon na ginagawa nito. Ang mga pamamaraan ay mga pag-andar. Halimbawa, tukuyin natin ang isang paraan na magpapakita ng pangalan at edad ng isang tao:

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

Tulad ng mga function, ang mga pamamaraan ay unang tinukoy at pagkatapos ay tinawag.

Ang mga pamamaraan ay maaari ding direktang tukuyin kapag tinutukoy ang isang bagay:

Var user = ( pangalan: "Tom", edad: 26, display: function())( console.log(this.name); console.log(this.age); ) );

Tulad ng mga pag-aari, ang isang pamamaraan ay itinalaga ng isang sanggunian ng function gamit ang isang tutuldok.

Upang ma-access ang mga katangian o pamamaraan ng isang bagay sa loob ng bagay na iyon, ginagamit ang keyword na ito. Nangangahulugan ito ng isang sanggunian sa kasalukuyang bagay.

Maaari ka ring gumamit ng shorthand na paraan upang tukuyin ang mga pamamaraan sa pamamagitan ng pag-alis sa colon at function:

Var user = ( pangalan: "Tom", edad: 26, display())( console.log(this.name, this.age); ), move(place)( console.log(this.name, "pupunta sa " , lugar); user.display(); // Tom 26 user.move("the shop"); //Pumunta si Tom sa tindahan

Syntax ng array

Mayroon ding alternatibong paraan upang tukuyin ang mga katangian at pamamaraan gamit ang array syntax:

Var user = (); user["name"] = "Tom"; user["edad"] = 26; user["display"] = function())( console.log(user.name); console.log(user.age); ); // calling the method user ["display"]();

Ang pangalan ng bawat ari-arian o pamamaraan ay nakapaloob sa mga quotation mark at square bracket, pagkatapos ay bibigyan din ito ng halaga. Halimbawa, user["age"] = 26 .

Kapag ina-access ang mga katangian at pamamaraang ito, maaari kang gumamit ng tuldok na notasyon (user.name) o gumamit ng user["pangalan"]

Mga String bilang Mga Katangian at Paraan

Dapat ding tandaan na ang mga pangalan ng mga katangian at pamamaraan ng bagay ay palaging mga string. Iyon ay, maaari naming muling isulat ang nakaraang kahulugan ng bagay tulad nito:

Var user = ( "pangalan": "Tom", "edad": 26, "display": function())( console.log(user.name); console.log(user.age); ) ); // method call user.display();

Sa isang banda, walang pagkakaiba sa pagitan ng dalawang kahulugan. Sa kabilang banda, may mga kaso kung saan ang paglalagay ng pamagat sa isang linya ay makakatulong. Halimbawa, kung ang pangalan ng property ay binubuo ng dalawang salita na pinaghihiwalay ng isang puwang:

Var user = ( pangalan: "Tom", edad: 26, "buong pangalan": "Tom Johns", "display info": function())( console.log(user.name); console.log(user.age ); console.log(user["buong pangalan"]); user["display info"]();

Sa kasong ito lamang, upang ma-access ang mga naturang katangian at pamamaraan, dapat nating gamitin ang array syntax.

Pag-aalis ng mga katangian

Sa itaas ay tiningnan namin kung paano namin dynamic na magdagdag ng mga bagong katangian sa isang bagay. Gayunpaman, maaari rin naming tanggalin ang mga katangian at pamamaraan gamit ang delete operator. At tulad ng pagdaragdag, maaari nating alisin ang mga katangian sa dalawang paraan. Ang unang paraan ay ang paggamit ng tuldok na notasyon:

Tanggalin ang object.property

O gumamit ng array syntax:

Tanggalin ang object["property"]

Halimbawa, alisin natin ang property:

Var user = (); user.name = "Tom"; user.age = 26; user.display = function())( console.log(user.name); console.log(user.age); ); console.log(user.name); // Tom tanggalin ang user.name; // tanggalin ang ari-arian // alternatibo // tanggalin ang user ["pangalan"]; console.log(user.name); // hindi natukoy

Pagkatapos ng pagtanggal, ang property ay hindi matukoy, kaya kapag sinubukan mong i-access ito, ibabalik ng program ang halaga na hindi natukoy.

Pagbati sa lahat ng nagbabasa ng publikasyong ito. Ngayon gusto kong gabayan ka sa isang pangunahing tool ng wika - mga bagay na JavaScript. Ipaalala ko sa iyo na ang js ay cross-browser at gumagana sa lahat ng operating system (windows, mac os, atbp.). Hindi tulad ng object-oriented programming language, ang pagpapatupad ng mga object sa js ay malaki ang pagkakaiba sa karaniwang functionality at mga variation sa paggamit ng mga instance, halimbawa, sa C#.

Samakatuwid, pagkatapos basahin ang kasalukuyang artikulo, matututunan mo ang mga pangunahing tampok na nakikilala ng mga bagay sa script, matutunan kung paano sila malikha, mai-update at matanggal. Aanhin ko rin ang paksa ng mga katangian, pamamaraan at konstruktor, at pag-uusapan kapaki-pakinabang na mga utos at siyempre kaunti tungkol sa mana. Sa tingin ko oras na para magsimulang mag-aral!

Ano ang isang bagay sa JavaScript at anong mga kakayahan mayroon ito?

Sa js, ang mga object ay simpleng associative arrays (tinatawag din silang mga hash).

Ano ang isang associative array?

Ito ay isang istraktura ng data na nag-iimbak ng isang tiyak na dami ng impormasyong nauugnay at naglalarawan sa isang partikular na elemento. Ang lahat ng data ay nakaayos at magkakaugnay bilang "key => value".

Halimbawa, kailangan mong ilarawan ang mga kotse. Pagkatapos ay lumikha ka ng isang auto object at ilarawan ang mga katangian nito sa isang array. Nagpasya akong ilarawan ang paggawa ng kotse (pangalan), kulay nito (kulay) at gastos (presyo). Sa ibaba ay inilakip ko ang code para sa pagpapatupad ng inilarawang gawain.

1 2 3 4 5

var avto = ( pangalan: "BMW 116i", kulay: "itim", presyo: 588000 );

Dito makikita mo ang isang paraan upang lumikha ng isang bagay na tinatawag na "avto". Ang pangalan, kulay at presyo ay mga susi na maaaring gamitin sa pagsulat ng aplikasyon.

Nauna ako sa halimbawang ito, kaya ngayon tingnan natin ang lahat sa pagkakasunud-sunod.

Maaari kang lumikha ng isang bagay sa maraming paraan:

var auto = (); o var auto = bagong Bagay();

Sa parehong mga kaso, isang walang laman na bagay ang nilikha gamit ang sikat na pangalan, ngunit ang unang pagpipilian ay ginagamit nang mas madalas, dahil ito ay mas maikli at mas maginhawang magsulat.

Lahat tungkol sa mga ari-arian

Ngayon ay kailangan mong punan ang walang laman na bagay na may mga parameter. Upang gawin ito, kailangan mong magdagdag ng mga katangian, na tinawag ko ring mga susi sa itaas. Muli, mayroong dalawang paraan upang magdeklara ng mga ari-arian.

Gusto kong tandaan na ang JavaScript ay walang mahigpit na balangkas para sa paglikha at pagsisimula ng mga naturang parameter. Maaaring lumabas ang mga bagong property sa buong code, tulad ng pagtanggal at pag-update ng mga ito.

Kaya, maaari mong gawin ang lahat ng mga susi nang sabay-sabay o ipahayag ang mga ito kapag magagamit na ang mga ito. At kahit na, habang nagsusulat ng isang programa, sumangguni ka sa mga hindi umiiral na mga susi, walang magiging error. Sa kasong ito, ibabalik ang "undefined".

Unang paraan.

Paglikha at pag-access ng mga katangian gamit ang isang tuldok. Upang ipatupad ang pagpipiliang ito, kailangan mong isulat ang pangalan ng bagay, at pagkatapos ay idagdag ang pangalan ng susi dito sa pamamagitan ng isang tuldok at pagkatapos ay magtalaga ng ilang halaga sa pamamagitan ng pantay na tanda:

avto.name = “BMW 116i”

Ngunit sa paraang ito ay magdaragdag ka ng isa pang elemento sa umiiral na mga susi:

Ginagamit ang paraang ito kapag alam na ang pangalan ng property at kailangan mong gumawa ng ilang partikular na pagkilos gamit ang mga value.

Pangalawang paraan.

Walang pinagkaiba sa una, kung ihahambing mo ang kanilang mga layunin. Gayunpaman, ang pamamaraang ito ay may kaunting kalamangan. Para sa pagpipiliang ito, ginagamit ang mga square bracket:

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

Ang isang magandang karagdagan ay ang kakayahang lumikha ng mga pangalan ng ari-arian sa anyo ng anumang string. Halimbawa,

avto[“pangalan ng kotse”] = “BMW 116i”

Ang pagtatrabaho sa mga susi sa pamamagitan ng mga square bracket ay ginagamit kapag ang ilang mga parameter ay ipinasok ng gumagamit at naka-imbak sa mga variable o kapag ang mga pangalan ng mga katangian ay hindi alam nang maaga. Halimbawa, hinihiling ng user ang presyo ng napiling kotse. Ang elementong tinawag ay isinulat sa variable, at ang presyo ay ipinadala bilang tugon:

var auto = (); avto.name = "BMW_116i"; avto.price = 588000; var key = "presyo"; // ang presyo ng kotse ay hiniling na alerto(avto);

Ngayon ay lumipat tayo sa pagtanggal ng mga katangian. Napakasimple ng lahat dito. Upang alisin, gamitin ang command tanggalin. Kaya, kung idagdag mo ang sumusunod na 2 linya sa huling halimbawa sa ibaba:

tanggalin ang auto.price;

alerto(auto);

Pagkatapos, kapag tumatawag ng alerto sa pangalawang pagkakataon, ang dialog box ay magpapakita ng "hindi natukoy".

Ang ilang mga salita tungkol sa pagiging compactness

Sa kasalukuyang yugto, sinabi ko sa iyo kung paano lumikha ng isang bagay at ilarawan ang mga katangian nito. Nag-attach ako ng mga halimbawa ng pagsubok dito, ngunit ang pinaka-matulungin sa inyo, mahal na mga mambabasa, ay napansin na ang unang code ng programa ay medyo naiiba sa lahat ng iba pa.

At lahat dahil gumagamit ito ng isang compact na representasyon ng data. Ito ay isang napaka-tanyag na paraan ng pagdedeklara ng mga susi dahil ito ay mas maikli sa pagsulat at mas madaling maunawaan nang biswal.

Dumaan tayo sa ating mga ari-arian

Sa JavaScript, maaari mong mabilis na umulit sa pamamagitan ng mga ginawang katangian. Para sa layuning ito, isang espesyal na mekanismo ang ibinigay, na mas kilala bilang ikot.

Kung pamilyar ka sa iba pang mga programming language, alam mo na kadalasang ginagawa ang mga loop gamit ang salita para sa, pagkatapos ay nakasulat sa panaklong ang kundisyon para sa pag-enumerate ng mga elemento.

Sa js ito ay nagpapaalala nito hitsura ikot foreach mula sa wikang C#. Tingnan ang pangkalahatang disenyo:

para sa (var obj sa object) ( // nagsasagawa ng paghahanap)

kung saan ang obj ay responsable para sa pangalan ng mga enumerated key,

bagay – para sa kanilang mga halaga.

At ngayon narito ang isang konkretong halimbawa para sa iyo.

1 2 3 4 5 6 7 8

var avto = ( pangalan: "BMW 116i", kulay: "itim", presyo: 588000 ); para sa (var obj sa bagay) ( alerto(obj + ":" + object) )

Panahon na upang maging pamilyar sa mga pamamaraan

Nagbibigay ang wika ng script para sa paglikha ng mga pamamaraan. Ito ay isang ganap na simpleng mekanismo kung saan sa anumang oras maaari kang magdagdag ng isang paraan o mga pamamaraan sa anumang bagay na nagpapalawak ng mga kakayahan ng nilikha na mga associative array. Tinatawag din silang mga katangian ng pag-andar.

Ang Js mismo ay napaka-dynamic at kamangha-manghang sa ilang lawak. Ito ay kung paano malikha ang mga elemento iba't ibang uri. Kapag nag-aaral ng wikang ito, hindi mo kailangang kabisaduhin ang mga kumplikadong istruktura, dahil maraming mga deklarasyon ang halos magkapareho sa bawat isa.

Kaya, upang lumikha ng isang paraan, kailangan mong magdeklara ng isang bagay, at pagkatapos ay simulan ang pagsusulat ng isang utos na eksaktong katulad ng paglikha ng mga katangian. Gayunpaman, pagkatapos ng “=” hindi na ang value ang isinulat, kundi ang keyword function (variable). At pagkatapos ay nakalista ang mga aksyon sa mga kulot na bracket.

Narito ang pagpapatupad ng mekanismong ito:

var avto =() avto.name = “BMV” avto.year = 1999 avto.drive = function(k) ( alert(“Nakalipas ang sasakyan”+n+“ km.”)) avto.drive(300) avto. pagmamaneho( 450)

Tulad ng nakikita mo, ang halimbawang ito ay naglalaman ng mga katangian at pamamaraan na ang mga tawag ay sa una ay magkapareho.

May mga constructor din ba ang JS?

tama yan! Sa wikang ito, lahat ng gumagamit ng keyword na " bago", awtomatikong nagiging constructor. Kaya, sa itaas nakita mo ang deklarasyon ng isang walang laman na bagay sa anyo: avto = new Object ();. Ito ang tagabuo.

Para sa kalinawan, isaalang-alang ang mga linya sa ibaba.

var bob = bagong Bagay();

bob.name = "Bob Smith";

Gayunpaman, hindi ito ang buong arsenal ng mga posibilidad. Sa js, maaari kang lumikha ng iyong sariling mga konstruktor at pagkatapos ay gamitin ang mga ito upang magdeklara ng mga bagong bagay.

Kaya, gusto kong "gumawa" ng custom na constructor para sa mga umiiral nang kotse. Mangyaring tandaan na ang pangalan ay dapat na nakasulat sa malaking titik. Ito ang tanda ng mga pag-andar. Upang gawin ito, isinusulat ko ang sumusunod na pagpapatupad ng software:

function na Auto (pangalan, presyo) (

ito.pangalan = pangalan;

ito.presyo = presyo;

Ngayon, kapag gumawa ka ng walang limitasyong bilang ng mga bagay at inilapat ang constructor na ito sa kanila, lahat sila ay kabilang sa parehong klase. Halimbawa:

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

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

Bilang karagdagan dito, maaari kang lumikha ng mga pamamaraan sa loob ng constructor.

Mga tampok ng mana sa JavaScript

Karaniwan, sa maraming wika, ang pamana ay batay sa mga klase na maaaring magmana sa isa't isa. Pagkatapos ay maririnig mo ang mga expression tulad ng "klase ng ninuno", "klase ng bata", atbp.

Gayunpaman, sa js lahat ay naiiba. Ito ay kung saan ang mga bagay ay minana.

Ang lahat ng mana ay nakabatay sa panloob na link sa pagitan ng mga bagay, na kilala bilang isang "prototype". Kung idinagdag mo ang ".prototype" sa isang paraan gamit ang isang tuldok, at pagkatapos ay ilagay ang pangalan ng prototype, ang lahat ng mga bagay ng napiling paraan ay mamanahin mula sa prototype na ito.

Lumipat tayo sa isang halimbawa.

function Transport (pangalan) ( this.name = name this.canDrive = true ) var transport = bagong Transport ("avto") // gumawa ng transport object function Bike (pangalan) ( this.name = pangalan ) Bike.prototype = transport / / tukuyin na lahat ng bagong object ng klase na ito ay gagamit ng transport bike1 = new Bike ("for_sport") bike2= new Bike ("for_child") console.log(bike1.name) console.log(bike2.name) console .log (bike1.canDrive)

Dito na yata ako magtatapos. Sinabi ko sa iyo ang tungkol sa mga pangunahing aspeto ng isang scripting language. Gayunpaman, ito ay mababaw na kaalaman lamang. Sa susunod ay lalalim pa tayo. Samantala, huwag kalimutang sumali sa mga ranggo ng aking mga tagasuskribi at ibahagi ang link sa artikulo sa iyong mga kaibigan. Good luck!

paalam na!

Pinakamahusay na pagbati, Roman Chueshov

Basahin: 97 beses

Ang mga bagay ay ang pundasyon ng JavaScript. Maraming mga built-in na uri ng data ang kinakatawan bilang mga bagay. Upang maging matagumpay na developer JavaScript, kailangan mong magkaroon ng malinaw na pag-unawa sa kung paano gumagana ang mga ito. Ang mga bloke ng gusali ng isang bagay ay tinatawag na mga field nito o mga katangian ng object ng JavaScript. Ginagamit ang mga ito upang ilarawan ang anumang aspeto ng isang bagay. Maaaring ilarawan ng property ang haba ng isang listahan, ang kulay ng langit, o ang petsa ng kapanganakan ng isang tao. Ang paglikha ng mga bagay ay isang madaling proseso. Ang wika ay nagbibigay ng isang syntax na kilala bilang mga literal ng bagay, na tinutukoy ng mga kulot na brace.

Pag-access sa Mga Katangian

Ang wika ay nagbibigay ng dalawang entry para sa pag-access ng mga katangian. Ang una at pinakakaraniwan ay kilala bilang dot notation. Sa notasyon ng tuldok, maaaring ma-access ang isang mapagkukunan sa pamamagitan ng pagtukoy sa pangalan ng host object, na sinusundan ng tuldok at pangalan ng property. Halimbawa, kapag ang object.foo ay unang naitalaga sa value na isa, ang value nito ay magiging 2 pagkatapos maisagawa ang JavaScript objects statement.

Ang isang alternatibong access syntax ay kilala bilang bracket notation. Sa notasyon, ang pangalan ng bagay ay sinusundan ng isang hanay ng mga square bracket. Sa kanila, ang pangalan ng property ay tinukoy bilang isang string:

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

Ito ay mas nagpapahayag kaysa sa dot notation dahil pinapayagan nito ang isang variable na tukuyin ang lahat o bahagi ng isang pangalan ng property. Posible ito dahil awtomatikong kino-convert ng JavaScript object interpreter ang expression na ito sa isang string at pagkatapos ay nakukuha ang kaukulang property. Mabilis na nilikha ang mga pangalan ng property sa pamamagitan ng pagsasama-sama ng mga nilalaman ng variable f sa string na "oo":

bagay = "bar".

Binibigyang-daan ng bracket notation ang mga pangalan ng property na maglaman ng mga character na ipinagbabawal sa dot notation. Halimbawa, ang sumusunod na pahayag ay ganap na legal sa panaklong. Gayunpaman, kung susubukan ng user na gumawa ng parehong pangalan ng property sa dot notation, makakatagpo sila ng syntax error:

object["!@#$% &*()."] = totoo.

Maaaring ma-access ang mga katangian ng mga nested JavaScript object sa pamamagitan ng mga chaining tuldok at/o panaklong. Halimbawa, ang sumusunod na object ay naglalaman ng nested object na pinangalanang baz na naglalaman ng isa pang object na pinangalanang foo na may property na pinangalanang bar na naglalaman ng value na limang:

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

Ina-access ng mga sumusunod na expression ang bar attached property. Ang unang expression ay gumagamit ng dot notation, habang ang pangalawang expression ay gumagamit ng square notation. Pinagsasama ng ikatlong expression ang parehong mga entry upang makamit ang parehong resulta:

object.baz.foo.bar;
bagay["baz"]["foo"]["bar"];
bagay ["baz"].foo["bar"].

Ang mga ekspresyong tulad ng ipinakita sa nakaraang halimbawa ay maaaring magdulot ng pagkasira ng pagganap kapag maling paggamit at gawing hindi nagagamit ang JavaScript object. Ang pagsusuri sa bawat tuldok o bracket na expression ay nangangailangan ng oras. Kung ginamit nang maraming beses ang parehong property, makatuwirang i-access ang property nang isang beses at pagkatapos ay iimbak ang value sa isang lokal na variable para sa lahat ng paggamit sa hinaharap.

Pag-andar bilang pamamaraan

Kapag ang isang function ay ginamit bilang isang pag-aari ng isang bagay, ito ay tinatawag na isang pamamaraan. Tulad ng mga katangian, tinukoy ang mga ito sa literal na notasyon ng object. Halimbawa:

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

Ang mga pamamaraan ng object ng JavaScript ay maaaring tawagin gamit ang mga marka at panaklong. Tinatawag ng sumusunod na halimbawa ang sum() na paraan mula sa nakaraang halimbawa gamit ang parehong mga entry:

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

Ang literal na notasyon ng object ay kapaki-pakinabang para sa paglikha ng mga bagong bagay, ngunit hindi ito maaaring magdagdag ng mga katangian o pamamaraan sa mga umiiral na. Sa kabutihang-palad, ang pagdaragdag ng bagong data ay kasingdali ng paggawa ng statement ng pagtatalaga. Ang isang walang laman na bagay ay nilikha. Pagkatapos, gamit ang mga operator ng pagtatalaga, nagdaragdag kami ng dalawang katangian, foo, at bar, at ang paraan ng baz:

var object = ();
object.foo = 1;
object.bar = null;
object.baz = function() ( ibalik ang "hello from baz()"; ).

Program Encapsulation

Ang pangunahing ideya ng object-oriented programming ay hatiin ang mga programa sa mas maliliit na bahagi at gawing responsable ang bawat bahagi para sa pamamahala ng sarili nitong estado. Kaya, ang ilang kaalaman tungkol sa kung paano gumagana ang isang bahagi ng isang programa ay maaaring lokal sa bahaging iyon. Ang isang taong nagtatrabaho sa natitirang bahagi ng programa ay hindi dapat matandaan o kahit na malaman ang tungkol dito. Sa tuwing magbabago ang lokal na data na ito, ang code lang sa paligid nito ang kailangang i-update.

Ang iba't ibang bahagi ng naturang programa ay nakikipag-usap sa isa't isa sa pamamagitan ng mga interface, limitadong hanay ng mga function o binding na nagbibigay ng kapaki-pakinabang na functionality sa isang mas abstract na antas habang itinatago ang kanilang eksaktong pagpapatupad. Ang mga nasabing bahagi ng isang programa ay namodelo gamit ang mga bagay. Ang kanilang interface ay binubuo ng isang tiyak na hanay ng mga pamamaraan at katangian. Ang mga katangian na bahagi ng isang interface ay tinatawag na pampubliko. Ang natitira, na hindi dapat hawakan ang panlabas na code, ay tinatawag na pribado.

Maraming mga wika ang nagbibigay ng kakayahang makilala sa pagitan ng pampubliko at pribadong pag-aari at hindi pinapayagan ang panlabas na code na ma-access ang mga pribado. Ang JavaScript, na muling kumukuha ng minimalist na diskarte, ay wala pa. Kasalukuyang isinasagawa ang trabaho upang idagdag ang wikang ito. Samakatuwid, matagumpay na magagamit ng mga programmer ng JavaScript ang ideyang ito. Bilang isang tuntunin, naa-access na interface inilarawan sa dokumentasyon o komento. Karaniwang kasanayan din na maglagay ng underscore (_) sa simula ng mga pangalan ng property upang isaad na pribado ang mga property. Paghihiwalay ng interface mula sa pagpapatupad - magandang ideya. Ito ay karaniwang tinatawag na encapsulation.

Mga Katangian

Ang isang bagay na may panaklong (...) ay tinatawag na literal na bagay. Maaari mong agad na ilagay ang ilang mga katangian sa naturang mga bracket (...). Halimbawa, ipares ang "key: value at iba pa":

let user = ( // isang object name: "John", // by key "name" store value "John" age: 30 // by key "age" store value 30 }.!}

Ang isang property ay may key (kilala rin bilang isang "pangalan" o "identifier") bago ang isang colon ":" at isang halaga sa kanan nito. Ang object ng gumagamit ay may dalawang katangian. Ang resultang user JavaScript object na may dalawang nilagdaang file na may label na "pangalan" at "edad". Maaari kang magdagdag, magtanggal at magbasa ng mga file mula rito anumang oras. Naa-access ang mga value ng property gamit ang dot notation. Maaari itong maging anumang uri. Maaari kang magdagdag ng boolean value. Para mag-alis ng property, gamitin ang delete sa Error case ng isang JavaScript object.

Ang lahat ng mga object ng error sa JavaScript ay mga inapo ng object ng Error o isang minanang object:

Ang Syntax Error object ay namamana mula sa Error object.
JSON Parse error ng isang partikular na uri ng Syntax Error object.

Para mas malalim pa ang pag-unawa sa kung paano nakikitungo ang mga application sa mga error sa JavaScript, tingnang mabuti ang Airbrake JavaScript, isang tool sa pagsubaybay ng error para sa mga real-time na alerto at agarang insight sa kung ano ang naging mali sa iyong JavaScript code.

Mga mensahe ng error na maaaring matanggap ng isang user bago magtanggal ng object ng JavaScript:

Masamang control character sa literal na string.
Masamang karakter sa literal na string.
Mahina ang output ng Unicode.
Masamang karakter sa pagtakas.
Walang katapusang string.
Hindi inaasahang non-numeric code.
Walang mga numero pagkatapos ng decimal point.
Unterminated fractional number.
Walang mga numero pagkatapos ng tagapagpahiwatig ng antas.
Walang mga numero pagkatapos ng exponent sign.
Ang exponential part ay walang numero.
Hindi inaasahang pagtatapos ng data.
Hindi inaasahang keyword.
Isang hindi inaasahang simbolo.
Pagtatapos ng data kapag binabasa ang mga nilalaman ng isang bagay.
Inaasahang pangalan ng pag-aari o ")".

Mga Katangian ng Computational

Maaari kang gumamit ng mga square bracket sa literal na bagay. Ang mga ito ay tinatawag na computed properties. Ang isang halimbawa ay ibinigay sa ibaba.

Ang kahulugan ng isang nakalkulang ari-arian ay simple: nangangahulugan ito na ang pangalan ng ari-arian ay dapat na kinuha mula sa prutas. Kaya kung ang isang bisita ay pumasok sa "mansanas", ang bag ay magiging (mansanas: 5). Maaaring magamit nang higit pa kumplikadong mga ekspresyon sa mga square bracket:

hayaan ang prutas = "mansanas";

: 5 // bag.appleComputers = 5

Ang mga square bracket ay mas malakas kaysa sa dot notation. Pinapayagan nila ang mga pangalan at variable ng property. Pero mas mahirap din silang magsulat. Kaya kadalasan, kapag ang mga pangalan ng ari-arian ay kilala at simple, isang tuldok ang ginagamit. At kung kailangan mo ng isang bagay na mas kumplikado, pagkatapos ay lumipat sa mga square bracket.

Pagpapareserba ng salita

Ang isang variable ay hindi maaaring magkaroon ng isang pangalan na katumbas ng isa sa mga nakalaan na salita tulad ng 'para', 'hayaan', 'bumalik', atbp. Ngunit kapag nag-uuri ng mga bagay sa JavaScript, walang ganoong paghihigpit.

Sa prinsipyo, ang anumang pangalan ay pinapayagan, ngunit mayroong isang espesyal na isa: ito "__proto__" ay nakakakuha ng espesyal na paggamot para sa makasaysayang mga kadahilanan. Halimbawa, hindi mo ito maaaring itakda sa isang halaga maliban sa isang bagay:

obj.__proto__ = 5;

alert(obj.__proto__); // hindi gumana ayon sa nilalayon

Tulad ng nakikita mo mula sa code, ang layunin ng primitive 5 ay hindi pinansin. Ito ay maaaring pagmulan ng mga error at kahit na mga kahinaan kung ang operator ay nagnanais na mag-imbak ng mga arbitrary na key-value pairs sa isang bagay at payagan ang bisita na tukuyin ang mga susi. Sa kasong ito, maaaring piliin ng bisita ang "proto" bilang susi at magdagdag ng JavaScript sa bagay. May isang paraan upang gawing regular na ari-arian ang mga bagay gamit ang __proto__. Mayroon ding isa pang mapa ng mga istruktura ng data na sumusuporta sa mga arbitrary key.

Integer Properties

Ang terminong "integer property" dito ay nangangahulugang isang string na maaaring ma-convert mula sa isang integer nang walang pagbabago. Kaya, halimbawa, ang "49" ay isang integer na pangalan ng property dahil kapag na-convert ito sa isang integer at bumalik muli, ito ay pareho pa rin. Ngunit ang "+49" at "1.2" ay hindi ganoon. Sa kabilang banda, kung ang mga susi ay hindi integer, kung gayon ang mga ito ay nakalista sa pagkakasunud-sunod ng pagkakalikha ng mga ito. Halimbawa sa ibaba.

Upang ayusin ang problema sa mga dialing code, maaari kang "mandaya" sa pamamagitan ng paggawa ng mga code na hindi kumpleto. Pagdaragdag ng "+" (plus sign) bago ang bawat code ay sapat. Ngayon ay gagana ito ayon sa nilalayon.

Ang pagkakaiba sa pagitan ng mga bagay at primitive ay ang mga ito ay naka-imbak at kinopya "sa pamamagitan ng sanggunian". Ang mga primitive na halaga ay itinalaga at kinopya "bilang isang integer na halaga". Ang isang variable ay nag-iimbak ng isang "address sa memorya" sa halip na ang object mismo o isang "reference" dito. Maaari mong gamitin ang anumang variable upang ma-access at baguhin ang mga nilalaman nito.

Ang halimbawa sa itaas ay nagpapakita na mayroon lamang isang bagay at admin upang mag-log in dito. Pagkatapos, kung ibang key (user) ang gagamitin sa ibang pagkakataon, mapapansin ng user ang mga pagbabago.

Ang mga operator ng pagkakapantay-pantay == at mahigpit na pagkakapantay-pantay === para sa mga bagay ay gumagana sa parehong paraan. Ang dalawang bagay ay pantay lamang kung sila ay iisang bagay. Para sa mga paghahambing tulad ng obj1 > obj2 o mga paghahambing sa primitive obj == 5, ang mga bagay ay kino-convert sa primitives. Upang maging tapat, ang mga naturang paghahambing ay napakabihirang kailangan at kadalasan ay resulta ng isang error sa coding.

Pagpapatunay ng Bagay ng JavaScript

Ang mga bagay ay may access sa anumang ari-arian. Gayunpaman, kung wala man ito, hindi ito magiging error. Ang pag-access lamang sa isang hindi umiiral na ari-arian ay nagbabalik ng hindi natukoy. Nagbibigay ito ng isang napaka-karaniwang paraan upang subukan ang isang property at ihambing ito sa isang hindi natukoy. Nasa ibaba ang isang halimbawa.

Paggamit ng "in" para sa mga property na nag-iimbak ng hindi natukoy. Karaniwan ang isang mahigpit na "=== undefined" na pagsusuri sa paghahambing ay gumagana nang maayos. Mayroong isang espesyal na kaso kung saan ito nabigo at "in" ay gumagana nang tama. Ito ay kapag ang isang ari-arian ng isang bagay ay umiiral ngunit nananatiling hindi natukoy.

Sa code sa itaas, teknikal na umiiral ang obj.test property. Samakatuwid gumagana nang tama ang in operator. Ang mga sitwasyong tulad nito ay napakabihirang dahil hindi natukoy ang karaniwang itinalaga. Ang mga null na "hindi alam" o "walang laman" na mga halaga ay kadalasang ginagamit. Kaya, ang in operator ay epektibong isang bisita sa code.

"para sa..sa" loop

Upang mailipat ang lahat ng mga susi mula sa bagay patungo sa bagay, mayroong isang espesyal na anyo ng loop: para..sa. Ito ay isang ganap na naiibang bagay mula sa for(;;) construct.

Nasa ibaba ang isang halimbawa.

Pakitandaan na lahat ng "para sa" constructor ay nagbibigay-daan sa iyo na magdeklara ng isang looping variable sa loob ng isang loop bilang isang let key. Bilang kahalili, maaari kang gumamit ng ibang pangalan ng variable, key, sa halip.

Halimbawa, ang for(let prop in obj) ay malawak ding ginagamit.

Mayroong alternatibong "square bracket" na gumagana sa anumang string.

Ang punto dito ay nangangailangan na ang mga key ng object ng JavaScript ay isang wastong variable identifier, ibig sabihin ay walang mga puwang o iba pang mga paghihigpit. Dapat gawin ang pangangalaga upang matiyak na ang linya sa loob ng mga bracket ay sinipi nang tama. Nagbibigay din ang mga square bracket ng paraan upang makuha ang pangalan ng property mula sa resulta ng anumang expression, kumpara sa literal na string mula sa isang variable:

let key = "gusto ng mga ibon";

// same as user["likes birds"] = true;

user = totoo.

Dito maaring kalkulahin ang key variable sa runtime at depende sa input ng user at pagkatapos ay gagamitin para ma-access ang property. Nagbibigay ito ng mga programmer ng higit na kakayahang umangkop. Ang notasyon ng tuldok ay hindi maaaring gamitin sa katulad na paraan, dahil umuulit ito sa object ng JavaScript. Nasa ibaba ang isang halimbawa.

Const object

Ang isang ipinahayag na const object ay maaaring mabago. Ang isang halimbawa ay ibinigay sa ibaba.

Maaaring mukhang ang JavaScript object sa linya (*) ay magtapon ng isang error, ngunit hindi iyon ang kaso. Ito ay dahil kinukuha ng const ang halaga ng user mismo. At dito ang gumagamit ay nagpapanatili ng isang sanggunian sa parehong bagay sa lahat ng oras. Ang linya (*) ay napupunta sa loob ng bagay, hindi ito muling itinalaga sa user. Magbibigay ng error ang Const kung susubukan mong itakda ang user at iba pa. Ang pag-clone at pagsasama, ang Object.assign ay lumilikha ng isa pang reference sa parehong bagay kung kailangan itong ma-duplicate. Magagawa rin ito, ngunit medyo mas mahirap dahil walang built-in na pamamaraan ang JavaScript. Sa katunayan, ito ay bihirang kinakailangan. Ang pagkopya sa pamamagitan ng sanggunian ay ginagamit sa karamihan ng mga kaso. Ngunit kung talagang kailangan mo ito, kailangan mong lumikha ng isang JavaScript object at kopyahin ang istraktura ng isang umiiral na, pagkopya ng mga katangian nito sa isang primitive na antas. Nasa ibaba ang isang halimbawa.

At maaari mo ring gamitin ang Object.assign na paraan para dito. Ang mga argumentong dest at src1, ..., srcN ay mga bagay. Kinokopya nito ang mga katangian ng lahat ng mga bagay src1, ..., srcNINTO dest. Sa madaling salita, ang mga katangian ng lahat ng mga argumento, simula sa pangalawa, ay kinopya hanggang sa ika-1. Pagkatapos ay bumalik ito sa dest. Halimbawa, maaari mo itong gamitin upang pagsamahin ang ilang mga bagay sa isa.

At maaari mo ring gamitin ang Object.assign upang palitan ang loop simpleng cloning. Kinokopya nito ang lahat ng mga katangian ng user sa isang walang laman na bagay at ibinabalik ito, tulad ng isang loop, ngunit mas maikli. Hanggang ngayon, ipinapalagay na ang lahat ng mga katangian ng user ay primitive. Ngunit ang mga katangian ay maaaring maging mga sanggunian sa iba pang mga bagay.

Upang ayusin ito, kailangan mong gumamit ng clone loop na sumusuri sa bawat halaga ng user at, kung ito ay isang bagay, pagkatapos ay ginagaya ang istraktura nito. Ito ay tinatawag na "deep cloning."

Umiiral karaniwang algorithm malalim na pag-clone, na humahawak sa kaso sa itaas at mas kumplikadong mga kaso na tinatawag na Structured cloning algorithm. Upang maiwasan ang muling pag-imbento ng gulong, maaari kang gumamit ng gumaganang pagpapatupad mula sa lodash JavaScript library, ang pamamaraan ay tinatawag na _.cloneDeep(obj).

Mga Advanced na Pamamaraan

Kung ang isang programmer ay umiikot sa isang bagay at nais na makuha ang lahat ng mga katangian sa parehong pagkakasunud-sunod na idinagdag sa mga ito, maaari siyang umasa sa "espesyal na pag-order," kung saan ang mga katangian ng integer ay pinagbukod-bukod at ang iba ay nabuo sa pagkakasunud-sunod kung saan nilikha ang object ng JavaScript. .

Ang mga advanced na object method ay tumatalakay sa mga konsepto na bihirang ginagamit sa JavaScripting. Ito ay dahil sa mga normal na senaryo ay hindi kailangan ang mga makapangyarihang feature na ito. Ang ilan sa mga pamamaraang ito ay maaaring hindi gumana sa mas lumang mga browser, tulad ng mga maagang paglabas ng Netscape 4.

Ang prototype ay maaaring gamitin upang lumikha ng mga bagay na JavaScript at lahat ng mga pamamaraan ng mycircle, hindi lamang ang mga bago. Ito ay may magkahalong epekto sa pagganap. Hindi nila kailangang mag-imbak ng hiwalay na mga kopya ng mga pamamaraan para sa bawat halimbawa ng bagay, kaya maaaring mangailangan sila ng mas kaunting memorya upang gumana, ngunit dapat na hanapin ng browser ang kasalukuyan at parent na saklaw upang mahanap ang mga ito. Maaari itong magresulta sa matinding latency. Sa pangkalahatan, dapat gamitin ng user kung ano ang naaangkop para sa code sa halip na ibase ang desisyong iyon sa pagganap, maliban kung nakikipag-ugnayan sila sa isang napaka-tiyak na kinokontrol na kapaligiran.

Bumalik ng totoo

Sa ilang mga kaso, maaaring kailanganin para sa pag-aari ng isang bagay na itali sa mismong bagay o sa isang lugar sa prototype chain. Sa JavaScript, ginagamit ng lahat ng object ang hasOwnProperty method, na nagbabalik ng true kung ang property na iyon ay nakatali sa isang indibidwal na object instance. Sa kasong ito, magiging posible na suriin kung ang tagabuo ng isang bagay ay may parehong pag-aari na may parehong halaga ng bagay na halimbawa mismo. Ito ay maaaring magbigay ng mga maling resulta kung mayroong hiwalay na JavaScript object properties na may ang parehong halaga para sa parehong bagay na halimbawa at ang circuit prototype. Ang hasOwnProperty method ay tumatagal ng isang parameter - ang pangalan ng property bilang isang string.

Maaari kang lumikha ng mga pribadong pamamaraan sa katulad na paraan. Ito ay isang function na nilikha sa loob ng isang constructor function. Ito ay maaaring mukhang nakalilito sa ilan, ngunit iyan ay kung paano ito gumagana. Ang isang pribadong function ay maaari lamang tawagin ng mismong tagabuo o ng mga pamamaraan na tinukoy sa linya. Magagamit ang mga ito bilang mga pampublikong pamamaraan kung itinalaga sa isang pampublikong tagabuo at na-access gamit ang mga pampublikong pamamaraan ng mga bagay na Javascript.

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

) var secretValue = "";

this.method1 = function () ( secretValue = "no surprises";!}

this.method2 = cantBeSeen;

) var oneOb = bagong myob();

oneOb.method1();

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

//alerts "walang sorpresa".

Template ng Command

Ang mga command object ay nagbibigay-daan para sa maluwag na pinagsamang mga system sa pamamagitan ng paghihiwalay sa mga naglalabas ng kahilingan mula sa mga bagay at sa mga aktwal na nagpoproseso ng kahilingan. Ang mga kahilingang ito ay tinatawag na mga kaganapan, at ang code na nagpoproseso ng mga kahilingan ay tinatawag na mga tagapangasiwa ng kaganapan.

Ipagpalagay na gumagawa ka ng mga application na sumusuporta sa mga aksyon sa clipboard na Gupitin, Kopyahin at I-paste. Ang mga pagkilos na ito ay maaaring ma-trigger sa iba't ibang paraan sa buong application: sa pamamagitan ng system ng menu, sa pamamagitan ng isang menu ng konteksto, halimbawa sa pamamagitan ng pag-click kanang pindutan mouse sa pamamagitan ng field ng teksto o isang keyboard shortcut. Nagbibigay-daan sa iyo ang mga command object na isentro ang pagpoproseso ng mga pagkilos na ito, isa para sa bawat operasyon, kapag isang command lang ang kailangan para iproseso ang lahat ng kahilingan sa Pag-cut, isa para sa lahat ng kahilingan sa Kopyahin, at isa para sa lahat ng kahilingan sa I-paste.

Dahil ang mga koponan ay nakasentro sa lahat ng pagpoproseso, madalas din silang kasangkot sa paghawak ng mga pag-andar ng pag-undo para sa buong aplikasyon. Ang mga makabuluhang pagpapabuti ay maaaring makamit sa pamamagitan ng paglalapat ng mga makabagong pamamaraan ng JavaScript, na nagreresulta sa mas mahusay, maaasahan, at mapanatili na mga application.

Upang matutunan kung paano ito gawin, maaari mong gamitin ang mga template ng JavaScript + jQuery. Kasama sa natatanging package na ito ang naka-optimize na JavaScript para sa lahat ng template ng GoF gamit ang mga mas advanced na feature gaya ng mga namespace, prototype, module, function object, pagsasara, anonymous na function at higit pa. Kung kailangan ng mga user ang pinakabagong mga tool at diskarte para sa mga template ng JavaScript, mga template ng jQuery, at mga arkitektura ng template, kung gayon ito ang pinakamahusay na kaso ng paggamit. Ang paketeng ito ay naglalaman ng mahalagang, up-to-date na impormasyon para sa mga developer ng JavaScript. Narito kung ano ang kasama:

Mga template ng GoF na naka-optimize sa JavaScript.
Mga Modernong Pattern ng Disenyo ng JavaScript.
Mga Pattern ng Disenyo ng Model-View.
Mga Template ng Disenyo ng jQuery.
Mga pattern ng arkitektura ng mga idyoma ng JavaScript.
Mga halimbawang application (MVC, SPA, atbp.)

Ang mga iminungkahing pangunahing kaalaman ng JavaScript object syntax ay napakahalaga para sa mga nagsisimulang programmer. Dapat munang maunawaan ng isa ang mga bagay, pagkatapos ay magkakaroon ng kaalaman sa object-oriented programming. Mahalagang magkaroon ng malalim na pag-unawa sa materyal na ito dahil nagsisilbi itong pundasyon para sa natitirang wika ng JavaScript.

Mga bagay

Ang object ay isang pangunahing uri ng data sa wikang JavaScript. Bagay ay isang pinagsama-samang halaga: pinagsasama nito ang isang hanay ng mga halaga (mga simpleng halaga o iba pang mga bagay) at pinapayagan ang mga halagang iyon na maimbak at makuha sa pamamagitan ng pangalan.

Ang isang bagay ay isang hindi nakaayos na koleksyon ng mga katangian, ang bawat isa ay may pangalan at halaga. Ang mga pangalan ng property ay mga string, kaya ang mga bagay ay masasabing nagmamapa ng mga string sa mga value. Ang pagmamapa na ito ng mga string sa mga halaga ay maaaring pumunta sa maraming pangalan: Maaaring pamilyar ka na sa isang pangunahing istruktura ng data gaya ng hash, diksyunaryo, o isang associative array. Gayunpaman, mayroong higit pa sa isang bagay kaysa sa isang simpleng pagmamapa ng mga string sa mga halaga.

Bilang karagdagan sa kanilang sariling mga katangian, ang mga bagay ng JavaScript ay maaari ding magmana ng mga katangian mula sa iba pang mga bagay, na kilala bilang mga prototype. Ang mga pamamaraan ng object ay mga tipikal na kinatawan ng mga minanang katangian, at " mana sa pamamagitan ng mga prototype" ay isang pangunahing tampok ng wikang JavaScript.

Ang mga bagay sa JavaScript ay dynamic—karaniwan kang pinapayagan ka nitong magdagdag at mag-alis ng mga property—ngunit maaari rin itong gamitin upang tularan ang mga static na bagay at "mga istruktura" na makikita sa mga statically typed programming language. Magagamit din ang mga ito (kung balewalain mo na ang mga bagay ay nagmamapa ng mga string sa mga halaga) upang kumatawan sa mga hanay ng mga string.

Ang anumang value sa JavaScript na hindi string, numero, true, false, null, o hindi natukoy ay isang object. At kahit na ang mga string, numero, at boolean na hindi mga bagay ay maaaring kumilos tulad ng mga hindi nababagong bagay (may mga String, Number, atbp. na mga bagay na wrapper).

Ang mga bagay ay mga nababagong halaga at ang mga pagpapatakbo sa kanila ay ginagawa sa pamamagitan ng sanggunian, hindi sa pamamagitan ng halaga. Kung ang variable na x ay tumutukoy sa isang bagay at ang pahayag na var y = x; , ang y variable ay maglalaman ng reference sa parehong bagay, hindi isang kopya nito. Ang anumang pagbabagong ginawa sa object ng y variable ay makikita rin sa x variable.

May pangalan at value ang isang property. Ang pangalan ng property ay maaaring anumang string, kabilang ang walang laman na string, ngunit ang isang bagay ay hindi maaaring magkaroon ng dalawang katangian na may parehong pangalan. Ang value ng property ay maaaring maging anumang value na pinapayagan sa wikang JavaScript, o (sa ECMAScript 5) isang read o write function (o pareho).

Bilang karagdagan sa mga pangalan at halaga, ang bawat ari-arian ay may ilang mga halaga na nauugnay dito, na tinatawag na mga katangian ng ari-arian :

Katangian maisusulat tinutukoy kung ang isang halaga ng ari-arian ay maisusulat.

Katangian mabilang tinutukoy kung available ang pangalan ng property para sa enumeration sa isang for/in loop.

Katangian maaaring i-configure tinutukoy ang posibilidad ng pagpapasadya, i.e. pagtanggal ng isang property at pagpapalit ng mga katangian nito.

Bago ang pagdating ng pamantayan ng ECMAScript 5, lahat ng mga katangian sa mga bagay nilikha ng programa, magagamit para sa pag-record, paglilista at pagpapasadya. Ang ECMAScript 5 ay nagbibigay ng kakayahang i-customize ang mga katangian ng iyong mga ari-arian.

Bilang karagdagan sa mga katangian, ang bawat bagay ay may tatlo katangian ng bagay :

Katangian klase naglalaman ng isang string na may pangalan ng klase ng bagay at tinutukoy ang uri ng bagay.

Bandila napapalawak(sa ECMAScript 5) ay nagpapahiwatig ng kakayahang magdagdag ng mga bagong katangian sa isang bagay.

Panghuli, nasa ibaba ang isang paglalarawan ng ilang termino na makakatulong sa amin na makilala ang pagitan ng tatlong malawak na kategorya ng mga bagay sa JavaScript at ang dalawang uri ng mga katangian:

Bagay batayang wika

Ito ay isang bagay o klase ng mga bagay na tinukoy ng detalye ng ECMAScript. Ang mga array, function, petsa, at regular na expression (halimbawa) ay mga pangunahing object ng wika.

Runtime object

Ito ay isang bagay na tinukoy ng runtime environment (tulad ng isang web browser) kung saan naka-embed ang JavaScript interpreter. Ang mga object ng HTMLElement, na kumakatawan sa istruktura ng isang web page sa client-side JavaScript, ay mga runtime object. Ang mga runtime object ay maaari ding maging base language object, halimbawa kapag ang runtime ay tumutukoy sa mga pamamaraan na regular na Function object ng batayang wika ng JavaScript.

Custom na bagay

Anumang bagay na nilikha sa pamamagitan ng pagpapatupad ng JavaScript code.

Sariling ari-arian

Ito ay isang pag-aari na direktang tinukoy sa isang partikular na bagay.

minanang ari-arian

Ito ay isang pag-aari na tinukoy ng prototype ng object.

Paglikha ng mga Bagay

Maaaring malikha ang mga bagay gamit ang mga literal na bagay, ang bagong keyword, at (sa ECMAScript 5) na mga function Object.create().

Mga literal na bagay

Ang pinakasimpleng paraan upang lumikha ng isang bagay ay ang pagsama ng isang bagay na literal sa iyong programa. Ang literal na bagay ay isang bagay na nakapaloob braces isang listahan ng mga katangian (pangalan/mga pares ng halaga) na pinaghihiwalay ng mga kuwit. Ang pangalan ng property ay maaaring isang identifier o isang string literal (ang walang laman na string ay katanggap-tanggap). Ang value ng isang property ay maaaring anumang expression na pinapayagan sa JavaScript - ang value ng expression (ito ay maaaring isang simpleng value o isang object) ang magiging value ng property.

Nasa ibaba ang ilang halimbawa ng paglikha ng mga bagay:

Var walang laman = (); // Bagay na walang katangian var point = ( x:0, y:0 ); // Dalawang katangian var point2 = ( x:point.x, y:point.y+1 ); // Higit pang kumplikadong mga halaga var site = ( "url site": "www..NET Framework", // at mga gitling, kaya gumamit ng mga quote author: ( // Ang halaga ng property na ito ay firstname: "Alexandr", / / object. Mangyaring tandaan na ang apelyido: "Frolov" // ang mga pangalan ng mga pag-aari na ito ay walang mga panipi) );

Ang ECMAScript 5 (at ilang pagpapatupad ng ECMAScript 3) ay nagbibigay-daan sa mga nakareserbang salita na magamit bilang mga pangalan ng property nang walang mga panipi. Gayunpaman, sa pangkalahatan, tumutugma ang mga pangalan ng property nakalaan na salita, sa ECMA-Script 3 ay dapat na nakapaloob sa mga panipi. Sa ECMAScript 5, ang huling kuwit kasunod ng huling property sa isang object na literal ay binabalewala. Karamihan sa mga pagpapatupad ng ECMAScript 3 ay binabalewala din ang mga trailing comma, ngunit binibigyang-kahulugan ng IE ang kanilang presensya bilang isang error.

Ang literal na object ay isang expression na lumilikha at nagpapasimula ng bagong object tuwing sinusuri ang expression na iyon. Ang halaga ng bawat ari-arian ay muling kinakalkula kapag ang halaga ng literal ay nasuri. Nangangahulugan ito na ang isang literal na bagay ay maaaring lumikha ng maraming bagong mga bagay kung ang literal ay inilagay sa katawan ng isang loop o function na tatawagin nang paulit-ulit, at ang mga halaga ng ari-arian ng mga bagay na ito ay maaaring magkaiba sa isa't isa.

Paglikha ng mga Bagay Gamit ang Bagong Operator

Ang bagong operator ay lumilikha at nagpasimula ng isang bagong bagay. Ang pahayag na ito ay dapat na sinundan ng pangalan ng function. Ang isang function na ginamit sa ganitong paraan ay tinatawag na isang constructor at ginagamit upang simulan ang isang bagong nilikha na bagay. Kasama sa Basic JavaScript ang maraming built-in na constructor para sa paglikha ng mga object ng base language. Halimbawa:

Var o = bagong Bagay(); // Lumikha ng bagong walang laman na bagay: katulad ng () var a = new Array(); // Lumikha ng isang walang laman na array: katulad ng var d = new Date(); // Create a Date object na kumakatawan sa kasalukuyang oras var r = new RegExp("js"); // Lumikha ng isang bagay na RegExp para sa mga pagpapatakbo ng pagtutugma ng pattern

Bilang karagdagan sa mga built-in na constructor na ito, posibleng tukuyin ang sarili mong mga function ng constructor para masimulan ang mga bagong likhang bagay. Kung paano ito ginagawa ay inilarawan sa susunod na artikulo.

Object.create()

Tinutukoy ng pamantayan ng ECMAScript 5 ang Object.create() na paraan, na lumilikha ng bagong bagay at ginagamit ang unang argumento nito bilang prototype ng bagay na iyon. Bilang karagdagan, ang Object.create() ay maaaring kumuha ng pangalawang opsyonal na argumento na naglalarawan sa mga katangian ng bagong bagay.

Ang Object.create() ay isang static na function, hindi isang method na tinatawag sa ilang partikular na object. Upang tawagan ang function na ito, ipasa lamang ang nais na prototype object:

// obj inherits properties x and y var obj = Object.create((x:1, y:2));

Upang lumikha ng isang bagay na walang prototype, maaari mong ipasa ang null, ngunit sa kasong ito ang bagong nilikha na bagay ay hindi magmamana ng anumang mga katangian o mga pangunahing pamamaraan, tulad ng toString() (na nangangahulugan na ang bagay na ito ay hindi maaaring gamitin sa mga expression na may + operator):

// obj2 does not inherit any properties or method var obj2 = Object.create(null);

Kung ang iyong programa ay kailangang lumikha ng isang regular na walang laman na bagay (tulad ng ibinalik ng isang literal() o isang bagong Object() na expression), ipasa ang Object.prototype bilang unang argumento:

// ang obj3 ay parang bagay na nilikha // gamit ang () o bagong Object() var obj3 = Object.create(Object.prototype);

Ang kakayahang lumikha ng mga bagong bagay na may di-makatwirang mga prototype (ilagay natin ito sa ibang paraan: ang kakayahang lumikha ng "mga tagapagmana" mula sa anumang mga bagay) ay makapangyarihang kasangkapan, ang epekto nito ay maaaring gayahin sa ECMAScript 3 gamit ang function na ipinakita sa halimbawa sa ibaba:

// inherit() ay nagbabalik ng bagong likhang object na nagmamana ng mga katangian // ng prototype object p. Gumagamit ng ECMAScript 5 Object.create() function // kung tinukoy, kung hindi ay gumagamit ng mas lumang pamamaraan. function inherit(p) ( if (p == null) throw TypeError(); // p cannot be null if (Object.create) // If Object.create() is defined... return Object.create(p ) ; // gamitin ito. var t = typeof p; // Kung hindi, alamin ang uri at suriin ito kung (t !== "object" && t !== "function") isang walang laman na constructor .

Ang pagpapatupad ng inherit() function ay magiging mas makabuluhan kapag nakilala natin ang mga constructor sa susunod na artikulo. Sa ngayon, ipagpalagay na lang na nagbabalik ito ng bagong bagay na nagmamana ng mga katangian ng bagay sa argumento. Tandaan na ang inherit() ay hindi isang kumpletong kapalit para sa Object.create(): hindi ka nito pinapayagang lumikha ng mga object na walang prototype, at hindi ito nangangailangan ng opsyonal na pangalawang argumento tulad ng ginagawa ng Object.create().

Pagkuha at pagpapalit ng mga katangian

Makukuha mo ang halaga ng isang property gamit ang mga operator ng tuldok (.) at square bracket (). Sa kaliwa ng operator dapat mayroong isang expression na nagbabalik ng isang bagay. Kapag ginagamit ang operator ng tuldok, dapat mayroong isang simpleng identifier sa kanan na tumutugma sa pangalan ng property. Kapag gumagamit ng mga square bracket, ang mga square bracket ay dapat may kasamang expression na nagbabalik ng string na naglalaman ng pangalan ng gustong property:

// Simple object var user = ( login:"kot86", name:"Alexandr", edad:26 ); var login = user.login; // Kunin ang "login" property ng user object var name = user.name; // Kunin ang "name" property ng user object var age = user["age"]; // Kunin ang "edad" na pag-aari ng object ng user

Upang gumawa ng bagong property o baguhin ang value ng isang umiiral nang property, ginagamit din ang mga operator ng tuldok at square bracket, tulad ng sa mga operasyon ng pagbabasa ng mga value ng property, ngunit ang mismong expression ay inilalagay sa kaliwa ng assignment operator:

User.age = 28; // Baguhin ang halaga ng "age" property user["login"] = "kot84"; // Baguhin ang halaga ng "login" property user["apelyido"] = "Frolov"; // Lumikha ng bagong property na "apelyido"

Sa ECMAScript 3, ang isang identifier na sumusunod sa isang tuldok ay hindi maaaring maging isang reserbang salita: hindi ka maaaring magsulat ng isang tawag sa ari-arian sa o.for o o.class dahil ang para ay isang keyword at ang klase ay isang salita na nakalaan para magamit sa hinaharap.

Kung ang isang bagay ay may mga katangian na ang mga pangalan ay tumutugma sa mga nakareserbang salita, dapat mong gamitin ang square-bracket na notasyon upang ma-access ang mga ito: o["para sa"] at o["klase"]. Ang pamantayan ng ECMAScript 5 ay nagpapaluwag sa pangangailangang ito (tulad ng ginagawa na ng ilang pagpapatupad ng ECMAScript 3) at pinapayagan ang paggamit ng mga nakareserbang salita pagkatapos ng operator ng tuldok.

Mga prototype

Ang bawat object sa JavaScript ay may pangalawang object (o null, ngunit mas madalas) na nauugnay dito. Ang pangalawang bagay na ito ay tinatawag na prototype, at ang unang bagay ay nagmamana ng mga katangian nito mula sa prototype.

Ang lahat ng mga bagay na nilikha gamit ang mga literal ng object ay may parehong prototype object, na maaaring i-reference sa isang JavaScript program bilang Object.prototype .

Ang mga bagay na nilikha gamit ang bagong keyword at isang constructor call ay tumatanggap ng halaga ng prototype property ng constructor function bilang kanilang prototype. Samakatuwid, ang isang bagay na nilikha ng bagong Object() ay nagmamana ng mga katangian ng Object.prototype na parang nilikha ito gamit ang isang literal na brace (). Katulad nito, ang prototype ng isang object na nilikha ng bagong Array() ay Array.prototype, at ang prototype ng isang object na nilikha ng bagong Date() ay Date.prototype.

Ang Object.prototype ay isa sa ilang bagay na walang prototype: wala itong minanang katangian. Ang iba pang mga prototype na bagay ay mga ordinaryong bagay lamang na may sariling mga prototype.

Lahat ng mga built-in na konstruktor (at karamihan sa mga custom na konstruktor) ay nagmamana ng Object.prototype na prototype. Halimbawa, ang Date.prototype ay nagmamana ng mga katangian mula sa Object.prototype, kaya ang isang Date object na ginawa ng bagong Date() ay nagmamana ng mga katangian mula sa parehong Date.prototype at Object.prototype. Ang ganitong konektadong pagkakasunod-sunod ng mga bagay na prototype ay tinatawag na isang prototype chain.

Mana

Ang mga bagay sa JavaScript ay may maraming "sariling katangian" at maaari ding magmana ng maraming katangian mula sa kanilang prototype na object. Upang maunawaan ito, kailangan mong maingat na pag-aralan ang mekanismo ng pag-access ng ari-arian. Ang mga halimbawa sa seksyong ito ay gumagamit ng inherit() function na ipinapakita sa itaas upang lumikha ng mga bagay na may mga partikular na prototype.

Ipagpalagay na ang programa ay nag-access ng property x ng object obj. Kung ang obj ay walang sariling pag-aari na may ganoong pangalan, isang pagtatangka na hanapin ang pag-aari x sa prototype ng obj. Kung ang prototype object ay walang sariling property na may ganoong pangalan, ngunit mayroon itong sariling prototype, isang pagtatangka na hanapin ang property sa prototype ng prototype. Nagpapatuloy ito hanggang sa matagpuan ang property x o maabot ang isang bagay na walang prototype. Tulad ng nakikita mo, ang prototype na katangian ng isang bagay ay lumilikha ng isang chain, o naka-link na listahan, ng mga bagay kung saan ang mga katangian ay minana.

Var obj = (); // obj inherits ang mga pamamaraan ng object Object.prototype obj.x = 1; // at may sariling ari-arian x. var p = magmana(obj); // Nagmana ang p ng mga katangian ng mga object obj at Object.prototype p.y = 2; // at may sariling ari-arian y. var q = magmana(p); // q nagmamana ng mga katangian ng mga bagay p, obj at Object.prototype q.z = 3; // at may sariling ari-arian z. var s = q.toString(); // toString inherit mula sa Object.prototype var d = q.x + q.y // Resulta 3: x at y inherit mula sa obj at p

Ngayon ipagpalagay na ang programa ay nagtatalaga ng ilang halaga sa x property ng obj. Kung ang obj ay mayroon nang sariling ari-arian (hindi minana) na pinangalanang x, ang pagpapatakbo ng pagtatalaga ay babaguhin lamang ang halaga ng kasalukuyang ari-arian. Kung hindi, isang bagong property na pinangalanang x ang gagawin sa obj. Kung ang obj ay dating minana ang ari-arian x, ang minanang ari-arian ay itatago na ngayon ng isang bagong likhang pag-aari ng sarili nitong may parehong pangalan.

Ang pagpapatakbo ng pagtatalaga ng isang halaga sa isang ari-arian ay susuriin ang pagkakaroon ng ari-arian na iyon sa prototype chain upang matiyak na ang pagtatalaga ay wasto. Halimbawa, kung minana ng object obj ang read-only na property x, hindi mangyayari ang pagtatalaga. Gayunpaman, kung ang pagtatalaga ay wasto, ang property ay palaging ginagawa o binago sa orihinal na bagay at hindi kailanman sa prototype chain. Ang katotohanan na gumagana ang mekanismo ng inheritance kapag nagbabasa ng mga property, ngunit hindi gumagana kapag nagsusulat ng mga bagong value, ay isang pangunahing tampok ng wikang JavaScript dahil pinapayagan ka nitong piliing i-override ang mga minanang katangian:

Var unitcircle = ( r:1 ); // Ang bagay kung saan ang ari-arian ay minana var c = inherit(unitcircle); // c minana ang ari-arian r c.x = 1; c.y = 1; // Tinutukoy ng c ang dalawang katangian ng sarili nitong c.r = 2; // in-override ng c ang minanang property console.log(unitcircle.r); // => 1: hindi nagbago ang prototype object

May isang pagbubukod sa panuntunang ito, kapag nabigo ang pagpapatakbo ng pagtatalaga ng ari-arian o nagresulta sa paglikha/pagbabago ng isang ari-arian ng orihinal na bagay. Kung nagmamana ng property x ang obj at na-access ang property na iyon sa pamamagitan ng mga accessor, sa halip na gumawa ng bagong property x sa obj, tinatawag ang isang paraan para sa pagsulat ng bagong value. Gayunpaman, tandaan na ang paraan ng pagsulat ay tinatawag sa obj, hindi sa prototype kung saan tinukoy ang property, kaya kung ang paraan ng pagsusulat ay tumutukoy sa anumang mga katangian, ang mga ito ay gagawin sa obj, at ang chain ng prototype ay muling mananatiling hindi nagbabago.

Mga error sa pag-access sa ari-arian

Ang mga expression ng pag-access sa ari-arian ay hindi palaging nagbabalik o nagbabago sa halaga ng isang ari-arian. Ang seksyong ito ay naglalarawan ng mga sitwasyon kapag nabigo ang mga operasyon sa pagbabasa o pagsulat ng property.

Ang pagtatangkang i-access ang isang hindi umiiral na ari-arian ay hindi itinuturing na isang error. Kung ang property x ay hindi makikita sa mga sarili o minanang property ng obj, ang property access expression obj.x ay babalik na hindi natukoy.

Gayunpaman, ang pagtatangkang i-access ang isang pag-aari ng isang hindi umiiral na bagay ay itinuturing na isang error. Ang mga null at hindi natukoy na mga halaga ay walang mga katangian, at ang mga pagtatangka na ma-access ang mga katangian ng mga halagang ito ay itinuturing na isang error:

// Simple object var user = ( login:"kot86", name:"Alexandr", edad:26 ); var a = user.password; // undefined: property is missing // Nagtataas ng TypeError exception. // Ang hindi natukoy na halaga ay walang length property var len = user.password.length;

Kung hindi ka sigurado na ang user at user.password ay mga bagay (o kumikilos tulad ng mga bagay), hindi mo dapat gamitin ang user.password.length na expression dahil maaari itong magbigay ng exception. Ang sumusunod ay nagpapakita ng dalawang paraan upang maprotektahan laban sa ganitong uri ng pagbubukod:

// Higit pang visual at prangka na paraan var len = undefined; if (user) ( if (user.password) len = user.password.length; ) // Isang mas maikli, tukoy sa JavaScript na alternatibo // sa pagkuha ng haba ng value ng property ng password var len = user && user. password && user.password.length ;

Ang pagtatangkang itakda ang halaga ng isang ari-arian sa iba pang mga halaga ay hindi palaging matagumpay: ang ilang mga pag-aari ay read-only at hindi pinapayagan ang kanilang mga halaga na baguhin. Bilang karagdagan, ang ilang mga bagay ay hindi nagpapahintulot sa iyo na magdagdag ng mga bagong katangian sa kanila. Gayunpaman, ang pinaka-kagiliw-giliw na bagay ay ang gayong mga pagkabigo, bilang isang patakaran, ay hindi humantong sa isang pagbubukod na itinaas:

// Ang prototype properties ng built-in constructors ay read-only Object.prototype = 0; // Ang pagtatalaga ay hindi magtataas ng eksepsiyon;

// ang halaga ng Object.prototype ay hindi magbabago

Ang makasaysayang kapintasan ng JavaScript na ito ay itinatama sa mahigpit na mode, gaya ng tinukoy ng ECMAScript 5 na pamantayan.

Ang mga patakaran para sa pagtukoy kung kailan magtatagumpay ang isang pagtatangka na magsagawa ng isang pagpapatakbo ng pagtatalaga at kung kailan ito mabibigo ay simple at diretso, ngunit mahirap ipahayag sa isang sapat na maigsi na paraan. Ang pagtatangkang magtalaga ng value sa property p ng obj ay mabibigo sa mga sumusunod na kaso:

Ang object obj ay may sariling read-only na property p: hindi mo mababago ang halaga ng isang read-only na property. (Tandaan, gayunpaman, na ang paraan ng defineProperty() ay isang pagbubukod na nagbibigay-daan sa iyong baguhin ang mga halaga ng read-only na custom na mga katangian.)

Ang obj object ay may read-only inherited property p: ang inherited read-only na mga katangian ay hindi maaaring ma-override ng sarili mong mga property na may parehong mga pangalan.

Pag-aalis ng mga katangian

Ang object obj ay walang sariling ari-arian p; Hindi namamana ng obj ang property p gamit ang mga paraan ng accessor, at mali ang extensible attribute ng obj. Kung ang property p ay wala sa obj at walang write method na tinukoy para dito, ang assignment operation ay susubukan na magdagdag ng property p sa obj. Ngunit dahil hindi extensible ang obj, mabibigo ang pagtatangkang magdagdag ng bagong property dito. tanggalin Operator nag-aalis ng isang ari-arian mula sa isang bagay. Ang tanging operand nito ay dapat na isang property access expression. Maaaring mukhang nakakagulat, ngunit tanggalin ang operator

hindi nakakaapekto sa halaga ng ari-arian - ito ay nagpapatakbo sa mismong ari-arian:

// Simple object var user = ( login:"kot86", name:"Alexandr", edad:26 ); tanggalin ang user.login; // Ngayon ang user object ay walang login property delete user["name"]; // Ngayon ang object ng user ay walang property na pangalan

Ang delete expression ay nagbabalik ng true kapag ang property ay matagumpay na natanggal o kapag ang delete operation ay hindi nabago ang object (halimbawa, kapag sinusubukang tanggalin ang isang property na wala). Ang delete expression ay nagbabalik din ng true kapag nagpasa ng expression na hindi isang property access expression:

Obj = (x:1); // obj has its own property x and inherits toString delete obj.x; //Nagtatanggal ng x at nagbabalik ng true delete obj.x; //Does nothing (x does not exist) at nagbabalik ng true delete obj.toString; // Will do nothing (toString is not its own property) and return true delete 1; // Walang kabuluhan, ngunit babalik ng totoo

Ang delete operator ay hindi nagtatanggal ng hindi na-configure na mga katangian, katangian maaaring i-configure na may value na false. (Gayunpaman, maaari nitong alisin ang mga custom na katangian ng mga hindi napapalawak na mga bagay.) Ang mga hindi nako-configure na katangian ay mga built-in na katangian ng object, pati na rin ang mga pandaigdigang katangian ng object na ginawa gamit ang mga pahayag ng variable at function na deklarasyon. Ang pagsubok na mag-alis ng hindi na-configure na property sa mahigpit na mode ay nagpapataas ng TypeError. Sa hindi mahigpit na mode (at sa mga pagpapatupad ng ECMAScript 3), ang delete operator ay nagbabalik lamang ng false sa mga ganitong kaso:

Tanggalin ang Object.prototype; // Removal is not possible - non-configurable property var x = 1; // Deklarasyon ng isang pandaigdigang variable tanggalin ito.x; // This property cannot be deleted function f() () // Global function declaration delete this.f; // Ang property na ito ay hindi rin matatanggal

Sinusuri ang pagkakaroon ng mga ari-arian

Ang mga bagay sa JavaScript ay maaaring ituring na mga hanay ng mga katangian, at kadalasan ay kapaki-pakinabang na masubukan ang pagiging miyembro sa isang set - upang suriin kung ang isang bagay ay may ari-arian na may ibinigay na pangalan. Maaari kang magsagawa ng naturang pagsusuri gamit ang operator sa, gamit ang mga pamamaraan hasOwnProperty() At propertyIsEnumerable() o sa pamamagitan lamang ng pag-access sa property.

Kinakailangan ng in operator na bigyan ito ng isang property name (bilang isang string) bilang kaliwang operand nito at isang object bilang kanang operand nito. Nagbabalik ito ng totoo kung ang bagay ay may sarili o minanang pag-aari na may ganoong pangalan:

Var obj = ( x:1 ) "x" sa obj; // true: obj has its own property "x" "y" in obj; // false: ang obj ay walang property na "y" "toString" sa obj; // true: namamana ng obj ang toString property

Ang hasOwnProperty() na paraan ng isang bagay ay nagsusuri kung ang bagay ay may sariling pag-aari na may tinukoy na pangalan. Para sa mga minanang pag-aari, nagbabalik ito ng false:

Var obj = ( x:1 ) obj.hasOwnProperty("x"); // true: obj has its own property "x" obj.hasOwnProperty("y"); // false: obj does not have property "y" obj.hasOwnProperty("toString"); // false: toString - minanang ari-arian

Ang pamamaraan ng propertyIsEnumerable() ay nagpapataw ng mga karagdagang paghihigpit kumpara sa hasOwnProperty(). Nagbabalik lang ito ng true kung ang tinukoy na property ay isang native na property na ang enumerable attribute ay nakatakda sa true. Ang mga katangian ng mga built-in na bagay ay hindi mabilang. Ang mga property na ginawa ng isang regular na JavaScript program ay mabibilang maliban kung ang isa sa mga pamamaraan ng ECMAScript 5 sa ibaba ay ginamit upang gawing hindi mabilang ang mga katangian.

Kadalasan, sa halip na in operator, sapat na ang gumamit ng simpleng property access expression at gamitin ang !== operator upang suriin ang hindi pagkakapantay-pantay sa hindi natukoy na halaga:

Var obj = ( x:1 ) obj.x !== undefined; // true: obj has property "x" obj.y !== undefined; // false: ang obj ay walang property na "y" obj.toString !== undefined; // true: namamana ng obj ang toString property

Gayunpaman, ang in operator ay nakikilala sa pagitan ng mga sitwasyon na hindi matukoy gamit ang property-based technique na ipinakita sa itaas. Tinutukoy ng in operator ang kawalan ng property mula sa property na hindi natukoy ang halaga.

Enumerating Properties

Sa halip na suriin ang availability mga indibidwal na katangian Minsan kinakailangan na umulit sa lahat ng umiiral na mga katangian o upang makakuha ng isang listahan ng lahat ng mga katangian ng isang bagay. Karaniwan itong ginagawa gamit ang for/in loop, ngunit ang ECMAScript 5 na pamantayan ay nagbibigay ng dalawang maginhawang alternatibo.

Ang for/in loop statement ay nagpapatupad ng katawan ng loop para sa bawat enumerable property (alinman sa sarili nito o minana) ng tinukoy na object, na nagtatalaga ng property name sa isang loop variable. Ang mga built-in na pamamaraan na minana ng mga bagay ay hindi mabilang, at ang mga pag-aari na idinagdag sa mga bagay ng iyong programa ay mabibilang (maliban kung ginamit mo ang mga function na inilarawan sa ibaba upang gawing hindi mabilang ang mga katangian). Halimbawa:

// A simple object with three enumerable properties var user = ( login:"kot86", name:"Alexandr", age:26 ); user.propertyIsEnumerable("toString"); // false, toString - built-in na paraan para sa (n sa user) console.log(n);

Ang ilang mga aklatan ay nagdaragdag ng mga bagong pamamaraan (o iba pang mga katangian) sa object.prototype na bagay upang sila ay mamana at maging available sa lahat ng mga bagay. Gayunpaman, hanggang sa pagdating ng pamantayan ng ECMAScript 5, hindi posible na gawin ang mga ito karagdagang mga pamamaraan non-enumerable, kaya available sila para sa enumeration sa for/in loops. Upang malutas ang isyung ito, maaaring kailanganin mong i-filter ang mga property na ibinalik ng for/in loop. Nasa ibaba ang dalawang halimbawa ng pagpapatupad ng naturang pag-filter:

Para sa (n sa user) ( if (!user.hasOwnProperty(n)) continue; console.log(n); ) for (n in user) ( if (typeof user[n] === "function") continue; console.log(n);

Bilang karagdagan sa for/in loop, ang pamantayan ng ECMAScript 5 ay tumutukoy sa dalawang function na nagsasaad ng mga pangalan ng property. Ang una sa kanila, Object.keys(), ay nagbabalik ng hanay ng mga pangalan ng sariling enumerable properties ng object.

Ang pangalawang function ng ECMAScript 5 na nagsasagawa ng enumeration ng property ay Object.getOwnPropertyNames(). Ito ay gumaganap tulad ng Object.keys() function, ngunit ibinabalik ang mga pangalan ng lahat ng mga sariling katangian ng tinukoy na object, hindi lamang mga enumerable. Ang mga pagpapatupad ng ECMAScript 3 ay walang kakayahan na ipatupad ang naturang functionality dahil ang ECMAScript 3 ay hindi nagbibigay ng kakayahang makakuha ng hindi mabilang na mga katangian ng isang bagay.

Mga pamamaraan para sa pagbabasa at pagsulat ng mga katangian

Nasabi na sa itaas na ang isang object property ay may pangalan, isang halaga, at isang set ng mga katangian. Sa ECMAScript 5, ang isang halaga ay maaaring palitan ng isa o dalawang pamamaraan, na kilala bilang mga pamamaraan nagbabasa (getter) At mga tala (setter). Tinatawag kung minsan ang mga katangian kung saan tinukoy ang mga paraan ng pagbasa at pagsulat mga katangian na may mga paraan ng pag-access upang makilala ang mga ito mula sa mga katangian ng data na kumakatawan sa isang simpleng halaga.

Kapag sinubukan ng isang programa na makuha ang halaga ng isang ari-arian na may mga pamamaraan ng accessor, tatawagin ng interpreter ang read method (nang walang mga argumento). Ang halaga na ibinalik ng pamamaraang ito ay nagiging halaga ng expression ng pag-access ng property. Kapag sinubukan ng program na magsulat ng value sa isang property, tatawagin ng interpreter ang write method, na ipinapasa ang value sa kanan ng assignment operator. Ang pamamaraang ito ay responsable para sa "pagtatakda" ng halaga ng ari-arian. Ang halaga na ibinalik ng paraan ng pagsulat ay binabalewala.

Hindi tulad ng mga pag-aari ng data, ang mga katangian ng accessor ay walang naisulat na katangian. Kung ang isang property ay may parehong read at write na mga pamamaraan, ito ay read/write. Kung ang isang property ay may read-only na paraan, ito ay read-only. At kung ang isang pag-aari ay mayroon lamang isang paraan ng pagsulat, ito ay maisusulat lamang (ito ay hindi posible para sa mga katangian ng data) at ang mga pagtatangka na basahin ang halaga ng naturang pag-aari ay palaging babalik na hindi natukoy.

Ang pinakasimpleng paraan upang tukuyin ang isang ari-arian na may mga pamamaraan ng accessor ay ang paggamit ng pinalawak na object literal na kahulugan syntax:

Var obj = ( // Normal data property data_prop: value, // Ang isang property na may mga paraan ng pag-access ay tinukoy bilang isang pares ng mga function na nakakuha ng accessor_prop() ( /* function body */ ), itakda ang accessor_prop(value) ( /* function body */ ) );

Tinutukoy ang mga property na may mga paraan ng accessor bilang isa o dalawang function na ang mga pangalan ay kapareho ng pangalan ng property at pinalitan ang keyword ng function ng get at/o set.

Tandaan na hindi ka kinakailangang gumamit ng colon para paghiwalayin ang pangalan ng property mula sa function na kumokontrol sa access sa property, ngunit kailangan mo pa ring gumamit ng kuwit pagkatapos ng function body upang paghiwalayin ang paraan mula sa iba pang mga pamamaraan o katangian ng data.

Halimbawa, isaalang-alang ang sumusunod na bagay na kumakatawan Mga coordinate ng Cartesian mga puntos sa isang eroplano. Mayroon itong karaniwang mga katangian ng data upang kumatawan sa X at Y na mga coordinate, pati na rin sa mga property na may mga paraan ng accessor upang makuha ang katumbas na polar coordinates ng isang punto:

Var p = ( // x at y ay regular na data properties, read/write x: 1.0, y: 1.0, // r ay read/write property na may dalawang access method. // Huwag kalimutang magdagdag ng mga kuwit pagkatapos ng method access get r() ( return 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; ang tanging paraan reads get theta() ( return Math.atan2(this.y, this.x); ) );

Tandaan ang paggamit ng keyword na ito sa mga paraan ng pagbasa at pagsulat sa itaas. Tatawagin ng interpreter ang mga function na ito bilang mga pamamaraan ng object kung saan tinukoy ang mga ito, i.e. sa katawan ng function na ito ay tumutukoy sa point object. Binibigyang-daan nito ang read method ng property r na sumangguni sa mga property na x at y, tulad nito.x at this.y.

Ang mga katangian na may mga pamamaraan ng accessor ay minana tulad ng mga regular na katangian ng data, kaya ang p object na tinukoy sa itaas ay maaaring gamitin bilang isang prototype para sa iba pang mga point object. Maaaring tukuyin ng mga bagong bagay ang kanilang sariling mga katangian ng x at y, at mamanahin nila ang mga katangian ng r at theta.

Mga Katangian ng Bagay

Ang lahat ng mga bagay ay may prototype, klase at mga extensible na katangian. Ang lahat ng mga katangiang ito ay inilalarawan sa mga subseksyon sa ibaba.

katangian ng prototype

Tinutukoy ng katangian ng prototype ng object ang object kung saan minana ang mga katangian. Mahalagang maunawaan na kapag lumitaw ang isang prototype reference sa program code, ito ay tumutukoy sa isang regular na katangian ng isang bagay, hindi ang prototype na katangian.

Ang katangian ng prototype ay itinakda kapag nilikha ang bagay. Para sa mga bagay na ginawa gamit ang mga literal, ang prototype ay Object.prototype. Ang prototype ng isang bagay na nilikha gamit ang bagong operator ay ang halaga ng prototype property ng constructor. At ang prototype ng object na nilikha gamit ang Object.create() ay nagiging unang argumento ng function na ito (na maaaring null).

Ang pamantayan ng ECMAScript 5 ay nagbibigay ng kakayahang tukuyin ang prototype ng anumang bagay sa pamamagitan ng pagpasa nito sa isang pamamaraan Object.getPrototypeOf(). Ang ECMAScript 3 ay walang katumbas na function, ngunit madalas mong matukoy ang prototype ng obj gamit ang expression na obj.constructor.prototype.

Ang mga bagay na nilikha gamit ang bagong operator ay karaniwang nagmamana ng ari-arian tagabuo Isang sanggunian sa constructor function na ginamit upang likhain ang object. At tulad ng nabanggit sa itaas, ang mga function ng constructor ay may isang prototype property, na tumutukoy sa prototype ng mga bagay na nilikha gamit ang constructor na ito.

Tandaan na ang mga bagay na ginawa gamit ang object literals o Object.create() ay tumatanggap ng isang constructor property na tumutukoy sa Object() constructor. Kaya, ang constructor.prototype ay tumutukoy sa tunay na prototype para sa mga literal na bagay, ngunit kadalasan hindi ito ang kaso para sa mga bagay na nilikha sa pamamagitan ng pagtawag sa Object.create().

Upang matukoy kung ang isang bagay ay isang prototype (o isang link sa isang hanay ng mga prototype) ng isa pang bagay, gamitin ang pamamaraan isPrototypeOf(). Upang malaman kung ang p ay ang prototype ng obj, kailangan mong isulat ang expression na p.isPrototypeOf(obj). Halimbawa:

Var p = (x:1); // Tukuyin ang isang prototype object. var obj = Object.create(p); // Lumikha ng object gamit ang prototype na ito. p.isPrototypeOf(obj); // => true: obj inherits p Object.prototype.isPrototypeOf(p); // => true: pinamana ng p ang Object.prototype

katangian ng klase

katangian ng klase Ang object ay isang string na naglalaman ng impormasyon tungkol sa uri ng bagay. Ang ECMAScript 3 o ECMAScript 5 ay hindi nagbibigay ng kakayahang baguhin ang katangiang ito at nagbibigay lamang ng mga hindi direktang paraan upang matukoy ang halaga nito. Bilang default, ang toString() na pamamaraan (na minana mula sa Object.prototype) ay nagbabalik ng isang string tulad ng:

Samakatuwid, upang matukoy ang klase ng isang bagay, maaari mong subukang tawagan ang toString() na paraan ng bagay na ito at i-extract ang substring mula sa ikawalo hanggang sa penultimate na karakter mula sa resulta. Ang nakakalito na bahagi ay ang maraming mga pamamaraan na nagmamana mula sa iba, mas kapaki-pakinabang na mga pagpapatupad ng toString(), at para matawag ang tamang bersyon ng toString() kailangan mong gumawa ng hindi direktang tawag gamit ang Function.call() na paraan.

Ang halimbawa sa ibaba ay tumutukoy sa isang function na nagbabalik sa klase ng anumang bagay na ipinasa dito:

// Name of the object class function classof(obj) ( if (obj === null) return "Null"; if (obj === undefined) return "Undefined"; return Object.prototype.toString.call(obj) .hiwa (8,-1);

Ang classof() function na ito ay maaaring maipasa ang anumang value na pinapayagan sa JavaScript. Ang mga numero, string, at boolean ay kumikilos tulad ng mga bagay kapag ang toString() ay tinatawag sa kanila, ngunit ang mga null at hindi natukoy na mga halaga ay naiiba ang pagtrato.

napapalawak na katangian

Ang napapalawak na katangian ng isang bagay ay tumutukoy kung ang mga bagong katangian ay maaaring idagdag sa bagay. Sa ECMAScript 3, ang lahat ng mga built-in at tinukoy ng user na mga bagay ay implicitly extensible, at ang extensibility ng mga runtime object ay tukoy sa pagpapatupad. Sa ECMAScript 5, ang lahat ng built-in at user-defined na object ay extensible maliban na lang kung na-convert ang mga ito sa non-extensible object, at ang extensibility ng runtime object ay tukoy pa rin sa pagpapatupad.

Tinutukoy ng pamantayan ng ECMAScript 5 ang mga function para sa pagkuha at pagbabago ng extensibility attribute ng isang bagay. Upang matukoy kung ang isang bagay ay maaaring pahabain, dapat mong ipasa ito sa pamamaraan Object.isExtensible(). Upang gawing hindi mapalawak ang isang bagay, kailangan mong ipasa ito sa isang paraan Object.preventExtensions(). Tandaan na kapag ang isang bagay ay ginawang di-napapalawak, hindi na ito maaaring gawing extensible muli. Tandaan din na ang pagtawag sa preventExtensions() ay nakakaapekto lamang sa extensibility ng object mismo. Kung ang mga bagong property ay idinagdag sa prototype ng isang non-extensible object, ang non-extensible object ay magmamana ng mga bagong property na iyon.

Ang layunin ng extensible attribute ay gawing posible na "ayusin" ang mga bagay sa isang partikular na estado, na nagbabawal sa mga pagbabago. Ang napapalawak na katangian ng mga bagay ay kadalasang ginagamit kasabay ng mga katangiang maaaring i-configure at maisusulat, kaya ang ECMAScript 5 ay tumutukoy sa mga function na nagpapadali sa pagtakda ng mga katangiang ito nang sabay-sabay.

Pamamaraan Object.seal() gumaganap tulad ng Object.preventExtensions() na paraan, ngunit hindi lamang nito ginagawang hindi mapalawak ang bagay, ginagawa rin nitong hindi ma-configure ang lahat ng katangian ng bagay na iyon. Iyon ay, ang mga bagong katangian ay hindi maaaring idagdag sa bagay, at ang mga umiiral na katangian ay hindi maaaring tanggalin o i-configure. Gayunpaman, maaari pa ring baguhin ang mga umiiral nang naisusulat na katangian.

Kapag tinawag na ang Object.seal(), ang object ay hindi na maibabalik sa dati nitong estado. Upang matukoy kung ang Object.seal() na pamamaraan ay tinawag sa isang bagay, maaari mong tawagan ang pamamaraan Object.isSealed().

Pamamaraan Object.freeze() nagbibigay ng mas mahigpit na pag-aayos ng mga bagay. Bilang karagdagan sa paggawa ng object na hindi na-extensible at ang mga katangian nito ay hindi na-configure, ginagawa rin nitong read-only ang lahat ng native na katangian ng data. (Hindi ito nalalapat sa mga katangian ng object na may mga paraan ng accessor na may mga paraan ng pagsulat; tatawagin pa rin ang mga pamamaraang iyon sa pamamagitan ng mga pahayag ng pagtatalaga.) Upang matukoy kung tinawag ang pamamaraang Object.freeze() ng object, maaari mong tawagan ang Object.isFrozen().

Mahalagang maunawaan na ang Object.seal() at Object.freeze() ay nakakaapekto lamang sa bagay na ipinapasa sa kanila: hindi nila naaapektuhan ang prototype ng bagay na iyon. Kung ang iyong programa ay kailangang ganap na gumawa ng isang bagay, malamang na kakailanganin mo ring makuha ang mga bagay sa prototype chain.

Object Serialization

Ang Object serialization ay ang proseso ng pag-convert ng mga bagay sa isang string representation form, na maaaring magamit sa ibang pagkakataon upang ibalik ang mga ito. Nagbibigay ang ECMAScript 5 ng mga built-in na function para sa pagse-serialize at pagpapanumbalik ng mga bagay sa JavaScript JSON.stringify() At JSON.parse(). Ang mga function na ito ay gumagamit ng JSON data interchange format. Ang pangalang JSON ay nagmula sa JavaScript Object Notation, at ang syntax ng notation na ito ay katulad ng syntax ng JavaScript object at array literals:

Var obj = (x:1, y:(z:)); // Define a test object var s = JSON.stringify(obj); // s == "("x":1,"y":("z":))" var p = JSON.parse(s); // p - kopya ng object obj

Ang syntax ng format ng JSON ay isang subset lamang ng JavaScript syntax at hindi maaaring gamitin upang kumatawan sa lahat ng posibleng value na pinapayagan sa JavaScript. Sinusuportahan at maaaring i-serialize at i-restore: mga object, array, string, finite numeric values, true, false at null. Ang mga halaga ng NaN, Infinity, at -Infinity ay naka-serialize sa null. Ang mga bagay sa petsa ay naka-serialize sa mga string ng petsa sa format ng ISO, ngunit iniiwan sila ng JSON.parse() sa kanilang representasyon ng string at hindi nire-restore ang orihinal na mga object ng Date.

Function, RegExp, at Error object at ang hindi natukoy na halaga ay hindi maaaring i-serialize o maibalik. Ang JSON.stringify() function ay nagse-serialize lang ng mga enumerable na native na katangian ng isang object. Kung hindi ma-serialize ang value ng property, ibubukod lang ang property sa representasyon ng string. Parehong JSON.stringify() at JSON.parse() ay kumukuha ng opsyonal na pangalawang argumento na maaaring magamit upang i-customize ang serialization at/o proseso ng pagbawi, halimbawa sa pamamagitan ng pagtukoy ng listahan ng mga property na ise-serialize o isang function na mag-transform ng mga value sa panahon ng serialization.

Ang pagbisita sa isang web resource ay isang partikular na URI sa address bar browser. Tinukoy ng bisita ang address ng page, at ito ay na-parse ng browser sa mga elemento ng DOM tree - Document Object Model. Ang anumang link sa pahinang ito ay nagsasabi sa browser na mag-parse ng isa pang pahina at bumuo ng isa pang puno ng mga bagay.

Pinapayagan ng browser ang bisita na bumalik o pasulong sa pamamagitan ng isang hanay ng mga pahina na natingnan na sa kasalukuyang session.

Sa katunayan, ang mga aksyon ng gumagamit ay ang paggalaw sa pagitan ng mga sistema ng mga bagay na nabuo sa proseso ng pagbisita sa mga pahina. Ang bawat pahina ay sarili nitong DOM tree at, bilang karagdagan, ang mga bagay sa JavaScript ay mga object ng syntax ng wika mismo at mga paglalarawan ng user.

DOM: naglo-load, nag-a-update at nagbabago

May tatlong pangunahing opsyon na bumubuo sa mga object ng isang web resource page, parehong sa antas ng DOM at sa JavaScript mismo, na nagsagawa ng mga variable na pagbuo ng paglikha, at batay sa mga paglalarawang ginawa ng developer:

naglo-load - dumating ang bisita sa pahina ng site;
update - bisita (button ng browser o Ctrl-F5);
pagpapalit ng elemento ng pahina, halimbawa (AJAX, script, kaganapan, ...).

Ang lahat ng tatlong proseso ay sa panimula ay naiiba, ngunit ang pagkilala sa mga tampok ng unang dalawa ay lalong mahalaga. Mahirap pigilan ang isang bisita na i-refresh ang isang pahina - ito ay isang hindi maalis na "masamang" ugali ng bisita na dapat tandaan ng developer.

Ang pag-navigate sa pahina at higit pa ay dapat na nakasalalay lamang sa pag-andar ng pahina mismo, at hindi sa kasaysayan ng browser at sa mga pag-andar ng mga pindutan nito. Maraming mga site ang nagpahayag ng mahalagang kinakailangan na ito, ngunit ang mga bisita ay tradisyonal na lumalabag dito.

Ang pagpapalit ng page nang hindi ito nire-reload sa antas ng indibidwal na elemento nito (halimbawa, AJAX). karaniwang solusyon para sa mga dynamic na pahina. Bilang panuntunan, ito ay ginagamit upang mag-navigate sa mga elemento ng pahina, baguhin ang mga bagay nito, at pamahalaan ang dialogue sa bisita.

Mga Pangunahing Bagay sa JavaScript

Ang JavaScript ay batay sa object. Halos lahat mga variable ng wika- ito ay mga bagay. Ang developer ay maaaring magbalangkas sariling paglalarawan mga bagay na gumagamit ng iba't ibang opsyon sa syntax.

Ang anumang bagay na hindi "string", "number", true, false, null o undefined ay isang object. Sa loob ng balangkas ng syntax ng wika, maaari itong balewalain, ibig sabihin, ang mga bagay ay mga elemento lamang ng DOM at kanilang sarili. Mga paglalarawan ng JavaScript Object's. Ang pangunahing istraktura ng wika sa karamihan ng mga kaso ay walang makabuluhang praktikal na kahalagahan para sa developer.

Halimbawa, ang mga mathematical function ay kinakatawan ng isang Math object. Ito ay maginhawa sa loob ng balangkas ng konsepto ng wika, ngunit para sa developer ito ay isang maginhawang syntax para sa paggamit ng kinakailangang arsenal ng mga pagpapatakbong matematikal.

Mahalagang gumana nang tama sa DOM at wastong ilarawan ang iyong sariling mga bagay. Ang syntax ng JavaScript object function at mga expression para sa kanilang paggamit ay isang paraan ng pagtatala ng logic ng kinakailangang algorithm.

Strings, Arrays at Objects

Nakabatay ang lahat ng object ng JavaScript sa panuntunan: "property" = "value" at ang konsepto ng isang associative array. Sa pinaka simpleng kaso Ang JavaScript object ay isang koleksyon ng property = value pairs. Gayunpaman, ang "halaga" ay maaaring hindi palaging isang numero, at ang ari-arian ay hindi palaging nakasulat nang walang mga panipi.

Hindi mo dapat gamitin nang labis ang pagpapangalan ng ari-arian. Tamang-tama kapag ang mga pangalan ng property ay naglalaman lamang ng mga character alpabetong Latin, matugunan ang mga kinakailangan para sa pagbibigay ng pangalan sa mga variable at hindi susi (kabilang ang nakalaan) na mga salita ng wika.

Walang inaasahang pag-order ng mga katangian, ngunit kapag lumilikha o nagpasimula ng isang associative array, medyo katanggap-tanggap na malaman kung paano nakaayos ang mga elemento nito. Hindi inirerekumenda na gamitin ang sitwasyong ito, ngunit posible na panatilihin ito sa isip.

Ang pagsisimula ng isang hanay ng mga katangian ay nangangahulugan ng sabay-sabay:

paglikha ng isang array;
paglikha ng bagay.

Sa isang tiyak na konteksto ng aplikasyon, maaari mong isaalang-alang ang isang object ng JavaScript bilang isang associative array, at sa ibang lugar sa algorithm bilang isang object, italaga ang mga kinakailangang pamamaraan dito, baguhin ang mga halaga ng mga elemento nito.

Dahil ang mga pangalan ng property at ang kanilang mga halaga ay dapat na tukuyin sa format ng string kapag ginawa o binago, inirerekomendang gumamit ng string notation at mga panipi.

Pag-access sa Object Properties

Maaari mong makuha at baguhin ang mga halaga ng mga katangian ng isang bagay gamit ang pagbuo ng Object.keys: Ang JavaScript ay bumubuo ng isang hanay ng lahat ng mga katangian ng bagay. Kapag ang mga bagay ay dynamic na nilikha, ang konstruksiyon na ito ay napaka-maginhawa, dahil awtomatiko itong bumubuo ng isang listahan ng lahat ng mga katangian na naroroon sa bagay.

Sa halimbawang ito, ang dalawang array ay inilarawan sa iba't ibang paraan. Sa aplikasyon, ang parehong mga array ay katumbas, dahil naglalaman ang mga ito ng mga katangian ng parehong pangalan at ang kanilang mga halaga. Ang loop ay umuulit sa lahat ng mga katangian ng pangalawang array at bumubuo ng isang string ng lahat ng mga halaga.

Ang isang katulad na epekto ay maaaring makamit sa tuldok o bracket na notasyon:

x1_Obj.NameLast;
x1_Obj ["NameFirst" ].

Ang parehong mga konstruksyon ay wasto at nagbibigay ng nais na resulta. Sa halimbawa sa itaas, kapag tinukoy ang isang array sa pamamagitan ng curly braces "()", maaaring gumawa ng error sa anyo ng "," na simbolo sa dulo ng enumeration (minarkahan sa halimbawa ng pulang bilog). Karaniwang binabalewala ng mga browser ang dagdag na karakter sa enumeration, ngunit mas mabuting huwag gawin ito.

Pag-alis ng mga katangian ng bagay

Dahil ang object ay isang associative array, ang operasyon Ang JavaScript delete object ay isinasagawa sa antas ng kasalukuyang object (kapag nagmamana - mahalaga ito) at isinasaalang-alang sa koleksyon ng mga katangian ng bagay na ito.

Sa konteksto ng halimbawa sa itaas, maaari mong gamitin ang mga sumusunod na konstruksyon:

tanggalin ang x1_Obj .NameLast ;
tanggalin ang x2_Obj ["NameFirst" ];

Ang unang konstruksyon ay nag-aalis ng pangalawang elemento ng unang bagay, ang pangalawang konstruksyon ay nag-aalis ng unang elemento ng pangalawang bagay. Ang delete operator ay hindi gumagana sa prototype properties at nagbabalik ng false kung ang property ay hindi matatanggal.

Mga katangian at pamamaraan ng mga bagay

Ang syntax ng JavaScript object properties at function (paraan) ay katulad ng mga pangkalahatang canon ng syntax at semantics ng wika. Sa katunayan, ang kabaligtaran ay totoo.

Ang mga katangian at pamamaraan ng isang bagay ay isang variant ng paglalarawan ng impormasyon at ang mga pagkilos na pinapayagan kasama nito sa pamamagitan ng object-oriented na JavaScript paradigm.

Ang halimbawang ito ay naglalarawan ng isang x3_Obj object na may dalawang katangian lamang: item at pos. Pagkatapos ay idinagdag ang paraan ng hello() bilang isang function. Bilang resulta, bibigyang-kahulugan ng mga halaga ng object ng JavaScript ang paglalarawang ito sa konteksto ng mga halaga ng ari-arian tulad ng ipinapakita sa window ng resulta, iyon ay, ilalagay nito ang function body (1) bilang isang halaga.

Kapag direktang tinatawag ang Hello() property, ito ay binibigyang kahulugan bilang isang method (function) at ang resulta (2) ay ang execution ng code ng method na ito.

Ang keyword na ito sa isang bagay

Upang mag-navigate sa espasyo ng property ng isang bagay, maaaring gamitin ng developer ang keyword na ito at sumangguni dito sa mga property na inilalarawan nito upang makuha o baguhin ang kanilang mga value.

Ito ay simula pa lamang ng paglalarawan ng isang bagay na may lamang constructor body. Ang halimbawang ito ay naglalarawan ng isang bagay para sa pagtatrabaho sa cookies. Ang bagay ay sinisimulan kapag ang pahina ay na-load ng construct:

var oCookie = bagong scCookies(cOwnerCode);
oCookie.Init();

Sa halimbawang ito, ang coOwnerCode ay ang natatanging code ng bisita. Kung wala ito, gagawa ng bagong code sa constructor ng object ng oCookie. Hindi mahalaga kung ano ang ibig sabihin ng nag-develop ng bagay na ito ng awtorisasyon ng bisita, ang mahalaga ay kung paano ginagamit ang keyword na ito dito upang ilarawan ang mga pamamaraan ng bagay at kung paano tinawag ang mga ito mula sa iba pang mga pamamaraan ng bagay:

ito .GetCookie = function (cName) ( ... );
ito .SetCookie = function (cName, cValue) ( ... ).

Inilalarawan nito ang mga pamamaraan ng object para sa pagbabasa ng cookie sa pamamagitan ng pangalan nito at pagsusulat ng halaga ng cookie na may partikular na pangalan.

ito .GetCookie("cOwner");
this .SetCookie ( "cOwner" , cOwner );

Ito ay kung paano sila ginagamit, kung bilang isang resulta ng unang konstruksiyon ang halaga ay hindi kinakatawan, pagkatapos ay ang pangalawang konstruksiyon ay nagtatatag nito.

Isang halimbawa ng isang bagay para sa pagtatrabaho sa cookies

Maaari mong talakayin ang Object's at ang paradigm ng object-oriented na diskarte ng isang wika na tumatakbo sa isang browser na kapaligiran, ngunit sa katotohanan ay nangangailangan ito ng pagsasanay, hindi teorya Mga pahina ng DOM, Ang pagbibigay ng mga tool para sa pagmamanipula ng mga bagay at paglipat sa mga ,system ng mga bagay ay lakas ng JavaScript.

Sa object-oriented practice, may iba pang mahalaga. Ang pagtatrabaho sa cookies sa halos lahat ng web resources ay par para sa kurso. Ang pagpapatupad nito sa object format ay isang magandang ideya. Sa kontekstong ito, ang pagsisimula ng bagay ay nangyayari sa sandaling mabuksan ang pahina: ang pahina ay na-load = ang cookie object ay umiiral at lahat ay nabasa na, at kung ano ang wala doon ay nilikha.

Habang nagtatrabaho sa page, nagsasagawa ang bisita ng ilang partikular na pagkilos at dapat magbago o gumawa ng cookies ang browser. Mayroong dalawang object method (na may label sa itaas) na gumagawa nito.

Sa katunayan, lumilitaw kaagad ang cookie object pagkatapos buuin ng browser ang DOM at magdagdag ng bagong functionality sa JavaScript object system: pagbabasa at paggawa (pagbabago) ng cookies.

Tungkol dito simpleng halimbawa ay itinuturing bilang isang pamamaraan para sa paglikha ng mga tunay na bagay na may eksklusibong sariling mga katangian at pag-andar (mga pamamaraan). Ang bawat bagay ay gumagawa ng sarili nitong trabaho at hindi nakikilahok sa pangkalahatang algorithm, hindi binabago ang data ng iba pang mga bagay o karaniwang espasyo mga pangalan

Sa diskarteng ito, tinitiyak ng developer ang paglikha ng isang sistema ng mga natatanging bagay na sapat upang ilarawan at serbisyo ang problemang niresolba.

Mga kaganapan sa pahina at bagay

Isang mahalagang elemento ng paggana ng DOM at JavaScript: object event "s - na nagbibigay-daan sa iyong makakuha ng impormasyon tungkol sa isang kaganapan sa tagapangasiwa nito. Halos bawat elemento ng page ay maaaring magtalaga ng sarili nitong tagapangasiwa para sa isa o higit pang mga kaganapan.

Sa katunayan, ang isang JavaScript developer ay gumagawa ng hindi isang malaking "piraso" ng code, ngunit maraming mga paglalarawan ng mga function, mga bagay, mga istruktura ng data at mga pagtatalaga. mga tiyak na elemento mga pahina ng tagapangasiwa ng kaganapan.

Ang Object event ay impormasyon tungkol sa kaganapang naging sanhi ng handler at sa kakayahan ng handler na ito na magsagawa ng sapat na tugon sa event na ito. Ang bawat kaganapan ay naiiba hindi lamang sa pangalan at lugar ng paglitaw nito, kundi pati na rin sa maraming iba pang mga parameter.

Sa partikular, ang mga kaganapan sa keyboard ay isang hanay ng mga parameter, ang mga kaganapan sa mouse ay isang ganap na magkakaibang hanay ng data, at ang tugon ng server sa pamamagitan ng AJAX ay ganap na binalak ng developer mismo.

Sa bawat partikular na kaso, ang larawan ng mga kaganapan na maaaring mangyari sa pahina ay binago sa isang hanay ng mga pinaganang tagapangasiwa sa labas ng mga ibinigay na opsyon para sa pagproseso ng isang partikular na hanay ng mga kaganapan, ang pahina ay hindi nagsasagawa ng anumang aksyon.

Paglikha at pagpapatakbo ng mga bagay

"Binabago" ng browser ang URI, ang address ng web resource na tinukoy ng bisita, sa DOM tree - ang sistema ng mga object ng page ng web resource na ito. Kapag ang isang bisita ay sumusunod sa mga link sa isang pahina, ang browser ay pumupunta sa mga kaukulang puno ng iba pang mga pahina.

Ang sitwasyong ito ay nagbibigay-daan sa developer na bumuo ng kanyang sistema ng mga bagay bilang pundasyon ng isang mapagkukunan ng web na sapat na tumutugon sa gawi ng bisita. Kung ihihiwalay mo ang pangkalahatang pag-andar, halimbawa:

nagtatrabaho sa cookies;
pagtanggap/pagpapadala ng data (AJAX);
mga tooltip;
mga panloob na mensahe (website chat);
iba pang mga gawain;

pagkatapos, kapag nalikha na, maaaring gamitin ang mga object system sa pagbuo ng iba pang mga site. Ito ay isang makabuluhang bentahe ng object approach kaysa sa karaniwang paggamit ng JavaScript bilang isang wika ng browser na nagsisiguro sa paggana ng page at pagtugon sa mga kaganapan.

Ang mga bagay ay mga kumpletong bahagi na maaaring ma-format bilang hiwalay na mga file at magamit sa hinaharap. Ang isang tampok na katangian ng diskarte na ito ay ang posibilidad ng feedback, kapag ang isang na-update, pinabuting bagay ay maaaring magamit sa isang nakaraang pag-unlad, awtomatikong ina-update ang pag-andar nito nang hindi binabago ang site.