Kitu cha Javascript: kuunda vitu na kufanya kazi navyo. Mali na mbinu za vitu. Kuunda kitu kipya

Sasisho la mwisho: 04/08/2018

Upangaji programu unaolenga kitu ni mojawapo ya dhana kuu katika ukuzaji wa programu leo, na katika JavaScript tunaweza pia kuchukua faida kamili ya OOP. Wakati huo huo, kuhusiana na JavaScript, programu inayolenga kitu ina baadhi ya vipengele.

Vitu

Katika mada zilizopita, tulifanya kazi na data ya zamani - nambari, mifuatano, lakini data haiwakilishi aina za zamani kila wakati. Kwa mfano, ikiwa katika programu yetu tunahitaji kuelezea kiini cha mtu ambaye ana jina, umri, jinsia, na kadhalika, basi kwa kawaida hatutaweza kuwakilisha kiini cha mtu kama nambari au kamba. Tutahitaji mistari michache au nambari ili kumwelezea mtu vizuri. Katika suala hili, mtu atafanya kama muundo tata, ambao utakuwa na mali ya mtu binafsi - umri, urefu, jina la kwanza, jina la mwisho, nk.

Kufanya kazi na miundo kama hii, JavaScript hutumia . Kila kitu kinaweza kuhifadhi mali zinazoelezea hali yake na njia zinazoelezea tabia yake

Kuunda kitu kipya

Kuna njia kadhaa za kuunda kitu kipya.

Njia ya kwanza ni kutumia mjenzi wa Kitu:

Var user = new Object();

Katika kesi hii, kitu kinaitwa mtumiaji. Inafafanuliwa kwa njia sawa na tofauti yoyote ya kawaida kwa kutumia neno kuu la var.

Usemi mpya Object() inawakilisha mwito kwa mjenzi - kazi inayounda kitu kipya. Opereta mpya hutumiwa kumwita mjenzi. Kumwita mjenzi kimsingi ni kama kuita kazi ya kawaida.

Njia ya pili ya kuunda kitu ni kwa kutumia brashi za curly:

Var mtumiaji = ();

Leo, njia ya pili ni ya kawaida zaidi.

Mali ya kitu

Baada ya kuunda kitu, tunaweza kufafanua mali juu yake. Ili kufafanua mali, unahitaji kutaja jina la mali baada ya jina la kitu, kilichotenganishwa na dot, na kukipa thamani:

Var mtumiaji = (); user.name = "Tom"; mtumiaji.umri = 26;

Katika kesi hii, jina la mali mbili na umri hutangazwa na kupewa maadili yanayolingana. Baada ya hayo, tunaweza kutumia mali hizi, kwa mfano, kuonyesha maadili yao kwenye koni:

Console.log(jina la mtumiaji); console.log(user.age);

Unaweza pia kufafanua mali wakati wa kufafanua kitu:

Var user = ( jina: "Tom", umri: 26 );

Katika kesi hii, mhusika wa koloni hutumiwa kugawa thamani kwa mali, na koma (badala ya semicolon) huwekwa baada ya ufafanuzi wa mali.

Kwa kuongeza, kuna njia ya mkato ya kufafanua mali:

Var name = "Tom"; var umri = 34; var user = (jina, umri); console.log(jina la mtumiaji); // Tom console.log(user.age); // 34

Katika kesi hii, majina ya vigezo pia ni majina ya mali ya kitu. Na kwa njia hii unaweza kuunda miundo ngumu zaidi:

Var name = "Tom"; var umri = 34; var user = (jina, umri); var mwalimu = (mtumiaji, kozi: "JavaScript"); console.log(mwalimu.user); // (jina: "Tom", umri: 34) console.log(teacher.course); // JavaScript

Mbinu za Kitu

Mbinu za kitu hufafanua tabia yake, au vitendo vinavyofanya. Mbinu ni kazi. Kwa mfano, hebu tufafanue njia ambayo ingeonyesha jina na umri wa mtu:

Var mtumiaji = (); user.name = "Tom"; mtumiaji.umri = 26; user.display = function())( console.log(user.name); console.log(user.age); ); // mbinu piga user.display();

Kama ilivyo kwa kazi, mbinu hufafanuliwa kwanza na kisha kuitwa.

Mbinu pia zinaweza kufafanuliwa moja kwa moja wakati wa kufafanua kitu:

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

Kama ilivyo kwa mali, njia imepewa rejeleo la kazi kwa kutumia koloni.

Ili kufikia sifa au mbinu za kitu ndani ya kitu hicho, tumia neno kuu hili. Inamaanisha marejeleo ya kitu cha sasa.

Unaweza pia kutumia njia fupi ya kufafanua njia kwa kuacha koloni na kazi:

Var user = ( jina: "Tom", umri: 26, display())( console.log(this.name, this.age); ), move(place)( console.log(this.name, "huenda kwa ", mahali);)); user.display(); // Tom 26 user.move("duka"); //Tom huenda dukani

Sintaksia ya safu

Pia kuna njia mbadala ya kufafanua mali na njia kwa kutumia syntax ya safu:

Var mtumiaji = (); user["name"] = "Tom"; mtumiaji["umri"] = 26; user["display"] = function())( console.log(user.name); console.log(user.age); ); // kumwita mtumiaji wa mbinu["display"]();

Jina la kila mali au mbinu imefungwa katika alama za nukuu na mabano ya mraba, kisha inapewa thamani. Kwa mfano, mtumiaji["age"] = 26 .

Unapofikia sifa na mbinu hizi, unaweza kutumia nukuu za nukta (user.name) au utumie: user["name"]

Kamba kama Sifa na Mbinu

Inapaswa pia kuzingatiwa kuwa majina ya mali ya kitu na mbinu daima ni masharti. Hiyo ni, tunaweza kuandika tena ufafanuzi uliopita wa kitu kama hiki:

Var user = ( "jina": "Tom", "umri": 26, "display": function())( console.log(user.name); console.log(user.age); ) ); // mbinu piga user.display();

Kwa upande mmoja, hakuna tofauti kati ya fasili hizo mbili. Kwa upande mwingine, kuna matukio ambapo kuifunga kichwa kwenye mstari kunaweza kusaidia. Kwa mfano, ikiwa jina la sifa lina maneno mawili yaliyotenganishwa na nafasi:

Var user = ( jina: "Tom", umri: 26, "full name": "Tom Johns", "display info": function())( console.log(user.name); console.log(user.age) ;)); console.log(mtumiaji["jina kamili"]); mtumiaji["maelezo ya kuonyesha"]();

Ni katika kesi hii pekee, lazima tutumie syntax ya safu kufikia mali na mbinu kama hizo.

Kuondoa mali

Hapo juu tuliangalia jinsi tunaweza kuongeza sifa mpya kwa kitu. Hata hivyo, tunaweza pia kufuta mali na mbinu kwa kutumia operator kufuta. Na kama tu na kuongeza, tunaweza kuondoa mali kwa njia mbili. Njia ya kwanza ni kutumia nukuu za nukta:

Futa kitu.mali

Au tumia syntax ya safu:

Futa kitu["mali"]

Kwa mfano, wacha tuondoe mali:

Var mtumiaji = (); user.name = "Tom"; mtumiaji.umri = 26; user.display = function())( console.log(user.name); console.log(user.age); ); console.log(jina la mtumiaji); // Tom futa jina la mtumiaji; // futa mali // mbadala // futa mtumiaji["jina"]; console.log(jina la mtumiaji); //haijafafanuliwa

Baada ya kufutwa, mali itakuwa haijafafanuliwa, hivyo unapojaribu kuipata, programu itarudi thamani isiyojulikana.

Salamu kwa kila mtu anayesoma chapisho hili. Leo nataka kukutembeza kupitia zana muhimu ya lugha - vitu vya JavaScript. Acha nikukumbushe kwamba js ni kivinjari na inafanya kazi kwenye mifumo yote ya uendeshaji (windows, mac os, nk). Tofauti na lugha za programu zinazoelekezwa na kitu, utekelezaji wa vitu katika js hutofautiana kwa kiasi kikubwa kutoka kwa utendaji wa kawaida na tofauti katika matumizi ya matukio, kwa mfano, katika C #.

Kwa hiyo, baada ya kusoma makala ya sasa, utajifunza sifa kuu za kutofautisha za vitu vya script, jifunze kwa njia gani zinaweza kuundwa, kusasishwa na kufutwa. Pia nitagusa juu ya mada ya mali, mbinu na wajenzi, na kuzungumza juu amri muhimu na bila shaka kidogo kuhusu urithi. Nadhani ni wakati wa kuanza kujifunza!

Ni kitu gani kwenye JavaScript na ina uwezo gani?

Katika js, vitu ni safu rahisi za ushirika (pia huitwa heshi).

Safu ya ushirika ni nini?

Huu ni muundo wa data ambao huhifadhi kiasi fulani cha maelezo yanayohusiana na kuelezea kipengele maalum. Data zote zimeundwa na kuunganishwa kama "kifunguo => thamani".

Kwa mfano, unahitaji kuelezea magari. Kisha unaunda kitu kiotomatiki na ueleze sifa zake katika safu. Niliamua kuelezea utengenezaji wa gari (jina), rangi yake (rangi) na gharama (bei). Hapo chini nimeambatisha nambari ya kutekeleza kazi iliyoelezewa.

1 2 3 4 5

var avto = ( jina: "BMW 116i", rangi: "nyeusi", bei: 588000);

Hapa unaona njia moja ya kuunda kitu kinachoitwa "avto". Jina, rangi na bei ni funguo zinazoweza kutumika wakati wa kuandika programu.

Nilijitangulia na mfano huu, kwa hiyo sasa hebu tuangalie kila kitu kwa utaratibu.

Unaweza kuunda kitu kwa njia kadhaa:

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

Katika visa vyote viwili kitu tupu huundwa na jina maarufu, lakini chaguo la kwanza hutumiwa mara nyingi zaidi, kwa kuwa ni mfupi na rahisi zaidi kuandika.

Yote kuhusu mali

Sasa unahitaji kujaza kitu tupu na vigezo. Ili kufanya hivyo, unahitaji kuongeza mali, ambayo pia niliita funguo hapo juu. Tena, kuna njia mbili za kutangaza mali.

Ningependa kutambua kuwa JavaScript haina mfumo madhubuti wa kuunda na kuanzisha vigezo kama hivyo. Sifa mpya zinaweza kuonekana kote kwenye msimbo, jinsi zinavyoweza kufutwa na kusasishwa.

Kwa hivyo, unaweza kuunda funguo zote mara moja au kuzitangaza kadri zinavyopatikana. Na hata ikiwa, wakati wa kuandika programu, unarejelea funguo ambazo hazipo, hakutakuwa na kosa. Katika kesi hii, "isiyojulikana" itarejeshwa.

Njia ya kwanza.

Kuunda na kupata mali kwa kutumia nukta. Ili kutekeleza chaguo hili, unahitaji kuandika jina la kitu, na kisha uongeze jina la ufunguo kwa njia ya dot na kisha upe thamani fulani kupitia ishara sawa:

avto.name = "BMW 116i"

Lakini kwa njia hii utaongeza kipengee kimoja zaidi kwa funguo zilizopo:

Njia hii hutumiwa wakati jina la mali tayari linajulikana na unahitaji kufanya vitendo fulani na maadili.

Njia ya pili.

Sio tofauti na ya kwanza, ikiwa unalinganisha madhumuni yao. Hata hivyo, njia hii ina faida kidogo. Kwa chaguo hili, mabano ya mraba hutumiwa:

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

Aidha nzuri ni uwezo wa kuunda majina ya mali kwa namna ya kamba yoyote. Kwa mfano,

avto[“jina la gari”] = “BMW 116i”

Kufanya kazi na funguo kupitia mabano ya mraba hutumiwa wakati baadhi ya vigezo vimeingizwa na mtumiaji na kuhifadhiwa katika vigezo au wakati majina ya mali haijulikani mapema. Kwa mfano, mtumiaji anaomba bei ya gari iliyochaguliwa. Kipengele kilichoitwa kimeandikwa kwa kutofautisha, na bei inatumwa kwa kujibu:

var auto = (); avto.name = "BMW_116i"; avto.bei = 588000; var key = "bei"; // bei ya gari iliombwa tahadhari (avto);

Sasa hebu tuendelee kwenye kufuta mali. Kila kitu ni rahisi sana hapa. Kuondoa, tumia amri kufuta. Kwa hivyo, ikiwa unaongeza mistari 2 ifuatayo kwa mfano wa mwisho hapa chini:

futa auto.bei;

tahadhari (otomatiki);

Kisha, wakati wa kupiga simu kwa mara ya pili, sanduku la mazungumzo litaonyesha "isiyofafanuliwa".

Maneno machache kuhusu compactness

Katika hatua ya sasa, nilikuambia jinsi ya kuunda kitu na kuelezea mali zake. Nimeambatanisha kesi za majaribio kwa hili, lakini wasikilizaji wako zaidi, wasomaji wapendwa, wamegundua kuwa nambari ya programu ya kwanza ni tofauti na zingine zote.

Na yote kwa sababu inatumia uwakilishi wa data kompakt. Hii ni njia maarufu sana ya kutangaza funguo kwa sababu ni fupi kuandika na rahisi kuelewa kwa macho.

Wacha tupitie mali zetu

Katika JavaScript, unaweza kurudia haraka kupitia vipengele vilivyoundwa. Kwa kusudi hili, utaratibu maalum ulitolewa, unaojulikana zaidi kama mzunguko.

Ikiwa unafahamu lugha nyingine za programu, unajua kwamba mara nyingi vitanzi huundwa kwa kutumia neno kwa, basi hali ya kuorodhesha vipengele imeandikwa kwenye mabano.

Katika js inakumbusha yake mwonekano mzunguko kwa kila kutoka kwa lugha ya C #. Angalia muundo wa jumla:

kwa (var obj katika kitu) ( // kufanya utaftaji)

ambapo obj inawajibika kwa jina la funguo zilizoorodheshwa,

kitu - kwa maadili yao.

Na sasa hapa kuna mfano halisi kwako.

1 2 3 4 5 6 7 8

var avto = ( jina: "BMW 116i", rangi: "nyeusi", bei: 588000); kwa (var obj katika kitu) ( tahadhari(obj + ":" + kitu) )

Ni wakati wa kufahamiana na mbinu

Lugha ya uandishi hutoa uundaji wa mbinu. Huu ni utaratibu rahisi kabisa ambao wakati wowote unaweza kuongeza njia au njia kwa kitu chochote ambacho kinapanua uwezo wa safu za ushirika iliyoundwa. Pia huitwa sifa za kazi.

Js yenyewe ni ya nguvu sana na ya kushangaza kwa kiasi fulani. Hivi ndivyo vipengele vinaweza kuundwa aina tofauti. Wakati wa kujifunza lugha hii, hauitaji kukariri miundo ngumu, kwani matamko mengi yanafanana sana.

Kwa hivyo, ili kuunda njia, unahitaji kutangaza kitu, na kisha uanze kuandika amri ambayo ni sawa na kuunda mali. Hata hivyo, baada ya "=" sio tena thamani iliyoandikwa, lakini kazi ya neno kuu (kigeu). Na kisha vitendo vimeorodheshwa kwenye mabano ya curly.

Hapa kuna utekelezaji wa utaratibu huu:

var avto =() avto.name = “BMV” avto.year = 1999 avto.drive = kazi(k) ( tahadhari(“Gari limepita”+n+“ km.”)) avto.drive(300) avto. kuendesha (450)

Kama unaweza kuona, mfano huu una mali na njia ambazo simu zao zinafanana mwanzoni.

Je, JS pia ina wajenzi?

Ndiyo bwana! Katika lugha hii, kila kitu kinachotumia neno kuu " mpya", moja kwa moja huwa mjenzi. Kwa hiyo, hapo juu uliona tamko la kitu tupu katika fomu: avto = Kitu kipya ();. Huyu ndiye mjenzi.

Kwa uwazi, fikiria mistari hapa chini.

var bob = Kitu kipya ();

bob.name = "Bob Smith";

Walakini, hii sio safu nzima ya uwezekano. Katika js, unaweza kuunda wajenzi wako mwenyewe na kisha uwatumie kutangaza vitu vipya.

Kwa hivyo, nataka "kutengeneza" kijenzi maalum kwa magari yaliyopo tayari. Tafadhali kumbuka kuwa jina lazima liandikwe na herufi kubwa. Hii ndio alama ya kazi. Ili kufanya hivyo, ninaandika utekelezaji wa programu ifuatayo:

kazi Auto (jina, bei) (

this.name = jina;

hii.bei = bei;

Sasa, unapounda idadi isiyo na kikomo ya vitu na kutumia kijenzi hiki kwao, wote watakuwa wa darasa moja. Kwa mfano:

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

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

Kwa kuongeza hii, unaweza kuunda njia ndani ya mjenzi.

Vipengele vya urithi katika JavaScript

Kwa kawaida, katika lugha nyingi, urithi hutegemea madarasa ambayo yanaweza kurithi kutoka kwa kila mmoja. Kisha unaweza kusikia maneno kama vile "darasa la mababu", "darasa la watoto", nk.

Walakini, katika js kila kitu ni tofauti. Hapa ndipo vitu vinaporithiwa.

Urithi wote unategemea kiungo cha ndani kati ya vitu, ambayo inajulikana kama "mfano". Ikiwa unaongeza ".prototype" kwa njia kwa kutumia dot, na kisha uingize jina la mfano, basi vitu vyote vya njia iliyochaguliwa vitarithiwa kutoka kwa mfano huu.

Hebu tuendelee kwa mfano.

kazi Usafiri (jina) ( this.name = name this.canDrive = true ) var transport = new Transport ("avto") // imeunda utendakazi wa kitu cha usafiri Baiskeli (jina) ( this.name = name ) Baiskeli.prototype = usafiri // bainisha kuwa vitu vyote vipya vya darasa hili vitatumia usafiri bike1 = Baiskeli mpya ("kwa_michezo") bike2= Baiskeli mpya ("for_child") console.log(bike1.name) console.log(bike2.name) console .log (baiskeli1.canDrive)

Nadhani nitaishia hapa. Nimekuambia kuhusu vipengele vya msingi vya lugha ya uandishi. Walakini, hii ni maarifa ya juu juu tu. Ifuatayo tutaingia ndani zaidi. Wakati huo huo, usisahau kujiunga na safu ya waliojiandikisha na ushiriki kiunga cha kifungu na marafiki zako. Bahati njema!

Kwaheri!

Salamu nzuri, Roman Chueshov

Soma: mara 97

Vitu ndio msingi wa JavaScript. Aina nyingi za data zilizojumuishwa zinawakilishwa kama vitu. Kuwa msanidi aliyefanikiwa JavaScript, unahitaji kuwa na ufahamu wazi wa jinsi wanavyofanya kazi. Majengo ya kitu huitwa sehemu zake au sifa za kitu cha JavaScript. Hutumika kuelezea kipengele chochote cha kitu. Mali inaweza kuelezea urefu wa orodha, rangi ya anga, au tarehe ya kuzaliwa ya mtu. Kuunda vitu ni mchakato rahisi. Lugha hutoa sintaksia inayojulikana kama neno halisi la kitu, ambalo huonyeshwa kwa viunga vilivyopinda.

Kufikia Mali

Lugha hutoa maingizo mawili ya kupata sifa. Ya kwanza na ya kawaida zaidi inajulikana kama nukuu ya nukta. Katika nukuu ya nukta, rasilimali inaweza kufikiwa kwa kubainisha jina la kifaa mwenyeji, ikifuatiwa na kipindi na jina la sifa. Kwa mfano, kitu.foo kilipowekwa awali kuwa moja, basi thamani yake itakuwa 2 baada ya taarifa ya vipengee vya JavaScript kutekelezwa.

Sintaksia mbadala ya ufikiaji inajulikana kama nukuu ya mabano. Katika nukuu, jina la kitu linafuatwa na seti ya mabano ya mraba. Ndani yao, jina la mali limeainishwa kama kamba:

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

Inajieleza zaidi kuliko nukuu za nukta kwa sababu inaruhusu kigezo kubainisha yote au sehemu ya jina la sifa. Hili linawezekana kwa sababu mkalimani wa kitu cha JavaScript hubadilisha kiotomati usemi huu kuwa mfuatano na kisha kupata sifa inayolingana. Majina ya mali huundwa kwa kuruka kwa kuunganisha yaliyomo kwenye kigezo f na kamba "oo":

object = "bar".

Uwekaji alama kwenye mabano huruhusu majina ya vipengee kuwa na herufi ambazo haziruhusiwi katika nukuu za nukta. Kwa mfano, taarifa ifuatayo ni halali kabisa katika mabano. Walakini, ikiwa mtumiaji atajaribu kuunda jina la sifa sawa katika nukuu ya nukta, atakumbana na hitilafu ya kisintaksia:

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

Sifa za vipengee vya JavaScript vilivyoorodheshwa vinaweza kufikiwa kwa kuunganisha nukta na/au mabano. Kwa mfano, kitu kifuatacho kina kitu kiota kinachoitwa baz ambacho kina kitu kingine kinachoitwa foo ambacho kina sifa inayoitwa bar iliyo na thamani ya tano:

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

Maneno yafuatayo yanafikia kipengee kilichoambatishwa cha upau. Usemi wa kwanza unatumia nukuu ya nukta, huku usemi wa pili unatumia nukuu za mraba. Usemi wa tatu unachanganya maingizo yote mawili kufikia matokeo sawa:

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

Semi kama zile zilizoonyeshwa katika mfano uliopita zinaweza kusababisha uharibifu wa utendaji wakati matumizi mabaya na kutoa kitu cha JavaScript kutotumika. Kutathmini kila usemi wa nukta au mabano huchukua muda. Ikiwa mali hiyo hiyo inatumiwa mara nyingi, basi inaeleweka kupata mali hiyo mara moja na kisha kuhifadhi thamani katika kigezo cha ndani kwa matumizi yote ya baadaye.

Kazi kama mbinu

Wakati kipengele cha kukokotoa kinapotumika kama sifa ya kitu, huitwa mbinu. Kama sifa, zimebainishwa katika nukuu halisi ya kitu. Kwa mfano:

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

Mbinu za kitu cha JavaScript zinaweza kuitwa kwa kutumia alama na mabano. Mfano ufuatao unaita sum() njia kutoka kwa mfano uliopita kwa kutumia maingizo yote mawili:

kitu.jumla (1, 2);
object["jumla"](1, 2).

Nukuu halisi ya kitu ni muhimu kwa kuunda vitu vipya, lakini haiwezi kuongeza sifa au mbinu kwa zilizopo. Kwa bahati nzuri, kuongeza data mpya ni rahisi kama kuunda taarifa ya kazi. Kitu tupu kinaundwa. Halafu, kwa kutumia waendeshaji wa mgawo, tunaongeza mali mbili, foo, na bar, na njia ya baz:

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

Ufungaji wa Programu

Wazo la msingi la upangaji unaolenga kitu ni kugawa programu katika sehemu ndogo na kufanya kila sehemu kuwajibika kwa kusimamia hali yake. Kwa hivyo, ujuzi fulani kuhusu jinsi sehemu ya programu inavyofanya kazi inaweza kuwa ya ndani kwa sehemu hiyo. Mtu anayeshughulikia programu iliyosalia hapaswi kukumbuka au hata kujua kuihusu. Wakati wowote data hii ya ndani inabadilika, msimbo unaoizunguka pekee ndio unahitaji kusasishwa.

Sehemu mbalimbali za programu kama hiyo huwasiliana kupitia violesura, seti chache za vitendakazi au vifungo ambavyo hutoa utendakazi muhimu katika kiwango cha muhtasari zaidi huku kikificha utekelezaji wake haswa. Sehemu kama hizo za programu zinaundwa kwa kutumia vitu. Interface yao ina seti maalum ya mbinu na mali. Sifa ambazo ni sehemu ya kiolesura huitwa umma. Zingine, ambazo hazipaswi kugusa msimbo wa nje, huitwa faragha.

Lugha nyingi hutoa uwezo wa kutofautisha kati ya mali ya umma na ya kibinafsi na hairuhusu msimbo wa nje kufikia zile za kibinafsi. JavaScript, tena ikichukua mbinu ndogo, haipo bado. Kazi inaendelea kwa sasa ya kuongeza lugha hii. Kwa hivyo, watengenezaji wa programu za JavaScript watatumia wazo hili kwa mafanikio. Kwa kawaida, kiolesura kinachoweza kufikiwa ilivyoelezwa katika nyaraka au maoni. Pia ni kawaida kuweka alama chini (_) mwanzoni mwa majina ya mali ili kuonyesha kuwa mali hizo ni za kibinafsi. Kutenganisha kiolesura kutoka kwa utekelezaji - wazo kubwa. Hii kawaida huitwa encapsulation.

Mali

Kitu chenye mabano (...) kinaitwa kitu halisi. Unaweza kuweka mali mara moja kwenye mabano kama hayo (...). Kwa mfano, jozi "ufunguo: thamani na kadhalika":

acha mtumiaji = ( // jina la kitu: "John", // kwa ufunguo "jina" thamani ya duka "John" age: 30 // by key "age" store value 30 }.!}

Sifa ina ufunguo (pia hujulikana kama "jina" au "kitambulisho") kabla ya koloni ":" na thamani iliyo upande wake wa kulia. Kitu cha mtumiaji kina sifa mbili. Kitu cha mtumiaji cha JavaScript kilicho na faili mbili zilizotiwa saini zinazoitwa "jina" na "umri". Unaweza kuongeza, kufuta na kusoma faili kutoka kwayo wakati wowote. Thamani za mali hupatikana kwa kutumia nukuu ya nukta. Inaweza kuwa ya aina yoyote. Unaweza kuongeza thamani ya boolean. Ili kuondoa kipengele, tumia kufuta kwenye kesi ya Hitilafu ya kitu cha JavaScript.

Vipengee vyote vya hitilafu za JavaScript ni vizazi vya kitu cha Hitilafu au kitu kilichorithiwa:

Kipengee cha Hitilafu ya Sintaksia hurithi kutoka kwa kifaa cha Hitilafu.
Hitilafu ya kuchanganua ya JSON ya aina fulani ya kifaa cha Hitilafu ya Sintaksia.

Ili kutafakari kwa kina zaidi jinsi programu hushughulikia hitilafu za JavaScript, angalia kwa karibu Airbrake JavaScript, zana ya kufuatilia makosa kwa arifa za wakati halisi na maarifa ya papo hapo kuhusu kile ambacho kilienda vibaya na msimbo wako wa JavaScript.

Ujumbe wa hitilafu ambao mtumiaji anaweza kupokea kabla ya kufuta kitu cha JavaScript:

Herufi mbaya ya udhibiti katika mfuatano halisi.
Tabia mbaya katika mfuatano halisi.
Utoaji duni wa Unicode.
Tabia mbaya ya kutoroka.
Mfuatano ambao haujakamilika.
Msimbo usio wa nambari usiotarajiwa.
Hakuna nambari baada ya nukta ya desimali.
Nambari ya sehemu isiyokamilika.
Hakuna nambari baada ya kiashiria cha digrii.
Hakuna nambari baada ya ishara ya kielelezo.
Sehemu ya kielelezo haina nambari.
Mwisho usiotarajiwa wa data.
Neno kuu lisilotarajiwa.
Ishara isiyotarajiwa.
Mwisho wa data wakati wa kusoma yaliyomo ya kitu.
Jina la mali inayotarajiwa au ")".

Tabia za hesabu

Unaweza kutumia mabano ya mraba katika kitu halisi. Hizi huitwa mali za hesabu. Mfano umetolewa hapa chini.

Maana ya mali iliyohesabiwa ni rahisi: inamaanisha kwamba jina la mali lazima lichukuliwe kutoka kwa matunda. Kwa hivyo ikiwa mgeni anaingia "apple", begi litakuwa (apple: 5). Inaweza kutumika zaidi semi tata katika mabano ya mraba:

acha matunda = "apple";

: 5 // bag.appleComputers = 5

Mabano ya mraba yana nguvu zaidi kuliko nukuu ya nukta. Wanaruhusu majina ya mali na vigezo. Lakini pia ni ngumu zaidi kuandika. Kwa hivyo mara nyingi, wakati majina ya mali yanajulikana na rahisi, nukta hutumiwa. Na ikiwa unahitaji kitu ngumu zaidi, kisha ubadilishe kwenye mabano ya mraba.

Uhifadhi wa neno

Tofauti haiwezi kuwa na jina sawa na moja ya maneno yaliyohifadhiwa kama vile "kwa", "ruhusu", "rejesha", nk. Lakini wakati wa kupanga vitu vya JavaScript, hakuna kizuizi kama hicho.

Kimsingi, jina lolote linaruhusiwa, lakini kuna maalum: "__proto__" hupata matibabu maalum kwa sababu za kihistoria. Kwa mfano, huwezi kuiweka kwa thamani nyingine isipokuwa kitu:

obj.__proto__ = 5;

tahadhari(obj.__proto__); // haikufanya kazi kama ilivyokusudiwa

Kama unaweza kuona kutoka kwa nambari, madhumuni ya 5 ya kwanza hayazingatiwi. Hiki kinaweza kuwa chanzo cha hitilafu na hata udhaifu ikiwa opereta anatarajia kuhifadhi jozi za thamani ya vitufe kiholela kwenye kitu na kumruhusu mgeni kubainisha funguo. Katika kesi hii, mgeni anaweza kuchagua "proto" kama ufunguo na kuongeza JavaScript kwa kitu. Kuna njia ya kufanya vitu kutibiwa na __proto__ kama mali ya kawaida. Pia kuna ramani nyingine ya miundo ya data inayotumia funguo za kiholela.

Mali Nambari

Neno "mali kamili" hapa linamaanisha kamba inayoweza kubadilishwa kutoka nambari kamili bila kubadilishwa. Kwa hivyo, kwa mfano, "49" ni jina kamili la mali kwa sababu linapobadilishwa kuwa nambari kamili na kurudishwa tena, bado ni sawa. Lakini "+49" na "1.2" sio hivyo. Kwa upande mwingine, ikiwa funguo sio kamili, basi zimeorodheshwa kwa mpangilio ambao ziliundwa. Mfano hapa chini.

Ili kurekebisha tatizo na misimbo ya kupiga simu, unaweza "kudanganya" kwa kufanya misimbo lisiwe kamili. Kuongeza "+" (ishara ya pamoja) kabla ya kila msimbo inatosha. Sasa itafanya kazi kama ilivyokusudiwa.

Tofauti kati ya vitu na primitives ni kwamba huhifadhiwa na kunakiliwa "kwa kumbukumbu". Thamani za awali hupewa na kunakiliwa "kama thamani kamili". Tofauti huhifadhi "anwani katika kumbukumbu" badala ya kitu chenyewe au "rejeleo" kwake. Unaweza kutumia tofauti yoyote kufikia na kubadilisha yaliyomo.

Mfano hapo juu unaonyesha kuwa kuna kitu kimoja tu na msimamizi wa kuingia ndani yake. Kisha, ikiwa ufunguo tofauti (mtumiaji) unatumiwa baadaye, mtumiaji ataona mabadiliko.

Waendeshaji usawa == na usawa madhubuti === kwa vitu hufanya kazi kwa njia ile ile. Vitu viwili ni sawa ikiwa tu ni kitu kimoja. Kwa ulinganisho kama obj1 > obj2 au ulinganisho na primitive obj == 5, vitu hubadilishwa kuwa primitives. Kuwa waaminifu, ulinganisho kama huo hauhitajiki sana na kwa kawaida ni matokeo ya hitilafu ya usimbaji.

Uthibitishaji wa Kitu cha JavaScript

Vitu vina ufikiaji wa mali yoyote. Walakini, ikiwa haipo kabisa, haitakuwa kosa. Kufikia tu mali ambayo haipo kunarudisha bila kufafanuliwa. Inatoa njia ya kawaida sana ya kujaribu mali na kuilinganisha na isiyofafanuliwa. Chini ni mfano.

Kutumia "in" kwa mali ambazo huhifadhi bila kufafanuliwa. Kawaida ukaguzi madhubuti wa "=== undefined" hufanya kazi vizuri. Kuna kesi maalum ambapo inashindwa na "ndani" inafanya kazi kwa usahihi. Huu ndio wakati mali ya kitu iko lakini inabaki bila kufafanuliwa.

Katika msimbo ulio hapo juu, kipengele cha obj.test kipo kitaalam. Kwa hivyo in operator hufanya kazi kwa usahihi. Hali kama hizi ni nadra sana kwa sababu undefined huwa hawagawiwi. Mara nyingi maadili "isiyojulikana" au "tupu" hutumiwa. Kwa hivyo, mwendeshaji wa ndani ni mgeni katika msimbo.

"kwa..katika" kitanzi

Ili kusonga funguo zote kutoka kwa kitu hadi kitu, kuna aina maalum ya kitanzi: kwa..in. Hili ni jambo tofauti kabisa na for(;;) construct.

Chini ni mfano.

Tafadhali kumbuka kuwa wajenzi wote wa "kwa" hukuruhusu kutangaza utofauti wa kitanzi ndani ya kitanzi kama kitufe cha kuruhusu. Vinginevyo, unaweza kutumia jina tofauti tofauti, ufunguo, badala yake.

Kwa mfano, for(let prop in obj) pia inatumika sana.

Kuna "bracket ya mraba" mbadala ambayo inafanya kazi na kamba yoyote.

Hoja hapa inahitaji funguo za kitu cha JavaScript ziwe kitambulisho halali cha kutofautisha, kumaanisha kuwa hakuna nafasi au vizuizi vingine. Uangalifu lazima uchukuliwe ili kuhakikisha kuwa mstari ndani ya mabano umenukuliwa kwa usahihi. Mabano ya mraba pia hutoa njia ya kupata jina la mali kutoka kwa matokeo ya usemi wowote, kinyume na kamba halisi kutoka kwa kutofautisha:

let key = "anapenda ndege";

// sawa na mtumiaji["anapenda ndege"] = kweli;

mtumiaji = kweli.

Hapa kigezo muhimu kinaweza kuhesabiwa wakati wa kukimbia na inategemea ingizo la mtumiaji na kisha kutumika kufikia mali. Hii huwapa watayarishaji programu kubadilika zaidi. Nukuu ya nukta haiwezi kutumika kwa njia sawa, kwani inaweza kurudia juu ya kitu cha JavaScript. Chini ni mfano.

Const kitu

Kitu kilichotangazwa cha const kinaweza kurekebishwa. Mfano umetolewa hapa chini.

Inaweza kuonekana kama kitu cha JavaScript kwenye mstari (*) kinaweza kutupa makosa, lakini sivyo ilivyo. Hii ni kwa sababu const inachukua thamani ya mtumiaji yenyewe. Na hapa mtumiaji huweka kumbukumbu kwa kitu kimoja wakati wote. Mstari (*) unaingia ndani ya kitu, haujakabidhiwa tena kwa mtumiaji. Const itatoa hitilafu ikiwa utajaribu kuweka mtumiaji na kitu kingine. Kuunganisha na kuunganisha, Object.assign huunda marejeleo mengine kwa kitu sawa ikiwa kinahitaji kunakiliwa. Hili pia linaweza kutekelezeka, lakini ni gumu zaidi kwa sababu JavaScript haina mbinu iliyojengewa ndani. Kwa kweli, hii ni mara chache muhimu. Kunakili kwa kumbukumbu hutumiwa katika hali nyingi. Lakini ikiwa unahitaji hii kweli, basi unahitaji kuunda kitu cha JavaScript na kuiga muundo wa iliyopo, kuiga mali zake kwa kiwango cha zamani. Chini ni mfano.

Na unaweza pia kutumia Object.assign mbinu kwa hili. Hoja dest na src1, ..., srcN ni vitu. Inakili mali ya vitu vyote src1, ..., srcNINTO dest. Kwa maneno mengine, mali ya hoja zote, kuanzia ya pili, zinakiliwa hadi 1. Kisha inarudi kwenye hali mbaya. Kwa mfano, unaweza kuitumia kuchanganya vitu kadhaa kuwa moja.

Na pia unaweza kutumia Object.assign kuchukua nafasi ya kitanzi cloning rahisi. Hunakili mali zote za mtumiaji kwa kitu tupu na kurudisha, kama kitanzi, lakini kifupi. Hadi sasa, imechukuliwa kuwa mali zote za watumiaji ni za zamani. Lakini mali inaweza kuwa marejeleo ya vitu vingine.

Ili kurekebisha hili, unahitaji kutumia kitanzi cha clone ambacho hukagua kila thamani ya mtumiaji na, ikiwa ni kitu, kisha huiga muundo wake. Hii inaitwa "cloning ya kina."

Ipo algorithm ya kawaida cloning ya kina, ambayo hushughulikia kesi iliyo hapo juu na kesi ngumu zaidi inayoitwa algorithm ya uundaji wa muundo. Ili kuepuka kurejesha gurudumu, unaweza kutumia utekelezaji wa kazi kutoka kwa maktaba ya JavaScript ya lodash, njia inaitwa _.cloneDeep(obj).

Mbinu za Juu

Ikiwa programu itazunguka juu ya kitu na anataka kupata mali zote kwa mpangilio sawa ziliongezwa, anaweza kutegemea "kuagiza maalum," ambapo sifa kamili hupangwa na zingine huundwa kwa mpangilio ambao kitu cha JavaScript kiliundwa. .

Mbinu za hali ya juu hushughulikia dhana ambazo hazitumiki sana katika JavaScripting. Hii ni kwa sababu katika hali za kawaida vipengele hivi vya nguvu hazihitajiki. Baadhi ya njia hizi huenda zisifanye kazi katika vivinjari vya zamani, kama vile matoleo ya mapema ya Netscape 4.

Mfano huo unaweza kutumika kuunda vipengee vya JavaScript na mbinu zote za mycircle, sio tu mpya. Hii ina athari mchanganyiko ya utendaji. Sio lazima kuhifadhi nakala tofauti za mbinu kwa kila mfano wa kitu, kwa hivyo zinaweza kuhitaji kumbukumbu kidogo ili kufanya kazi, lakini kivinjari lazima kitafute wigo wa sasa na mzazi ili kuzipata. Hii inaweza kusababisha ucheleweshaji uliokithiri. Kwa ujumla, mtumiaji anapaswa kutumia kile kinachofaa kwa msimbo badala ya kuegemeza uamuzi huo kwenye utendakazi, isipokuwa anashughulika na mazingira mahususi yaliyodhibitiwa.

Rudi kweli

Katika baadhi ya matukio, inaweza kuhitajika kwa mali ya kitu kufungwa kwa kitu chenyewe au mahali pengine kwenye mnyororo wa mfano. Katika JavaScript, vitu vyote hutumia njia ya hasOwnProperty, ambayo inarudi kuwa kweli ikiwa mali hiyo inahusishwa na mfano wa kitu cha mtu binafsi. Katika kesi hii, inawezekana kuangalia ikiwa mjenzi wa kitu ana mali sawa na thamani sawa na mfano wa kitu yenyewe. Hii inaweza kutoa matokeo yasiyo sahihi ikiwa kuna sifa tofauti za kitu cha JavaScript thamani sawa kwa mfano wa kitu na mfano wa mzunguko. Njia ya hasOwnProperty inachukua kigezo kimoja - jina la mali kama kamba.

Unaweza kuunda njia za kibinafsi kwa njia sawa. Ni kazi tu ambayo imeundwa ndani ya kazi ya mjenzi. Hii inaweza kuonekana kuwachanganya wengine, lakini ndivyo inavyofanya kazi. Kazi ya kibinafsi inaweza kuitwa tu na mjenzi yenyewe au kwa njia ambazo zinafafanuliwa kwenye mstari. Zinaweza kutumika kama njia za umma ikiwa zimepewa mjenzi wa umma na kupatikana kwa kutumia njia za umma za vitu vya Javascript.

kazi myob() ( kazi cantBeSeen() ( alert(secretValue);

) var secretValue = "";

this.method1 = kazi () ( secretValue = "hakuna mshangao";!}

this.method2 = cantBeSeen;

) var oneOb = myob mpya();

oneOb.njia1();

//tahadhari "hakuna mshangao" oneOb.method2();

// alerts "hakuna mshangao".

Amri Kigezo

Vitu vya amri huruhusu mifumo iliyounganishwa kwa urahisi kwa kutenganisha zile zinazotoa ombi kutoka kwa vitu na zile zinazoshughulikia ombi. Maombi haya yanaitwa matukio, na msimbo unaochakata maombi huitwa washughulikiaji wa hafla.

Tuseme unaunda programu zinazotumia vitendo vya ubao wa kunakili Kata, Nakili na Bandika. Vitendo hivi vinaweza kuanzishwa kwa njia tofauti katika programu: kwa mfumo wa menyu, na menyu ya muktadha, kwa mfano kwa kubofya. kitufe cha kulia panya kwa uwanja wa maandishi au njia ya mkato ya kibodi. Vitu vya amri hukuruhusu kuweka uchakataji wa vitendo hivi, moja kwa kila operesheni, wakati amri moja tu inahitajika kushughulikia maombi yote ya Kata, moja kwa ombi zote za Nakili, na moja kwa ombi zote za Bandika.

Kwa sababu timu huweka uchakataji wote kati, pia mara nyingi huhusika katika kushughulikia vitendaji vya kutendua programu nzima. Maboresho makubwa yanaweza kupatikana kwa kutumia mbinu za kisasa za JavaScript, na hivyo kusababisha programu bora zaidi, zinazotegemeka na zinazoweza kudumishwa.

Ili kujifunza jinsi ya kufanya hivyo, unaweza kutumia violezo vya JavaScript + jQuery. Kifurushi hiki cha kipekee kinajumuisha JavaScript iliyoboreshwa kwa violezo vyote vya GoF kwa kutumia vipengele vya juu zaidi kama vile nafasi za majina, prototypes, moduli, vipengee vya kukokotoa, kufungwa, vitendaji visivyojulikana na zaidi. Iwapo watumiaji wanahitaji zana na mbinu za hivi punde zaidi za violezo vya JavaScript, violezo vya jQuery na usanifu wa violezo, basi hii ndiyo kesi bora zaidi ya utumiaji. Kifurushi hiki kina thamani, habari za kisasa kwa watengenezaji JavaScript. Hivi ndivyo vilivyojumuishwa:

Violezo vya GoF vilivyoboreshwa na JavaScript.
Miundo ya Kisasa ya Usanifu wa JavaScript.
Miundo ya Kubuni ya Muundo-Mtazamo.
jQuery kubuni templates.
Miundo ya usanifu wa nahau za JavaScript.
Mfano wa programu (MVC, SPA, nk.)

Misingi iliyopendekezwa ya syntax ya kitu cha JavaScript ni muhimu sana kwa waanzisha programu. Mtu lazima kwanza aelewe vitu, basi kutakuwa na ujuzi wa programu inayolenga kitu. Ni muhimu kuwa na uelewa wa kina wa nyenzo hii kwani hutumika kama msingi wa lugha yote ya JavaScript.

Vitu

Kitu ni aina ya data ya kimsingi katika lugha ya JavaScript. Kitu ni thamani ya mchanganyiko: inachanganya seti ya thamani (thamani rahisi au vitu vingine) na inaruhusu thamani hizo kuhifadhiwa na kurejeshwa kwa jina.

Kitu ni mkusanyiko usio na mpangilio wa mali, ambayo kila moja ina jina na thamani. Majina ya mali ni mifuatano, kwa hivyo vitu vinaweza kusemwa ili kuweka mifuatano ya thamani. Upangaji huu wa mifuatano kwa thamani unaweza kwenda kwa majina mengi: Huenda tayari unafahamu muundo msingi wa data kama vile heshi, kamusi au safu shirikishi. Walakini, kuna zaidi kwa kitu kuliko uchoraji wa ramani rahisi wa kamba kwa maadili.

Kando na sifa zao wenyewe, vipengee vya JavaScript vinaweza pia kurithi sifa kutoka kwa vitu vingine, vinavyojulikana kama prototypes. Njia za kitu ni wawakilishi wa kawaida wa mali ya urithi, na " urithi kupitia prototypes" ni kipengele muhimu cha lugha ya JavaScript.

Vipengee katika JavaScript vinabadilika—kwa kawaida hukuruhusu kuongeza na kuondoa sifa—lakini vinaweza pia kutumiwa kuiga vitu tuli na “miundo” inayopatikana katika lugha za programu zilizochapwa kwa takwimu. Zinaweza pia kutumika (ikiwa utapuuza kwamba vitu huweka alama kwa maadili) kuwakilisha seti za mifuatano.

Thamani yoyote katika JavaScript ambayo si mfuatano, nambari, kweli, uongo, batili, au isiyobainishwa ni kitu. Na hata nyuzi, nambari, na booleans ambazo si vitu zinaweza kuwa kama vitu visivyoweza kubadilika (kuwa na Kamba, Nambari, n.k. vitu vya kanga).

Vitu ni thamani zinazoweza kubadilika na shughuli juu yao hufanywa kwa kumbukumbu, sio kwa thamani. Ikiwa mabadiliko ya x yanarejelea kitu na taarifa var y = x; , utofauti wa y utakuwa na marejeleo ya kitu kimoja, sio nakala yake. Mabadiliko yoyote yaliyofanywa kwa kitu na utofauti wa y pia yataonyeshwa kwenye utofauti wa x.

Mali ina jina na thamani. Jina la sifa linaweza kuwa kamba yoyote, ikiwa ni pamoja na kamba tupu, lakini kitu hakiwezi kuwa na sifa mbili zilizo na jina moja. Thamani ya sifa inaweza kuwa thamani yoyote inayoruhusiwa katika lugha ya JavaScript, au (katika ECMAScript 5) chaguo la kukokotoa la kusoma au kuandika (au zote mbili).

Mbali na majina na maadili, kila mali ina idadi ya maadili yanayohusiana nayo, inayoitwa sifa za mali :

Sifa zinazoweza kuandikwa huamua kama thamani ya mali inaweza kuandikwa.

Sifa kuhesabika huamua kama jina la mali linapatikana kwa kuhesabiwa kwa kitanzi cha/katika.

Sifa inayoweza kusanidiwa huamua uwezekano wa ubinafsishaji, i.e. kufuta mali na kubadilisha sifa zake.

Kabla ya ujio wa kiwango cha ECMAScript 5, mali zote katika vitu iliyoundwa na programu, inapatikana kwa kurekodi, kuorodheshwa na kubinafsishwa. ECMAScript 5 hutoa uwezo wa kubinafsisha sifa za mali yako.

Mbali na mali, kila kitu kina tatu sifa ya kitu :

Sifa darasa ina mfuatano wenye jina la darasa la kitu na inabainisha aina ya kitu.

Bendera kupanuka(katika ECMAScript 5) inaonyesha uwezo wa kuongeza sifa mpya kwa kitu.

Hatimaye, hapa chini kuna maelezo ya baadhi ya maneno ambayo yatatusaidia kutofautisha kati ya kategoria tatu pana za vitu katika JavaScript na aina mbili za sifa:

Kitu lugha ya msingi

Ni kitu au aina ya vitu vilivyofafanuliwa na vipimo vya ECMAScript. Safu, chaguo za kukokotoa, tarehe na misemo ya kawaida (kwa mfano) ni vitu vya lugha kuu.

Kipengee cha wakati wa utekelezaji

Hiki ni kitu kinachofafanuliwa na mazingira ya wakati wa utekelezaji (kama vile kivinjari cha wavuti) ambamo mkalimani wa JavaScript amepachikwa. Vipengee vya HTMLElement, ambavyo vinawakilisha muundo wa ukurasa wa wavuti katika JavaScript ya upande wa mteja, ni vitu vya wakati wa utekelezaji. Vipengee vya wakati wa utekelezaji vinaweza pia kuwa vitu vya lugha ya msingi, kwa mfano wakati muda wa utekelezaji unafafanua mbinu ambazo ni Vipengee vya Kazi vya kawaida vya lugha msingi ya JavaScript.

Kitu maalum

Kitu chochote kilichoundwa kwa kutekeleza msimbo wa JavaScript.

Mali mwenyewe

Hii ni mali iliyofafanuliwa moja kwa moja kwenye kitu fulani.

Mali ya kurithi

Hii ni mali iliyofafanuliwa na mfano wa kitu.

Kuunda Vitu

Vitu vinaweza kuundwa kwa kutumia neno halisi la kitu, neno kuu jipya, na (katika ECMAScript 5) utendakazi. Object.create().

Maneno halisi ya kitu

Njia rahisi zaidi ya kuunda kitu ni kujumuisha kitu halisi katika programu yako. Kitu halisi ni kilichofungwa ndani braces orodha ya sifa (jozi za jina/thamani) ikitenganishwa na koma. Jina la sifa linaweza kuwa kitambulisho au mfuatano halisi (kamba tupu inakubalika). Thamani ya sifa inaweza kuwa usemi wowote unaoruhusiwa katika JavaScript - thamani ya usemi (hii inaweza kuwa thamani rahisi au kitu) itakuwa thamani ya sifa.

Ifuatayo ni baadhi ya mifano ya kuunda vitu:

Var tupu = (); // Kitu kisicho na mali var point = ( x:0, y:0); // Sifa mbili var point2 = ( x:point.x, y:point.y+1); // Thamani ngumu zaidi = var site = ( "tovuti ya url": "www..NET Framework", // na hyphens, kwa hivyo tumia nukuu mwandishi: ( // Thamani ya mali hii ni jina la kwanza: "Alexandr", / / kitu Tafadhali kumbuka kuwa jina la ukoo: "Frolov" // majina ya mali hizi hayana nukuu. ));

ECMAScript 5 (na baadhi ya utekelezaji wa ECMAScript 3) inaruhusu maneno yaliyohifadhiwa kutumika kama majina ya sifa bila nukuu. Walakini, kwa ujumla, majina ya mali yanayolingana maneno yaliyohifadhiwa, katika ECMA-Script 3 lazima iambatanishwe katika alama za nukuu. Katika ECMAScript 5, koma ya mwisho kufuatia sifa ya mwisho katika kitu halisi imepuuzwa. Utekelezaji mwingi wa ECMAScript 3 pia hupuuza koma zinazofuata, lakini IE hutafsiri uwepo wao kama kosa.

Kitu halisi ni usemi unaounda na kuanzisha kitu kipya kila usemi huo unapotathminiwa. Thamani ya kila mali huhesabiwa upya wakati thamani ya halisi inatathminiwa. Hii ina maana kwamba kitu kimoja halisi kinaweza kuunda vitu vingi vipya ikiwa halisi imewekwa kwenye mwili wa kitanzi au kazi ambayo itaitwa mara kwa mara, na kwamba maadili ya mali ya vitu hivi yanaweza kutofautiana kutoka kwa kila mmoja.

Kuunda Vitu Kwa Kutumia Opereta Mpya

Opereta mpya huunda na kuanzisha kitu kipya. Taarifa hii lazima ifuatwe na jina la fomula. Kazi inayotumika kwa njia hii inaitwa mjenzi na hutumiwa kuanzisha kitu kipya. JavaScript ya Msingi inajumuisha wajenzi wengi waliojengewa ndani kwa ajili ya kuunda vitu vya lugha msingi. Kwa mfano:

Var o = Kitu kipya(); // Unda kitu kipya tupu: sawa na () var a = new Array(); // Unda safu tupu: sawa na var d = Tarehe mpya (); // Unda kitu cha Tarehe kinachowakilisha wakati wa sasa var r = new RegExp("js"); // Unda kitu cha RegExp kwa shughuli za kulinganisha muundo

Mbali na wajenzi hawa waliojengwa ndani, inawezekana kufafanua kazi zako za wajenzi ili kuanzisha vitu vipya vilivyoundwa. Jinsi hii inafanywa inaelezwa katika makala inayofuata.

Object.create()

Kiwango cha ECMAScript 5 kinafafanua mbinu ya Object.create() , ambayo huunda kitu kipya na kutumia hoja yake ya kwanza kama mfano wa kitu hicho. Zaidi ya hayo, Object.create() inaweza kuchukua hoja ya pili ya hiari inayoelezea sifa za kitu kipya.

Object.create() ni chaguo za kukokotoa tuli, si mbinu inayoitwa kwa baadhi ya kitu mahususi. Ili kuiita kazi hii, ipitishe tu kitu cha mfano unachotaka:

// obj hurithi mali x na y var obj = Object.create((x:1, y:2));

Ili kuunda kitu ambacho hakina mfano, unaweza kupita null, lakini katika kesi hii kitu kipya hakitarithi mali yoyote au mbinu za msingi, kama vile toString() (ambayo ina maana kwamba kitu hiki hakiwezi kutumika katika misemo na opereta +):

// obj2 hairithi mali au mbinu zozote var obj2 = Object.create(null);

Ikiwa programu yako inahitaji kuunda kitu cha kawaida kisicho na kitu (kama inavyorejeshwa na usemi halisi () au Object() mpya), pitisha Object.prototype kama hoja ya kwanza:

// obj3 ni kama kitu kilichoundwa // kwa kutumia () au Object mpya() var obj3 = Object.create(Object.prototype);

Uwezo wa kuunda vitu vipya na prototypes za kiholela (wacha tuiweke kwa njia nyingine: uwezo wa kuunda "warithi" kutoka kwa vitu vyovyote) chombo chenye nguvu, athari ambayo inaweza kuigwa katika ECMAScript 3 kwa kutumia chaguo la kukokotoa lililowasilishwa katika mfano hapa chini:

// inherit() inarudisha kitu kipya ambacho kinarithi mali // ya kitu cha mfano p. Hutumia kitendakazi cha ECMAScript 5 Object.create() // ikifafanuliwa, vinginevyo hutumia mbinu ya zamani. chaguo la kukokotoa kurithi(p) ( ikiwa (p == null) tupa TypeError(); // p haiwezi kubatilishwa ikiwa (Object.create) // Ikiwa Object.create() imefafanuliwa... return Object.create(p ) ; // itumie. var t = typeof p; // Vinginevyo, tafuta aina na uangalie ikiwa (t !== "object" && t !== "kazi") tupa TypeError(); kazi f() () ; // Bainisha mjenzi tupu. f.prototype = p; // Weka sifa yake ya mfano // kwa marejeleo ya kitu p. rudisha f(); // Tumia f() kuunda // " mrithi" wa kitu cha p.)

Utekelezaji wa kazi ya inherit() itakuwa na maana zaidi mara tu tutakapojua wajenzi katika nakala inayofuata. Kwa sasa, fikiria tu kwamba inarudisha kitu kipya ambacho kinarithi mali ya kitu kwenye hoja. Kumbuka kuwa inherit() sio mbadala kamili wa Object.create(): haikuruhusu kuunda vitu bila mfano, na haichukui hoja ya pili ya hiari kama vile Object.create() inavyofanya.

Kupata na kubadilisha mali

Unaweza kupata thamani ya mali kwa kutumia vitone (.) na mabano ya mraba () waendeshaji. Upande wa kushoto wa opereta lazima kuwe na usemi unaorudisha kitu. Unapotumia opereta ya nukta, kunapaswa kuwa na kitambulisho rahisi upande wa kulia kinacholingana na jina la sifa. Unapotumia mabano ya mraba, mabano ya mraba lazima yajumuishe usemi unaorudisha mfuatano ulio na jina la sifa inayotaka:

// Kitu rahisi var user = ( kuingia:"kot86", jina:"Alexandr", umri:26 ); var login = user.login; // Pata mali ya "kuingia" ya kitu cha mtumiaji var name = user.name; // Pata mali ya "jina" ya kitu cha mtumiaji var age = mtumiaji["umri"]; // Pata mali ya "umri" ya kitu cha mtumiaji

Ili kuunda mali mpya au kubadilisha thamani ya mali iliyopo, waendeshaji wa nukta na mabano ya mraba hutumiwa pia, kama katika shughuli za kusoma maadili ya mali, lakini usemi yenyewe umewekwa upande wa kushoto wa mwendeshaji mgawo:

Umri.mtumiaji = 28; // Badilisha thamani ya mtumiaji wa mali ya "umri"["ingia"] = "kot84"; // Badilisha thamani ya mtumiaji wa mali ya "kuingia"["surname"] = "Frolov"; // Unda mali mpya "jina la ukoo"

Katika ECMAScript 3, kitambulishi kinachofuata nukta hakiwezi kuwa neno lililohifadhiwa: huwezi kuandika simu ya mali kwa o.for au o.class kwa sababu for ni neno kuu na darasa ni neno lililohifadhiwa kwa matumizi ya baadaye.

Ikiwa kitu kina sifa ambazo majina yake yanalingana na maneno yaliyohifadhiwa, lazima utumie nukuu ya mabano ya mraba ili kuvifikia: o["for"] na o["class"]. Kiwango cha ECMAScript 5 hulegeza hitaji hili (kama baadhi ya utekelezaji wa ECMAScript 3 tayari hufanya) na kuruhusu matumizi ya maneno yaliyohifadhiwa baada ya opereta ya nukta.

Mifano

Kila kitu kwenye JavaScript kina kitu cha pili (au null, lakini mara chache sana) kinachohusishwa nacho. Kitu hiki cha pili kinaitwa mfano, na kitu cha kwanza kinarithi mali yake kutoka kwa mfano.

Vipengee vyote vilivyoundwa kwa kutumia kipengee halisi vina kitu cha mfano sawa, ambacho kinaweza kurejelewa katika programu ya JavaScript kama Object.prototype .

Vipengee vilivyoundwa kwa kutumia nenomsingi jipya na simu ya kijenzi hupokea thamani ya sifa ya mfano ya kitendakazi cha kijenzi kama kielelezo chao. Kwa hivyo, kitu kilichoundwa na new Object() kinarithi sifa za Object.prototype kana kwamba kiliundwa kwa kutumia brace halisi (). Vile vile, mfano wa kitu kilichoundwa na Array() mpya ni Array.prototype, na mfano wa kitu kilichoundwa na Date() mpya ni Date.prototype.

Object.prototype ni mojawapo ya vitu vichache ambavyo havina mfano: hakina sifa za kurithi. Vitu vingine vya mfano ni vitu vya kawaida tu ambavyo vina mifano yao wenyewe.

Wajenzi wote waliojengewa ndani (na wajenzi wengi maalum) hurithi mfano wa Object.prototype. Kwa mfano, Date.prototype hurithi sifa kutoka kwa Object.prototype, kwa hivyo kitu cha Tarehe kilichoundwa na Date() mpya kinarithi sifa kutoka kwa Date.prototype na Object.prototype. Mlolongo huo uliounganishwa wa vitu vya mfano huitwa mnyororo wa mfano.

Urithi

Vitu katika JavaScript vina "sifa" nyingi na vinaweza pia kurithi mali nyingi kutoka kwa kitu chao cha mfano. Ili kuelewa hili, unahitaji kujifunza kwa makini utaratibu wa upatikanaji wa mali. Mifano katika sehemu hii hutumia kazi ya kurithi() iliyoonyeshwa hapo juu ili kuunda vitu vilivyo na prototypes maalum.

Tuseme programu inafikia mali x ya kitu obj. Ikiwa obj haina mali yake yenyewe yenye jina hilo, jaribio linafanywa kutafuta mali x katika mfano wa obj. Ikiwa kitu cha mfano hakina mali yake chenye jina hilo, lakini kina kielelezo chake, jaribio linafanywa kutafuta sifa hiyo katika mfano wa mfano. Hii inaendelea hadi mali x ipatikane au kitu ambacho hakina mfano kitafikiwa. Kama unaweza kuona, sifa ya mfano ya kitu huunda mnyororo, au orodha iliyounganishwa, ya vitu ambavyo mali hurithiwa.

Var obj = (); // obj hurithi mbinu za kitu Object.prototype obj.x = 1; // na ina mali yake x. var p = kurithi(obj); // p hurithi mali ya vitu obj na Object.prototype p.y = 2; // na ina mali yake y. var q = kurithi(p); // q hurithi mali ya vitu p, obj na Object.prototype q.z = 3; // na ina mali yake z. var s = q.toString(); // toString hurithi kutoka kwa Object.prototype var d = q.x + q.y // Matokeo ya 3: x na y hurithi kutoka kwa obj na p

Sasa tuseme kwamba programu inapeana thamani fulani kwa mali ya x ya obj. Ikiwa obj tayari ina mali yake mwenyewe (haijarithiwa) inayoitwa x, basi operesheni ya mgawo itabadilisha tu thamani ya mali iliyopo. Vinginevyo, mali mpya inayoitwa x itaundwa katika obj. Ikiwa oj ya mali iliyorithiwa hapo awali x, mali iliyorithiwa sasa itafichwa na mali yake mpya iliyoundwa yenye jina sawa.

Uendeshaji wa kugawa thamani kwa mali utakagua uwepo wa mali hiyo katika msururu wa mfano ili kuhakikisha kuwa kazi hiyo ni halali. Kwa mfano, ikiwa kitu obj kitarithi mali ya kusoma tu x, basi kazi haitafanyika. Hata hivyo, ikiwa ugawaji ni halali, mali huundwa kila wakati au kubadilishwa katika kitu asili na kamwe katika msururu wa mfano. Ukweli kwamba utaratibu wa urithi hufanya kazi wakati wa kusoma mali, lakini haifanyi kazi wakati wa kuandika maadili mapya, ni kipengele muhimu cha lugha ya JavaScript kwa sababu hukuruhusu kubatilisha kwa hiari mali zilizorithiwa:

Var unitcircle = ( r:1 ); // Kitu ambacho mali imerithiwa var c = inherit(unitcircle); // c hurithi mali r c.x = 1; c.y = 1; // c inafafanua mali mbili za c.r yake = 2; // c hubatilisha urithi console.log(unitcircle.r); // => 1: kitu cha mfano hakijabadilika

Kuna ubaguzi mmoja kwa sheria hii, wakati operesheni ya ugawaji wa mali inashindwa au kusababisha mali kuundwa / kurekebishwa kwenye kitu cha asili. Ikiwa obj inarithi mali x na mali hiyo inapatikana kupitia wafikiaji, basi badala ya kuunda mali mpya x kwenye obj, njia ya kuandika thamani mpya inaitwa. Walakini, kumbuka kuwa njia ya uandishi inaitwa obj, sio kwa mfano ambao mali imefafanuliwa, kwa hivyo ikiwa njia ya uandishi inafafanua mali yoyote, itasisitizwa kwenye obj, na mlolongo wa mfano utabaki bila kubadilika.

Makosa ya ufikiaji wa mali

Maneno ya ufikiaji wa mali hayarudishi au kubadilisha thamani ya mali kila wakati. Sehemu hii inaelezea hali wakati shughuli za kusoma au kuandika zinashindwa.

Jaribio la kufikia mali ambayo haipo haizingatiwi kuwa kosa. Ikiwa sifa x haipatikani kati ya mali ya obj mwenyewe au iliyorithiwa, usemi wa ufikiaji wa mali obj.x utarudi bila kufafanuliwa.

Hata hivyo, kujaribu kufikia mali ya kitu kisichokuwepo inachukuliwa kuwa kosa. Thamani tupu na zisizofafanuliwa hazina mali, na majaribio ya kufikia sifa za maadili haya yanachukuliwa kuwa kosa:

// Kitu rahisi var user = ( kuingia:"kot86", jina:"Alexandr", umri:26 ); var a = user.password; // haijafafanuliwa: mali haipo // Huongeza ubaguzi wa TypeError. // Thamani isiyobainishwa haina urefu wa mali var len = user.password.length;

Iwapo huna uhakika kuwa mtumiaji na nenosiri la mtumiaji ni vitu (au hufanya kama vitu), hupaswi kutumia usemi wa user.password.length kwa sababu huenda ukawa tofauti. Ifuatayo inaonyesha njia mbili za kulinda dhidi ya aina hii ya ubaguzi:

// Njia zaidi ya kuona na ya moja kwa moja var len = haijafafanuliwa; ikiwa (mtumiaji) ( ikiwa (user.password) len = user.password.length; ) // Njia fupi zaidi, mahususi ya JavaScript // ya kupata urefu wa thamani ya sifa ya nenosiri var len = mtumiaji && mtumiaji. nenosiri && user.password.length ;

Kujaribu kuweka thamani ya mali kwa thamani zingine hakufanikiwa kila wakati: baadhi ya sifa husomwa tu na haziruhusu thamani zake kubadilishwa. Kwa kuongeza, vitu vingine havikuruhusu kuongeza mali mpya kwao. Walakini, jambo la kufurahisha zaidi ni kwamba mapungufu kama haya, kama sheria, hayaongoi ubaguzi kuinuliwa:

// Tabia za mfano za wajenzi waliojengwa ni kusoma tu Object.prototype = 0; // Mgawo hautaongeza ubaguzi; // thamani ya Object.prototype haitabadilika

Hitilafu hii ya kihistoria ya JavaScript inarekebishwa katika hali kali, kama inavyofafanuliwa na kiwango cha ECMAScript 5. Majaribio yote yasiyofaulu ya kubadilisha thamani ya kipengele katika hali kali husababisha ubaguzi wa TypeError.

Sheria za kuamua wakati jaribio la kufanya operesheni ya mgawo litafanikiwa na wakati itashindwa ni rahisi na moja kwa moja, lakini ni ngumu kuelezea kwa ufupi wa kutosha. Jaribio la kupeana thamani kwa mali p ya obj litashindwa katika hali zifuatazo:

Kitu obj kina mali yake ya kusoma tu p: huwezi kubadilisha thamani ya mali ya kusoma tu. (Kumbuka, hata hivyo, kuwa defineProperty() mbinu ni ubaguzi unaokuruhusu kubadilisha maadili ya sifa maalum za kusoma pekee.)

Kitu cha obj kina mali ya kurithi ya kusoma pekee p: mali ya kurithi ya kusoma tu haiwezi kubatilishwa na mali yako mwenyewe yenye majina sawa.

Kitu obj hakina mali yake p; obj hairithi mali p na njia za nyongeza, na sifa ya kupanuka ya obj ni ya uwongo. Ikiwa mali p haipo katika obj na hakuna njia ya kuandika iliyofafanuliwa, basi operesheni ya mgawo itajaribu kuongeza mali p kwa obj. Lakini kwa kuwa obj haiwezi kupanuliwa, kujaribu kuongeza mali mpya kutashindwa.

Kuondoa mali

Opereta kufuta huondoa mali kutoka kwa kitu. Operesheni yake pekee lazima iwe usemi wa ufikiaji wa mali. Inaweza kuonekana kuwa ya kushangaza, lakini kufuta operator haiathiri thamani ya mali - inafanya kazi kwenye mali yenyewe:

// Kitu rahisi var user = ( kuingia:"kot86", jina:"Alexandr", umri:26 ); futa user.login; // Sasa kitu cha mtumiaji hakina kipengee cha kufuta mtumiaji["jina"]; // Sasa kitu cha mtumiaji hakina mali ya jina

Opereta ya kufuta hufuta tu mali zake mwenyewe na haifuti zilizorithiwa. (Ili kuondoa sifa ya kurithi, lazima uiondoe kutoka kwa kifaa cha mfano ambamo imefafanuliwa. Uendeshaji huu utaathiri vitu vyote vinavyorithi mfano huo.)

Usemi wa kufuta unarudi kweli wakati mali ilifutwa kwa ufanisi au wakati operesheni ya kufuta haikubadilisha kitu (kwa mfano, wakati wa kujaribu kufuta sifa ambayo haipo). Usemi wa kufuta pia hurejesha ukweli unapopitishwa usemi ambao sio usemi wa ufikiaji wa mali:

Obj = (x:1); // obj ina mali yake x na hurithi toString delete obj.x; //Inafuta x na inarudisha ufutaji wa kweli obj.x; //Hafanyi chochote (x haipo) na hurejesha kufuta kwa kweli obj.toString; // Haitafanya chochote (toString sio mali yake mwenyewe) na kurudisha kufuta kweli 1; // Haina maana, lakini itarudi kweli

Opereta ya kufuta haifuti sifa zisizoweza kusanidiwa, sifa inayoweza kusanidiwa ambayo ina thamani ya uwongo. (Hata hivyo, inaweza kuondoa sifa maalum za vitu visivyopanuliwa.) Sifa zisizoweza kusanidiwa ni sifa za kitu kilichojengewa ndani, pamoja na sifa za vitu vya kimataifa zinazoundwa kwa kutumia taarifa za tamko la kutofautiana na kazi. Kujaribu kuondoa mali isiyoweza kusanidiwa katika hali madhubuti huinua TypeError. Katika hali isiyo ngumu (na katika utekelezaji wa ECMAScript 3), mendeshaji wa kufuta hurejesha uwongo katika hali kama hizi:

Futa Object.prototype; // Uondoaji hauwezekani - mali isiyoweza kusanidiwa var x = 1; // Tamko la mabadiliko ya kimataifa futa this.x; // Sifa hii haiwezi kufutwa kazi f() () // Tamko la kazi ya kimataifa futa hii.f; // Mali hii haiwezi kufutwa pia

Kuangalia uwepo wa mali

Vitu katika JavaScript vinaweza kuzingatiwa kama seti za mali, na mara nyingi ni muhimu kuweza kujaribu uanachama katika seti - kuangalia ikiwa kitu kina mali iliyo na jina fulani. Unaweza kufanya ukaguzi kama huo kwa kutumia opereta katika, kwa kutumia mbinu hasOwnProperty() Na propertyIsEnumerable() au kwa kupata tu mali hiyo.

Opereta katika inahitaji kupewa jina la mali (kama kamba) kama operesheni yake ya kushoto na kitu kama operesheni yake ya kulia. Inarudi kweli ikiwa kitu kina mali yake mwenyewe au ya kurithi na jina hilo:

Var obj = ( x:1 ) "x" katika obj; // kweli: obj ina mali yake "x" "y" katika obj; // uongo: obj haina mali "y" "toString" katika obj; // kweli: obj hurithi mali ya toString

Njia ya hasOwnProperty() ya kitu hukagua ikiwa kitu hicho kina mali yake chenye jina lililobainishwa. Kwa mali iliyorithiwa inarudi kuwa ya uwongo:

Var obj = ( x:1 ) obj.hasOwnProperty("x"); // kweli: obj ina mali yake mwenyewe "x" obj.hasOwnProperty("y"); // uongo: obj haina mali "y" obj.hasOwnProperty("toString"); // uongo: toString - mali ya kurithi

Mbinu ya PropertyIsEnumerable() inaweka vizuizi vya ziada ikilinganishwa na hasOwnProperty(). Inarudi kuwa kweli ikiwa tu mali iliyobainishwa ni mali asili ambayo sifa yake inayoweza kuhesabika imewekwa kuwa kweli. Sifa za vitu vilivyojengwa hazihesabiki. Sifa zilizoundwa na programu ya kawaida ya JavaScript zinaweza kuhesabika isipokuwa mojawapo ya mbinu za ECMAScript 5 zilizo hapa chini zimetumika kufanya sifa ziwe zisizohesabika.

Mara nyingi, badala ya opereta, inatosha kutumia usemi rahisi wa ufikiaji wa mali na kutumia !== opereta kuangalia ukosefu wa usawa na thamani isiyofafanuliwa:

Var obj = ( x:1 ) obj.x !== haijafafanuliwa; // kweli: obj ina mali "x" obj.y !== isiyofafanuliwa; // uongo: obj haina mali "y" obj.toString !== isiyofafanuliwa; // kweli: obj hurithi mali ya toString

Hata hivyo, opereta katika hutofautisha hali ambazo haziwezi kutofautishwa kwa kutumia mbinu ya mali iliyowasilishwa hapo juu. Opereta katika hutofautisha kutokuwepo kwa mali kutoka kwa mali ambayo ina thamani isiyofafanuliwa.

Kuhesabu Sifa

Badala ya kuangalia upatikanaji mali ya mtu binafsi Wakati mwingine ni muhimu kusisitiza juu ya mali zote zilizopo au kupata orodha ya mali zote za kitu. Hii kawaida hufanywa kwa kutumia kwa/katika kitanzi, lakini kiwango cha ECMAScript 5 hutoa njia mbadala mbili zinazofaa.

Taarifa ya kwa/katika kitanzi hutekeleza mwili wa kitanzi kwa kila mali inayoweza kuhesabika (yake au ya kurithiwa) ya kitu kilichobainishwa, ikitoa jina la mali kwa mabadiliko ya kitanzi. Mbinu zilizojengewa ndani zinazorithiwa na vitu hazihesabiki, na sifa zinazoongezwa kwa vitu na programu yako zinaweza kuhesabika (isipokuwa unatumia vipengele vilivyofafanuliwa hapa chini kufanya sifa zisizohesabika). Kwa mfano:

// Kitu rahisi chenye sifa tatu zinazoweza kuhesabika var user = ( login:"kot86", name:"Alexandr", age:26 ); user.propertyIsEnumerable("toString"); // uongo, toString - mbinu iliyojengwa kwa ajili ya (n katika mtumiaji) console.log(n);

Baadhi ya maktaba huongeza mbinu mpya (au sifa nyingine) kwa kitu cha Object.prototype ili ziweze kurithiwa na kupatikana kwa vitu vyote. Walakini, hadi ujio wa kiwango cha ECMAScript 5, haikuwezekana kufanya haya mbinu za ziada zisizohesabika, kwa hivyo zilipatikana kwa kuhesabiwa kwa/katika vitanzi. Ili kutatua suala hili, unaweza kuhitaji kuchuja sifa zilizorejeshwa na for/in loop. Ifuatayo ni mifano miwili ya kutekeleza uchujaji kama huu:

Kwa (n katika mtumiaji) ( ikiwa (!user.hasOwnProperty(n)) itaendelea; console.log(n); ) kwa (n katika mtumiaji) ( ikiwa (typeof user[n] === "function") itaendelea; console.log(n);)

Kando na kitanzi cha/katika, kiwango cha ECMAScript 5 kinafafanua vitendakazi viwili ambavyo vinaorodhesha majina ya sifa. Wa kwanza wao, Kitu.funguo(), hurejesha safu ya majina ya sifa zinazoweza kuhesabika za kitu.

Kitendakazi cha pili cha ECMAScript 5 kinachofanya hesabu ya mali ni Object.getOwnPropertyNames(). Inafanya kazi kama chaguo la kukokotoa la Object.keys(), lakini hurejesha majina ya sifa zote za kitu kilichobainishwa, si zile zinazohesabika tu. Utekelezaji wa ECMAScript 3 hauna uwezo wa kutekeleza utendakazi kama huu kwa sababu ECMAScript 3 haitoi uwezo wa kupata sifa zisizohesabika za kitu.

Mbinu za kusoma na kuandika mali

Tayari ilisemwa hapo juu kuwa mali ya kitu ina jina, thamani na seti ya sifa. Katika ECMAScript 5, thamani inaweza kubadilishwa na mbinu moja au mbili, zinazojulikana kama mbinu anasoma (kupata) Na rekodi (setter). Sifa ambazo njia za kusoma na kuandika zinafafanuliwa wakati mwingine huitwa mali na njia za ufikiaji ili kuzitofautisha na sifa za data zinazowakilisha thamani rahisi.

Programu inapojaribu kupata thamani ya mali kwa kutumia mbinu za vifikia, mkalimani huita njia ya kusoma (bila hoja). Thamani iliyorejeshwa na njia hii inakuwa thamani ya usemi wa ufikiaji wa mali. Wakati mpango unajaribu kuandika thamani kwa mali, mkalimani huita njia ya kuandika, akiipitisha thamani kwa haki ya operator wa kazi. Njia hii inawajibika kwa "kuweka" thamani ya mali. Thamani iliyorejeshwa na njia ya uandishi imepuuzwa.

Tofauti na sifa za data, sifa za kifikia hazina sifa ya kuandikwa. Ikiwa mali ina njia za kusoma na kuandika, inasomwa / kuandikwa. Ikiwa mali ina njia ya kusoma tu, inasomwa tu. Na ikiwa mali ina njia ya kuandika pekee, ni ya kuandika tu (hii haiwezekani kwa sifa za data) na majaribio ya kusoma thamani ya mali kama haya yatarudi bila kufafanuliwa kila wakati.

Njia rahisi zaidi ya kufafanua mali na njia za ufikiaji ni kutumia syntax ya ufafanuzi wa kitu kilichopanuliwa:

Var obj = ( // Data_prop ya data ya kawaida: thamani, // Sifa iliyo na mbinu za ufikiaji inafafanuliwa kama jozi ya chaguo za kukokotoa get accessor_prop() ( /* kipengele cha utendaji */ ), weka accessor_prop(thamani) ( /* kazi ya mwili */ ));

Sifa zilizo na mbinu za vifikia hufafanuliwa kama chaguo la kukokotoa moja au mbili ambazo majina yake ni sawa na jina la sifa na neno kuu la chaguo la kukokotoa likibadilishwa na pata na/au seti.

Kumbuka kuwa huhitajiki kutumia koloni kutenganisha jina la sifa kutoka kwa chaguo za kukokotoa zinazodhibiti ufikiaji wa mali, lakini bado unatakiwa kutumia koma baada ya chombo cha kukokotoa ili kutenganisha mbinu na mbinu nyingine au sifa za data.

Kwa mfano, fikiria kitu kifuatacho kikiwakilisha Kuratibu za Cartesian pointi kwenye ndege. Inayo mali ya kawaida ya data kuwakilisha viwianishi vya X na Y, na vile vile mali zilizo na njia za ufikiaji kupata viwianishi sawa vya nukta:

Var p = ( // x na y ni sifa za kawaida za data, soma/andika x: 1.0, y: 1.0, // r ni mali ya kusoma/kuandika yenye mbinu mbili za ufikiaji. // Usisahau kuongeza koma baada ya ufikiaji wa mbinu pata r() ( rudisha Math.sqrt(this.x*this.x + this.y*this.y); ), weka r(thamani mpya) ( var oldvalue = Math.sqrt(this.x*) this.x + this.y*this.y); var ratio = newvalue/oldvalue; this.x *= ratio; this.y *= ratio; ), // theta ni mali ya kusoma tu yenye njia pekee inasoma pata theta() ( rudisha Math.atan2(this.y, this.x); ));

Kumbuka matumizi ya neno kuu hili katika njia za kusoma na kuandika hapo juu. Mkalimani ataziita kazi hizi kama mbinu za kitu ambamo zimefafanuliwa, i.e. katika mwili wa kitendakazi hii itarejelea kitu cha uhakika. Hii inaruhusu mbinu ya kusoma ya mali r kurejelea sifa x na y, kama hii.x na this.y.

Sifa zilizo na njia za ufikiaji zimerithiwa kama sifa za kawaida za data, kwa hivyo kitu cha p kilichofafanuliwa hapo juu kinaweza kutumika kama mfano wa vitu vingine vya uhakika. Vitu vipya vinaweza kufafanua sifa zao za x na y, na vitarithi sifa za r na theta.

Sifa za Kitu

Vitu vyote vina mfano, darasa na sifa zinazoweza kupanuka. Sifa hizi zote zimefafanuliwa katika vifungu vifuatavyo.

sifa ya mfano

Sifa ya kielelezo cha kitu hubainisha kitu ambacho sifa hurithiwa. Ni muhimu kuelewa kwamba wakati rejeleo la mfano linapotokea katika msimbo wa programu, inaashiria mali ya kawaida ya kitu, si sifa ya mfano.

Sifa ya mfano huwekwa wakati kitu kinaundwa. Kwa vitu vilivyoundwa kwa kutumia maandishi halisi, mfano ni Object.prototype. Mfano wa kitu kilichoundwa kwa kutumia opereta mpya ni thamani ya sifa ya mfano ya mjenzi. Na mfano wa kitu kilichoundwa kwa kutumia Object.create() inakuwa hoja ya kwanza ya chaguo hili la kukokotoa (ambalo linaweza kuwa batili).

Kiwango cha ECMAScript 5 hutoa uwezo wa kufafanua mfano wa kitu chochote kwa kuipitisha kwa mbinu. Object.getPrototypeOf(). ECMAScript 3 haina chaguo za kukokotoa sawa, lakini mara nyingi unaweza kufafanua mfano wa obj kwa kutumia usemi obj.constructor.prototype.

Vitu vilivyoundwa kwa kutumia opereta mpya kawaida hurithi mali hiyo mjenzi Rejeleo la chaguo la kukokotoa la kijenzi lililotumiwa kuunda kitu. Na kama ilivyoelezwa hapo juu, kazi za wajenzi zina mali ya mfano, ambayo inafafanua mfano wa vitu vilivyoundwa kwa kutumia mjenzi huyu.

Kumbuka kuwa vitu vilivyoundwa kwa kutumia maandishi halisi au Object.create() hupokea sifa ya mjenzi ambayo inarejelea Object() mjenzi. Kwa hivyo, constructor.prototype inarejelea mfano halisi wa neno halisi la kitu, lakini hii kwa kawaida sivyo kwa vitu vilivyoundwa kwa kuita Object.create().

Kuamua ikiwa kitu kimoja ni mfano (au kiunga katika mlolongo wa prototypes) wa kitu kingine, tumia mbinu. isPrototypeOf(). Ili kujua kama p ni mfano wa obj, unahitaji kuandika usemi p.isPrototypeOf(obj). Kwa mfano:

Var p = (x:1); // Bainisha kitu cha mfano. var obj = Kitu.unda(p); // Unda kitu na mfano huu. p.isPrototypeOf(obj); // => kweli: obj hurithi p Object.prototype.isPrototypeOf(p); // => kweli: p hurithi Object.prototype

sifa ya darasa

sifa ya darasa object ni mfuatano ulio na taarifa kuhusu aina ya kitu. ECMAScript 3 wala ECMAScript 5 haitoi uwezo wa kubadilisha sifa hii na hutoa njia zisizo za moja kwa moja pekee za kubainisha thamani yake. Kwa chaguo-msingi, toString() mbinu (iliyorithiwa kutoka kwa Object.prototype) hurejesha mfuatano kama:

Kwa hivyo, ili kuamua darasa la kitu, unaweza kujaribu kupiga toString() njia ya kitu hiki na kutoa kamba ndogo kutoka kwa nane hadi mhusika wa mwisho kutoka kwa matokeo. Sehemu ya ujanja ni kwamba mbinu nyingi hurithi kutoka kwa utekelezaji mwingine, muhimu zaidi wa toString(), na kupiga toleo sahihi la toString() unahitaji kupiga simu isiyo ya moja kwa moja kwa kutumia Function.call() mbinu.

Mfano hapa chini unafafanua kazi ambayo inarudisha darasa la kitu chochote kilichopitishwa kwake:

// Jina la chaguo la kukokotoa la darasa la kitu(obj) (ikiwa (obj === null) rudisha "Batili"; ikiwa (obj === haijafafanuliwa) rudisha "Undefined"; rudisha Object.prototype.toString.call(obj) .kipande (8,-1); )

Chaguo hili la kukokotoa la classof() linaweza kupitishwa thamani yoyote inayoruhusiwa katika JavaScript. Nambari, mifuatano, na booleans hufanya kama vitu wakati toString() inapoitwa juu yao, lakini maadili matupu na yasiyobainishwa huchukuliwa kwa njia tofauti.

sifa ya kupanuka

Sifa ya kupanuka ya kitu huamua kama sifa mpya zinaweza kuongezwa kwa kitu. Katika ECMAScript 3, vitu vyote vilivyojengewa ndani na vilivyofafanuliwa na mtumiaji vilipanuliwa kwa njia isiyo dhahiri, na upanuzi wa vitu vya wakati wa kukimbia ulikuwa mahususi wa utekelezaji. Katika ECMAScript 5, vitu vyote vilivyojengewa ndani na vilivyoainishwa na mtumiaji vinaweza kupanuliwa isipokuwa vimebadilishwa kuwa vitu visivyoweza kurefuka, na upanuzi wa vitu vya wakati wa kutekelezwa bado ni mahususi wa utekelezaji.

Kiwango cha ECMAScript 5 kinafafanua chaguo za kukokotoa za kupata na kubadilisha sifa ya upanuzi wa kitu. Kuamua ikiwa kitu kinaweza kupanuliwa, lazima uipitishe kwa mbinu Object.isExtensible(). Ili kufanya kitu kisiweze kupanuliwa, unahitaji kuipitisha kwa njia Object.preventExtensions(). Kumbuka kwamba mara kitu kinapofanywa kuwa kisichoweza kurefushwa, hakiwezi kufanywa kuwa kirefuke tena. Kumbuka pia kwamba simu ya kuzuiaExtensions() huathiri tu upanuzi wa kitu chenyewe. Iwapo sifa mpya zitaongezwa kwa mfano wa kitu kisichoweza kuongezwa, kitu kisichoweza kuongezwa kitarithi sifa hizo mpya.

Madhumuni ya sifa ya kupanua ni kufanya iwezekanavyo "kurekebisha" vitu katika hali fulani, kuzuia mabadiliko. Sifa ya kupanuka ya vitu mara nyingi hutumika pamoja na sifa zinazoweza kusanidiwa na kuandikwa, kwa hivyo ECMAScript 5 inafafanua vipengele vinavyofanya iwe rahisi kuweka sifa hizi kwa wakati mmoja.

Njia Object.seal() hufanya kama njia ya Object.preventExtensions() , lakini sio tu kwamba hufanya kitu kisirefuke, pia hufanya sifa zote za kitu hicho kutosanidiwa. Hiyo ni, mali mpya haiwezi kuongezwa kwa kitu, na mali zilizopo haziwezi kufutwa au kusanidiwa. Walakini, mali zilizopo zinazoweza kuandikwa bado zinaweza kubadilishwa.

Mara Object.seal() inapoitwa, kitu hakiwezi kurejeshwa katika hali yake ya awali. Kuamua ikiwa njia ya Object.seal() imeitwa kwenye kitu, unaweza kupiga njia Object.isSealed().

Njia Object.freeze() hutoa urekebishaji mgumu zaidi wa vitu. Mbali na kufanya kitu kisiongezeke na sifa zake zisiweze kusanidiwa, pia hufanya sifa zote za data asili zisomeke pekee. (Hii haitumiki kwa sifa za kitu kilicho na mbinu za viongezi ambazo zina mbinu za kuandika; njia hizo bado zitaitwa kwa taarifa za mgawo.) Ili kubaini kama njia ya kitu Object.freeze() imeitwa, unaweza kupiga simu kwa Object.isFrozen().

Ni muhimu kuelewa kwamba Object.seal() na Object.freeze() huathiri tu kitu ambacho hupitishwa kwao: haziathiri mfano wa kitu hicho. Ikiwa programu yako inahitaji kufanya kitu kabisa, labda utahitaji pia kunasa vitu kwenye mnyororo wa mfano.

Usasishaji wa Kitu

Usanishaji wa kitu ni mchakato wa kubadilisha vitu kuwa fomu ya uwakilishi wa kamba, ambayo inaweza kutumika baadaye kuirejesha. ECMAScript 5 hutoa vitendakazi vilivyojengewa ndani vya kuratibu na kurejesha vipengee vya JavaScript JSON.stringify() Na JSON.changanua(). Vitendaji hivi hutumia umbizo la kubadilishana data la JSON. Jina JSON linatokana na "JavaScript Object Notation" (aina ya nukuu ya kitu cha JavaScript), na syntax ya nukuu hii ni sawa na syntax ya kitu na safu halisi katika JavaScript:

Var obj = (x:1, y:(z:)); // Fafanua kitu cha majaribio var s = JSON.stringify(obj); // s == "("x":1,"y":("z":))" var p = JSON.changanua; // p - nakala ya kitu obj

Sintaksia ya umbizo la JSON ni seti ndogo tu ya sintaksia ya JavaScript na haiwezi kutumika kuwakilisha thamani zote zinazoruhusiwa katika JavaScript. Inatumika na inaweza kusasishwa na kurejeshwa: vitu, safu, mifuatano, nambari pungufu za nambari, kweli, si kweli na batili. NaN, Infinity, na -Infinity maadili yamepangwa ili kuwa batili. Vipengee vya tarehe hupangwa kwa mifuatano ya tarehe Muundo wa ISO, lakini JSON.parse() inaziacha katika uwakilishi wao wa kamba na hairejeshi vipengee asili vya Tarehe.

Vipengee vya Kutenda kazi, RegExp, na Hitilafu na thamani isiyobainishwa haziwezi kusasishwa au kurejeshwa. Chaguo za kukokotoa za JSON.stringify() huratibu tu sifa asilia zinazohesabika za kitu. Ikiwa thamani ya mali haiwezi kugawanywa, mali hiyo haitajumuishwa kwa uwakilishi wa kamba. JSON.stringify() na JSON.parse() huchukua hoja ya pili ya hiari inayoweza kutumika kubinafsisha usakinishaji na/au mchakato wa urejeshaji, kwa mfano kwa kufafanua orodha ya sifa zitakazowekwa mfululizo au kazi ya kubadilisha thamani. wakati wa serialization.

Kutembelea rasilimali ya wavuti ni URI maalum ndani upau wa anwani kivinjari. Mgeni hutaja anwani ya ukurasa, na huchanganuliwa na kivinjari katika vipengele vya mti wa DOM - Mfano wa Kitu cha Hati. Kiungo chochote kwenye ukurasa huu huambia kivinjari kuchanganua ukurasa mwingine na kuunda mti mwingine wa vitu.

Kivinjari huruhusu mgeni kurudi nyuma au mbele kupitia msururu wa kurasa ambazo tayari zimetazamwa katika kipindi cha sasa.

Kwa kweli, vitendo vya mtumiaji ni harakati kati ya mifumo ya vitu vilivyoundwa katika mchakato wa kutembelea kurasa. Kila ukurasa ni mti wake wa DOM na, kwa kuongeza, vipengee vya JavaScript ni vitu vya syntax ya lugha yenyewe na maelezo ya mtumiaji.

DOM: kupakia, kusasisha na kubadilisha

Kuna chaguzi kuu tatu ambazo huunda vitu vya ukurasa wa rasilimali ya wavuti, katika kiwango cha DOM na lugha ya JavaScript yenyewe, ambayo ilifanya muundo wa uundaji tofauti, na kulingana na maelezo yaliyotolewa na msanidi programu:

kupakia - mgeni alikuja kwenye ukurasa wa tovuti;
sasisha - mgeni (kifungo cha kivinjari au Ctrl-F5);
kubadilisha kipengele cha ukurasa, kwa mfano (AJAX, script, tukio, ...).

Taratibu zote tatu kimsingi ni tofauti, lakini kutofautisha sifa za mbili za kwanza ni muhimu sana. Ni vigumu kumzuia mgeni kuonyesha upya ukurasa - hii ni tabia ya mgeni "mbaya" ambayo msanidi anapaswa kukumbuka.

Urambazaji kwenye ukurasa na zaidi unapaswa kulala tu katika utendaji wa ukurasa yenyewe, na sio katika historia ya kivinjari na kazi za vifungo vyake. Tovuti nyingi hutangaza hitaji hili muhimu, lakini wageni hukiuka jadi.

Kubadilisha ukurasa bila kuipakia upya katika kiwango cha kipengele chake binafsi (kwa mfano, AJAX) ni suluhisho la kawaida kwa kurasa zinazobadilika. Kama sheria, hii hutumiwa kupitia vipengee vya ukurasa, kubadilisha vitu vyake, na kudhibiti mazungumzo na mgeni.

Vitu vya Msingi vya JavaScript

JavaScript inategemea kitu. Karibu kila kitu vigezo vya lugha- hizi ni vitu. Msanidi programu anaweza kuunda maelezo mwenyewe vitu kwa kutumia chaguzi anuwai za sintaksia.

Kitu chochote ambacho si "kamba", "nambari", kweli, uongo, null au isiyofafanuliwa ni kitu. Ndani ya mfumo wa sintaksia ya lugha, hii inaweza kupuuzwa, ikimaanisha kuwa vitu ni vipengee vya DOM tu na vyao wenyewe. Maelezo ya JavaScript Muundo wa kimsingi wa lugha mara nyingi hauna umuhimu wa kiutendaji kwa msanidi programu.

Kwa mfano, kazi za hisabati zinawakilishwa na kitu cha Hisabati. Hii ni rahisi ndani ya mfumo wa dhana ya lugha, lakini kwa msanidi programu ni syntax rahisi ya kutumia safu muhimu ya shughuli za hisabati.

Ni muhimu kufanya kazi kwa usahihi na DOM na kuelezea kwa usahihi vitu vyako mwenyewe. Sintaksia ya vitendakazi vya JavaScript na misemo kwa matumizi yao ni aina ya kurekodi mantiki ya algoriti inayohitajika.

Kamba, Safu na Vitu

Vipengee vyote vya JavaScript vinatokana na kanuni: "property" = "value" na dhana ya safu shirikishi. Katika sana kesi rahisi Kitu cha JavaScript ni mkusanyiko wa mali = jozi za thamani. Walakini, "thamani" haiwezi kuwa nambari kila wakati, na mali haiandikwa kila wakati bila nukuu.

Haupaswi kutumia kupita kiasi kutaja mali. Inafaa wakati majina ya mali yana herufi pekee Alfabeti ya Kilatini, inakidhi mahitaji ya kutaja vigezo na si maneno muhimu (pamoja na yaliyohifadhiwa) ya lugha.

Hakuna mpangilio wa mali unatarajiwa, lakini wakati wa kuunda au kuanzisha safu ya ushirika, inakubalika kabisa kujua jinsi mambo yake yamepangwa. Haipendekezi kutumia hali hii, lakini inawezekana kuiweka katika akili.

Kuanzisha safu ya mali inamaanisha wakati huo huo:

kuunda safu;
uundaji wa kitu.

Katika muktadha maalum wa matumizi, unaweza kuzingatia kitu cha JavaScript kama safu ya ushirika, na mahali pengine kwenye algorithm kama kitu, toa njia zinazofaa kwake, ubadilishe maadili ya vitu vyake.

Kwa sababu majina ya vipengee na thamani zao lazima zibainishwe katika umbizo la mfuatano unapoundwa au kurekebishwa, inashauriwa kutumia nukuu za mfuatano na alama za nukuu.

Kufikia Sifa za Kitu

Unaweza kupata na kubadilisha thamani za sifa za kitu kwa kutumia Object.keys ujenzi: JavaScript hutengeneza safu ya sifa zote za kitu. Wakati vitu vinapoundwa kwa nguvu, ujenzi huu ni rahisi sana, kwani huzalisha moja kwa moja orodha ya mali zote zilizopo kwenye kitu.

Katika mfano huu, safu mbili zinaelezewa kwa njia tofauti. Katika maombi, safu zote mbili ni sawa, kwani zina mali ya jina moja na maadili yao. Kitanzi hurudia kupitia sifa zote za safu ya pili na hutoa mfuatano wa maadili yote.

Athari sawa inaweza kupatikana katika nukuu ya nukta au mabano:

x1_Obj.NameLast;
x1_Obj ["NameFirst" ].

Miundo yote miwili ni halali na hutoa matokeo yaliyohitajika. Katika mfano hapo juu, wakati wa kubainisha safu kwa njia ya braces curly "()", hitilafu inaweza kufanywa kwa namna ya "," ishara mwishoni mwa hesabu (iliyowekwa alama katika mfano na mduara nyekundu). Vivinjari kawaida hupuuza herufi ya ziada katika hesabu, lakini ni bora kutofanya hivi.

Kuondoa sifa za kitu

Kwa kuwa kitu ni safu ya ushirika, operesheni Kitu cha kufuta JavaScript kinatekelezwa kwa kiwango cha kitu cha sasa (wakati wa kurithi - hii ni muhimu) na inazingatiwa kwenye mkusanyiko wa sifa za kitu hiki.

Katika muktadha wa mfano hapo juu, unaweza kutumia miundo ifuatayo:

futa x1_Obj .NameLast ;
futa x2_Obj ["NameFirst" ];

Ujenzi wa kwanza huondoa kipengele cha pili cha kitu cha kwanza, ujenzi wa pili huondoa kipengele cha kwanza cha kitu cha pili. Opereta ya kufuta haifanyi kazi kwenye sifa za mfano na hurejesha sivyo ikiwa sifa haiwezi kufutwa.

Mali na mbinu za vitu

Sintaksia ya sifa na kazi za kitu cha JavaScript (mbinu) ni sawa na kanuni za jumla za sintaksia na semantiki za lugha. Kwa kweli, kinyume chake ni kweli.

Sifa na mbinu za kitu ni lahaja ya kuelezea maelezo na vitendo vinavyoruhusiwa kupitia dhana ya JavaScript inayolengwa na kitu.

Mfano huu unaelezea kitu cha x3_Obj ambacho kina sifa mbili tu: kipengee na pos. Kisha njia ya hello() iliongezwa kama kazi. Kama matokeo, maadili ya kitu cha JavaScript yatatafsiri maelezo haya katika muktadha wa thamani za mali kama inavyoonyeshwa kwenye dirisha la matokeo, ambayo ni, itaweka chombo cha kukokotoa (1) kama thamani.

Wakati wa kupiga simu Hello() mali moja kwa moja, inatafsiriwa kama njia (kazi) na matokeo (2) ni utekelezaji wa nambari ya njia hii.

Neno kuu hili katika kitu

Ili kuabiri nafasi ya kipengele cha kitu, msanidi programu anaweza kutumia nenomsingi hili na kurejelea kwa sifa zinazoelezea ili kupata au kubadilisha thamani zake.

Huu ni mwanzo tu wa kuelezea kitu kilicho na mwili wa mjenzi tu. Mfano huu unaelezea kitu cha kufanya kazi na vidakuzi. Kitu kinaanzishwa wakati ukurasa unapakiwa na muundo ufuatao:

var oCookie = new scookies(cOwnerCode);
oCookie.Init();

Katika mfano huu, cOwnerCode ni msimbo wa kipekee wa mgeni. Ikiwa haipo, basi nambari mpya itaundwa katika mjenzi wa kitu cha oCookie. Haijalishi msanidi wa kitu hiki alimaanisha nini kwa idhini ya mgeni, muhimu ni jinsi neno kuu linatumiwa hapa kuelezea njia za kitu na jinsi zinavyoitwa kutoka kwa njia zingine za kitu:

hii .GetCookie = kazi (cName) ( ... );
this .SetCookie = kazi (cName, cValue) ( ... ).

Hii inaelezea mbinu za kitu cha kusoma kidakuzi kwa jina lake na kuandika thamani ya kuki yenye jina maalum.

hii .GetCookie("Mmiliki");
hii .SetCookie ( "Mmiliki" , Mmiliki );

Hii ndio jinsi hutumiwa, ikiwa kutokana na ujenzi wa kwanza thamani haijawakilishwa, basi ujenzi wa pili huiweka.

Mfano wa kitu cha kufanya kazi na vidakuzi

Unaweza kujadili Object na dhana ya mbinu inayolenga kitu ya lugha inayofanya kazi katika mazingira ya kivinjari. Inavutia, lakini kwa kweli inahitaji mazoezi, si nadharia. Kurasa za DOM,Kutoa zana za kudhibiti vitu na kusonga kupitia, mifumo ya vitu ni nguvu ya JavaScript.

Katika mazoezi yenye mwelekeo wa kitu, kitu kingine ni muhimu. Kufanya kazi na vidakuzi kwenye takriban rasilimali zote za wavuti ni sawa kwa kozi. Utekelezaji huu katika umbizo la kitu ni wazo nzuri. Katika muktadha huu, uanzishaji wa kitu hutokea wakati ukurasa unafunguliwa: ukurasa umewekwa = kitu cha kuki kipo na kila kitu kimesomwa, na kile ambacho hakikuwepo kinaundwa.

Wakati wa kufanya kazi na ukurasa, mgeni hufanya vitendo fulani na kivinjari lazima kibadilishe au kuunda vidakuzi. Kuna njia mbili za kitu (zilizoandikwa hapo juu) ambazo hufanya hivi.

Kwa kweli, kitu cha kuki kinaonekana mara baada ya kivinjari kuunda DOM na kuongeza utendakazi mpya kwenye mfumo wa kitu cha JavaScript: kusoma na kuunda (kurekebisha) vidakuzi.

Juu ya hili mfano rahisi inachukuliwa kama utaratibu wa kuunda vitu halisi ambavyo vina mali na utendaji wao pekee (mbinu). Kila kitu hufanya kazi yake mwenyewe na haishiriki katika algorithm ya jumla, haibadilishi data ya vitu vingine au nafasi ya pamoja majina

Kwa mbinu hii, msanidi huhakikisha kuundwa kwa mfumo wa vitu vya kipekee vya kutosha kuelezea na kuhudumia tatizo linalotatuliwa.

Matukio ya ukurasa na kitu

Kipengele muhimu cha utendakazi wa DOM na JavaScript: object event "s - ambayo hukuruhusu kupata taarifa kuhusu tukio kwenye kidhibiti chake. Takriban kila kipengele cha ukurasa kinaweza kugawiwa kidhibiti chake kwa tukio moja au zaidi.

Kwa kweli, msanidi programu wa JavaScript huunda sio "kipande" kimoja kikubwa cha msimbo, lakini maelezo mengi ya kazi, vitu, miundo ya data na mgao. vipengele maalum kurasa za kushughulikia tukio.

Tukio la kitu ni taarifa kuhusu tukio lililosababisha kidhibiti na uwezo wa kidhibiti hiki kutekeleza jibu la kutosha kwa tukio hili. Kila tukio hutofautiana tu kwa jina lake na mahali pa tukio, lakini pia katika vigezo vingine vingi.

Hasa, matukio ya kibodi ni seti moja ya vigezo, matukio ya panya ni aina tofauti kabisa ya data, na majibu ya seva kupitia AJAX imepangwa kabisa na msanidi mwenyewe.

Katika kila hali mahususi, picha ya matukio ambayo yanaweza kutokea kwenye ukurasa hubadilishwa kuwa anuwai ya vidhibiti vilivyowezeshwa; nje ya chaguo zilizotolewa za kuchakata seti mahususi ya matukio, ukurasa hauchukui hatua yoyote.

Uumbaji na uendeshaji wa vitu

Kivinjari "hubadilisha" URI, anwani ya rasilimali ya wavuti iliyoainishwa na mgeni, kuwa mti wa DOM - mfumo wa vitu vya ukurasa wa rasilimali hii ya wavuti. Wakati mgeni anafuata viungo kwenye ukurasa, kivinjari huenda kwenye miti inayofanana ya kurasa zingine.

Hali hii inamruhusu msanidi programu kuunda mfumo wake wa vitu kama msingi wa rasilimali ya wavuti ambayo inajibu vya kutosha kwa tabia ya wageni. Ikiwa utatenga utendaji wa jumla, kwa mfano:

kufanya kazi na kuki;
kupokea/kusambaza data (AJAX);
vidokezo vya zana;
ujumbe wa ndani (soga ya tovuti);
kazi zingine;

basi, mara baada ya kuundwa, mifumo ya kitu inaweza kutumika wakati wa kuendeleza tovuti nyingine. Hii ni faida kubwa ya mbinu ya kifaa juu ya matumizi ya kawaida ya JavaScript kama lugha ya kivinjari ambayo inahakikisha utendakazi wa ukurasa na majibu kwa matukio.

Vipengee ni vijenzi kamili vinavyoweza kuumbizwa kama faili tofauti na kutumika katika siku zijazo. Kipengele cha tabia ya mbinu hii ni uwezekano wa maoni, wakati kitu kilichosasishwa, kilichoboreshwa kinaweza kutumika katika maendeleo ya awali, kusasisha moja kwa moja utendaji wake bila kurekebisha tovuti.