Գործառույթի օգտագործող (անուն, տարիք) (այս .Name \u003d անուն; սա. 33); Console.log (user.name);

Կառուցվածքի օգտագործմամբ ստեղծված յուրաքանչյուր օբյեկտը ենթադրաբար ավելացված շինարարության սեփականություն է, որը պարունակում է հղում դեպի շինարարը, որի արդյունքում ստեղծվել է օբյեկտը.

Console.log (user.constructor \u003d\u003d\u003d օգտվող); // Ճիշտ.

Շինարար գույքը նախատեսված է օբյեկտի տեսակը պարզելու համար: Նույնը թույլ է տալիս օրինակ լինել օպերատորին.

Console.Log (օգտվողի օրինակ); // Ճիշտ.

Դիզայներ օգտագործելիս օբյեկտ ստեղծելու համար, ստեղծված յուրաքանչյուր օբյեկտի համար ստեղծված հատկությունների եւ մեթոդների պատճեն:

Կաղապար «Նախատիպը»

Երբ ստեղծվում է առանձնահատկություն, դրանում ավելացվում է նախատիպի գույքը: Նախատիպի գույքի արժեքը օբյեկտ է, որը պարունակում է ընդհանուր հատկություններ եւ մեթոդներ, որոնք հասանելի են այս դիզայների օգտագործմամբ ստեղծված բոլոր օբյեկտների համար:

Դիզայներներում հատկությունները եւ մեթոդները նշելու փոխարեն դրանք կարող են ուղղակիորեն ցուցադրել նախատիպը.

Գործառույթ օգտագործող () () user.prototype.Name \u003d "Homer"; User.prototype.age \u003d "33"; User.prototype.sayhi \u003d գործառույթ () (Console.Log («Բարեւ!»);); Թող օգտագործողը \u003d նոր օգտվող (); Console.log (user.name);

Լռելյայն, բոլոր նախատիպերը ունեն միայն շինարարության գույք, որը պարունակում է հղում այն \u200b\u200bգործառույթին, որին պատկանում է.

Fount Foo () () Console.log (foo.prototype.constructor \u003d\u003d\u003d Foo); // Ճիշտ.

Բոլոր մյուս մեթոդներն ու հատկությունները ժառանգվում են օբյեկտի տեսակից: Երբ նոր օբյեկտ է ստեղծվում դիզայներների միջոցով, ներքին ցուցիչը դրա մեջ սահմանվում է դիզայներների նախատիպով: Այս ցուցիչի հասանելիությունը կարելի է ձեռք բերել `օգտագործելով Object.getProtypef () մեթոդը.

Fount Foo () () Թող OBJ \u003d NEW FOO (); Console.Log (object.getprototypef (obj) \u003d\u003d\u003d foo.prototype); // Ճիշտ.

Օբյեկտի հատկությունները կարդալիս սկսում է իր որոնումը: Նախ, գույքը Ս. Նշված անուն Գտնվում է հենց օբյեկտի մեջ: Եթե \u200b\u200bայն հայտնաբերվի օբյեկտից, գույքի արժեքը վերադարձվում է, եթե օբյեկտի հետ օբյեկտի հատկությունները մատչելի չեն, որոնումը շարունակվում է նախատիպով: Գույքի հայտնաբերման դեպքում նախատիպը վերադարձնում է դրա արժեքը: Այսպիսով, նախատիպերը ապահովում են օբյեկտների գույքի եւ մեթոդների փոխանակում:

Եթե \u200b\u200bօբյեկտը անունով ավելացրեք գույքը, ինչպես նախատիպի հատկությունները, ապա օբյեկտը կստեղծի ձեր սեփականությունը, այս դեպքում օգտագործվելու է հետեւյալ գույքը, եւ ոչ թե նախատիպային գույքը չի օգտագործվի:

Ավելի քիչ կոդ գրելու համար կարող եք վերագրել նախատիպը բառացի օբյեկտով, որը պարունակում է բոլոր հատկությունները եւ մեթոդները.

Գործառույթ օգտագործող () () user.prototype \u003d (Անուն, «Հոմեր», Տարիք: 33, Sayhi: Function () ("Hello!");));));));));)); // վերականգնել շինարարի օբյեկտի հատկությունները: DefineProperty (user.prototype, "կոնստրուկտոր", (հնարավոր է, կեղծ, արժեք));

Այս օրինակում օգտագործողը .Prototype գույքը նշանակվում է բառացիորեն ստեղծված նոր օբյեկտ: Այն ամբողջովին փոխարինում է լռելյայն առաջարկվող օբյեկտին: Արդյունքը նույնն է, ինչ նախորդ օրինակով, մեկ բացառությամբ. Շինարարական գույքն այլեւս չի նշում օգտագործողի գործառույթը: Կոնստրուկտորային գույքի բացահայտ հավելումը օբյեկտի օգտագործողի արժեքով բառացիորեն լուծում է այս խնդիրը: Ներկառուցված լռելյայն օբյեկտներում շինարարությունը անհասկանալի է, ուստի այն ավելացնելու համար օգտագործվել է օբյեկտի () մեթոդը:

Կաղապարների «դիզայներ» եւ «նախատիպ» ձեւանմուշներ

Օգտագործելով դիզայներ, իր սեփական հատկությունները որոշում են եւ օգտագործելով նախատիպը `ընդհանուր մեթոդներ եւ հատկություններ.

Գործառույթի օգտագործող (անուն, տարիք) (այս .Name \u003d Անուն; սա. Ageოageageე ageი;) user.prototype.sayhi \u003d գործառույթ () ("Hello!");)

JavaScript Fexibility- ը թույլ է տալիս ստեղծել տարբեր եղանակներով առարկաներ: Բայց, ինչպես դա հաճախ է պատահում, ինքնին շատ թերություններ շատ բարձրացնողներ: Այս հոդվածից դուք կսովորեք, թե ինչպես տեսնել եւ մտնել այս վտանգավոր առագաստների մեջ:

Հիմունքների հիմունքներ

Մեզ չի հիշեցվի, որ JavaScript- ում առարկաները ներկայացնում են իրենց եւ ինչպես կարող են ստեղծվել դրանք: JavaScript- ում առարկան պարզապես բանալիների եւ արժեքների հեշի սեղան է: Եթե \u200b\u200bարժեքները հիմնական տեսակներն են կամ այլ առարկաներ, դրանք կանչվում են ՀատկություններԵթե \u200b\u200bդրանք գործառույթներ են, դրանք կանչվում են Մեթոդներ օբյեկտ

Օգտագործողի կողմից ստեղծված օբյեկտները կարող են փոխվել սցենարի կատարման ցանկացած պահի: Ներկառուցված օբյեկտների շատ հատկություններ նույնպես փոփոխական են: Այսինքն, դուք պարզապես կարող եք ստեղծել դատարկ առարկա եւ անհրաժեշտության դեպքում ավելացնել հատկություններ եւ մեթոդներ դրան: Դա կատարելու ամենահեշտ ձեւը Բառացիություն:
// Ստեղծեք դատարկ օբյեկտ Var Cat \u003d (); // Ավելացնել գույքը. Cat.Name \u003d "Garfield"; // կամ մեթոդ, Cat.GetName \u003d գործառույթ () (վերադարձի կատուն););
Օբյեկտն ստեղծելու եւս մեկ եղանակ է օգտագործել Դիզայներների գործառույթները.
// Բառացիության նոտացիա. Var Cat \u003d (Անուն, "Գարֆիլդ"); // դիզայներների գործառույթ. Var Cat \u003d նոր օբյեկտ (); Cat.Name \u003d "Garfield";
Ակնհայտ է, որ բառացիությունը դիզայներից կարճ է: Կա նաեւ դիզայներների բառացիլանշետը գերադասելու փիլիսոփայական պատճառ. Այն շեշտում է, որ օբյեկտը պարզապես փոփոխական խանգ է, եւ ոչ թե ձեւանմուշի սահմանված դասի կողմից ստեղծված մի բան:

Բացի այդ, օբյեկտի շինարարի օգտագործումը ստիպում է թարգմանությանը ստուգել, \u200b\u200bթե արդյոք այս գործառույթը վերաձեւակերպվում է տեղական համատեքստում:

Օբեկտների ձեւավորում ստորջրյա քար

Օբյեկտի կոնստրուկտորը օգտագործելու պատճառ չկա: Բայց մենք բոլորս գիտենք, որ երբեմն պետք է օգտագործել մի տեսակ հին կոդ, եւ այս դեպքում օգտակար է իմանալ այս դիզայների մեկ բնույթի մասին: Դա փաստարկ է պահանջում, եւ կախված դրա տեսակից, այն կարող է վստահել օբյեկտի ստեղծումը մեկ այլ ներկառուցված շինարարի. Արդյունքում մենք չենք ստանա այն օբյեկտը, որը մենք սպասում էինք.
// Դատարկ օբյեկտ Var O \u003d նոր օբյեկտ (); O.Constructor \u003d\u003d\u003d օբյեկտ; // True Var O \u003d նոր օբյեկտ (1); O.Constructor \u003d\u003d\u003d համարը; // True Var O \u003d նոր օբյեկտ («լարային»); O.Constructor \u003d\u003d\u003d լար; // ճշմարիտ // Մենք չէինք ենթադրում, որ ստեղծված օբյեկտը կունենա այս մեթոդը, O.SubString- ի տեսակը. // «գործառույթ»
Օբեկտների դիզայների նման պահվածքը կարող է հանգեցնել անսպասելի արդյունքների, եթե մենք փոխանցենք արժեքը, որն անհայտ է կատարման փուլում:

Բարոյականն ակնհայտ է. Մի օգտագործեք օբյեկտի կոնստրուկտորը:

Սեփական դիզայներներ

Մենք կարող ենք սահմանել մեր սեփական շինարարները: Օգտագործեք դրանք այսպիսին է.
Var Cat \u003d նոր կատու («Գարֆիլդ»); Cat.Say (); // «Ես Garfield» - ը
Սինտաքսը նման է Java կոնստրուկտորին, բայց JavaScript- ում դիզայները սովորական գործառույթ է եւ, հետեւաբար, սահմանվում է հետեւյալ կերպ.
Var Cat \u003d գործառույթ (անուն) (այս .Name \u003d Անուն; սա. «Ես եմ» (Վերադարձ))
Գործառույթի ներսում նոր օպերատորի հետ այս դիզայներին զանգահարելիս տեղի է ունենում.

• Ստեղծվում է դատարկ օբյեկտ, որը նշված է այս փոփոխականով. Այս օբյեկտը ժառանգում է գործառույթի նախատիպը.
• Սրանում պահվող օբյեկտին ավելացվում են հատկություններ եւ մեթոդներ.
• Դրանում պահվող առարկան ակնհայտորեն վերադարձվում է գործառույթի ավարտին (որովհետեւ ոչինչ չէինք վերադարձրել):

Օրինակ, պարզության համար ասվածի () մեթոդը ավելացվում է օբյեկտին: Դա այնքան էլ լավ չէ, քանի որ ամեն անգամ նոր մարդ անվանում ես () կստեղծվի հիշողության մեջ Նոր հատկություն, Քանի որ ասում են () մեթոդը նույնն է այս դիզայներ օգտագործող բոլոր օբյեկտների համար, ավելի լավ է այն ավելացնել նախատիպային կատվի մեջ.
Cat.prototype.say \u003d գործառույթ () (Վերադարձ «Ես եմ» + սա.);
Բացի այդ, ամբողջովին ճիշտ չէ պնդել, որ դիզայներներում այս ենթադրյալ ստեղծված օբյեկտը դատարկ է. Այն ժառանգվում է նախատիպի կատուից, բայց նախատիպերի քննարկումը սույն հոդվածի սահմաններից դուրս է:

Ինչն է վերադառնում դիզայներին

Նոր օպերատորն օգտագործելիս շինարարը միշտ վերադարձնում է օբյեկտը: Լռելյայն, սա առարկա է, որը վկայում է դրանով: Դիզայները այն ենթադրաբար վերադառնում է այս ենթադրաբար, մենք կարող ենք բացահայտորեն վերադարձնել որեւէ այլ օբյեկտ, օրինակ.
Var Cat \u003d գործառույթ () () (այսպիսին եմ \u003d "Ես Garfield"; var True \u003d (); thate.name \u003d "Ես կատուն եմ կին"; Var Cat \u003d նոր կատու (); Cat.Name // «Ես կատու-կին եմ»
Այսպիսով, մենք կարող ենք ցանկացած արժեք վերադարձնել դիզայներից, բայց միայն այն դեպքում, եթե դա օբյեկտ է: Եթե \u200b\u200bմենք փորձենք վերադառնալ, ասել, մի լար կամ կեղծ, այն չի սխալվի, բայց վերադարձի օպերատորը անտեսվելու է, եւ դիզայները կվերադառնա դա:

Covarian New.

Դիզայներները պարզապես գործառույթներն են, որոնք կոչվում են նոր օպերատորի հետ: Ինչ է պատահում, եթե մոռանում եք այս օպերատորը: Թարգմանիչը նախազգուշացում չի տա, բայց դա կհանգեցնի տրամաբանական սխալների: Այս փոփոխականը չի նշելու դիզայներների նախատիպից ժառանգված օբյեկտը եւ համաշխարհային օբյեկտի վրա (զննարկչի դեպքում պատուհան).
Գործառույթի կատու () (այս .Name \u003d "Garfield"; // նոր օբյեկտ Var Cat \u003d նոր կատու (); CAT- ի տեսակը; // «Օբեկտ» կատուն. Անունը; // "Garfield" // մոռանալ նոր `Var Cat \u003d Cat (); CAT- ի տեսակը; // «Undefined» պատուհանը. Անունը; // «Գարֆիլդ»
Խիստ ռեժիմով, ECAMACT 5 Այս դեպքում այս դեպքում չի նշվի գլոբալ օբյեկտը: Տեսնենք, թե ինչպես կարելի է խուսափել այս սխալից, եթե EcmaScript- ը հասանելի չէ:

Ֆունկցիոնալ անվանման պայմանագրեր

Մեծ մասը. Պարզ ձեւ Դա խիստ համապատասխանություն է տեղեկատվական անվանումների համաձայնագրերին. Մենք սկսում ենք սովորական գործառույթները փոքրատառից (MyFunction ()) եւ վերնագրով դիզայներների կողմից (MyConstruction ()): Դժբախտաբար, նման ձեւը ոչինչ չի խնայում:

Բացատրություն

Դիզայներները կարող են վերադարձնել ցանկացած առարկա: Ծրագրավորողները կարող են օգտվել դրանից.
Գործառույթի կատու () (var that \u003d (); that.name \u003d "Garfield"; վերադարձնել դա;)
Փոփոխականի անվանումը ընտրվում է կամայականորեն, սա ճշգրտման մաս չէ: Նույն հաջողությամբ մենք կարող ենք զանգահարել ինձ կամ ինքնուրույն կամ ինքնուրույն զանգահարել:

Պարզ օբյեկտների համար, ինչպիսիք են ստեղծվածը, օրինակ, մենք կարող ենք ընդհանրապես անել առանց լրացուցիչ փոփոխականների, օգտագործելով բառացիության նոտան.
Գործառույթի կատուն () (Անունը, «Գարֆիլդ»);)
Նման դիզայները միշտ կվերադարձնի օբյեկտը, անկախ նրանից, թե ինչպես կարելի է այն անվանել.
var առաջին \u003d նոր կատու (), երկրորդ \u003d կատու (); անուն; // «Գարֆիլդ» երկրորդը. Անունը; // «Գարֆիլդ»
Այս մեթոդը լուրջ թերություն ունի. Օբյեկտն չի ժառանգում շինարարի նախատիպը, այսինքն, կատվի համար ուղղակիորեն ավելացված մեթոդներն ու ունեցվածքը հասանելի չեն լինի դրանով ստեղծված օբյեկտներին:

Շինարար ինքնազսպություն

Այս խնդիրը լուծելու համար բավական է ստուգել, \u200b\u200bարդյոք սա շինարարի մարմնում է հենց այս դիզայներների խրանսալով, եւ եթե ոչ, ապա նորից առաջացրեք ինքներդ ձեզ, բայց այս անգամ նոր օպերատորի հետ: Այն կարծես վախկոտ է, բայց իրականում արդար.
Գործառույթի կատու (եթե (! (Այս օրինակով կատուն) (Վերադարձեք նոր կատու ();) սա. «Garfield»;) cat.prototype.meow \u003d "meow!"; var առաջին \u003d նոր կատու (), երկրորդ \u003d կատու (); անուն; // «Գարֆիլդ» երկրորդը. Անունը; // «Գարֆիլդ» նախ. // «Meow»: Երկրորդ. // «Meow»:
Եթե \u200b\u200bմեր դիզայները հետագայում վերանվանվի, ապա ստիպված կլինի ղեկավարել նրա մարմինը: Դուք կարող եք խուսափել դրանից `ստուգելով փաստարկները: Դիզայնի փոխարեն.
Եթե \u200b\u200b(! (Այս օրինակ փաստարկները .Callee)) (Վերադարձեք նոր փաստարկներ .Callee ();)
Այստեղ մենք օգտվեցինք այն փաստից, որ յուրաքանչյուր գործառույթի շրջանակներում ստեղծվում է փաստարկների օբյեկտ, որը պարունակում է զանգի պահին գործառույթներին փոխանցվող բոլոր պարամետրերը: Այս օբյեկտի Calee գույքը ցույց է տալիս կոչվող գործառույթը: Բայց այստեղ դուք պետք է հոգ տանել. EcmaScript- ի խիստ ռեժիմը 5-ի բացառություն է այս գույքին կապ հաստատելու համար, ուստի արժե ընտրություն կատարել վաղը վերափոխման եւ լույսի հարմարության միջեւ:

Ազատազրկման փոխարեն

JavaScript- ը ցնցող լեզու է: Այն բավականաչափ հեշտ է տիրապետելու համար, եւ առկա շրջանակները կստիպեն հեշտությամբ օգտագործել այն իրենց նախագծերում: Բայց շարահյուսության պարզության հետեւում թաքնված են ստորջրյա քարերի եւ շատ հզոր գործիքներ: Երբեմն օգտակար է դիտել, ինչ կա ներքեւում:

JavaScript- ը մշակողներին հնարավորություն է տալիս ստեղծել առարկաներ եւ աշխատել նրանց հետ: Դրա համար կան հետեւյալ տեխնիկան.

• Օպերատոր նոր:
• Բառացիություն
• Օբյեկտների դիզայներ
• Ասոցիատիվ զանգվածներ

Օգտագործեք նոր հայտարարությունը

Դա, հավանաբար, առավելագույնն է Հեշտ ճանապարհ Օբյեկտի ստեղծում: Դուք պարզապես ստեղծում եք օբյեկտի անվանումը եւ հավասարեցնում այն \u200b\u200bնորին javaScript օբյեկտ.

// Ստեղծեք մեր var myobject \u003d նոր օբյեկտ () օբյեկտ; // Variables MyObject.ID \u003d 5; // համարը myObject.Name \u003d "նմուշ"; // ROW // գործառույթներ MyOBJECT.GENNAME \u003d գործառույթ () (վերադարձրեք սա.)

Մինուս Այս մեթոդը Հենց դա կարող եք աշխատել միայն մեկ նորաստեղծ օբյեկտի հետ:

// Օգտագործեք մեր ազդանշանային օբյեկտը (MyObject.getname ());

Բառացիություն

Բառացիության նոտան նոր օբյեկտներ հայտնաբերելու մի փոքր անսովոր միջոց է, բայց հեշտ է հասկանալ: Բառացիության նշումը աշխատում է JavaScript- ի 1.3-ի հետ:

// Ստեղծեք մեր օբյեկտը օգտագործելով MyObject \u003d (ID: 1, Անուն `" Sample ", Boolval: True իշտ է, GetName; Function ())

Ինչպես տեսնում եք, այն բավականին պարզ է:

Օբեկտ \u003d (նույնականացում, արժեք, ...)

Եւ օրինակ օգտագործելու օրինակ.

Alert (myObject.getname ());

Օբյեկտների դիզայներ

Օբեկտների դիզայներները հզոր գործիք են այնպիսի առարկաներ ստեղծելու համար, որոնք կարող են օգտագործվել բազմիցս: Օբյեկտի դիզայները, ըստ էության, սովորական է javaScript առանձնահատկությունՈրը կարող է փոխանցվել նաեւ տարբեր պարամետրեր:

Գործառույթը `առ այսօր (ID, անուն) ()

Պարզապես մենք գրել ենք շինարարը: Դրանով մենք կստեղծենք մեր օբյեկտը:

Var myfirstobjectinstance \u003d նոր myObject (5, "նմուշ"); var mysecondobjectinstace \u003d նոր myObject (12, "Ote Sample");

Այսպիսով, մենք ստեղծեցինք օբյեկտի տարբեր դեպքեր: Այժմ մենք կարող ենք առանձին աշխատել MyObject օբյեկտի յուրաքանչյուր դեպքի հետ, առանց վախենալու այն փաստը, որ մեկ ատյանի հատկությունները փոխելը, մենք կանդրադառնանք մեկ այլ ատյանի հատկությունների վրա:

Ինչպես oop- ում, MyObject- ը կարող է ունենալ մեթոդներ եւ տարբեր հատկություններ: Հատկությունները կարող են նշանակել լռելյայն արժեքներ կամ օբյեկտի կոնստրուկտորում օգտագործողի կողմից փոխանցված արժեքները:

Ֆունկցիան myobject (id, name) (/ այս փոխանցմամբ փոխանցվող արժեքները ._ID \u003d ID; սա ._name \u003d Անուն; "(! Lang: MyDefaultvalue \u003d""; } !}

Նմանապես, մենք կարող ենք երկու գործառույթներ ստեղծել:

Ֆունկցիան myobject (ID, NAME) (սա ._ID \u003d ID; սա ._name \u003d Անուն; սա .Defaultvalue \u003d "(! Lang: MyDefaultValue)"; //Получение текущего значения this.getDefaultValue = function() { return this.defaultvalue; } //Установка нового значения this.setDefaultValue = function(newvalue) { this.defaultvalue = newvalue; } //Произвольная функция this.sum = function(a, b) { return (a+b); } } !}

Ասոցիատիվ զանգվածներ

Նման մեթոդը օգտակար կլինի մեծ թվով նույն տիպի օբյեկտներ հաղորդելու համար:

Var myobject \u003d նոր համարը (); Myobject [«ID»] \u003d 5; Myobject [«name»] \u003d "samplename";

Նման օբյեկտները շրջանցելու համար կարող եք օգտագործել այդպիսի ցիկլը.

For (MyElement in MyObject) (/ bypass կոդ // Մեգման մեջ - Ձայնագրման նույնացուցիչ // MyObject - բովանդակության ձայնագրում)

Նյութը պատրաստեց փոքր սխեմա:

Դուք դա կարող եք տեսնել ձեւաչափերով:

Ֆունկցիայի անձ (բռունցք, վերջին, տարիք, աչք) (այս .Firstname \u003d նախ; սա .LASTNAME \u003d վերջին; սա .EECOLOR \u003d EYE;

Այն համարվում է ծրագրավորման լավ պրակտիկա, որպեսզի դիզայներների գործառույթների անվանումը սկսվեց մեծատառով:

Օբեկտների տեսակներ (ձեւանմուշներ) (դասարաններ)

Նախորդ ղեկավարների օրինակները զգալիորեն սահմանափակ են: Նրանք ստեղծում են միայն մեկ առարկաներ:

Այնուամենայնիվ, երբեմն պահանջվում է ունենալ որոշակի «ձեւանմուշ», որը կարող է ստեղծվել նույն «տիպի» բազմաթիվ օբյեկտների կողմից:

«Օբյեկտի տեսակը» եւ օգտագործված Գործառույթի դիզայներական օբյեկտ.

Այս գլխի օրինակով օրինակի գործառույթը Անձ () Դա օբյեկտի դիզայների գործառույթն է:

Նույն տիպի օբյեկտները ստեղծվում են, օգտագործելով շինարար գործառույթի զանգը `բառով նոր:

Var myfather \u003d նոր մարդ ("John", "Doe", 50, "Blue"); Var mymothot \u003d նոր անձ ("Sally", "Rally", 48, "Green");

Հիմնաբառ սա

JavaScript- ում: Հիմնաբառ Սա Ցույց է տալիս մի առարկա, որը «պատկանում է» այս կոդին:

Հիմնաբառի արժեքը ՍաԵրբ այն օգտագործվում է օբյեկտում, օբյեկտն ինքնին է:

Դիզայներական գործառույթում հիմնաբառից Սա Ոչ մի արժեք: Սա «փոխարինում» է նոր օբյեկտի համար: Երբ ստեղծվում է նոր օբյեկտ, ապա բառի հիմնական արժեքը Սա Եվ այս նոր օբյեկտը կլինի:

Նկատի ունեցեք դա Սա Սա փոփոխական չէ, այլ հիմնաբառ: Դուք չեք կարող փոխել դրա արժեքը:

Հատկություններ ավելացնելը օբյեկտի համար

Նոր գույք գոյություն ունեցող օբյեկտին ավելացնելը շատ պարզ է.

Myfather.nationality \u003d "Անգլերեն";

Գույքը կավելացվի MyFather- ի օբյեկտին, բայց ոչ թե Mymother օբյեկտի համար: (Կամ ցանկացած այլ անձի տիպի օբյեկտ):

Առարկայի համար մեթոդ ավելացնելը

Ավելացնել Նոր մեթոդ Առկա օբյեկտի համար շատ պարզ է.

Myfatherh.name \u003d գործառույթ () (վերադարձիր սա: FirstName + "" +. Սա .LASTNAME;);

Մեթոդը կավելացվի MyFather- ի օբյեկտին, բայց ոչ դեպի Mymother օբյեկտը: (Կամ ցանկացած այլ անձի տիպի օբյեկտ):

Գույք ավելացնելը օբյեկտի կոնստրուկտորին

Դուք չեք կարող նոր գույք ավելացնել օբյեկտի կոնստրուկտորին այնպես, ինչպես դա արվում է գոյություն ունեցող օբյեկտի դեպքում:

Կառուցարանին նոր սեփականություն ավելացնելու համար հարկավոր է այն ավելացնել դիզայներների գործառույթին.

Ֆունկցիայի անձ (բռունցք, վերջին, տարիք, Eyecolor) (այս .FirstName \u003d նախ; սա .LAntName \u003d Վերջին; սա. Enticalial \u003d "

Այս դեպքում կանխադրված հատկությունները կարող են սահմանվել:

Մի մեթոդ ավելացնելով օբյեկտի կոնստրուկտորին

Դիզայներների գործառույթը կարող է որոշել նաեւ մեթոդները.

Ֆունկցիայի անձ (բռունցք, վերջին, տարիք, Eyecolor) (այս .FirstName \u003d նախ; սա .LAngname \u003d Վերջին; սա .Name \u003d Fungefe + " "+ սա .LASTNAME;);)

Դուք չեք կարող ավելացնել օբյեկտի կոնստրուկտորին նոր մեթոդներ նույն ձեւով, ինչպես դա արվում է առկա օբյեկտի դեպքում: Դիզայներների գործառույթի ներսում պետք է տեղի ունենա օբյեկտի մեթոդներ ավելացնելը.

Ֆունկցիայի անձը (անուն, ազգանուն, տարիք, Eyecolor) (այս.ֆիրիտ անուն \u003d FirstName; սա. CameName; sty.lastname \u003d Անուն) ;);)

Changename () առանձնահատկությունը անվանում է Անվան պարամետր արժեքը անձի օբյեկտի վերջին գույքի նկատմամբ.

Mymother.Changename ("Doe");

JavaScript- ը գիտի, թե ինչ առարկա է խոսում, «փոխարինելով» բանալի բառով Սա առարկա Իմ մայրիկը..

Ներկառուցված JavaScript դիզայներներ

JavaScript- ը ներկառուցված դիզայներներ ունի իրենց օբյեկտների համար.

Var x1 \u003d նոր օբյեկտ (); // Նոր օբյեկտի օբյեկտ Var X2 \u003d նոր լար (); // Նոր օբյեկտի լարային var x3 \u003d նոր համար (); // նոր օբյեկտի համարը var x4 \u003d նոր բուլյան (); // Նոր օբյեկտ Boolean var x5 \u003d նոր զանգված (); // NEW Array VAR X6 \u003d NEW REGEXP (); // նոր օբյեկտ Regexp var x7 \u003d նոր գործառույթ (); // Նոր օբյեկտի գործառույթ VAR X8 \u003d Նոր ամսաթիվ (); // Նոր ամսաթվի օբյեկտ

Այս ցուցակում չկա մաթեմատիկայի () առարկա, քանի որ սա համաշխարհային օբյեկտ է: Նոր հիմնաբառը չի կարող օգտագործվել մաթեմատիկական օբյեկտի հետ:

Գիտեք

Ինչպես երեւում է վերը նշված ծածկագրից, JavaScript- ը տվյալների օբյեկտների տարբերակներ ունի տողի, համարի եւ բուլյան: Այնուամենայնիվ, այս տիպի համար համապարփակ առարկաներ ստեղծելու պատճառ չկա: Առաջնային արժեքներն ավելի արագ են աշխատում:

Այս կերպ:

• Օգտագործեք օբյեկտի գրականություն { } Նոր օբյեկտի փոխարեն ():
• Օգտագործեք լարային գրականություն "" Նոր տողի փոխարեն ():
• Օգտագործեք թվային գրականություն 12345 Նոր համարի փոխարեն ():
• Օգտագործեք տրամաբանական գրականություն Ճիշտ է կեղծ է Նոր Boolean- ի փոխարեն ():
• Նոր զանգվածի փոխարեն օգտագործեք բառացի զանգվածներ ():
• Օգտագործեք բառացի ձեւանմուշներ /()/ Նոր Rexexp- ի փոխարեն ():
• Օգտագործեք գործառույթների արտահայտություններ () {} Նոր գործառույթի փոխարեն ():

var x1 \u003d (); // Նոր օբյեկտի օբյեկտ Var x2 \u003d "; // նոր պարզունակ լարային var x3 \u003d 0; // նոր պրիմիտիվ համարը var x4 \u003d կեղծ; // նոր պրիմիտիվ տրամաբանական արժեք var x5 \u003d; // նոր օբյեկտի զանգված Var x6 \u003d / () /// նոր օբյեկտ Regexp var x7 \u003d գործառույթ () (); // Նոր օբյեկտի գործառույթ

Բովանդակությունը շարժվել է հատվածներից մինչեւ հոդվածներ

Օգտագործելով նոր օպերատորը, կարող եք ստեղծել օբյեկտ (գործառույթի օբյեկտ):
Նոր օպերատորը պետք է նշի դիզայներների անունը. Այս գործառույթի դիզայները նախաձեռնում է օբյեկտի հատկությունները:
Դիզայներների գործառույթը փոխանցվում է գիտաժողովի հիմնաբառին, որը վերաբերում է նորաստեղծ օբյեկտին:

Կան ներկառուցված JavaScript շինարարներ, օրինակ `զանգված (), ամսաթիվ (), Regexp (): Հատկանշական է. Օբյեկտի () շինարարը ստեղծում է դատարկ առարկա, որը համարժեք է բառի բառացի ():

Նախատիպ - Սա դիզայներների նախատիպի գույքի արժեքն է: Յուրաքանչյուր գործառույթ ունի նախատիպային գույք, այս գույքը վերաբերում է նախանշված նախատիպային օբյեկտին: Այս օբյեկտը գործում է միայն այն դեպքում, եթե գործառույթը օգտագործվում է որպես շինարար, այսինքն `նոր օպերատորի հետ միասին:

Յուրաքանչյուր առարկա ունի շինարարի սեփականություն. Այս գույքը վերաբերում է դիզայներների գործառույթին, որը, ինչպես նշված է վերը, նախաստորագրում է օբյեկտի հատկությունները:

Ինչպես տեսնում եք, R_Method- ի գույքը միշտ վերաբերում է անփոխարինելի (ի տարբերություն յուրաքանչյուր օբյեկտի) գործառույթի: Հետեւաբար, ռացիոնալորեն ավելացրեք այն նախատիպին: Մենք կարող ենք պարզ եզրակացություն անել. Նախատիպային օբյեկտը հարմար է կայունության եւ մեթոդների համար: Քանի որ ցանկացած օբյեկտ ժառանգում է իր նախատիպի հատկությունները, ապա մեր գործառույթը (R_METHOD) ավտոմատ կերպով ավելացվում է դիզայներների (օրինակ_ կոնտեր):

JavaScript դասարաններ

JavaScript- ը չի աջակցում դասերին որպես այդպիսին: Այնուամենայնիվ, դուք կարող եք ստեղծել կեղծ դպրոցներ, օգտագործելով շինարարներ եւ առարկայի նախատիպեր: Դիզայները դաս է:

Կառուցել հանձնարարություն. Ստեղծեք նոր օբյեկտ, տեղադրել եւ վերադարձնել այն որպես շինարարի արժեք:

Դիզայնի անվանումը սովորաբար գոյականներ է, որոնք գրված են մեծատառից եւ նկարագրում են նախագծված օբյեկտը: Դիզայներները, որպես կանոն, օգտագործվում են մեկ ձեւանմուշին համապատասխան առարկաներ ստեղծելու համար:

Օբյեկտի ստեղծման օրինակ
Դիզայներների սահմանում,
եւ նախատիպի համար հատկություններ սահմանելը.

// VAR OPA \u003d () օբյեկտ; var opa_ \u003d (x: 0, y: "այո") var d \u003d նոր ամսաթիվ (); // ընթացիկ ամսաթիվը / * գույքի կոնստրուկտոր * / Document.write (D.Constructor); // գործառույթի ամսաթիվ () () D.Constructor \u003d\u003d Ամսաթիվ // ճշմարիտ // որոշում դիզայներ. Գործառույթի օրինակ_կոնտ (r, t), բայց դա է Ավելի լավ է որոշել, թե ինչպես SV-in- ի նախատիպը / * ic.r_method \u003d գործառույթ () (սա.) - սա. / / մեթոդ, բայց մեթոդը մի օգտագործեք օբյեկտի հատկությունները: A_Method \u003d գործառույթ (x, y) (ազդանշան (x + y);)) // Հայտարարեք նախատիպով (R_Method) մեթոդը // նախընտրելի է, քան R_Method- ը օգտագործելը f-and Constructor // այն պատճառով, որ R_Method- ի Fi- ն չունի եզակի SV-B, հակադրություն // վերը նշված հատկություններից (AD, AK) օրինակ_ constr.prototype.r_ mext - սա . AK;) // Զանգահարեք դիզայներին եւ ստեղծեք օրինակ_ կոնկրետ (Krot) օբյեկտ var krot \u003d New օրինակ_ կոնկրետ (14,15); // Ինչն է համարժեք krot \u003d (AD: 14, AK: 15) krot.r_method (); // դուրս կգա: //alert.krot.qu); // -1 //krot.a_method(111); // դուրս կգա. //2 22

Լրացում:
Ձեր սեփական դիզայներ ստեղծելու համար բավական է նկարագրել այն գործառույթը, որում այս հիմնաբառը կանդրադառնա օբյեկտներին (որոնք ստեղծվում են դիզայներների գործառույթի կողմից): Տեսեք վերեւում, օգտագործելով օրինակ_ կոնտեր:

console.dir.

jS.

Console.dir (OBJ); // վերցնել օբյեկտի բոլոր հատկությունները վահանակում

JavaScript- ում առարկաները թույլ են տալիս վերստեղծել օբյեկտի վրա հիմնված ծրագրավորման հայեցակարգը:

Օբյեկտներ ստեղծելու համար Մեկ տիպ Օգտագործեք գործառույթներ-դիզայներներ: Կառուցողի կողմից սովորական գործառույթից տարբերությունն այն է, որ շինարարը կոչվում է հատուկ նոր օպերատորի միջոցով:

Նորից օգտվելիս վերադարձի կառուցողի գործառույթում կարող է վերադարձվել միայն առարկա, եւ այս օբյեկտը կփոխարինի լռելյայն վերադարձված լռելյայն օբյեկտը:

Մասնավոր փոփոխականներ եւ գործառույթներ

Նախագծված գործառույթը կարող է նման լինել Մասնավոր տվյալներ (Արտաքին ծածկագրի վերաբերյալ նման տվյալներ կարելի է ձեռք բերել, բայց չի կարող փոխվել) եւ հասարակական:

javaScript.

// Որոշել դիզայներ. Գործառույթի օրինակ_ կոնտեր (R, T, անուն) (// այս \u003d () ստեղծվում է ինքնաբերաբար այս: x + y);) // կոնստրուկտորային գործառույթ եւ առանց որեւէ վերադարձի // վերադարձնում է օբյեկտը, որ // մասնավոր փոփոխական (այսինքն, այն կարող է ձեռք բերել). () (Վերադարձի անունը) // Կարող եք նաեւ օգտագործել սովորական փոփոխականներ, // որը հասանելի կլինի միայն դիզայներների գործառույթի սահմաններում. Var էջը, գաղտնաբառը (// .......) .........);) var newobj \u003d new օրինակ_/2, «Վասյա»); Console.dir (Newobj); Console.log (newobj.getname ()); //

իմանալ

• JavaScript- ի առարկաները աշխատում են միայն լարային հատկություններով, այսինքն, եթե գույքը նշված չէ որպես լարային, այն դեռ կդառնա տող: