Utilizator de funcții (nume, vârstă) (nume.name \u003d nume; acest.age.age.age.age.age.age.age.age \u003d vârsta; the.sayhi \u003d funcția (console.log ("salut!");)) Lasa utilizatorului \u003d utilizator nou ("Homer", 33); Consola.log (utilizator.name);

Fiecare obiect creat folosind constructorul este o proprietate constructorului adăugat implicit care conține o referință la constructor cu care a fost creat obiectul:

Consola.log (user.constructor \u003d\u003d\u003d utilizator); // Adevărat.

Proprietatea constructorului este destinată identificării tipului de obiect. Același lucru permite unui operator de instanță:

Consola.log (consumatorul de utilizator); // Adevărat.

Când utilizați un designer pentru a crea un obiect, o copie a proprietăților și a metodelor create pentru fiecare obiect creat.

Șablon "prototip"

Când se creează o caracteristică, proprietatea prototipului este adăugată la aceasta. Valoarea proprietății prototipului este un obiect care conține proprietăți și metode comune care sunt disponibile pentru toate obiectele create folosind acest designer.

În loc să specifice proprietățile și metodele în designer, ele pot fi specificate direct la prototip:

Utilizator de funcții () () user.protype.name \u003d "Homer"; User.protype.age \u003d "33"; User.protype.sayhi \u003d funcția () (consolă.log ("salut!");); Permite utilizatorului \u003d utilizator nou (); Consola.log (utilizator.name);

În mod implicit, toate prototipurile au doar proprietatea constructorului care conține o referință la funcția la care aparține:

Funcție Foo () () console.log (foo.protype.constructor \u003d\u003d\u003d foo); // Adevărat.

Toate celelalte metode și proprietăți sunt moștenite de la tipul de obiect. Când se creează un obiect nou utilizând designerul, indicatorul intern este definit în IT la prototipul de designer. Accesul la acest indicator poate fi obținut utilizând metoda Object.getProtyPoof ():

Funcție foo () () lăsați obj \u003d nou foo (); Consola.log (obiect.getprotypeof (obj) \u003d\u003d\u003d foo.protype); // Adevărat.

La citirea proprietăților obiectului începe căutarea. În primul rând, proprietatea S. numele specificat. Situat în obiectul în sine. Dacă este detectată din obiect, valoarea proprietății este returnată dacă proprietățile cu obiectul cu obiectul nu sunt disponibile, căutarea continuă în prototip. În cazul detectării proprietății, prototipul își întoarce valoarea. Deci, prototipurile asigură schimbul de proprietăți și metode în obiecte.

Dacă un obiect este o adaugare de proprietate cu un nume, cum ar fi proprietățile prototipului, atunci obiectul vă va crea propria proprietate, în acest caz, va fi utilizată următoarea proprietate, iar nu va fi utilizată proprietatea prototipului.

Pentru a scrie mai puțin cod, puteți suprascrie prototipul cu un obiect literal care conține toate proprietățile și metodele:

Utilizator de funcții () () user.protype \u003d (nume: "homer", vârstă: 33, Sayhi: funcția () (consola "(" salut! ");)); // restaurarea proprietăților obiectului constructor.defineproperty (user.protype, "constructor", (enumerabil: fals, valoare: utilizator));

În acest exemplu, proprietatea User.protype este atribuită unui nou obiect creat de literal. Înlocuiește complet obiectul oferit în mod implicit. Rezultatul este același ca în exemplul anterior, într-o singură excepție: proprietatea de construcție nu mai indică funcția utilizatorului. Adăugarea explicită a proprietății constructorului cu valoarea utilizatorului în obiectul literal rezolvă această problemă. Proprietatea constructorului din obiectele implicite încorporate este de neînțeles, astfel încât metoda Object.Defineproperty () a fost utilizată pentru ao adăuga.

Combinarea șabloanelor "Designer" și "prototip"

Folosind designerul, proprietățile sale proprii determină și utilizând prototipul - metode și proprietăți generale:

Utilizator de funcții (nume, vârstă) (denumit.name \u003d nume; this.age.age.age.age.age.age.age \u003d vârstă;) user.protype.sayhi \u003d funcția () (console.log ("salut!");)

Flexibilitatea JavaScript vă permite să creați obiecte cu o varietate de moduri. Dar, după cum se întâmplă adesea, o varietate de ridicare a multor capcane în sine. Din acest articol, veți afla despre cum să vedeți și să intrați în aceste recifuri periculoase.

Bazele de bază ale elementelor de bază

Nu ni se va aminti că obiectele din JavaScript reprezintă ei și cum pot fi create. Un obiect în JavaScript este doar un tabel hash de chei și valori. Dacă valorile sunt tipuri de bază sau alte obiecte, acestea sunt numite proprietățiDacă acestea sunt funcții, ele sunt numite metode obiect.

Obiectele create de utilizator pot fi modificate în orice punct de execuție al scriptului. Multe proprietăți ale obiectelor încorporate sunt, de asemenea, variabile. Adică, puteți crea pur și simplu un obiect gol și puteți adăuga proprietăți și metode după cum este necesar. Cea mai ușoară cale de a face acest lucru notație literală:
// creați un obiect gol var cat \u003d (); // Adăugați proprietate: cat.name \u003d "Garfield"; // sau metoda: CAT.GetName \u003d funcția () (return Cat.Name;);
O altă modalitate de a crea un obiect este de a utiliza funcțiile designerilor:
// notație literală: VAR CAT \u003d (Nume: "Garfield"); // funcția de designer: var cat \u003d obiect nou (); CAT.NAME \u003d "GARFIELD";
Evident, notația literală este mai scurtă decât designerul. Există, de asemenea, un motiv filosofic care preferă notația literală a designerilor: subliniază că obiectul este doar o hash variabil și nu ceva creat de clasa specificată de șablon.

În plus, utilizarea constructorului de obiecte forțează interpretul să verifice dacă această funcție este redefinită în contextul local.

Designul obiectului Piatra subacvatică

Nu există niciun motiv să folosiți constructorul de obiecte. Dar știm cu toții că uneori trebuie să utilizați un fel de cod vechi, iar în acest caz este util să știți despre un caracter al acestui designer. Este nevoie de un argument și, în funcție de tipul său, poate încredința crearea unui obiect unui alt constructor încorporat; Ca rezultat, nu vom obține obiectul pe care ne-am așteptat:
// obiect gol var o \u003d obiect nou (); O.constructor \u003d\u003d\u003d Obiect; // adevărat var o \u003d obiect nou (1); O.constructor \u003d\u003d\u003d Număr; // adevărat var o \u003d obiect nou ("șir"); O.constructor \u003d\u003d\u003d șir; // adevărat // Nu am presupus că obiectul creat va avea această metodă: Tipul O.SubString; // "funcția"
Un astfel de comportament al designerului de obiecte poate duce la rezultate neașteptate dacă transmitem o valoare necunoscută în faza de execuție.

Moralul este evident: nu utilizați constructorul de obiecte.

Designeri proprii

Putem defini propriii constructori. Utilizați-le arată astfel:
VAR CAT \u003d Noua pisică ("Garfield"); cat.say (); // "Eu sunt Garfield"
Sintaxa este similară cu constructorul Java, dar în JavaScript, designerul este o funcție convențională și, prin urmare, este definită după cum urmează:
Var Cat \u003d funcția (Nume) (Name.Name \u003d Nume; this.say \u003d funcția () (return "eu sunt" + acest nume;)
Când sunați la acest designer cu noul operator în interiorul funcției, se întâmplă următoarele:

• se creează un obiect gol, care este specificat de această variabilă; Acest obiect moștenește prototipul funcției;
• proprietățile și metodele sunt adăugate la obiectul stocat în acest sens;
• obiectul stocat în acest lucru este implicit returnat la sfârșitul funcției (pentru că nu am returnat nimic).

Pentru simplitate în exemplu, metoda Say () este adăugată la obiect. Nu este foarte bun, de fiecare dată când numiți o persoană nouă () va fi creată în memorie optiune noua. Deoarece metoda Say () este aceeași pentru toate obiectele create folosind acest designer, este mai bine să-l adăugați la Pisica prototipului:
Cat.protype.say \u003d funcția () (return "I am" + acest nume;);
În plus, nu este în întregime corect să susținem că obiectul acestui lucru implicit creat în designer este gol: este moștenit de la Pisica prototipului, dar luarea în considerare a prototipurilor depășește domeniul de aplicare al acestui articol.

Ce returnează designerul

Când utilizați noul operator, constructorul returnează întotdeauna obiectul. În mod implicit, acesta este un obiect referit de acest lucru. Designerul returnează acest lucru implicit, cu toate acestea, putem returna în mod explicit orice alt obiect, de exemplu:
VAR CAT \u003d FUNCTION () () (Nume.Name \u003d "Eu sunt Garfield"; var True \u003d (); acel nume \u003d "Eu sunt Cat-Femeie"; returnează acest lucru;); Var cat \u003d noua pisica (); Cat.Name // "Eu sunt pisica"
Astfel, putem returna orice valoare de la designer, dar numai dacă este un obiect. Dacă încercăm să ne întoarcem, să spunem, un șir sau fals, nu va fi confundat, dar operatorul de întoarcere va fi ignorat, iar designerul va returna acest lucru.

Covar Nou.

Designerii sunt doar funcțiile numite noul operator. Ce se întâmplă dacă uitați acest operator? Interpretul nu va da avertismente, dar acest lucru va duce la erori logice. Această variabilă nu va specifica obiectul moștenit din prototipul designerului și pe obiectul global (fereastră în cazul unui browser):
Funcție Cat () (acest nume.name \u003d "Garfield";) // Obiect nou Var Cat \u003d Cat nou (); Tipul de pisică; // "obiect" cat.name; // "Garfield" // uitați Nou: Var Cat \u003d Cat (); Tipul de pisică; // fereastra "nedefinită". Nume; // "Garfield"
În modul strict, ECMAScript 5 Acest eveniment în acest caz nu va indica obiectul global. Să vedem cum poate fi evitată această eroare dacă ECMASCRIPT 5 nu este disponibilă.

Funcții de numire funcțională

Cel mai. calea usoara Este respectarea strictă a acordurilor de numire a informațiilor: începem funcțiile obișnuite din litera minusculă (MyFuncțional ()) și de designerii de funcții cu titlul (Myconstruction ()). Din păcate, o astfel de cale nu salvează nimic.

Explicit rambursare

Designerii pot returna orice obiecte. Programatorii pot profita de aceasta:
Funcția Cat () (var \u003d (); acel nume \u003d "garfield"; întoarce-te;)
Denumirea variabilei este aleasă în mod arbitrar, aceasta nu face parte din specificație. Cu același succes, putem numi obiectul returnat pe mine sau pe sine sau la fel cum vă rog.

Pentru obiecte simple, cum ar fi create în exemplu, putem face fără variabile suplimentare, folosind notația literală:
Funcție Cat () (Return (Nume: "Garfield");)
Un astfel de designer va returna întotdeauna obiectul, indiferent de cum să-l numească:
mai întâi \u003d pisica nouă (), secundă \u003d pisică (); Nume; // "garfield" secund.name; // "Garfield"
Această metodă are un dezavantaj grav: Obiectul nu moștenește prototipul constructorului, adică metodele și proprietățile adăugate direct la pisica nu vor fi disponibile obiectelor create cu acesta.

Constructor auto-spune

Pentru a rezolva această problemă, este suficient să verificați dacă acest lucru este în corpul constructorului printr-o emițătoare a acestui designer, și dacă nu, provoacă din nou, dar de data aceasta cu noul operator. Sună înfricoșător, dar, de fapt, doar:
Funcție Cat () (dacă (această Cat instanță)) (returnați noua pisică ();) acest.name \u003d "Garfield";) cat.protype.meow \u003d "Miew!"; mai întâi \u003d pisica nouă (), secundă \u003d pisică (); Nume; // "garfield" secund.name; // "Garfield" în primul rând. // "MIAU!" Secundar. // "MIAU!"
Dacă designerul nostru este redenumit ulterior, va trebui să-și stăpânească corpul. Puteți evita acest lucru prin verificarea argumentelor.callee în loc de numele de design:
Dacă (! (Acest argument de exemplu.Callee)) (returnați noi argumente.Callee ();)
Aici am profitat de faptul că un obiect argumentează este creat în cadrul fiecărei funcții care conțin toți parametrii transmise funcțiilor în momentul apelului. Proprietatea Callee a acestui obiect indică funcția numită. Dar aici trebuie să aveți grijă: Modul strict EcMascript 5 determină excepția de tipEError atunci când contactați această proprietate, deci merită o alegere între confortul de refactorizare și lumină mâine.

În loc de închisoare

JavaScript este o limbă uimitoare. Este suficient de ușor să stăpânească, iar cadrele existente o vor face cu ușurință să o utilizeze în proiectele lor. Dar în spatele simplității sintaxei este recifele întregi ascunse ale pietrelor subacvatice - și instrumente foarte puternice. Uneori este util să urmăriți, ce este acolo în partea de jos.

JavaScript oferă dezvoltatorilor posibilitatea de a crea obiecte și de a lucra cu ei. Pentru aceasta, există următoarele tehnici:

• Operator nou.
• Notație literală
• Designeri de obiecte
• Arrays asociative

Utilizați noua declarație

Este probabil cel mai mult calea ușoară Crearea unui obiect. Pur și simplu creați numele obiectului și echivalează-l noii obiect javascript.

// Creați-vă Var MyObject \u003d Obiect nou (); // variabilele myobject.id \u003d 5; // numarul myobject.name \u003d "eșantion"; // rând // funcții myobject.getname \u003d funcția () (return acest nume.)

Minus aceasta metoda Este că puteți lucra numai cu un obiect nou creat.

// utilizați obiectul nostru de alertă (myobject.GetName ());

Notație literală

Notația literală este o modalitate oarecum neobișnuită de a identifica obiecte noi, dar ușor de înțeles. Notația literală funcționează cu JavaScript 1.3.

// Creați obiectul nostru folosind MyObject \u003d (ID: 1, Nume: "Eșantion", Boolval: Adevărat, GetName: Funcție () (returnați acest nume;))

După cum puteți vedea, este destul de simplu.

Obiect \u003d (identificator: valoare, ...)

Și un exemplu de utilizare:

Alertă (myobject.getname ());

Designeri de obiecte

Designerii obiectului sunt un instrument puternic pentru crearea obiectelor care pot fi utilizate în mod repetat. Designerul obiectului este, de fapt, obișnuit funcția JavaScriptcare pot fi, de asemenea, transmise diferiți parametri.

Funcția MyObject (ID, Nume) ()

Doar am scris constructorul. Cu aceasta, vom crea obiectul nostru.

Var MyfirstobjectInstanță \u003d New MyObject (5, "eșantion"); Var MysecondobjectInstace \u003d noul Myobject (12, "Eșantionul");

Astfel, am creat diverse cazuri ale obiectului. Acum putem lucra separat cu fiecare instanță a obiectului MyObject, fără a temina faptul că schimbarea proprietăților unei instanțe, vom afecta proprietățile unui alt caz.

Ca și în OOP, MyObject poate avea metode și diverse proprietăți. Proprietățile pot atribui valori implicite sau valorile transferate de utilizator în constructorul de obiecte.

Funcție MyObject (ID, Nume) (// Valori transmise de acest._id \u003d id; the._name \u003d nume; // valoare implicită this.defaultvalue \u003d "(! Lang: MyDefaultValue"; } !}

În mod similar, putem crea ambele funcții.

Funcție MyObject (ID, Nume) (this._id \u003d id; the._name \u003d nume; the.defaultvalue \u003d "(! Lang: mydefultValue"; //Получение текущего значения this.getDefaultValue = function() { return this.defaultvalue; } //Установка нового значения this.setDefaultValue = function(newvalue) { this.defaultvalue = newvalue; } //Произвольная функция this.sum = function(a, b) { return (a+b); } } !}

Arrays asociative

O astfel de metodă va fi utilă pentru simplificarea unui număr mare de obiecte de același tip.

Var myobject \u003d număr nou (); MyObject ["ID"] \u003d 5; MyObject ["nume"] \u003d "nume de eșantion";

Pentru a ocoli astfel de obiecte, puteți utiliza un astfel de ciclu:

Pentru (MyElement în MyObject) (// cod de bypass // în MyElement - Identificatorul de înregistrare // În înregistrarea conținutului)

Materialul a preparat o schemă mică.

Îl puteți vedea în formate.

Persoana funcției (pumn, ultima, vârstă, ochi) (this.firstname \u003d mai întâi; acest.age.Lastname \u003d ultima; acest lucru.age.age.age.age.ages.age.age.age.age \u003d vârsta; acest lucru.eecolor \u003d ochi;)

Se consideră o bună practică de programare, astfel încât numele funcțiilor designerilor să înceapă cu o scrisoare de capital.

Tipuri de obiecte (șabloane) (clase)

Exemple de la capetele anterioare sunt semnificativ limitate. Ele creează numai obiecte unice.

Cu toate acestea, uneori este necesar să aveți un anumit "șablon", care ar putea fi creat de multe obiecte de același "tip".

Pentru a crea un "tip obiect" și utilizat obiect de designer de funcții.

În exemplul acestui capitol, funcția de exemplu Persoană () Este funcția designerului de obiecte.

Obiectele de același tip sunt create utilizând un apel de funcționare a constructorului cu un cuvânt cheie nou:

Var Myfather \u003d Noua persoană ("John", "Doe", 50, "albastru"); Var Mymother \u003d persoană nouă ("Sally", "Rally", 48, "verde");

Cuvânt cheie acest lucru

În JavaScript. cuvânt cheie. aCEST Indică un obiect care "aparține" acestui cod.

Valoarea cuvintelor cheie aCESTCând este folosit în obiect, obiectul în sine este.

În funcția de designer din cuvântul cheie aCEST Fără valoare. Aceasta este o "substituție" pentru un obiect nou. Când se creează un obiect nou, atunci valoarea cuvântului cheie aCEST Și acest nou obiect va fi.

Rețineți că aCEST Aceasta nu este o variabilă, ci un cuvânt cheie. Nu vă puteți schimba valoarea.

Adăugarea de proprietăți la obiect

Adăugați o proprietate nouă la un obiect existent este foarte simplu:

Myfather.nationality \u003d "Engleză";

Proprietatea va fi adăugată la obiectul MyFather, dar nu la obiectul MyMother. (Sau orice alt obiect de tip al unei persoane).

Adăugând o metodă la obiect

Adăuga noua metoda La obiectul existent este foarte simplu:

Myfather.name \u003d funcția () (return this.firstname + "+ acest.lastname;);

Metoda va fi adăugată la obiectul MyFather, dar nu la obiectul MyMother. (Sau orice alt obiect de tip al unei persoane).

Adăugarea unei proprietăți unui constructor de obiecte

Nu puteți adăuga o proprietate nouă constructorului de obiecte în același mod ca și în cazul unui obiect existent.

Pentru a adăuga o proprietate nouă constructorului, trebuie să o adăugați la funcția de designer:

Persoana funcției (pumn, ultima, vârstă, eyecolor) (this.fiRstName \u003d mai întâi; the.Lastname \u003d ultima; acest lucru.age.age.age.age.age.age.age.age \u003d vârsta; the.eyecolor \u003d Eyecolor; this.nationity \u003d "Engleză";)

În acest caz, pot fi setate proprietățile implicite.

Adăugând o metodă pentru a obiecta constructor

Funcția de designer poate determina, de asemenea, metodele:

Persoana funcției (pumn, ultima, vârstă, eyecolor) (this.fiRstName \u003d mai întâi; the.age.Lastname \u003d ultima; acest.age.age \u003d vârsta; the.eecolor \u003d eyecolor; acest.name \u003d funcția (returnați acest.FirstName + " "+ acest.Lastname;);)

Nu puteți adăuga metode noi pentru constructorul de obiecte în același mod ca și în cazul unui obiect existent. Adăugarea metodelor la un obiect trebuie să apară în interiorul funcției de designer:

Persoana funcției (numele, numele, numele, vârsta, eyecolor) (this.fiRstName \u003d FirstName; Acest.age.age.age.age.age.age.age.age.age \u003d vârsta; the.eyecolor \u003d Eyecolor; the.changenme \u003d funcția (Nume) (Nume.LastName \u003d Nume ;););););););););

Caracteristica Changename () atribuie valoarea parametrului de nume la numele de proprietate a obiectului persoanei:

Mama .changename ("Doe");

JavaScript știe ce obiect vorbește, "substituiți" în cuvântul cheie aCEST un obiect mama mea..

Designeri JavaScript încorporat

JavaScript are designeri încorporați pentru obiectele proprii:

Var x1 \u003d obiect nou (); // nou obiect obiect var x2 \u003d nou șir (); // noul șir de obiect nou var x3 \u003d număr nou (); // Numărul de obiect nou var x4 \u003d nou boolean (); // obiect nou boolean var x5 \u003d nou matrice (); // New Array var x6 \u003d nou regexp (); // Obiect nou REGEXP VAR X7 \u003d Funcție nouă (); // noua funcție de obiect var x8 \u003d data nouă (); // Obiect nou Data

Nu există obiecte matematice () în această listă, deoarece acesta este un obiect global. Noul cuvânt cheie nu poate fi utilizat cu obiectul matematic.

Știați?

Așa cum se poate observa din codul de mai sus, JavaScript are versiuni de obiecte ale șirului de date primitive, număr și boolean. Cu toate acestea, nu există niciun motiv pentru a crea obiecte cuprinzătoare pentru aceste tipuri. Valorile primitive funcționează mai repede.

În acest fel:

• utilizați literale de obiecte { } În loc de obiect nou ().
• utilizați literale de șir "" În loc de noul șir ().
• utilizați literale numerice 12345 În loc de un număr nou ().
• utilizați literale logice adevarat fals În loc de noul boolean ().
• utilizați matrice literale în loc de noi matrice ().
• utilizați șabloane literale /()/ În loc de noul REXEXP ().
• utilizați expresii de funcții () {} În loc de o nouă funcție ().

var x1 \u003d (); // nou obiect obiect var x2 \u003d ""; // nou șir primitiv var x3 \u003d 0; // Număr primitiv nou Var X4 \u003d FALSE; // noua valoare logică primitivă var x5 \u003d; // noul obiect Array var x6 \u003d / () /// nou obiect regexp var x7 \u003d funcția () (); // Funcție nouă obiect

conținutul sa mutat de la fragmente la articole

Folosind noul operator, puteți crea un obiect (obiect funcție).
Noul operator trebuie să specifice numele designerului; Acest designer de funcții inițializează proprietățile obiectului.
Funcția de designer este transmisă cuvântului cheie al conferinței, care se referă la obiectul nou creat.

Există constructori JavaScript încorporați, de exemplu: matrice (), data (), regexp (). Este demn de remarcat: constructorul obiectului () creează un obiect gol, care este echivalent cu utilizarea obiectului literal ().

Prototip - Aceasta este valoarea proprietății prototip a designerului. Fiecare funcție are proprietatea prototipului, această proprietate se referă la un obiect prototip predefinit. Acest obiect funcționează numai dacă funcția este utilizată ca constructor, adică împreună cu noul operator.

Fiecare obiect are o proprietate a constructorului; Această proprietate se referă la funcția de designer, care, după cum sa menționat mai sus, inițializează proprietățile obiectului.

După cum puteți vedea, proprietatea R_Method se referă întotdeauna la o funcție imuabilă (spre deosebire de proprietăți care sunt unice pentru fiecare obiect). Prin urmare, îl adăugați rațional la prototip. Putem face o concluzie simplă: obiectul prototip este potrivit pentru constante și metode. Deoarece orice obiect moștenește proprietățile prototipului său, atunci funcția noastră (R_Method) este adăugată automat la toate obiectele inițializate de designer (example_constr).

Clase JavaScript.

JavaScript nu acceptă cursuri ca atare. Cu toate acestea, puteți crea pseudo-școlare folosind constructori și prototipuri de obiecte. Designerul este o clasă.

Construct Alocare - Creați un obiect nou, instalați și returnați-l ca valoare a constructorului.

Numele de design este de obicei substantive, scrise dintr-o scrisoare de capital și descrie obiectul proiectat. Designerii, de regulă, sunt folosite pentru a crea obiecte corespunzătoare unui singur șablon.

Un exemplu de creare a unui obiect
Definirea designerului,
și setarea proprietăților pentru prototip:

// var opa \u003d () obiect; var opa_ \u003d (x: 0, y: "da") var d \u003d noua dată (); // Data curentă / * Constructor de proprietăți * / document.write (d.constructor); // Data funcției () () d.constructor \u003d\u003d Data // TRUE // Determinați designerul: funcția Exemplu_Constr (R, T) (acest lucru.ad \u003d r; această metodă.ak \u003d t; //, dar este Mai bine pentru a determina modul în care SV-in PROTOTYPE / * Acest.R_METHOD \u003d FUNCTION () (this.qu \u003d this.ad - the.ak;) * /// metoda, dar în interiorul metodei nu utilizați proprietățile obiectului. A_METHOD \u003d FUNCȚIA (X, Y) (Alertă (x + Y);)) // Declarați metoda (R_Method) în prototip // este preferabilă decât utilizarea R_Method în f-și constructor // Datorită faptului că Fi-ul R_Method nu are SV-B unic, în contrast // din proprietățile de mai sus (AD, AK) example_constr.protype.r_method \u003d funcție () (this.qu \u003d this.ad - acest lucru . Ak;) // Apelați designerul și creați un exemplu_constr (krot) obiect var krot \u003d noul exemplu_constr (14,15); // ceea ce este echivalent cu krot \u003d (AD: 14, AK: 15) krot.r_method (); // va ieși: //alert.krot.qu); // -1 ///krot.a_metod (11,11); // va ieși: // 22

Plus:
Pentru a crea propriul designer, este suficient pentru a descrie funcția în care acest cuvânt cheie se va referi la obiecte (care sunt create de funcția de designer). Vedeți mai sus folosind exemplul_constr.

consola.Dir.

js.

Consola.Dir (obj); // retrageți toate proprietățile unui obiect în consola

Obiectele din JavaScript vă permit să recreați conceptul de programare orientată pe obiecte.

Pentru a crea obiecte un tip. Utilizați funcții-designeri. Diferența dintre constructor din funcția obișnuită este că constructorul este chemat printr-un nou operator special.

Când se utilizează Nou, numai un obiect poate fi returnat în funcția Constructorului de întoarcere, iar acest obiect va înlocui obiectul implicit care este returnat în mod implicit.

Variabile și funcții private

Funcția proiectată poate fi ca date private. (Aceste date privind codul extern pot fi obținute, dar nu se pot schimba) și public.

javaScript.

// Determinați designerul: funcția Exemplu_Constr (R, T, Nume) (// this \u003d () este creat automat acest.ad \u003d r; the.ak \u003d t; the.a_method \u003d funcție (x, y) (Alertă ( x + y);) // Funcția constructorului și fără nici o întoarcere // returnează obiectul că // variabila privată (adică poate fi obținută din codul extern, // dar nu poate fi schimbat): this.GetName \u003d funcția () (Numele de returnare;) // De asemenea, puteți utiliza variabilele convenționale, // care va fi disponibilă numai în limitele funcției de designer: Var Page, parolă; Var Ogo \u003d Funcție () (// ............. ........););); var nowobj \u003d noul exemplu_constr (1,2, "vasya"); Consola.dir (Newobj); Consola.log (Newobj.GetName ()); //

știi

• Obiectele JavaScript funcționează numai cu proprietăți de șir, adică dacă proprietatea nu este specificată ca șir, acesta va deveni șir.