Definirea proprietăților pentru un tip de obiect

Puteți adăuga o proprietate la un tip de obiect definit anterior folosind proprietatea specială prototip. Folosind prototip, este creată o proprietate care este aceeași pentru toate obiectele de acest tip, mai degrabă decât o singură instanță a acelui tip de obiect. Următorul cod demonstrează acest lucru prin adăugarea unei proprietăți de culoare la toate obiectele de tip car și apoi atribuirea unei valori proprietății de culoare a obiectului car1.

Car.prototype.color = null; car1.color = „negru”;

Codul de mai jos arată cum puteți utiliza un getter și setter pentru a extinde prototipul obiectului Date și pentru a adăuga o proprietate year la acesta, care va funcționa pentru toate instanțele clasei Date. Acest cod folosește metode existente Clasa de date - getFullYear și setFullYear pentru operarea getter și setter.

Definirea unui getter și setter pentru proprietatea year:

Var d = Data.prototip; Object.defineProperty(d, „an”, ( get: function() ( return this.getFullYear(); ), set: function(y) ( this.setFullYear(y); ) ));

Folosind proprietatea year specificată de un getter și setter:

Var acum = data noua(); console.log(acum.an); // 2000 acum.an = 2001; // 987617605170 console.log(acum); // Miercuri, 18 aprilie 11:13:25 GMT-0700 (Ora de vară a Pacificului) 2001

Practic, getters și setters pot fi fie:

Când definiți un getter și setter folosind , tot ce trebuie să faceți este să prefixați getter-ul cu get și setter-ul cu set . În acest caz, metoda getter nu ar trebui să aștepte niciun parametru, în timp ce metoda setter ia un singur parametru (noua valoare de atribuit proprietății). De exemplu:

Var o = ( a: 7, get b() ( return this.a + 1; ), set c(x) ( this.a = x / 2; ) );

Getters și setters pot fi adăugați la un obiect existent în orice moment folosind metoda Object.defineProperties. Primul parametru al acestei metode este obiectul căruia doriți să îi atribuiți getter-ul și setter-ul. Al doilea parametru este un obiect ale cărui nume de proprietate vor corespunde numelor proprietăților create, iar valorile sunt obiecte care definesc getter-ul și setter-ul proprietăților create. Următorul exemplu creează exact același getter și setter ca exemplul de mai sus:

Var o = ( a: 0 ); Object.defineProperties(o, ( "b": ( get: function() ( return this.a + 1; ) ), "c": ( set: function(x) ( this.a = x / 2; ) ) )); o.c = 10; // Rulează un setter care atribuie 10 / 2 (5) proprietății „a” console.log(o.b); // Declanșează un getter care returnează un + 1 (adică 6)

Care dintre cele două forme pe care le utilizați pentru a defini proprietăți depinde de stilul dvs. de programare și de sarcina la îndemână. Dacă utilizați deja un inițializator de obiect pentru a defini un prototip, probabil că veți folosi prima formă în majoritatea cazurilor. Este mai compact și mai natural. Cu toate acestea, nu este neobișnuit ca a doua formă să fie singura posibilă în cazurile în care lucrați cu un obiect existent fără acces la definiția acestuia. A doua formă reflectă cel mai bine natura dinamică a JavaScript - dar poate face codul dificil de citit și de înțeles.

Îndepărtarea proprietăților

Puteți șterge o proprietate folosind operatorul de ștergere. Următorul cod arată cum să eliminați o proprietate.

//Creează un nou obiect, myobj, cu două proprietăți, a și b. var myobj = obiect nou; myobj.a = 5; myobj.b = 12; //Elimină proprietatea a, lăsând myobj doar proprietatea b. sterge myobj.a;

De asemenea, puteți utiliza ștergerea pentru a elimina o variabilă globală dacă cuvântul cheie var nu a fost folosit când ați declarat-o:

G = 17; șterge g;

• Pentru studiu detaliat citit .
• Pentru a afla despre clasele ECMAScript 2015 (noul mod de a defini obiecte), citiți capitolul.

Obiecte

Object este un tip de date fundamental în limbajul JavaScript. Un obiect este o valoare compusă: combină un set de valori (valori simple sau alte obiecte) și permite ca acele valori să fie stocate și preluate după nume.

Un obiect este o colecție neordonată de proprietăți, fiecare având un nume și o valoare. Numele proprietăților sunt șiruri de caractere, așa că se poate spune că obiectele mapează șiruri de caractere la valori. Această mapare a șirurilor de caractere la valori poate avea mai multe nume: este posibil să fiți deja familiarizați cu o structură fundamentală de date, cum ar fi un hash, un dicționar sau o matrice asociativă. Cu toate acestea, la un obiect există mai mult decât o simplă mapare a șirurilor de caractere la valori.

Pe lângă propriile proprietăți, obiectele JavaScript pot moșteni și proprietăți de la alte obiecte, cunoscute sub numele de prototipuri. Metodele obiect sunt reprezentanți tipici ai proprietăților moștenite și „ moștenire prin prototipuri" este caracteristica cheie limbaj JavaScript.

Obiectele din JavaScript sunt dinamice - de obicei vă permit să adăugați și să eliminați proprietăți - dar pot fi folosite și pentru a emula obiectele și „structurile” statice găsite în limbajele de programare JavaScript. sistem static tipuri. Ele pot fi, de asemenea, folosite (dacă ignorați că obiectele mapează șiruri la valori) pentru a reprezenta seturi de șiruri.

Orice valoare din JavaScript care nu este un șir, număr, adevărat, fals, nul sau nedefinit este un obiect. Și chiar și șirurile de caractere, numerele și booleanele care nu sunt obiecte se pot comporta ca obiecte imuabile (au obiecte de tip String, Number etc.).

Obiectele sunt valori modificabile iar operatiile asupra acestora se fac prin referinta, nu dupa valoare. Dacă variabila x se referă la un obiect și afirmația var y = x; , variabila y va conține o referință la același obiect, nu o copie a acestuia. Orice modificări aduse obiectului de variabila y se vor reflecta și în variabila x.

O proprietate are un nume și o valoare. Numele proprietății poate fi orice șir, inclusiv șirul gol, dar un obiect nu poate avea două proprietăți cu același nume. Valoarea proprietății poate fi orice valoare permisă în limbajul JavaScript sau (în ECMAScript 5) o funcție de citire sau scriere (sau ambele).

Pe lângă nume și valori, fiecare proprietate are un număr de valori asociate cu ea, numite atribute de proprietate :

Atribut inscriptibil determină dacă valoarea unei proprietăți poate fi scrisă.

Atribut enumerabil determină dacă numele proprietății este disponibil pentru enumerare într-o buclă for/in.

Atribut configurabil determină posibilitatea personalizării, adică ștergerea unei proprietăți și modificarea atributelor acesteia.

Înainte de apariția standardului ECMAScript 5, toate proprietățile din obiecte creat de program, disponibil pentru înregistrare, listare și personalizare. ECMAScript 5 oferă posibilitatea de a personaliza atributele proprietăților dvs.

Pe lângă proprietăți, fiecare obiect are trei atributul obiectului :

Atribut clasă conține un șir cu numele clasei obiectului și specifică tipul obiectului.

Steag extensibil(în ECMAScript 5) indică capacitatea de a adăuga noi proprietăți unui obiect.

În cele din urmă, mai jos este o descriere a unor termeni care ne vor ajuta să distingem între cele trei categorii largi de obiecte din JavaScript și cele două tipuri de proprietăți:

Este un obiect sau o clasă de obiecte definită de specificația ECMAScript. Matricele, funcțiile, datele și expresiile regulate (de exemplu) sunt obiecte de bază ale limbajului.

Acesta este un obiect definit de mediul de rulare (cum ar fi un browser web) în care este încorporat interpretul JavaScript. Obiectele HTMLElement, care reprezintă structura unei pagini web în JavaScript pe partea clientului, sunt obiecte de rulare. Obiectele runtime pot fi, de asemenea, obiecte limbaj de bază, de exemplu atunci când runtime definește metode care sunt obiecte Function obișnuite ale limbajului JavaScript de bază.

Orice obiect creat prin executarea codului JavaScript.

Aceasta este o proprietate definită direct pe un obiect dat.

Aceasta este o proprietate definită de prototipul obiectului.

Crearea obiectelor

Obiectele pot fi create folosind literalmente obiect, noul cuvânt cheie și (în ECMAScript 5) funcții Object.create().

Literale obiect

Cel mai simplu mod de a crea un obiect este să includeți un obiect literal în programul dvs. Un obiect literal este o listă de proprietăți separate prin virgulă (perechi nume/valoare) închisă între acolade. Numele proprietății poate fi un identificator sau un șir literal (șirul gol este acceptabil). Valoarea unei proprietăți poate fi orice expresie permisă în JavaScript - valoarea expresiei (aceasta poate fi o valoare simplă sau un obiect) va deveni valoarea proprietății.

Mai jos sunt câteva exemple de creare a obiectelor:

Var gol = (); // Obiect fără proprietăți var point = ( x:0, y:0 ); // Două proprietăți var point2 = ( x:punct.x, y:punct.y+1 ); // Valori mai complexe ​​var site = ( "url site": "www..NET Framework", // și cratime, deci folosiți ghilimele autor: ( // Valoarea acestei proprietăți este prenume: "Alexandr", / / obiect. Vă rugăm să rețineți că numele de familie: „Frolov” // numele acestor proprietăți sunt fără ghilimele. ) );

ECMAScript 5 (și unele implementări ale ECMAScript 3) permite cuvintelor rezervate să fie folosite ca nume de proprietăți fără ghilimele. Cu toate acestea, în general, numele de proprietăți care se potrivesc cu cuvintele rezervate din ECMA-Script 3 trebuie să fie cuprinse între ghilimele. În ECMAScript 5, ultima virgulă după ultima proprietate dintr-un literal obiect este ignorată. Majoritatea implementărilor ECMAScript 3 ignoră, de asemenea, virgulele de sfârșit, dar IE interpretează prezența lor ca o eroare.

Un obiect literal este o expresie care creează și inițializează un nou obiect ori de câte ori acea expresie este evaluată. Valoarea fiecărei proprietăți este recalculată atunci când este evaluată valoarea literalului. Aceasta înseamnă că un singur obiect literal poate crea multe obiecte noi dacă literalul este plasat în corpul unei bucle sau funcție care va fi apelată în mod repetat și că valorile proprietăților acestor obiecte pot diferi unele de altele.

Crearea de obiecte folosind noul operator

Noul operator creează și inițializează un nou obiect. Această declarație trebuie să fie urmată de numele funcției. O funcție folosită în acest fel se numește constructor și servește la inițializarea noului creat a acestui obiect. JavaScript de bază include mulți constructori încorporați pentru crearea obiectelor limbajului de bază. De exemplu:

Var o = obiect nou(); // Creați un nou obiect gol: la fel ca () var a = new Array(); // Creați o matrice goală: la fel ca var d = new Date(); // Creați un obiect Date reprezentând ora curentă var r = new RegExp("js"); // Creați un obiect RegExp pentru operațiunile de potrivire a modelelor

În plus față de acești constructori încorporați, este posibil să definiți propriile funcții de constructor pentru a inițializa obiectele nou create. Cum se face acest lucru este descris în articolul următor.

Object.create()

Standardul ECMAScript 5 definește metoda Object.create(), care creează un nou obiect și folosește primul său argument ca prototip al acelui obiect. În plus, Object.create() poate lua un al doilea argument opțional care descrie proprietățile noului obiect.

Object.create() este o funcție statică, nu o metodă numită pe un anumit obiect. Pentru a apela această funcție, trebuie doar să îi transmiteți obiectul prototip dorit:

// obj moștenește proprietățile x și y var obj = Object.create((x:1, y:2));

Pentru a crea un obiect care nu are prototip, puteți trece null, dar în acest caz obiectul nou creat nu va moșteni nicio proprietate sau metode de bază, cum ar fi toString() (ceea ce înseamnă că acest obiect nu poate fi folosit în expresii cu operator +) :

// obj2 nu moștenește nicio proprietate sau metodă var obj2 = Object.create(null);

Dacă programul dvs. trebuie să creeze un obiect gol obișnuit (așa cum este returnat de o expresie literal() sau o nouă expresie Object(), transmite Object.prototype ca prim argument:

// obj3 este ca un obiect creat // folosind () sau nou Object() var obj3 = Object.create(Object.prototype);

Capacitatea de a crea obiecte noi cu prototipuri arbitrare (să spunem altfel: abilitatea de a crea „moștenitori” din orice obiecte) este un instrument puternic care poate fi simulat în ECMAScript 3 folosind funcția prezentată în exemplul de mai jos:

// inherit() returnează un obiect nou creat care moștenește proprietățile // obiectului prototip p. Utilizează funcția ECMAScript 5 Object.create() // dacă este definită, în caz contrar folosește o tehnică mai veche. funcția moștenire(p) (dacă (p == null) aruncă TypeError(); // p nu poate fi nulă dacă (Object.create) // Dacă Object.create() este definit... return Object.create(p ) ; // folosiți-l. var t = tipul p; // În caz contrar, aflați tipul și verificați-l dacă (t !== „obiect” && t !== „funcție”) aruncă TypeError(); funcția f() () ; // Definiți un constructor gol. f.prototype = p; // Setați proprietatea de prototip // la o referință la obiectul p. return new f(); // Folosiți f() pentru a crea // " succesorul" obiectului p. )

Implementarea funcției inherit() va avea mai mult sens odată ce vom cunoaște constructorii în articolul următor. Pentru moment, presupuneți doar că returnează un nou obiect care moștenește proprietățile obiectului din argument. Rețineți că inherit() nu este un înlocuitor complet pentru Object.create(): nu vă permite să creați obiecte fără un prototip și nu necesită un al doilea argument opțional așa cum face Object.create().

Obținerea și schimbarea proprietăților

Puteți obține valoarea unei proprietăți folosind operatorii punct (.) și paranteze pătrate (). În stânga operatorului trebuie să existe o expresie care returnează un obiect. Când utilizați operatorul punct, în dreapta ar trebui să existe un identificator simplu care să se potrivească cu numele proprietății. Când utilizați paranteze pătrate, parantezele pătrate trebuie să includă o expresie care returnează un șir care conține numele proprietății dorite:

// Obiect simplu var user = ( login:"kot86", nume:"Alexandr", varsta:26); var login = user.login; // Obține proprietatea „login” a obiectului utilizator var name = user.name; // Obține proprietatea „nume” a obiectului utilizator var age = user[„varsta”]; // Obține proprietatea „vârstă” a obiectului utilizator

Pentru a crea o proprietate nouă sau a modifica valoarea unei proprietăți existente, se folosesc și operatorii punct și paranteze drepte, ca în operațiunile de citire a valorilor proprietăților, dar expresia însăși este plasată în stânga operatorului de atribuire:

User.age = 28; // Schimbați valoarea proprietății „age” user["login"] = "kot84"; // Schimbați valoarea proprietății "login" user["surname"] = "Frolov"; // Creați o nouă proprietate "nume"

În ECMAScript 3, un identificator care urmează unui punct nu poate fi un cuvânt rezervat: nu puteți scrie un apel de proprietate la o.for sau o.class deoarece for este un cuvânt cheie și class este un cuvânt rezervat pentru utilizare ulterioară.

Dacă un obiect are proprietăți ale căror nume se potrivesc cu cuvintele rezervate, trebuie să utilizați notația dintre paranteze drepte pentru a le accesa: o["for"] și o["class"]. Standardul ECMAScript 5 relaxează această cerință (cum o fac deja unele implementări ECMAScript 3) și permite utilizarea cuvintelor rezervate după operatorul punct.

Prototipuri

Fiecare obiect din JavaScript are un al doilea obiect (sau nul, dar mult mai rar) asociat cu el. Acest al doilea obiect se numește prototip, iar primul obiect își moștenește proprietățile de la prototip.

Toate obiectele create folosind literale obiect au același obiect prototip, care poate fi referit într-un program JavaScript ca Object.prototype .

Obiectele create folosind cuvântul cheie nou și un apel de constructor primesc valoarea proprietății prototip a funcției de constructor ca prototip. Prin urmare, un obiect creat de noua Object() moștenește proprietățile Object.prototype ca și cum ar fi fost creat folosind un literal acolade (). În mod similar, prototipul unui obiect creat de new Array() este Array.prototype, iar prototipul unui obiect creat de new Date() este Date.prototype.

Object.prototype este unul dintre puținele obiecte care nu are un prototip: nu are proprietăți moștenite. Alte obiecte prototip sunt doar obiecte obișnuite care au propriile lor prototipuri.

Toți constructorii încorporați (și majoritatea constructorilor personalizați) moștenesc prototipul Object.prototype. De exemplu, Date.prototype moștenește proprietăți de la Object.prototype, deci un obiect Date creat de new Date() moștenește proprietăți atât de la Date.prototype, cât și de la Object.prototype. O astfel de secvență conectată de obiecte prototip se numește lanț de prototipuri.

Moştenire

Obiectele din JavaScript au multe „proprietăți proprii” și pot, de asemenea, să moștenească multe proprietăți de la obiectul lor prototip. Pentru a înțelege acest lucru, trebuie să studiați cu atenție mecanismul de acces la proprietate. Exemplele din această secțiune folosesc funcția inherit() prezentată mai sus pentru a crea obiecte cu prototipuri specifice.

Să presupunem că programul accesează proprietatea x a obiectului obj. Dacă obj nu are propria sa proprietate cu acest nume, se încearcă să caute proprietatea x în prototipul lui obj. Dacă obiectul prototip nu are propria sa proprietate cu acest nume, dar are propriul prototip, se încearcă căutarea proprietății în prototipul prototipului. Aceasta continuă până când se găsește proprietatea x sau se ajunge la un obiect care nu are prototip. După cum puteți vedea, atributul prototip al unui obiect creează un lanț sau lista legată obiecte de la care sunt moștenite proprietăți.

Var obj = (); // obj moștenește metodele obiectului Object.prototype obj.x = 1; // și are propria sa proprietate x. var p = mostenire(obj); // p moștenește proprietățile obiectelor obj și Object.prototype p.y = 2; // și are proprietatea proprie y. var q = mostenire(p); // q moștenește proprietățile obiectelor p, obj și Object.prototype q.z = 3; // și are proprietatea proprie z. var s = q.toString(); // toString moștenește de la Object.prototype var d = q.x + q.y // Rezultatul 3: x și y moștenesc de la obj și p

Acum să presupunem că programul atribuie o anumită valoare proprietății x a lui obj. Dacă obj are deja propria sa proprietate (nu moștenită) numită x, atunci operația de atribuire va schimba pur și simplu valoarea proprietății existente. În caz contrar, o nouă proprietate numită x va fi creată în obj. Dacă obj a moștenit anterior proprietatea x, proprietatea moștenită va fi acum ascunsă de o proprietate nou creată proprie cu același nume.

Operația de atribuire a unei valori unei proprietăți va verifica prezența acelei proprietăți în lanțul de prototipuri pentru a se asigura că atribuirea este validă. De exemplu, dacă obiectul obj moștenește proprietatea de numai citire x, atunci atribuirea nu va avea loc. Cu toate acestea, dacă atribuirea este validă, proprietatea este întotdeauna creată sau modificată în obiectul original și niciodată în lanțul de prototipuri. Faptul că mecanismul de moștenire funcționează la citirea proprietăților, dar nu funcționează la scrierea unor valori noi, este o caracteristică cheie a limbajului JavaScript, deoarece vă permite să suprascrieți selectiv proprietățile moștenite:

Var unitcercle = (r:1); // Obiectul de la care este moștenită proprietatea var c = inherit(unitcircle); // c moștenește proprietatea r c.x = 1; c.y = 1; // c definește două proprietăți proprii c.r = 2; // c suprascrie proprietatea moștenită console.log(unitcircle.r); // => 1: obiectul prototip nu s-a schimbat

Există o excepție de la această regulă, atunci când operația de atribuire a proprietăților eșuează sau are ca rezultat crearea/modificarea unei proprietăți pe obiectul original. Dacă obj moștenește proprietatea x și acea proprietate este accesată prin accesorii, atunci în loc să creeze o nouă proprietate x pe obj, este apelată o metodă de scriere a noii valori. Totuși, rețineți că metoda de scriere este apelată pe obj, nu pe prototipul în care este definită proprietatea, deci dacă metoda de scriere definește orice proprietăți, acestea vor fi instanțiate pe obj, iar lanțul de prototipuri va rămâne din nou neschimbat.

Erori de acces la proprietate

Expresiile de acces la proprietate nu returnează întotdeauna sau modifică valoarea unei proprietăți. Această secțiune descrie situații în care operațiunile de citire sau scriere a proprietăților eșuează.

O încercare de a accesa o proprietate inexistentă nu este considerată o eroare. Dacă proprietatea x nu este găsită printre proprietățile proprii sau moștenite ale obj, expresia de acces la proprietate obj.x va returna nedefinit.

Cu toate acestea, încercarea de a accesa o proprietate a unui obiect inexistent este considerată o eroare. Valorile nule și nedefinite nu au proprietăți, iar încercările de a accesa proprietățile acestor valori sunt considerate o eroare:

// Obiect simplu var user = ( login:"kot86", nume:"Alexandr", varsta:26); var a = utilizator.parolă; // nedefinit: lipsește proprietatea // Declanșează o excepție TypeError. // Valoarea nedefinită nu are o proprietate de lungime var len = user.password.length;

Dacă nu sunteți sigur că user și user.password sunt obiecte (sau se comportă ca niște obiecte), nu ar trebui să utilizați expresia user.password.length deoarece poate crea o excepție. Următoarele demonstrează două moduri de a vă proteja împotriva acestui tip de excepție:

// Mod mai vizual și direct var len = nedefinit; if (utilizator) ( if (user.password) len = user.password.length; ) // O alternativă mai concisă, specifică JavaScript // pentru obținerea lungimii valorii proprietății parolei var len = user && user. parola && user.password.length ;

Încercarea de a seta valoarea unei proprietăți la alte valori nu are întotdeauna succes: unele proprietăți sunt doar pentru citire și nu permit modificarea valorilor lor. În plus, unele obiecte nu vă permit să adăugați noi proprietăți la ele. Cu toate acestea, cel mai interesant lucru este că astfel de eșecuri, de regulă, nu duc la ridicarea unei excepții:

// Proprietățile prototipului constructorilor încorporați sunt doar pentru citire Object.prototype = 0; // Atribuirea nu va ridica o excepție; // valoarea Object.prototype nu se va schimba

Această defecțiune istorică JavaScript este remediată în modul strict definit de standardul ECMAScript 5. Toate încercări nereușite modificarea valorii unei proprietăți în modul strict are ca rezultat o excepție TypeError.

Regulile pentru a determina când o încercare de a efectua o operațiune de atribuire va reuși și când va eșua sunt simple și directe, dar greu de exprimat într-o manieră suficient de concisă. O încercare de a atribui o valoare proprietății p a obj va eșua în următoarele cazuri:

Obiectul obj are propria sa proprietate de numai citire p: nu puteți modifica valoarea unei proprietăți numai de citire. (Rețineți, totuși, că metoda defineProperty() este o excepție care vă permite să modificați valorile proprietăților personalizate numai pentru citire.)

Obiectul obj are o proprietate moștenită numai în citire p: proprietățile numai în citire moștenite nu pot fi înlocuite de propriile proprietăți cu aceleași nume.

Obiectul obj nu are proprietatea proprie p; obj nu moștenește proprietatea p cu metodele accesorii, iar atributul extensibil al lui obj este fals. Dacă proprietatea p nu este prezentă în obj și nu există nicio metodă de scriere definită pentru aceasta, atunci operația de atribuire va încerca să adauge proprietatea p la obj. Dar, deoarece obj nu este extensibil, încercarea de a adăuga o nouă proprietate la acesta va eșua.

Îndepărtarea proprietăților

Operator șterge elimină o proprietate dintr-un obiect. Singurul său operand trebuie să fie o expresie de acces la proprietate. Poate părea surprinzător, dar operatorul de ștergere nu afectează valoarea proprietății - operează pe proprietatea în sine:

// Obiect simplu var user = ( login:"kot86", nume:"Alexandr", varsta:26); șterge user.login; // Acum obiectul utilizator nu are o proprietate de conectare delete user["nume"]; // Acum obiectul utilizator nu are o proprietate de nume

Operatorul de ștergere șterge doar propriile proprietăți și nu le șterge pe cele moștenite. (Pentru a elimina o proprietate moștenită, trebuie să o eliminați din obiectul prototip în care este definită. Această operație va afecta toate obiectele care moștenesc acel prototip.)

Expresia de ștergere returnează true când proprietatea a fost ștearsă cu succes sau când operația de ștergere nu a schimbat obiectul (de exemplu, când se încearcă ștergerea unei proprietăți care nu există). Expresia de ștergere returnează, de asemenea, adevărată atunci când este transmisă o expresie care nu este o expresie de acces la proprietate:

Obj = (x:1); // obj are propria sa proprietate x și moștenește toString delete obj.x; //Șterge x și returnează true delete obj.x; //Nu face nimic (x nu există) și returnează true delete obj.toString; // Nu va face nimic (toString nu este proprietatea sa) și va returna true delete 1; // Inutil, dar va returna adevărat

Operatorul de ștergere nu șterge proprietățile neconfigurabile, atributul configurabil care are valoarea false. (Cu toate acestea, poate elimina proprietățile personalizate ale obiectelor neextensibile.) Proprietățile neconfigurabile sunt proprietăți încorporate ale obiectului, precum și proprietățile globale ale obiectelor create folosind declarații de variabile și funcții. Încercarea de a elimina o proprietate neconfigurabilă în modul strict generează o TypeError. În modul non-strict (și în implementările ECMAScript 3), operatorul de ștergere returnează pur și simplu false în astfel de cazuri:

Șterge Object.prototype; // Eliminarea nu este posibilă - proprietatea neconfigurabilă var x = 1; // Declararea unei variabile globale delete this.x; // Această proprietate nu poate fi ștearsă funcția f() () // Declarație globală a funcției delete this.f; // Nici această proprietate nu poate fi ștearsă

Verificarea existentei proprietatilor

Obiectele din JavaScript pot fi gândite ca seturi de proprietăți și este adesea util să poți testa apartenența la un set - pentru a verifica dacă un obiect are o proprietate cu un nume dat. Puteți efectua o astfel de verificare folosind operatorul în, folosind metode hasOwnProperty()Și propertyIsEnumerable() sau pur și simplu prin accesarea proprietății.

Operatorul in cere să i se dea un nume de proprietate (sub formă de șir) ca operand stânga și un obiect ca operand din dreapta. Returnează adevărat dacă obiectul are proprietatea proprie sau moștenită cu acest nume:

Var obj = ( x:1 ) "x" în obj; // adevărat: obj are propria sa proprietate „x” „y” în obj; // false: obj nu are proprietatea „y” „toString” în obj; // true: obj moștenește proprietatea toString

Metoda hasOwnProperty() a unui obiect verifică dacă obiectul are propria sa proprietate cu numele specificat. Pentru proprietățile moștenite, returnează false:

Var obj = ( x:1 ) obj.hasOwnProperty("x"); // true: obj are propria sa proprietate "x" obj.hasOwnProperty("y"); // false: obj nu are proprietatea "y" obj.hasOwnProperty("toString"); // false: toString - proprietate moștenită

Metoda propertyIsEnumerable() impune restricții suplimentare în comparație cu hasOwnProperty(). Returnează true numai dacă proprietatea specificată este o proprietate nativă al cărei atribut enumerabil este setat la true. Proprietățile obiectelor încorporate nu sunt enumerabile. Proprietățile create de un program JavaScript obișnuit sunt enumerabile, cu excepția cazului în care una dintre metodele ECMAScript 5 de mai jos a fost utilizată pentru a face proprietățile nenumerabile.

Adesea, în loc de operatorul in, este suficient să folosiți o expresie simplă de acces la proprietate și să utilizați operatorul !== pentru a verifica inegalitatea cu valoarea nedefinită:

Var obj = ( x:1 ) obj.x !== nedefinit; // adevărat: obj are proprietatea "x" obj.y !== nedefinit; // false: obj nu are proprietatea "y" obj.toString !== nedefinit; // true: obj moștenește proprietatea toString

Cu toate acestea, operatorul in distinge situațiile care nu se pot distinge folosind tehnica bazată pe proprietăți prezentată mai sus. Operatorul in distinge absența unei proprietăți de o proprietate care are valoarea nedefinită.

Enumerarea proprietăților

În loc să verificați proprietățile individuale, uneori doriți să iterați peste toate proprietățile existente sau să obțineți o listă cu toate proprietățile unui obiect. Acest lucru se face de obicei folosind o buclă for/in, dar standardul ECMAScript 5 oferă două alternative convenabile.

Instrucțiunea for/in loop execută corpul buclei pentru fiecare proprietate enumerabilă (fie proprie, fie moștenită) a obiectului specificat, atribuind numele proprietății unei variabile de buclă. Metodele încorporate moștenite de obiecte nu sunt enumerabile, iar proprietățile adăugate obiectelor de către programul dvs. sunt enumerabile (cu excepția cazului în care utilizați funcțiile descrise mai jos pentru a face proprietățile nenumerabile). De exemplu:

// Un obiect simplu cu trei proprietăți enumerabile var user = ( login:"kot86", nume:"Alexandr", vârsta:26); user.propertyIsEnumerable("toString"); // false, toString - metoda încorporată pentru (n în utilizator) console.log(n);

Unele biblioteci adaugă metode noi (sau alte proprietăți) obiectului Object.prototype, astfel încât acestea să poată fi moștenite și puse la dispoziție pentru toate obiectele. Cu toate acestea, până la standardul ECMAScript 5, nu a existat nicio modalitate de a face aceste metode suplimentare nenumerabile, așa că au ajuns să fie enumerate în bucle for/in. Pentru a rezolva această problemă, poate fi necesar să filtrați proprietățile returnate de bucla for/in. Mai jos sunt două exemple de implementare a unei astfel de filtre:

Pentru (n în utilizator) ( dacă (!user.hasOwnProperty(n)) continuă; console.log(n); ) pentru (n în utilizator) ( dacă (tip de utilizator[n] === „funcție”) continuă; console.log(n); )

În plus față de bucla for/in, standardul ECMAScript 5 definește două funcții care enumerează numele proprietăților. Primul dintre ei, Object.keys(), returnează o matrice de nume ale proprietăților enumerabile ale obiectului.

A doua funcție ECMAScript 5 care realizează enumerarea proprietăților este Object.getOwnPropertyNames(). Acționează ca funcția Object.keys(), dar returnează numele tuturor proprietăților proprii ale obiectului specificat, nu doar ale celor enumerabile. Implementările ECMAScript 3 nu au capacitatea de a implementa o astfel de funcționalitate deoarece ECMAScript 3 nu oferă capacitatea de a obține proprietăți nenumerabile ale unui obiect.

Metode de citire și scriere proprietăți

S-a spus deja mai sus că o proprietate de obiect are un nume, o valoare și un set de atribute. În ECMAScript 5, o valoare poate fi înlocuită cu una sau două metode, cunoscute sub numele de metode citește (getter)Și înregistrări (setter). Proprietățile pentru care sunt definite metode de citire și scriere sunt uneori numite proprietăți cu metode de acces pentru a le distinge de proprietățile datelor care reprezintă o valoare simplă.

Când un program încearcă să obțină valoarea unei proprietăți cu metode accesorii, interpretul apelează metoda read (fără argumente). Valoarea returnată de această metodă devine valoarea expresiei de acces la proprietate. Când un program încearcă să scrie o valoare într-o proprietate, interpretul apelează metoda write, pasând-i valoarea în dreapta operatorului de atribuire. Această metodă este responsabilă pentru „setarea” valorii proprietății. Valoarea returnată de metoda write este ignorată.

Spre deosebire de proprietățile datelor, proprietățile accesoriilor nu au un atribut care poate fi scris. Dacă o proprietate are atât metode de citire, cât și de scriere, este citire/scriere. Dacă o proprietate are doar o metodă de citire, este doar citire. Și dacă o proprietate are doar o metodă de scriere, este doar de scriere (acest lucru nu este posibil pentru proprietățile de date) și încercările de a citi valoarea unei astfel de proprietăți vor returna întotdeauna nedefinite.

Cel mai simplu mod de a defini o proprietate cu metode accesorii este de a folosi sintaxa de definiție literală a obiectului extins:

Var obj = ( // Proprietatea normală a datelor data_prop: valoare, // O proprietate cu metode de acces este definită ca o pereche de funcții get accessor_prop() ( /* corpul funcției */ ), set accessor_prop(valoare) ( ​​/* corpul funcției */ ) );

Proprietățile cu metode accesorii sunt definite ca una sau două funcții ale căror nume sunt aceleași cu numele proprietății și cu cuvântul cheie al funcției înlocuit cu get și/sau set.

Rețineți că nu vi se cere să utilizați două puncte pentru a separa numele proprietății de funcția care controlează accesul la proprietate, dar vi se cere totuși să utilizați o virgulă după corpul funcției pentru a separa metoda de alte metode sau proprietăți de date.

Ca exemplu, luați în considerare următorul obiect, care reprezintă coordonatele carteziene ale unui punct dintr-un plan. Are proprietățile obișnuite de date pentru a reprezenta coordonatele X și Y, precum și proprietăți cu metode accesorii pentru a obține coordonatele polare echivalente ale unui punct:

Var p = ( // x și y sunt proprietăți de date obișnuite, citire/scriere x: 1.0, y: 1.0, // r este o proprietate de citire/scriere cu două metode de acces. // Nu uitați să adăugați virgule după accesul metodelor get r() ( return Math.sqrt(this.x*this.x + this.y*this.y); ), set r(newvalue) ( ​​​​var oldvalue = Math.sqrt(this.x* this.x + this.y*this.y); var ratio = newvalue/oldvalue; this.x *= ratio; this.y *= ratio; ), // theta este o proprietate numai pentru citire cu singura metoda citește get theta() ( return Math.atan2(this.y, this.x); ) );

Rețineți utilizarea cuvântului cheie this în metodele de citire și scriere de mai sus. Interpretul va numi aceste funcții ca metode ale obiectului în care sunt definite, adică. în corpul funcției, aceasta se va referi la obiectul punct. Acest lucru permite metodei de citire a proprietății r să facă referire la proprietățile x și y, precum this.x and this.y.

Proprietățile cu metode accesorii sunt moștenite la fel ca proprietățile obișnuite ale datelor, astfel încât obiectul p definit mai sus poate fi folosit ca prototip pentru alte obiecte punct. Noile obiecte își pot defini propriile proprietăți x și y și vor moșteni proprietățile r și theta.

Atributele obiectului

Toate obiectele au atribute prototip, clasă și extensibile. Toate aceste atribute sunt descrise în subsecțiunile de mai jos.

atribut prototip

Atributul prototip al unui obiect specifică obiectul de la care sunt moștenite proprietățile. Este important să înțelegeți că atunci când codul programului Există o referință prototip, aceasta denotă o proprietate obișnuită a unui obiect, și nu atributul prototip.

Atributul prototip este setat atunci când obiectul este creat. Pentru obiectele create folosind literale, prototipul este Object.prototype. Prototipul unui obiect creat folosind operatorul new este valoarea proprietății prototip a constructorului. Iar prototipul obiectului creat folosind Object.create() este primul argument al acestei funcții (care poate fi nulă).

Standardul ECMAScript 5 oferă capacitatea de a defini prototipul oricărui obiect prin trecerea acestuia la o metodă Object.getPrototypeOf(). ECMAScript 3 nu are o funcție echivalentă, dar puteți defini adesea prototipul obj folosind expresia obj.constructor.prototype.

Obiectele create folosind operatorul nou moștenesc de obicei proprietatea constructor O referință la funcția de constructor folosită pentru a crea obiectul. Și așa cum am menționat mai sus, funcțiile de constructor au o proprietate prototip, care definește prototipul obiectelor create folosind acest constructor.

Rețineți că obiectele create folosind literalmente obiect sau Object.create() primesc o proprietate de constructor care se referă la constructorul Object(). Astfel, constructor.prototype se referă la adevăratul prototip pentru literalele obiect, dar de obicei nu este cazul obiectelor create prin apelarea Object.create().

Pentru a determina dacă un obiect este un prototip (sau o verigă dintr-un lanț de prototipuri) al altui obiect, utilizați metoda isPrototypeOf(). Pentru a afla dacă p este prototipul obj, trebuie să scrieți expresia p.isPrototypeOf(obj). De exemplu:

Var p = (x:1); // Definiți un obiect prototip. var obj = Object.create(p); // Creați un obiect cu acest prototip. p.isPrototypeOf(obj); // => adevărat: obj moștenește p Object.prototype.isPrototypeOf(p); // => adevărat: p moștenește Object.prototype

atribut de clasă

Atributul de clasă al unui obiect este un șir care conține informații despre tipul obiectului. Nici ECMAScript 3, nici ECMAScript 5 nu oferă posibilitatea de a schimba acest atribut și oferă doar modalități indirecte de a-i determina valoarea. În mod implicit, metoda toString() (moștenită de la Object.prototype) returnează un șir ca:

Prin urmare, pentru a determina clasa unui obiect, puteți încerca să apelați metoda toString() a acestui obiect și să extrageți subșirul de la al optulea până la penultimul caracter din rezultat. Partea dificilă este că multe metode moștenesc de la alte implementări mai utile ale toString(), iar pentru a apela versiunea corectă a toString() trebuie să efectuați un apel indirect folosind metoda Function.call().

Exemplul de mai jos definește o funcție care returnează clasa oricărui obiect care i-a fost transmis:

// Numele funcției clasei de obiect classof(obj) ( if (obj === null) return "Null"; if (obj === undefined) return "Undefined"; return Object.prototype.toString.call(obj) .slice (8,-1); )

Această funcție classof() poate primi orice valoare permisă în JavaScript. Numerele, șirurile de caractere și valorile booleene acționează ca obiecte atunci când toString() este apelat pe ele, dar valorile nule și nedefinite sunt tratate diferit.

atribut extensibil

Atributul extensibil al unui obiect determină dacă noi proprietăți pot fi adăugate obiectului. În ECMAScript 3, toate obiectele încorporate și definite de utilizator erau implicit extensibile, iar extensibilitatea obiectelor runtime era specifică implementării. În ECMAScript 5, toate obiectele încorporate și definite de utilizator sunt extensibile, cu excepția cazului în care au fost convertite în obiecte neextensibile, iar extensibilitatea obiectelor de execuție este încă specifică implementării.

Standardul ECMAScript 5 definește funcții pentru obținerea și modificarea atributului de extensibilitate al unui obiect. Pentru a determina dacă un obiect poate fi extins, trebuie să-l transmiteți metodei Object.isExtensible(). Pentru a face un obiect neextensibil, trebuie să-l transmiteți unei metode Object.preventExtensions(). Rețineți că, odată ce un obiect este făcut non-extensibil, nu poate fi făcut din nou extensibil. Rețineți, de asemenea, că apelul la preventExtensions() afectează doar extensibilitatea obiectului în sine. Dacă sunt adăugate noi proprietăți la prototipul unui obiect neextensibil, obiectul neextensibil va moșteni acele noi proprietăți.

Scopul atributului extensibil este de a face posibilă „repararea” obiectelor într-o anumită stare, interzicând modificările. Atributul extensibil al obiectelor este adesea folosit împreună cu atributele de proprietate configurabile și inscriptibile, astfel încât ECMAScript 5 definește funcții care facilitează setarea acestor atribute în același timp.

Metodă Object.seal() acționează ca metoda Object.preventExtensions(), dar nu numai că face obiectul neextensibil, ci face și toate proprietățile obiectului neconfigurabile. Adică, proprietăți noi nu pot fi adăugate la obiect și proprietățile existente nu pot fi șterse sau configurate. Cu toate acestea, proprietățile inscriptibile existente pot fi încă modificate.

Odată ce Object.seal() este apelat, obiectul nu poate fi returnat la starea anterioară. Pentru a determina dacă metoda Object.seal() a fost apelată pe un obiect, puteți apela metoda Object.isSealed().

Metodă Object.freeze() asigură o fixare și mai rigidă a obiectelor. Pe lângă faptul că face obiectul neextensibil și proprietățile sale neconfigurabile, face, de asemenea, toate proprietățile native ale datelor doar în citire. (Acest lucru nu se aplică proprietăților obiectului cu metode accesorii care au metode de scriere; acele metode vor fi în continuare apelate prin instrucțiuni de atribuire.) Pentru a determina dacă metoda Object.freeze() a obiectului a fost apelată, puteți apela Object.isFrozen().

Este important să înțelegeți că Object.seal() și Object.freeze() afectează doar obiectul care le este transmis: nu afectează prototipul acelui obiect. Dacă programul dvs. trebuie să comite complet un obiect, probabil că va trebui să capturați și obiectele din lanțul de prototipuri.

Serializarea obiectelor

Serializarea obiectelor este procesul de conversie a obiectelor într-o formă de reprezentare șir, care poate fi folosită ulterior pentru a le restaura. ECMAScript 5 oferă funcții încorporate pentru serializarea și restaurarea obiectelor JavaScript JSON.stringify()Și JSON.parse(). Aceste funcții folosesc formatul de schimb de date JSON. Numele JSON provine de la " Obiect JavaScript Notație" (o formă de notație pentru obiectele JavaScript), iar sintaxa acestei forme de notație amintește de sintaxa literalelor obiect și matrice în limbajul JavaScript:

Var obj = (x:1, y:(z:)); // Definiți un obiect de testare var s = JSON.stringify(obj); // s == "("x":1,"y":("z":))" var p = JSON.parse(s); // p - copie a obiectului obj

Sintaxa formatului JSON este doar un subset al sintaxei JavaScript și nu poate fi utilizată pentru a reprezenta toate valorile posibile permise în JavaScript. Suportat și poate fi serializat și restaurat: obiecte, matrice, șiruri de caractere, valori numerice finite, adevărat, fals și nul. Valorile NaN, Infinity și -Infinity sunt serializate la nul. Obiectele date sunt serializate în șiruri de date ISO, dar JSON.parse() le lasă în reprezentarea lor și nu restaurează obiectele originale Date.

Obiectele Function, RegExp și Error și valoarea nedefinită nu pot fi serializate sau restaurate. Funcția JSON.stringify() serializează numai proprietățile native enumerabile ale unui obiect. Dacă valoarea unei proprietăți nu poate fi serializată, proprietatea este pur și simplu exclusă din reprezentarea șirului. Atât JSON.stringify() cât și JSON.parse() au un al doilea argument opțional care poate fi utilizat pentru a personaliza procesul de serializare și/sau recuperare, de exemplu prin definirea unei liste de proprietăți care urmează să fie serializate sau a unei funcții pentru transformarea valorilor în timpul serializării.

depp 7 ianuarie 2009 la 23:56

Lucrul cu obiecte în JavaScript: teorie și practică

• JavaScript

În acest articol, vreau să vorbesc cât mai complet și consecvent posibil despre ce este un obiect în JavaScript, care sunt capabilitățile acestuia, ce relații pot fi construite între obiecte și ce metode de moștenire „nativă” decurg din aceasta, cum afectează toate acestea. performanta si ce sa faci in general cu toate astea :)

Articolul NU va avea un cuvânt despre: emularea paradigmei tradiționale de clasă-obiect, zahăr sintactic, învelișuri și cadre.

Complexitatea materialului va crește de la începutul până la sfârșitul articolului, așa că pentru profesioniști primele părți pot părea plictisitoare și banale, dar apoi va fi mult mai interesant :)

Obiecte în JavaScript

Într-adevăr, mult în limbaj este un obiect și chiar și ceea ce nu este un obiect poate avea unele dintre capacitățile sale.

Este important să înțelegem că cuvântul „obiect” este folosit aici nu în sensul „un obiect al unei clase”. Un obiect în JavaScript este în primul rând doar o colecție de proprietăți (dacă preferați, îl puteți numi o matrice sau o listă asociativă) constând din perechi cheie-valoare. Mai mult, cheia poate fi doar un șir (chiar și pentru elemente de matrice), dar valoarea poate fi orice tip de date enumerate mai jos.

Deci, în JavaScript există 6 tipuri de bază datele sunt Nedefinite (indicând absența unei valori), Null, Boolean (Boolean), String (șir), Number (număr) și Object (obiect).
Mai mult, primele 5 sunt primitiv tipuri de date, dar Object nu este. În plus, putem considera convențional că tipul Object are „subtipuri”: matrice (Matrice), funcție (Funcție), expresie regulată (RegExp) și altele.
Aceasta este o descriere oarecum simplificată, dar în practică este de obicei suficientă.

În plus, tipurile primitive String, Number și Boolean sunt legate în anumite moduri de „subtipurile” neprimitive ale Object: String, Number și, respectiv, Boolean.
Aceasta înseamnă că șirul „Hello, world”, de exemplu, poate fi creat fie ca valoare primitivă, fie ca obiect String.
Pe scurt, acest lucru se face astfel încât programatorul să poată folosi metode și proprietăți atunci când lucrează cu valori primitive ca și cum ar fi obiecte. Puteți citi mai multe despre acest lucru în secțiunea corespunzătoare a acestui articol.

Lucrați de pe link

test= funcția () (alertă ("Bună ziua!" )) //Creează o funcție (alertă ("Bună ziua!")) (și o funcție, după cum ne amintim, este un obiect cu drepturi depline) și face din variabila de test o referință la ea
test_link=test; //test_link se referă acum și la funcția noastră
Test(); //Buna ziua!
test_link(); //Buna ziua!

Funcția noastră, ca orice alt obiect, este pur și simplu o zonă din memorie și toate referințele la această zonă sunt absolut echivalente. Mai mult decât atât, este posibil ca obiectul să nu aibă deloc referințe - în acest caz se numește anonim și poate fi folosit numai imediat după creare (de exemplu, trecut la o funcție), altfel va fi imposibil de accesat și va fi în curând fi distrus de garbage collector (colectare de gunoi), care este responsabil pentru ștergerea obiectelor fără referințe.

Să vedem de ce este atât de important să înțelegem asta:

test=(prop: "un text") //Creează un obiect cu proprietatea prop
test_link=test; //Creează un alt link către acest obiect

Alert(test.prop); //un text

//Modifică proprietatea obiectului
test_link.prop="newtext" ;

Alert(test.prop); //text nou
alert(test_link.prop); //text nou
/*S-ar putea spune că proprietatea s-a schimbat atât aici, cât și acolo - dar nu este așa.
Există un singur obiect. Deci proprietatea s-a schimbat o dată pe ea, iar linkurile continuă doar să indice acolo unde indică. */

//Adăugați o nouă proprietate și eliminați-o pe cea veche
test.new_prop="bună ziua" ;
şterge test.prop;

Alertă(test_link.prop); //undefined - această proprietate nu mai există
alert(test_link.new_prop);

//Ștergeți linkul
sterge testul;
alert(test.new_prop);
/*În acest moment, scriptul va arunca o eroare, deoarece testul nu mai există, iar test.new_prop nu există cu atât mai mult */
alert(test_link.new_prop); //Buna ziua
/* dar aici totul este în ordine, pentru că nu am șters obiectul în sine, ci doar un link către el. Acum obiectul nostru este indicat de un singur link, test_link */

//Creează un nou obiect
test=test_link; //Mai întâi, creați din nou legătura de testare
test_link=(prop: "un text" ) //Și aici este noul obiect

Alertă(test_link.prop); //un text
alert(test.prop); //nedefinit
/* Crearea unui nou obiect rupe legătura de referință, iar acum test și test_link indică diferite obiecte.
De fapt, acest lucru este echivalent cu ștergerea test_link-ului și crearea lui din nou, dar arătând către un obiect diferit */
alert(test.new_prop); //bună ziua - acum testul conține un link către primul nostru obiect

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

De asemenea, este de remarcat faptul că lucrul cu obiecte prin referință, pe lângă efectele distractive enumerate mai sus, oferă și economii semnificative de memorie, ceea ce este important atunci când un obiect este utilizat pe scară largă în diferite locuri din program.

Valori primitive

obj= new String(„bună ziua”); //Creează un șir ca obiect
simplu="bună ziua"; //Creează o valoare primitivă

Alerta(obj); //Buna ziua
alertă (simplu); //bună ziua - până acum totul este previzibil

Alerta(lungimea obiectului); //6 - un obiect de tip String are o proprietate length care stochează lungimea șirului
alert(simple.length); //6
/* Deși simplu nu este un obiect, putem accesa același set de proprietăți ca și un obiect de tip String. Este destul de convenabil */

Obj.prop="text" ;
simple.prop="text" ;

Alert(obj.prop); //text - deoarece obj este un obiect obișnuit, îi putem oferi cu ușurință o altă proprietate
alert(simple.prop); //nedefinit - dar simplu nu este un obiect, iar acest număr nu va funcționa pentru noi

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Nu confundați utilizarea valorilor primitive cu utilizarea literalelor - de exemplu, dacă creăm o matrice ca „test=new Array()” sau ca „test=", rezultatul va fi în continuare același obiect. Nu vom primi nicio valoare primitivă.

Crearea și utilizarea obiectelor

test=(
simple_property: „Bună ziua”,
proprietate_obiect: (
user_1: „Petya” ,
user_2: „Vasya”
},
function_property: function (utilizator) (
alert(acest .simple_property + ", " + this .object_property);
}
}

Test.function_property("user_1" ); //Bună, Petya.

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Funcția noastră folosește de două ori cuvântul cheie this, care este un pointer (adică, o referință) la obiectul de la care este apelată funcția. Astfel, this.simple_property=test.simple_property="Bună ziua", și this.object_property=test.object_property="Peter".

Este important să fie clar că acest lucru indică întotdeauna obiectul de la care este apelată funcția și nu obiectul căruia îi aparține. Deși în acest exemplu sunt același obiect, nu este întotdeauna cazul.

test.function_property("utilizator_1"); //Bună, Petya.

Test2=Obiect nou(); //O altă formă de a crea un obiect nou, similar cu test2=()

Test.function_property.call(test2, "user_1" ); //eroare
/* Metoda de apel vă permite să apelați o funcție în numele altui obiect. ÎN în acest caz,, numim metoda function_property a obiectului de testare, iar aceasta nu mai indică la obiectul de testare, ci la obiectul test2. Și pentru că nu are proprietatea object_property, atunci când încercați să obțineți this.object_property scriptul va arunca o eroare */

//să încercăm să remediam situația
test2.simple_property="O zi bună" ;
test2.object_property=test.object_property; //În acest caz, vom folosi specificarea obiectului prin referință pentru a nu duplica codul

Test.function_property.call(test2, "user_1" ); //Bună ziua, Petya.

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Constructor

Un designer ne va veni în ajutor. Un constructor în JavaScript nu face parte dintr-o clasă (pentru că nu există clase), ci pur și simplu o funcție în sine. Cea mai comună funcție.

make_me= functie (_nume) (
alert("Am fost lansat");
acest .nume=_nume;

}

/* Să ne dăm seama ce se întâmplă aici. Interpretul vede noul operator și verifică ce este în dreapta acestuia. Deoarece make_me este o funcție și poate fi folosită ca constructor, apoi un nou obiect este creat în memorie și funcția make_me este lansată pentru execuție, iar acest lucru indică exact acest nou obiect. Apoi, acest obiect este adăugat cu o proprietate name, căruia i se atribuie valoarea din argumentul _name și o metodă show_name. De asemenea (nu știu în ce moment, dar nu contează) variabila copil începe să indice către obiectul nostru nou-nouț, tocmai născut */

Alerta(nume.copil); //Vasya
child.show_name(); //Vasya

child2.show_name(); //Petru

Child2.show_name=funcție () (alertă( „Nu îmi voi spune numele”);} //Nu uitați că ne putem schimba obiectele în orice moment
child2.show_name(); //Nu îmi voi spune numele

Child.show_name(); //Vasya - copiii nu se influențează între ei în niciun fel

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Dacă ne amintim descrierea tipurilor de date de la începutul articolului, devine clar că Object și subtipurile sale (Funcție, Matrice și altele) sunt de fapt constructori care conferă obiectului creat capabilitățile unei funcții, matrice etc.

Prototip

make_me= functie (_nume) (
alert("Am fost lansat");
acest .nume=_nume;
acest .show_name=funcție () (alertă (acest .nume);)
}
/*
Văzând cuvântul cheie al funcției, interpretul verifică codul din dreapta acestuia și așa mai departe. totul este ok - creează un nou obiect în memorie, care este și funcția noastră. Apoi, automat (fără intervenția programatorului) este creată o proprietate prototip pentru această funcție, care se referă la un obiect gol. Dacă am face acest lucru manual, ar arăta ca make_me.prototype=new Object();

Apoi, acestui obiect (indicat de proprietatea prototip) i se dă automat și o proprietate de constructor, indicând înapoi la funcție. Se pare că aceasta este o legătură ciclică.

Acum acest obiect, care poate fi descris ca (constructor: ... aici este o referință la o funcție...) este prototipul funcției.
*/

//Obiect - într-adevăr, un obiect
alert(typeof make_me.prototype.constructor); //Funcția este funcția noastră
alert(make_me.prototype.constructor === make_me); //Adevărat

//Adăugați o nouă metodă la prototipul funcției make_me

Copil=new make_me ("Vasya"); //Am fost lansat
/* Acum, pe lângă tot ceea ce este descris în exemplul anterior, o proprietate ascunsă suplimentară [] este creată în obiectul copil, care indică același obiect ca make_me.prototype. Deoarece Proprietatea este ascunsă, nu putem nici să-i vedem valoarea, nici să o schimbăm - cu toate acestea, joacă un rol important în lucrările ulterioare */

Alerta(nume.copil); //Vasya
child.show_name(); //Vasya

Child.set_name("Kolya");
/* În primul rând, interpretul caută metoda set_name în obiectul copil. Deoarece nu este acolo, continuă să caute în proprietatea child.[, o găsește acolo și o rulează. */
child.show_name(); //Kolya - acum numele lui Vasya este Kolya :)

Make_me.prototype.show_name2=funcție () (alertă ("Bună ziua, " + acest .nume;) //Deoarece un prototip este un obiect obișnuit, la fel de bine îl putem schimba din mers

Copil2=new make_me("Petya" );
copil2.show_name2(); //Bună, Petya
copil.show_name2(); //Bună, Kolya - modificările în prototip afectează nu numai obiectele nou create, ci și pe toate cele vechi

Child2.show_name2=funcție () (alertă( „Nu îmi voi spune numele”);} //Putem încă schimba obiectul în sine, în timp ce noua metodă show_name2 din acest obiect (și numai în el) este, parcă, „suprascrisă” metoda veche din prototip
copil2.show_name2(); //Nu îmi voi spune numele - pentru că... acum avem propria noastră metodă show_name2, apoi este numită, iar căutarea în prototip nu are loc

Child.show_name2(); //Bună ziua, Kolya - totul este la fel aici

Make_me.prototype=(prop: „bună ziua”) //Să încercăm să recreăm prototipul din nou

Alertă(copil.prop); //nedefinit
copil.show_name2(); //Bună Kolya
/* Dacă vă amintiți ce este lucrul prin referință, atunci totul este clar. Recrearea prototipului întrerupe conexiunea, iar acum proprietatea [] a obiectelor copil și child2 indică către un obiect (care era anterior prototipul funcției make_me), iar proprietatea make_me.prototype indică către un alt obiect, care este noul obiect. prototipul funcției make_me */

Child3=new make_me("Oleg" );
alert(copil3.prop); //bună ziua - așa cum era de așteptat

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Un pic despre terminologie
Atâta timp cât legătura primară dintre proiectant și prototip nu este întreruptă, putem observa următoarea imagine:

make_me= functie (_nume) (
alert("Am fost lansat");
acest .nume=_nume;
acest .show_name=funcție () (alertă (acest .nume);)
}

Make_me.prototype.set_name=funcție (_name) (acest .name=_name;)
copil=new make_me("Vasya" );

Alertă (tip de make_me.prototype); //obiect - funcția are o proprietate prototip
alert(tip de copil.prototip); //nedefinit - obiectul creat NU are o proprietate prototip
alert(child.constructor.prototype === make_me.prototype); //true - dar obiectul are o proprietate de constructor, care indică funcția de constructor make_me, care, la rândul său, are o proprietate de prototip

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Este întotdeauna necesar să înțelegem clar că, dacă vorbim despre prototipul constructorului, atunci aceasta este întotdeauna proprietatea prototipului, iar dacă vorbim despre prototipul obiectului creat, atunci aceasta este proprietatea ascunsă [].

Moştenire

pasăre= funcţie()() //Acesta este constructorul păsării
bird.prototype.cry=funcție ()(alertă(„Plânge!”);) //Pasarea poate striga
bird.prototype.fly=funcție ()(alertă(„zboară!”);) //și zboară

Duck=funcție () ()
duck.prototype=pasare noua();
duck.prototype.cry=funcție ()(alertă(„Cărlatan!” ;) //Rața țipă altfel
duck.prototype.constructor=rata; //Setați forțat proprietatea prototype.constructor la rață, deoarece altfel se va referi la pasăre

Billy = rata noua(); //Billy este rata noastră
billy.fly(); //Eu zbor! - Billy poate zbura pentru că este o pasăre.
billy.cry(); //Cărlatan, şarlatan! - Billy țipă șarlatan pentru că e o rață.

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Sarcina vedetă

make_me= funcţie()()
copil=nou make_me();
alert(child.toString()); //ieșiri

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

La rândul său, prototipul unui constructor Function este, de asemenea, un obiect, al cărui constructor este (surpriză!) Object (adică Function.prototype.[].constructor===Object), iar prototipul este un obiect care conține proprietățile standard. și metodele obiectului.cum ar fi toString, hasOwnProperty și altele (cu alte cuvinte - Function.prototype.[]["hasOwnProperty"] - aceasta este exact metoda pe care o putem folosi în toate obiectele derivate - și aceasta este metoda proprie a acestui obiect, și nu unul moștenit). În acest mod interesant descoperim că tot felul de obiecte sunt derivate din Object.

Putem continua mai departe? Se dovedește că nu. Object.prototype conține proprietățile de bază ale obiectului tocmai pentru că nu are propriul prototip. Object.prototype.[]=null; În acest moment, călătoria prin lanțul de prototipuri în căutarea unei proprietăți sau a unei metode se oprește.

O alta fapt interesant- constructorul Object este Function. Acestea. Object.[].constructor===Funcție.
Există o altă referință circulară - constructorul Object este Function, iar constructorul Function.prototype este Object.

Să revenim la exemplul nostru. Am înțeles deja cum este creată funcția, acum să trecem la a doua linie. Acolo creăm un obiect copil al cărui constructor este funcția make_me și al cărui prototip este make_me.prototype.

Ei bine, în a treia linie vedem cum interpretul urcă în lanț, de la copil la copil.[] (aka make_me.prototype), apoi la copil.[].[] (aka Object.prototype), și găsește deja acolo metoda toString, care lansează execuția.

Impurităţi

De exemplu, dacă dorim, nu putem folosi prototipuri deloc, ci programăm folosind conceptul de mixin. Pentru asta vom avea nevoie de vechii noștri prieteni buni - designeri.

//Acesta este un constructor uman
om=funcție() (
this .live=function ()(alerta ("Sunt live" ;) //Omul știe să trăiască
acest .walk=funcție ()(alertă(„Mă plimb” ;) //Omul poate merge
}

//Acesta este constructorul poetului
poet=funcție ()(
aceasta .kill=funcție ()(alertă( „Poetul a ucis un om”);} //Un poet poate ucide o persoană
acest .live=funcție ()(alertă(„Sunt mort” ;) //O persoană va muri din asta
}

Vladimir=om nou(); //Vladimir este bărbat
vladimir.live(); // Eu trăiesc - el este în viață
vladimir.walk(); //I'm walking - el merge

Poet.call(vladimir); //Execută poetul constructor pentru obiectul vladimir
vladimir.kill(); //Poetul a ucis un om
vladimir.live(); //Sunt mort

//Acum concentrează-te
man.call(vladimir);
vladimir.live(); //Eu traiesc

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Ce vedem în acest exemplu? În primul rând, este posibil să se moștenească de la mai multe obiecte care nu se află în aceeași ierarhie. În exemplu sunt 2, dar pot fi câte doriți.
În al doilea rând, nu există deloc ierarhie. Suprascrierea proprietăților și metodelor este determinată numai de ordinea în care sunt apelați constructorii.
În al treilea rând, aceasta este capacitatea de a schimba obiectul și mai dinamic și mai precis obiect separat, și nu toți copiii, ca la schimbarea prototipului.

Actualizare: Închideri și proprietăți private

Ce să faci acum cu toate astea

Mai mult decât atât, problema prețului este destul de nebanală, mai ales dacă vorbim de dezvoltare sub motor de cautare Versiunile Explorer 6 și 7.
1. Memorie - totul este simplu aici. În toate browserele, moștenirea pe prototipuri ocupă mult mai puțină memorie decât atunci când se creează metode prin constructori. Mai mult, cu cât avem mai multe metode și proprietăți, cu atât mai multa diferenta. Cu toate acestea, merită să ne amintim că, dacă nu avem o mie de obiecte identice, ci doar unul, atunci consumul de memorie va fi în orice caz mic, deoarece Există și alți factori de luat în considerare aici.
2. Timpul procesorului – aici principalele subtilități sunt legate în mod specific de browserele de la Microsoft.
Pe de o parte, obiectele în care metodele și proprietățile sunt create printr-un constructor pot fi create de multe ori (în unele cazuri de zeci și sute de ori) mai încet decât printr-un prototip. Cu cât sunt mai multe metode, cu atât este mai lent. Deci, dacă IE-ul tău se blochează pentru câteva secunde în timpul inițializării scriptului, există un motiv pentru a săpa în această direcție.

Pe de altă parte, metodele proprii ale unui obiect (cele create prin constructor) se pot executa puțin mai rapid decât metodele prototip. Dacă aveți nevoie disperată de a accelera execuția unei anumite metode în acest browser, atunci trebuie să țineți cont de acest lucru. Rețineți că apelul metodei (adică căutarea acestuia în obiect) este accelerat, nu execuția sa. Deci, dacă metoda în sine rulează pentru o secundă, atunci nu veți observa o creștere mare a performanței.

În alte browsere probleme similare Se observă că timpul pentru crearea obiectelor și apelarea metodelor acestora este aproximativ același pentru ambele abordări.

P.S. De obicei, în articole de acest fel, autorul oferă un fel de înveliș, fie încercând să implementeze moștenirea de clasă-obiect bazată pe moștenirea prototipică, fie pur și simplu zahăr sintactic pentru moștenirea prototipică. Nu fac asta în mod intenționat, pentru că... Cred că o persoană care înțelege semnificația acestui articol este capabilă să scrie orice pachet pentru sine și multe alte lucruri interesante :)

Etichete:

• OOP
• moştenire
• javascript