Lucrul cu obiecte în JavaScript: teorie și practică. Lucrul cu obiecte în javascript - Utilizarea funcțiilor - Teorie și practică. Ce este un obiect în JavaScript și ce capacități are?

Obiectele sunt piatra de temelie a JavaScript. Multe tipuri de date încorporate sunt reprezentate ca obiecte. Pentru a fi un dezvoltator JavaScript de succes, trebuie să înțelegeți clar modul în care funcționează. Blocurile de construcție ale unui obiect se numesc câmpurile sale sau proprietățile obiectului JavaScript. Sunt folosite pentru a descrie orice aspect al unui obiect. Proprietatea ar putea descrie lungimea unei liste, culoarea cerului sau data nașterii unei persoane. Crearea obiectelor este un proces ușor. Limbajul oferă o sintaxă cunoscută sub numele de literale obiect, care sunt notate cu acolade.

Accesarea Proprietăților

Limba oferă două intrări pentru accesarea proprietăților. Prima și cea mai comună este cunoscută sub numele de notație punct. În notație cu puncte, o resursă poate fi accesată specificând numele obiectului gazdă, urmat de punct și numele proprietății. De exemplu, când object.foo a fost setat inițial la unu, atunci valoarea sa va deveni 2 după ce instrucțiunea JavaScript objects este executată.

O sintaxă alternativă de acces este cunoscută sub numele de notație paranteze. În notație, numele obiectului este urmat de un set de paranteze drepte. În ele, numele proprietății este specificat ca șir:

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

Este mai expresiv decât notația cu puncte, deoarece permite unei variabile să specifice întregul sau parțial numele unei proprietăți. Acest lucru este posibil deoarece interpretul de obiect JavaScript convertește automat această expresie într-un șir și apoi obține proprietatea corespunzătoare. Numele proprietăților sunt create din mers prin concatenarea conținutului variabilei f cu șirul „oo”:

obiect = „bară”.

Notarea cu paranteze permite numelor de proprietăți să conțină caractere care sunt interzise în notația cu puncte. De exemplu, următoarea afirmație este complet legală între paranteze. Cu toate acestea, dacă utilizatorul încearcă să creeze același nume de proprietate în notație cu puncte, va întâlni o eroare de sintaxă:

obiect["!@#$% &*()."] = adevărat.

Proprietățile obiectelor JavaScript imbricate pot fi accesate prin înlănțuirea de puncte și/sau paranteze. De exemplu, următorul obiect conține un obiect imbricat numit baz care conține un alt obiect numit foo care are o proprietate numită bar care conține valoarea cinci:

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

Următoarele expresii accesează proprietatea atașată barei. Prima expresie folosește notația punct, în timp ce a doua expresie folosește notația pătrată. A treia expresie combină ambele intrări pentru a obține același rezultat:

• obiect.baz.foo.bar;
• obiect["baz"]["foo"]["bar"];
• obiect["baz"].foo["bar"].

Expresii precum cele prezentate în exemplul anterior pot cauza degradarea performanței dacă sunt utilizate incorect și pot duce la eșecul obiectului JavaScript. Evaluarea fiecărei expresii punct sau paranteză necesită timp. Dacă aceeași proprietate este folosită de mai multe ori, atunci este logic să accesați proprietatea o dată și apoi să stocați valoarea într-o variabilă locală pentru toate utilizările viitoare.

Funcționează ca metodă

Când o funcție este folosită ca proprietate a unui obiect, se numește metodă. La fel ca și proprietățile, ele sunt specificate în notația literală a obiectului. De exemplu:

var obiect = ( suma: function(foo, bar) ( return foo + bar; ) ).

Metodele obiectelor JavaScript pot fi apelate folosind semne și paranteze. Următorul exemplu apelează metoda sum() din exemplul anterior folosind ambele intrări:

• obiect.sumă(1, 2);
• obiect[„sumă”](1, 2).

Notația literală a obiectelor este utilă pentru crearea de noi obiecte, dar nu poate adăuga proprietăți sau metode celor existente. Din fericire, adăugarea de date noi este la fel de ușoară ca și crearea unei declarații de atribuire. Este creat un obiect gol. Apoi, folosind operatori de atribuire, adăugăm două proprietăți, foo și bar, și metoda baz:

• var obiect = ();
• obiect.foo = 1;
• obiect.bar = nul;
• object.baz = function() ( returnează „bună ziua de la baz()”; ).

Încapsularea programului

Ideea de bază a programării orientate pe obiect este de a împărți programele în părți mai mici și de a face fiecare parte responsabilă pentru gestionarea propriei stări. Astfel, unele cunoștințe despre cum funcționează o parte a unui program pot fi locale acelei părți. Cineva care lucrează la restul programului nu ar trebui să-și amintească sau chiar să știe despre el. Ori de câte ori aceste date locale se modifică, trebuie actualizat doar codul imediat din jurul lor.

Diferitele părți ale unui astfel de program interacționează între ele prin interfețe, seturi limitate funcții sau legături care oferă funcționalitate utilă la un nivel mai abstract în timp ce ascund implementarea lor exactă. Astfel de părți ale unui program sunt modelate folosind obiecte. Interfața lor constă dintr-un set specific de metode și proprietăți. Proprietățile care fac parte dintr-o interfață sunt numite publice. Restul, care nu ar trebui să atingă codul extern, se numesc private.

Multe limbi oferă posibilitatea de a distinge între proprietățile publice și private și nu permit codului extern să acceseze cele private. JavaScript, care adoptă din nou o abordare minimalistă, nu există încă. În prezent se lucrează pentru adăugarea acestei limbi. Prin urmare, programatorii JavaScript vor folosi cu succes această idee. De obicei, interfață accesibilă descrise în documentație sau comentarii. De asemenea, este o practică obișnuită să plasați o liniuță de subliniere (_) la începutul numelor de proprietate pentru a indica faptul că proprietățile sunt private. Separarea interfeței de implementare este o idee grozavă. Aceasta se numește de obicei încapsulare.

Proprietăți

Un obiect cu paranteze (...) se numește un obiect literal. Puteți plasa imediat unele proprietăți între astfel de paranteze (...). De exemplu, perechi „cheie: valoare și așa mai departe”:

permite utilizatorului = ( // un nume de obiect: „Ioan”, // prin cheie „nume” să stocheze valoarea „ Ioan" age: 30 // by key "age" store value 30 }.!}

O proprietate are o cheie (cunoscută și ca „nume” sau „identificator”) înainte de două puncte „:” și o valoare în dreapta acesteia. Obiectul utilizator are două proprietăți. Obiectul utilizator JavaScript rezultat cu două fișiere semnate etichetate „nume” și „vârstă”. Puteți adăuga, șterge și citi fișiere din acesta în orice moment. Valorile proprietăților sunt accesate folosind notația cu puncte. Poate fi de orice tip. Puteți adăuga o valoare booleană. Pentru a elimina o proprietate, utilizați ștergere în cazul de eroare al unui obiect JavaScript.

Toate obiectele de eroare JavaScript sunt descendenți ai obiectului Error sau ai unui obiect moștenit:

Obiectul Error de sintaxă moștenește de la obiectul Error.

Eroare de analiză JSON a unui anumit tip de obiect Eroare de sintaxă.

Pentru a vă scufunda și mai profund în înțelegerea modului în care se confruntă aplicațiile erori JavaScript, familiarizați-vă mai bine cu Airbrake JavaScript - un instrument de urmărire a erorilor pentru alerte în timp real și o perspectivă instantanee asupra a ceea ce a mers prost cu codul dvs. JavaScript.

Mesaje de eroare pe care un utilizator le poate primi înainte de a șterge un obiect JavaScript:

Caracter de control greșit într-un șir literal.

Caracter greșit într-un șir literal.

Ieșire Unicode slabă.

Personaj de evadare prost.

Șir neterminat.

Cod nenumeric neașteptat.

Nu există numere după virgulă.

Număr fracționar neterminat.

Nu există numere după indicatorul de grad.

Nu există numere după semnul exponentului.

Partea exponențială nu are număr.

Sfârșitul neașteptat al datelor.

Neașteptat cuvânt cheie.

Un simbol neașteptat.

Sfârșitul datelor la citirea conținutului unui obiect.

Numele de proprietate așteptat sau „)”.

Proprietăți de calcul

Puteți utiliza paranteze drepte într-un obiect literal. Acestea se numesc proprietăți calculate. Un exemplu este dat mai jos.

Sensul unei proprietăți calculate este simplu: înseamnă că numele proprietății trebuie luat din fructe. Deci, dacă un vizitator introduce „măr”, punga va deveni (măr: 5). Puteți folosi expresii mai complexe între paranteze drepte:

lasă fructe = „măr”;

: 5 // bag.appleComputers = 5

Parantezele pătrate sunt mult mai puternice decât notația cu puncte. Acestea permit nume de proprietăți și variabile. Dar sunt și mai greoi de scris. Deci, de cele mai multe ori, când numele proprietăților sunt cunoscute și simple, se folosește un punct. Și dacă aveți nevoie de ceva mai complex, atunci treceți la paranteze drepte.

Rezervarea cuvintelor

O variabilă nu poate avea un nume egal cu unul dintre cuvintele rezervate, cum ar fi „pentru”, „lasă”, „întoarce”, etc. Dar atunci când sortați obiecte JavaScript, nu există o astfel de restricție.

În principiu, orice nume este permis, dar există unul special: „__proto__” primește un tratament special din motive istorice. De exemplu, nu îl puteți seta la o altă valoare decât un obiect:

obj.__proto__ = 5;

alert(obj.__proto__); // nu a funcționat conform intenției

După cum puteți vedea din cod, scopul primitivei 5 este ignorat. Aceasta poate fi o sursă de erori și chiar vulnerabilități dacă operatorul intenționează să stocheze perechi cheie-valoare arbitrare într-un obiect și să permită vizitatorului să specifice cheile. În acest caz, vizitatorul poate selecta „proto” ca cheie și poate adăuga JavaScript la obiect. Există o modalitate de a face obiecte tratate cu __proto__ ca o proprietate obișnuită. Există, de asemenea, o altă hartă a structurilor de date care acceptă chei arbitrare.

Proprietăți întregi

Termenul „proprietate întreg” înseamnă aici un șir care poate fi convertit dintr-un număr întreg fără modificare. Deci, de exemplu, „49” este un nume de proprietate întreg, deoarece atunci când este convertit într-un număr întreg și înapoi, este în continuare același. Dar „+49” și „1,2” nu sunt așa. Pe de altă parte, dacă cheile nu sunt întregi, atunci ele sunt listate în ordinea în care au fost create. Exemplu de mai jos.

Pentru a remedia problema cu codurile de apelare, puteți „trișa” făcând codurile incomplete. Adăugarea unui „+” (semnul plus) înainte de fiecare cod este suficientă. Acum va funcționa conform intenției.

Diferența dintre obiecte și primitive este că acestea sunt stocate și copiate „prin referință”. Valorile primitive sunt atribuite și copiate „ca valoare întreagă”. O variabilă stochează o „adresă în memorie” mai degrabă decât obiectul în sine sau o „referință” la acesta. Puteți utiliza orice variabilă pentru a accesa și modifica conținutul acesteia.

Exemplul de mai sus arată că există un singur obiect și un administrator care să se conecteze la el. Apoi, dacă o cheie diferită (utilizator) este folosită ulterior, utilizatorul va observa modificările.

Operatorii de egalitate == și egalitatea strictă === pentru obiecte funcționează în același mod. Două obiecte sunt egale numai dacă sunt același obiect. Pentru comparații precum obj1 > obj2 sau comparații cu primitivul obj == 5, obiectele sunt convertite în primitive. Sincer să fiu, astfel de comparații sunt foarte rar necesare și sunt de obicei rezultatul unei erori de codare.

Validare obiect JavaScript

Obiectele au acces la orice proprietate. Totuși, dacă nu există deloc, nu va fi o eroare. Doar accesarea unei proprietăți inexistente returnează nedefinit. Oferă o modalitate foarte comună de a testa o proprietate și de a o compara cu una nedefinită. Mai jos este un exemplu.

Folosind „în” pentru proprietățile care stochează nedefinit. De obicei, o verificare strictă de comparație „=== nedefinit” funcționează bine. Mânca un caz special când eșuează și „în” funcționează corect. Acesta este momentul în care o proprietate a unui obiect există, dar rămâne nedefinită.

În codul de mai sus, proprietatea obj.test există din punct de vedere tehnic. Prin urmare, operatorul de intrare funcționează corect. Situații de acest fel sunt foarte rare, deoarece nedefinit nu este de obicei atribuit. În cea mai mare parte, sunt utilizate valori „necunoscute” sau „vide” nule. Astfel, operatorul in este efectiv un invitat în cod.

buclă „for..in”.

Pentru a naviga prin toate tastele de la obiect la obiect, există formă specială buclă: pentru..în. Acesta este un lucru complet diferit de constructul for(;;).

Mai jos este un exemplu.

Vă rugăm să rețineți că toți constructorii „for” vă permit să declarați o variabilă de buclă în interiorul unei bucle ca o cheie let. Alternativ, puteți utiliza un alt nume de variabilă, cheie.

De exemplu, for(let prop in obj) este, de asemenea, utilizat pe scară largă.

Există o alternativă „paranteză pătrată” care funcționează cu orice șir.

Ideea aici necesită ca cheile obiectului JavaScript să fie un identificator de variabilă valid, ceea ce înseamnă că nu există spații sau alte restricții. Trebuie avut grijă să vă asigurați că linia din interiorul parantezelor este citată corect. Parantezele pătrate oferă, de asemenea, o modalitate de a obține numele proprietății din rezultatul oricărei expresii, spre deosebire de un șir literal dintr-o variabilă:

let key = „îi plac păsările”;

// la fel ca user["like birds"] = true;

utilizator = adevărat.

Aici variabila cheie poate fi calculată în timpul execuției și depinde de intrarea utilizatorului și apoi utilizată pentru a accesa proprietatea. Acest lucru oferă programatorilor mai multă flexibilitate. Notația cu puncte nu poate fi utilizată într-un mod similar, deoarece ar repeta peste obiectul JavaScript. Mai jos este un exemplu.

Const obiect

Un obiect const declarat poate fi modificat. Un exemplu este dat mai jos.

Ar putea părea că obiectul JavaScript din linia (*) ar arunca o eroare, dar nu este cazul. Acest lucru se datorează faptului că const captează valoarea utilizatorului însuși. Și aici utilizatorul păstrează o referință la același obiect tot timpul. Linia (*) intră în interiorul obiectului, nu este reatribuită utilizatorului. Const va da o eroare dacă încercați să setați utilizatorul și altceva. Clonarea și fuzionarea, Object.assign creează o altă referință la același obiect dacă trebuie duplicat. Acest lucru este, de asemenea, realizabil, dar puțin mai dificil, deoarece JavaScript nu are o metodă încorporată. De fapt, acest lucru este rareori necesar. Copierea prin referință este utilizată în majoritatea cazurilor. Dar dacă chiar aveți nevoie de acest lucru, atunci trebuie să creați un obiect JavaScript și să replicați structura unuia existent, copierea proprietăților acestuia la un nivel primitiv. Mai jos este un exemplu.

Și puteți folosi și metoda Object.assign pentru aceasta. Argumentele dest și src1, ..., srcN sunt obiecte. Copiază proprietățile tuturor obiectelor src1, ..., srcNINTO dest. Cu alte cuvinte, proprietățile tuturor argumentelor, începând de la al doilea, sunt copiate în primul. Apoi se întoarce în dest. De exemplu, îl puteți folosi pentru a combina mai multe obiecte într-unul singur.

Și puteți utiliza, de asemenea, Object.assign pentru a înlocui bucla simplă de clonare. Copiază toate proprietățile utilizatorului într-un obiect gol și îl returnează, la fel ca o buclă, dar mai scurtă. Până acum, s-a presupus că toate proprietățile utilizatorului sunt primitive. Dar proprietățile pot fi referințe la alte obiecte.

Pentru a remedia acest lucru, trebuie să utilizați o buclă de clonare care verifică fiecare valoare de utilizator și, dacă este un obiect, apoi îi reproduce structura. Aceasta se numește „clonare profundă”.

Există un algoritm standard de clonare profundă care se ocupă de cazul de mai sus și de cazuri mai complexe numite algoritm de clonare structurată. Pentru a evita reinventarea roții, puteți folosi o implementare funcțională din biblioteca JavaScript lodash, metoda se numește _.cloneDeep(obj).

Metode avansate

Dacă un programator trece peste un obiect și dorește să obțină toate proprietățile în aceeași ordine în care au fost adăugate, el se poate baza pe „ordonare specială”, în care proprietățile întregi sunt sortate și altele sunt formate în ordinea în care a fost creat obiectul JavaScript. .

Metodele avansate de obiecte se ocupă de concepte care sunt rareori utilizate în JavaScript. Acest lucru se datorează faptului că, în scenariile normale, aceste caracteristici puternice nu sunt necesare. Este posibil ca unele dintre aceste metode să nu funcționeze în browserele mai vechi, cum ar fi versiunile timpurii ale Netscape 4.

Prototipul ar putea fi folosit pentru a crea obiecte JavaScript și toate metodele mycircle, nu doar pe cele noi. Acest lucru are un impact mixt asupra performanței. Nu trebuie să stocheze copii separate ale metodelor pentru fiecare instanță de obiect, așa că ar putea necesita mai puțină memorie pentru a funcționa, dar browserul trebuie să caute domeniile actuale și părinte pentru a le găsi. Acest lucru poate duce la o latență extremă. În general, utilizatorul ar trebui să folosească ceea ce este adecvat pentru cod, mai degrabă decât să bazeze acea decizie pe performanță, cu excepția cazului în care are de-a face cu un mediu controlat foarte specific.

Returnează adevărat

În unele cazuri, poate fi necesar ca proprietatea unui obiect să fie legată de obiectul în sine sau de undeva în lanțul de prototipuri. În JavaScript, toate obiectele folosesc metoda hasOwnProperty, care returnează adevărat dacă acea proprietate este legată de instanță obiect separat. În acest caz, devine posibil să se verifice dacă constructorul unui obiect are aceeași proprietate cu aceeași valoare ca și instanța obiectului în sine. Acest lucru poate da rezultate incorecte dacă există proprietăți separate ale obiectului JavaScript cu aceeași valoare atât pentru instanța obiectului, cât și pentru prototipul circuitului. Metoda hasOwnProperty ia un singur parametru - numele proprietății ca șir.

Puteți crea metode private într-un mod similar. Este pur și simplu o funcție care este creată în interiorul unei funcții de constructor. Acest lucru poate părea confuz pentru unii, dar așa funcționează. O funcție privată poate fi apelată doar de către constructorul însuși sau prin metode care sunt definite pe linie. Ele pot fi folosite ca metode publice dacă sunt atribuite unui constructor public și accesate folosind metode publice ale obiectelor Javascript.

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

) var secretValue = "";

this.method1 = function () ( secretValue = " fara surprize";!}

this.method2 = cantBeSeen;

) var oneOb = new myob();

oneOb.method1();

//alertează „fără surprize” oneOb.method2();

//avertizează „fără surprize”.

Șablon de comandă

Obiectele de comandă permit sistemele slab cuplate prin separarea celor care emit o solicitare de obiecte și a celor care procesează efectiv cererea. Aceste cereri se numesc evenimente, iar codul care procesează cererile se numește handler de evenimente.

Să presupunem că creați aplicații care acceptă acțiunile din clipboard Cut, Copy and Paste. Aceste acțiuni pot fi declanșate în diferite moduri de-a lungul aplicației: prin sistemul de meniu, prin meniul contextual, de exemplu făcând clic dreapta pe câmp de text sau o comandă rapidă de la tastatură. Obiectele de comandă vă permit să centralizați procesarea acestor acțiuni, câte una pentru fiecare operație, când este necesară o singură comandă pentru a procesa toate cererile Cut, una pentru toate cererile Copy și una pentru toate cererile Paste.

Deoarece echipele centralizează toată procesarea, ele sunt adesea implicate în gestionarea funcțiilor de anulare pentru întreaga aplicație. Îmbunătățiri semnificative pot fi obținute prin utilizarea modernului Metode JavaScript rezultând aplicații mai eficiente, mai fiabile și mai ușor de întreținut.

Pentru a afla cum să faceți acest lucru, puteți utiliza șabloane JavaScript + jQuery. Acest pachet unic include JavaScript optimizat pentru toate șabloanele GoF folosind funcții mai avansate, cum ar fi spații de nume, prototipuri, module, obiecte funcționale, închideri, funcții anonime și multe altele. Dacă utilizatorii au nevoie de cele mai recente instrumente și tehnici pentru șabloanele JavaScript, șabloanele jQuery și arhitecturile de șabloane, atunci aceasta cea mai bună opțiune utilizare. Acest pachet conține valori valoroase, informații la zi pentru dezvoltatorii JavaScript. Iată ce este inclus:

Șabloane GoF optimizate pentru JavaScript.

Modele moderne de design JavaScript.

Model-View Design Patterns.

Șabloane de design jQuery.

Modele arhitecturale ale idiomurilor JavaScript.

Exemple de aplicații (MVC, SPA etc.)

Elementele de bază propuse pentru sintaxa obiectelor JavaScript sunt foarte importante pentru programatorii începători. Mai întâi trebuie să înțelegem obiectele, apoi vor exista cunoștințe despre programarea orientată pe obiecte. Este extrem de important să aveți o înțelegere profundă a acestui material, deoarece servește drept bază pentru restul materialului. limbaj JavaScript.

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, iar „moștenirea prin prototipuri” este o caracteristică cheie a limbajului 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 limbaje de programare tipizate static. 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 :

Atributul care poate fi scris specifică dacă valoarea proprietății poate fi scrisă.

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

Atributul configurabil definește posibilitatea de configurare, adică. ștergerea unei proprietăți și modificarea atributelor acesteia.

Înainte de apariția standardului ECMAScript 5, toate proprietățile obiectelor create de un program erau inscriptibile, enumerate și configurabile. ECMAScript 5 oferă posibilitatea de a personaliza atributele proprietăților dvs.

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

Atributul class conține un șir cu numele clasei obiectului și specifică tipul obiectului.

Indicatorul 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:

Un obiect limbajul de bază

Este un obiect sau o clasă de obiecte definită de specificația ECMAScript. Matrice, funcții, date și expresii obisnuite(de exemplu) sunt obiecte ale limbajului de bază.

Obiect de rulare

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 obișnuite Funcția limbajului JavaScript de bază.

Obiect personalizat

Orice obiect creat prin executarea codului JavaScript.

Proprietate proprie

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

Proprietate moștenită

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ția 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 operatorul +):

// 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 noi obiecte cu prototipuri arbitrare (să spunem altfel: capacitatea de a crea „moștenitori” din orice obiecte) este Unealtă puternică, al cărui efect 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ă moștenirea funcționează atunci când proprietățile sunt citite, dar nu atunci când sunt scrise valori noi, este o caracteristică cheie a limbajului JavaScript, deoarece permite ca proprietățile moștenite să fie suprascrise selectiv:

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 corectată în modul strict, așa cum este definit de standardul ECMAScript 5. Toate încercările nereușite de a modifica valoarea unei proprietăți în modul strict au 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

Operatorul de ștergere 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 in, folosind metodele 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 comparativ 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.

Declarația for/in loop execută corpul buclei pentru fiecare proprietate enumerabilă (fie proprie, fie moștenită) obiect 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 acestea, 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 ca metode getter și 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 de înțeles că atunci când o referință de prototip apare în codul programului, aceasta denotă o proprietate obișnuită a unui obiect, 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 determina prototipul oricărui obiect prin trecerea lui la metoda 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 o proprietate de constructor, care se referă 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, acesta trebuie să fie trecut la metoda Object.isExtensible(). Pentru a face un obiect neextensibil, trebuie să-l transmiteți metodei 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.

Metoda Object.seal() acționează similar cu 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().

Metoda Object.freeze() permite ca obiectele să fie înghețate și mai strâns. 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(). ) metoda.

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. Pentru a serializa și a restaura obiecte JavaScript, standardul ECMAScript 5 oferă funcții încorporate JSON.stringify() și JSON.parse() . Aceste funcții folosesc formatul de schimb de date JSON. Numele JSON provine de la „JavaScript Object Notation” (o formă de notație de obiect JavaScript), iar sintaxa acestei notații este similară cu sintaxa literalelor obiect și matrice din 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, final valori numerice, 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.

O vizită la o resursă web este un URI specific din bara de adrese a browserului. Vizitatorul specifică adresa paginii și este analizată de browser în elemente ale arborelui DOM - Document Model obiect. Orice link de pe această pagină îi spune browserului să analizeze o altă pagină și să construiască un alt arbore de obiecte.

Browserul permite vizitatorului să meargă înapoi sau înainte printr-un lanț de pagini care au fost deja vizualizate în sesiunea curentă.

De fapt, acțiunile utilizatorului sunt mișcarea între sisteme de obiecte formate în procesul de vizitare a paginilor. Fiecare pagină este propriul arbore DOM și, în plus, obiectele JavaScript sunt obiecte ale sintaxei limbajului în sine și ale descrierilor utilizatorilor.

DOM: încărcare, actualizare și modificare

Există trei opțiuni principale care formează obiectele de pagină ale unei resurse web, atât la nivelul DOM, cât și al limbajului JavaScript însuși, care a realizat constructele de creare a variabilelor, și pe baza descrierilor făcute de dezvoltator:

• incarcare - vizitatorul a ajuns la pagina site-ului;
• actualizare - vizitator (buton browser sau Ctrl-F5);
• modificarea unui element de pagină, de exemplu (AJAX, script, eveniment, ...).

Toate cele trei procese sunt fundamental diferite, dar distingerea caracteristicilor primelor două este deosebit de importantă. Este dificil să împiedici un vizitator să reîmprospăteze o pagină - acesta este un obicei „rău” ineradicabil al vizitatorilor de care dezvoltatorul ar trebui să-l țină cont.

Navigarea pe pagină și dincolo ar trebui să se regăsească exclusiv în funcționalitatea paginii în sine, și nu în istoricul browserului și funcțiile butoanelor sale. Multe site-uri declară acest lucru cerință importantă, dar vizitatorii o încalcă în mod tradițional.

Schimbarea paginii fără a o reîncărca la nivel de element individual (de exemplu, AJAX) este o soluție comună pentru paginile dinamice. De regulă, acesta este folosit pentru a naviga prin elementele paginii, pentru a schimba obiectele acesteia și pentru a gestiona dialogul cu vizitatorul.

Obiecte JavaScript fundamentale

JavaScript este bazat pe obiecte. Aproape toate variabilele de limbaj sunt obiecte. Dezvoltatorul poate formula descrieri proprii obiecte folosind o varietate de opțiuni de sintaxă.

Orice lucru care nu este un „șir”, „număr”, adevărat, fals, nul sau nedefinit este un obiect. În cadrul sintaxei limbajului, acest lucru poate fi ignorat, ceea ce înseamnă că obiectele sunt doar elemente DOM și sunt proprii. Descrieri JavaScript Structura fundamentală a limbajului în majoritatea cazurilor nu are o semnificație practică semnificativă pentru dezvoltator.

De exemplu, funcțiile matematice sunt reprezentate de un obiect Math. Acest lucru este convenabil în cadrul conceptului de limbaj, dar pentru dezvoltator este pur și simplu o sintaxă convenabilă pentru utilizarea arsenalul necesar de operații matematice.

Este important să lucrați corect cu DOM-ul și să vă descrieți corect propriile obiecte. Sintaxa funcțiilor obiect JavaScript și expresiile pentru utilizarea lor este o formă de înregistrare a logicii algoritmului necesar.

Șiruri, tablouri și obiecte

Toate obiectele JavaScript se bazează pe regula: „proprietate” = „valoare” și pe conceptul de matrice asociativă. În chiar caz simplu Obiectul JavaScript este o colecție de perechi proprietate = valoare. Cu toate acestea, „valoarea” poate să nu fie întotdeauna un număr, iar proprietatea nu este întotdeauna scrisă fără ghilimele.

Nu ar trebui să folosiți excesiv denumirea proprietăților. În mod ideal, numele de proprietăți conțin doar caractere latine, satisfac cerințele pentru denumirea variabilelor și nu sunt cuvinte cheie (inclusiv rezervate) ale limbii.

Nu se așteaptă o ordonare a proprietăților, dar atunci când se creează sau se inițialează un tablou asociativ, este destul de acceptabil să știi cum sunt aranjate elementele sale. Nu este recomandat să folosiți această circumstanță, dar este posibil să o aveți în vedere.

Inițializarea unei matrice de proprietăți înseamnă simultan:

• crearea unei matrice;
• crearea obiectului.

Într-un context specific de aplicare, puteți considera un obiect JavaScript ca o matrice asociativă, iar într-un alt loc din algoritm ca un obiect, să îi atribuiți metodele necesare, să modificați valorile elementelor sale.

Deoarece numele proprietăților și valorile acestora trebuie specificate în format șir atunci când sunt create sau modificate, se recomandă utilizarea notării șirurilor și a ghilimelelor.

Accesarea proprietăților obiectului

Puteți obține și modifica valorile proprietăților unui obiect folosind construcția Object.keys: JavaScript generează o matrice cu toate proprietățile obiectului. Când obiectele sunt create dinamic, această construcție este foarte convenabilă, deoarece generează automat o listă cu toate proprietățile prezente în obiect.

ÎN în acest exemplu Cele două matrice sunt descrise diferit. În aplicație, ambele tablouri sunt echivalente, deoarece conțin proprietăți cu același nume și valorile lor. Bucla iterează prin toate proprietățile celei de-a doua matrice și generează un șir cu toate valorile.

Un efect similar poate fi obținut în notația punct sau paranteză:

• x1_Obj.NameLast;
• x1_Obj [„NameFirst” ].

Ambele construcții sunt valabile și dau rezultatul dorit. În exemplul de mai sus, când se specifică o matrice prin acolade „()”, poate fi făcută o eroare sub forma simbolului "," la sfârșitul enumerarii (marcat în exemplu cu un cerc roșu). Browserele ignoră de obicei caracterul suplimentar din enumerare, dar este mai bine să nu faci asta.

Eliminarea proprietăților obiectului

Deoarece un obiect este un tablou asociativ, operația de ștergere a obiectului JavaScript este efectuată la nivelul obiectului curent (când moștenire - acest lucru contează) și este luată în considerare pe colecția de proprietăți a acelui obiect.

În contextul exemplului de mai sus, puteți utiliza următoarele construcții:

• delete x1_Obj .NameLast ;
• șterge x2_Obj ["NameFirst"];

Prima construcție îndepărtează al doilea element al primului obiect, a doua construcție îndepărtează primul element al celui de-al doilea obiect. Operatorul de ștergere nu funcționează pe proprietățile prototipului și returnează false dacă proprietatea nu poate fi ștearsă.

Proprietăți și metode ale obiectelor

Sintaxa proprietăților și funcțiilor obiectelor JavaScript (metode) este similară cu canoanele generale de sintaxă și semantică ale limbajului. De fapt, contrariul este adevărat.

Proprietățile și metodele unui obiect sunt o variantă de descriere a informațiilor și a acțiunilor permise cu aceasta prin paradigma JavaScript orientată pe obiecte.

Acest exemplu descrie un obiect x3_Obj care are doar două proprietăți: item și pos. Apoi metoda hello() a fost adăugată ca funcție. Ca urmare, valorile obiectelor JavaScript vor interpreta această descriere în contextul valorilor proprietăților, așa cum se arată în fereastra de rezultat, adică va plasa corpul funcției (1) ca valoare.

Când se apelează direct proprietatea Hello(), aceasta este interpretată ca metodă (funcție), iar rezultatul (2) este execuția codului acestei metode.

Acest cuvânt cheie într-un obiect

Pentru a naviga în spațiul de proprietate al unui obiect, un dezvoltator poate folosi cuvântul cheie this și se poate referi prin el la proprietățile pe care le descrie pentru a obține sau a modifica valorile acestora.

Acesta este doar începutul descrierii unui obiect cu doar un corp de constructor. Acest exemplu descrie un obiect pentru lucrul cu cookie-uri. Obiectul este inițializat când pagina este încărcată de următorul construct:

• var oCookie = new scCookies(cOwnerCode);
• oCookie.Init();

În acest exemplu, cOwnerCode este codul unic de vizitator. Dacă nu este acolo, atunci va fi creat cod nou în constructorul obiectului oCookie. Nu contează ce a vrut să spună dezvoltatorul acestui obiect prin autorizarea vizitatorului, ceea ce este important este modul în care acest cuvânt cheie este folosit aici pentru a descrie metodele obiectului și cum sunt numite din alte metode ale obiectului:

• acest .GetCookie = function (cName) ( ... );
• acest .SetCookie = funcție (cName, cValue) ( ​​​​... ).

Acesta descrie metodele obiectului pentru citirea unui cookie după numele său și scrierea valorii unui cookie cu un nume specific.

• acest .GetCookie("cOwner");
• acest .SetCookie ( „cOwner” , coOwner );

Asa se folosesc, daca in urma primei constructii nu este reprezentata valoarea, atunci a doua constructie o stabileste.

Un exemplu de obiect pentru lucrul cu cookie-uri

Puteți discuta despre obiect și despre paradigma unei abordări de limbaj orientat pe obiecte care rulează într-un mediu de browser. Este interesant, dar în realitate necesită practică, nu teorie. Servirea DOM-ului unei pagini, oferind instrumente pentru manipularea obiectelor și navigarea prin sisteme de obiecte este un punct forte JavaScript.

În practica orientată pe obiect, altceva este important. Lucrul cu cookie-uri pe aproape toate resursele web este normal pentru curs. Implementarea acestui lucru în format obiect este o idee grozavă. În acest context, inițializarea obiectului are loc în momentul deschiderii paginii: pagina este încărcată = obiectul cookie există și totul a fost citit, iar ceea ce nu era acolo este creat.

În timp ce lucrează cu pagina, vizitatorul efectuează anumite acțiuni, iar browserul trebuie să schimbe sau să creeze cookie-uri. Există două metode obiect (etichetate mai sus) care fac acest lucru.

De fapt, obiectul cookie apare imediat după ce browserul construiește DOM-ul și adaugă noi funcționalități sistemului de obiecte JavaScript: citirea și crearea (modificarea) cookie-urilor.

Acest exemplu simplu este considerat ca o procedură de creare a obiectelor reale care au exclusiv proprietăți și funcționalități (metode) proprii. Fiecare obiect își face treaba lui și nu participă algoritm general, nu modifică datele altor obiecte sau spațiul de nume partajat.

Cu această abordare, dezvoltatorul asigură crearea unui sistem de obiecte unice suficient pentru a descrie și deservi problema rezolvată.

Evenimente de pagină și obiect

Un element important al funcționării DOM-ului și JavaScript: object event "s - care vă permite să obțineți informații despre un eveniment în handlerul său. Aproape fiecărui element de pagină i se poate atribui propriul handler pentru unul sau mai multe evenimente.

De fapt, un dezvoltator JavaScript nu creează o „piesă” mare de cod, ci multe descrieri ale funcțiilor, obiectelor, structurilor de date și atribuie handlere de evenimente unor elemente specifice ale paginii.

Evenimentul obiect este informații despre evenimentul care a determinat handler-ul și capacitatea acestui handler de a efectua un răspuns adecvat la acest eveniment. Fiecare eveniment diferă nu numai prin numele și locul de apariție, ci și prin mulți alți parametri.

În special, evenimentele de la tastatură sunt un set de parametri, evenimentele mouse-ului sunt o gamă complet diferită de date, iar răspunsul serverului prin AJAX este complet planificat de către dezvoltator însuși.

În fiecare caz specific, imaginea evenimentelor care pot apărea pe pagină este transformată într-o serie de handlere activate; în afara opțiunilor furnizate pentru procesarea unui set specific de evenimente, pagina nu întreprinde nicio acțiune.

Crearea și funcționarea obiectelor

Browserul „transformă” URI-ul, adresa resursei web specificate de vizitator, în arborele DOM - sistemul de obiecte al paginii acestei resurse web. Atunci când un vizitator urmărește link-uri de pe o pagină, browserul merge la arborii corespunzătoare a altor pagini.

Această împrejurare permite dezvoltatorului să-și construiască sistemul de obiecte ca fundație a unei resurse web care răspunde în mod adecvat la comportamentul vizitatorilor. Dacă izolați funcționalitatea generală, de exemplu:

• lucrul cu cookie-uri;
• primirea/transmiterea datelor (AJAX);
• sfaturi cu instrumente;
• mesaje interne (chat pe site);
• alte sarcini;

apoi, odată create, sistemele de obiecte pot fi folosite la dezvoltarea altor site-uri. Acesta este un avantaj semnificativ abordarea obiectuluiînainte de utilizarea obișnuită a JavaScript ca limbaj de browser care asigură funcționarea paginii și răspunsul la evenimente.

Obiectele sunt componente complete care pot fi formatate ca fişiere separateși utilizați în viitor. O trăsătură caracteristică a acestei abordări este posibilitatea de feedback, atunci când un obiect actualizat, îmbunătățit poate fi utilizat într-o dezvoltare anterioară, actualizându-și automat funcționalitatea fără modificarea site-ului.

Sarcina :

1. Sunt trei obiecte (trei mașini): primul_Mașină, al doilea_Mașină și al treilea_Mașină.

2. Fiecare dintre obiecte (masini) are un set de proprietăți și valorile corespunzătoare acestora (caracteristicile mașinii).

3. Luați în considerare unul dintre obiecte:

var first_Car = (
marca: "VAZ" , /* producător */
model: 2106 , /* model */
an: 1980 , /* an fabricatie */
culoare: "bej", /* culoare */
pasageri: 5 , /* numărul de pasageri */
decapotabil: fals, /* capota decapotabilă */
kilometraj: 80000 /* kilometraj */
}

Proprietățile marca și culoarea au valori de șir;

Proprietățile modelului, anului, pasagerii și kilometrajul sunt valori numerice;

Proprietatea convertibilă ia o valoare booleană.

Trebuie să faceți următoarele:

Scrieți o funcție care verifică o mașină folosind doi parametri (an fabricatie si kilometraj)și returnează valoarea booleană true sau false.

Detalii:

1. Funcția are un parametru mașină, care primește unul dintre cele 3 obiecte. De exemplu, mașina discutată mai sus este first_Car.

2. Funcția trebuie să funcționeze cu orice obiect similar.

Funcție de verificare a obiectului - adevărat sau fals

/* primul obiect */
var first_Car = (
marca: "VAZ",
model: 2106,
Anul: 1980,
culoare: "bej",
pasageri: 5,
convertibil: fals,
kilometraj: 80000
}

/* al 2-lea obiect */
var second_Car = (
marca: "VW",
model: "Passat b3",
anul: 1990,
culoare: „neptun”,
pasageri: 5,
convertibil: fals,
kilometraj: 160000
}

/* al treilea obiect */
var a treia_Masina = (
marca: "Hyundai",
model: "Solaris",
Anul: 2012,
culoare: „asfalt umed”,
pasageri: 5,
convertibil: fals,
kilometraj: 15000
}

function good_Car(masina) (
dacă (maşină. an< 2000 ){
returnează fals;
}
altfel dacă (kilometraj mașină > 50000 )(
returnează fals;
}
altceva(
returnează adevărat;
}
}

/* Apelați o funcție și scoateți rezultatul */
var rezultat = good_Car ( a treia_Masina );

document. scrie (rezultat);

Comentarii despre solutie:

• Deci avem trei obiecte (trei mașini), fiecare dintre acestea putând fi analizat folosind funcția good_Car.
• Funcția good_Car are un parametru car , care poate fi oricare dintre obiecte (masini): primul_Mașină , al doilea_Mașină sau al treilea_Mașină : funcția bună_Mașină(mașină) .
• Caroseria funcției good_Car conține o condiție conform căreia:

  Dacă valoarea anului proprietății obiectului auto este mai mică de 2000 (cu alte cuvinte: dacă mașina are mai puțin de 2.000 de ani), atunci funcția returnează false;

  În caz contrar, dacă valoarea proprietății de kilometraj a obiectului mașinii este mai mare de 50000 (dacă kilometrajul mașinii este mai mare de 50.000), atunci funcția returnează false;

  În caz contrar, funcția returnează true.

• Apoi, apelăm funcția și specificăm obiectul third_Car ca parametru (a treia mașină), care trece testul cu succes. Rezultatul funcției este stocat în variabila rezultat:
  var rezultat = good_Car(a treia_Masina); .
• Variabila rezultată este afișată pe ecran;
• Alte două obiecte (mașină) nu va îndeplini cerințele condițiilor.

Optimizarea codului

Să continuăm să lucrăm cu obiecte în javascript.

Deci, funcția discutată mai sus la verificarea obiectelor (masini) returnează adevărat sau fals (adevărat sau fals).

Puteți îmbunătăți ușor calitatea percepției soluției la problema luată în considerare, adică, în loc de adevărat sau fals, afișați un text. Pentru a face acest lucru, vom crea o condiție pentru analiza rezultatului.

/* primul obiect */
var first_Car = (
marca: "VAZ",
model: 2106,
Anul: 1980,
culoare: "bej",
pasageri: 5,
convertibil: fals,
kilometraj: 80000
}

/* al 2-lea obiect */
var second_Car = (
marca: "VW",
model: "Passat b3",
anul: 1990,
culoare: „neptun”,
pasageri: 5,
convertibil: fals,
kilometraj: 160000
}

/* al treilea obiect */
var a treia_Masina = (
marca: "Hyundai",
model: "Solaris",
Anul: 2012,
culoare: „asfalt umed”,
pasageri: 5,
convertibil: fals,
kilometraj: 15000
}

/* Funcție pentru verificarea unui obiect */
function good_Car(masina) (
dacă (maşină. an< 2000 ){
returnează fals;
}
altfel dacă (kilometraj mașină > 50000 )(
returnează fals;
}
altceva(
returnează adevărat;
}
}

var rezultat = good_Car ( a treia_Masina );

dacă (rezultat) (
document. scrie ("Ai o mașină bună: " + a treia_Mașină . an + " an de fabricație, cu kilometraj " + a treia_Mașină .kilometraj + " km." );
}
altceva(
document. scrie ("Nu vom vorbi despre masina ta....");
}

Soluție cu o condiție pentru rezultat - Rezultat...

Condiția de analiză a rezultatului este următoarea.

• Expresia if(rezult) este o formă scurtă a expresiei
  dacă(rezultat == adevărat) .
• Dacă rezultatul funcției good_Car este adevărat, atunci afișăm fraza: „Ai o mașină bună: 2012, cu un kilometraj de 15.000 km”, unde

  2012 și 15000 sunt valorile anului și proprietățile de kilometraj ale celui de-al treilea obiect_Car.

• Dacă condiția de verificare a rezultatului produce o valoare falsă false , atunci vom vedea: „Nu vom vorbi despre mașina ta...”. Adică obiectul în cauză (auto) nu a trecut testul.

Optimizarea codului - Continuarea - Adăugarea unei funcții

Dar asta nu este tot. Aruncă o privire atentă la fragmentul de cod pentru apelarea funcției și analizarea rezultatului:

/* Apelați funcția și analizați rezultatul */
var rezultat = good_Car( a treia_Masina );

dacă (rezultat) (
document.write("Ai o mașină bună: " + a treia_Mașină .an + " an de fabricație, cu kilometraj " + a treia_Mașină .kilometraj + " km.");
}
altceva(
document.write("Nu vom vorbi despre masina ta....");
}

Aici este al treilea obiect_Car (a treia mașină) indicat de trei ori:

• Prima dată când funcția good_Car este apelată, aceasta este specificată ca parametru: good_Car(third_Car) .
• Și apoi mai apare de două ori când îl accesăm pentru a indica proprietățile sale: third_Car.year și third_Car.mileage .

Nu mi-a plăcut asta pentru că atunci când analizez un alt obiect (mașină) va trebui sa-i indicam si numele de trei ori!!!

Pentru a obține o indicație unică a obiectului analizat, aveți nevoie atât de rezultatul funcției good_Car, cât și de o analiză a acestui rezultat (asta e tot) pus într-o altă funcție.

/* primul obiect */
var first_Car = (
marca: "VAZ",
model: 2106,
Anul: 1980,
culoare: "bej",
pasageri: 5,
convertibil: fals,
kilometraj: 80000
}

/* al 2-lea obiect */
var second_Car = (
marca: "VW",
model: "Passat b3",
anul: 1990,
culoare: „neptun”,
pasageri: 5,
convertibil: fals,
kilometraj: 160000
}

/* al treilea obiect */
var a treia_Masina = (
marca: "Hyundai",
model: "Solaris",
Anul: 2012,
culoare: „asfalt umed”,
pasageri: 5,
convertibil: fals,
kilometraj: 15000
}

/* Funcție pentru verificarea unui obiect */
function good_Car(masina) (
daca (masina .an< 2000){
returnează fals;
}
altfel dacă (mașină .kilometraj > 50000)(
returnează fals;
}
altceva(
returnează adevărat;
}
}

/* Introduceți rezultatul funcției good_Car și Analiza rezultatului într-o altă funcție */
funcția itog (mașină)
var rezultat = good_Car(masina);

Dacă (rezultat) (
document.write("Ai o mașină bună: " + mașină .an + " an fabricație, cu kilometraj " + mașină .kilometraj + " km.");
}
altceva(
document.write("Nu vom vorbi despre masina ta....");
}
}

itog( a treia_Masina );

Soluție folosind altă funcție - Rezultat...

Ai o mașină bună: fabricată în 2012, cu un kilometraj de 15.000 km.

Salutări tuturor celor care citesc această publicație. Astăzi vreau să vă ghidez printr-un instrument cheie al limbajului - obiectele JavaScript. Permiteți-mi să vă reamintesc că js este cross-browser și funcționează pe toate sistemele de operare (windows, mac os etc.). Spre deosebire de limbajele de programare orientate pe obiecte, implementarea obiectelor în js diferă semnificativ de funcționalitatea obișnuită și variațiile în utilizarea instanțelor, de exemplu, în C#.

Prin urmare, după ce ați citit articolul curent, veți afla principalele caracteristici distinctive ale obiectelor script, veți afla în ce moduri pot fi create, actualizate și șterse. Voi aborda, de asemenea, subiectul proprietăților, metodelor și constructorilor și voi vorbi despre comenzi utileși bineînțeles puțin despre moștenire. Cred că este timpul să începi să înveți!

Ce este un obiect în JavaScript și ce capacități are?

În js, obiectele sunt simple tablouri asociative (se mai numesc și hash-uri).

Ce este un tablou asociativ?

Aceasta este o structură de date care stochează o anumită cantitate de informații referitoare la și descriind un anumit element. Toate datele sunt structurate și interconectate ca „cheie => valoare”.

De exemplu, trebuie să descrii mașini. Apoi creați un obiect automat și descrieți caracteristicile acestuia într-o matrice. Am decis să descriu marca mașinii (numele), culoarea (culoarea) și costul (prețul). Mai jos am atașat codul pentru implementarea sarcinii descrise.

1 2 3 4 5

var avto = ( nume: "BMW 116i", culoare: "negru", pret: 588000 );

var avto = ( nume: "BMW 116i", culoare: "negru", pret: 588000 );

Aici vedeți o modalitate de a crea un obiect numit „avto”. Numele, culoarea și prețul sunt chei care pot fi folosite în timpul scrierii aplicației.

M-am devansat cu acest exemplu, așa că acum să ne uităm la totul în ordine.

Puteți crea un obiect în mai multe moduri:

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

În ambele cazuri, este creat un obiect gol cu ​​un nume cunoscut, dar prima opțiune este folosită mult mai des, deoarece este mai scurt și mai convenabil de scris.

Totul despre proprietăți

Acum trebuie să umpleți obiectul gol cu ​​parametri. Pentru a face acest lucru, trebuie să adăugați proprietăți, pe care le-am numit și chei mai sus. Din nou, există două moduri de a declara proprietăți.

Aș dori să remarc faptul că JavaScript nu are un cadru strict pentru crearea și inițializarea unor astfel de parametri. Pot apărea noi proprietăți în întregul cod, așa cum pot fi șterse și actualizate.

Astfel, puteți crea toate cheile simultan sau le puteți declara pe măsură ce devin disponibile. Și chiar dacă, în timpul scrierii unui program, te referi la chei inexistente, nu va exista nicio eroare. În acest caz, „nedefinit” va fi returnat.

Prima cale.

Crearea și accesarea proprietăților folosind un punct. Pentru a implementa această opțiune, trebuie să scrieți numele obiectului, apoi să adăugați numele cheii printr-un punct și apoi să atribuiți o valoare prin semnul egal:

avto.name = „BMW 116i”

Dar în această metodă veți adăuga încă un element la cheile existente:

Această metodă este utilizată atunci când numele proprietății este deja cunoscut și trebuie făcut anumite actiuni cu sensuri.

A doua cale.

Nu diferă de primul, dacă le compari scopurile. Cu toate acestea, această metodă are un mic avantaj. Pentru această opțiune, se folosesc paranteze drepte:

avto[„nume”] = „BMW 116i”

Un plus frumos este capacitatea de a crea nume de proprietăți sub forma oricărui șir. De exemplu,

avto[„numele mașinii”] = „BMW 116i”

Lucrul cu cheile prin paranteze pătrate este folosit atunci când unii parametri sunt introduși de utilizator și stocați în variabile sau când numele proprietăților sunt necunoscute în prealabil. De exemplu, un utilizator solicită prețul unei mașini selectate. Elementul care a fost apelat este scris în variabilă, iar prețul este trimis ca răspuns:

var auto = (); avto.name = "BMW_116i"; avto.price = 588000; var cheie = „preț”; // a fost solicitat prețul mașinii alert(avto);

Acum să trecem la ștergerea proprietăților. Totul este foarte simplu aici. Pentru a șterge, utilizați comanda de ștergere. Deci, dacă adăugați următoarele 2 rânduri la ultimul exemplu de mai jos:

sterge auto.pret;

alert(auto);

Apoi, la apelarea alertei a doua oară, caseta de dialog va afișa „nedefinit”.

Câteva cuvinte despre compactitate

În stadiul actual, v-am spus cum să creați un obiect și să descrieți proprietățile acestuia. Am atașat cazuri de testare la aceasta, dar cei mai atenți dintre voi, dragi cititori, ați observat că primul cod de program este oarecum diferit de toate celelalte.

Și totul pentru că folosește o reprezentare compactă a datelor. Aceasta este o metodă foarte populară de declarare a cheilor, deoarece este mai scurtă de scris și mai ușor de înțeles vizual.

Să trecem prin proprietățile noastre

În JavaScript, puteți itera rapid prin proprietățile create. Pentru aceasta a fost prevăzut un mecanism special, mai bine cunoscut sub numele de ciclu.

Dacă sunteți familiarizat cu alte limbaje de programare, știți că cel mai adesea buclele sunt create folosind cuvântul pentru , apoi în parantezele este specificată condiţia de enumerare a elementelor.

În js își amintește aspect bucla foreach din limbajul C#. Consultați designul general:

pentru (var obj în obiect) ( // efectuează căutarea)

unde obj este responsabil pentru numele cheilor enumerate,

obiect – pentru valorile lor.

Și acum iată un exemplu concret pentru tine.

1 2 3 4 5 6 7 8

var avto = ( nume: "BMW 116i", culoare: "negru", pret: 588000 ); pentru (var obj în obiect) ( alert(obj + ":" + obiect) )

var avto = ( nume: "BMW 116i", culoare: "negru", pret: 588000 ); pentru (var obj în obiect) ( alert(obj + ":" + obiect) )

Este timpul să vă familiarizați cu metodele

Limbajul de scripting prevede crearea de metode. Acesta este un mecanism absolut simplu cu ajutorul căruia în orice moment puteți adăuga o metodă sau metode oricărui obiect care extind capacitățile tablourilor asociative create. Ele sunt numite și proprietăți ale funcției.

Js în sine este foarte dinamic și uimitor într-o oarecare măsură. Acesta este modul în care puteți crea elemente de diferite tipuri. Când învățați această limbă, nu trebuie să memorați structuri complexe, deoarece multe declarații sunt foarte asemănătoare între ele.

Deci, pentru a crea o metodă, trebuie să declarați un obiect și apoi să începeți să scrieți o comandă care este exact ca și crearea proprietăților. Totuși, după „=” nu se mai scrie valoarea, ci funcția de cuvânt cheie (variabilă). Și apoi acțiunile sunt enumerate în paranteze.

Iată implementarea acestui mecanism:

var avto =() avto.name = „BMV” avto.year = 1999 avto.drive = function(k) ( alert(„Mașina a trecut”+n+“ km.”)) avto.drive(300) avto. conduce (450)

După cum puteți vedea, acest exemplu conține proprietăți și metode ale căror apeluri sunt inițial identice.

JS are și constructori?

Da domnule! În acest limbaj, orice folosește cuvântul cheie „nou” devine automat un constructor. Deci, mai sus ați văzut declarația unui obiect gol sub forma: avto = new Object ();. Acesta este constructorul.

Pentru claritate, luați în considerare rândurile de mai jos.

var bob = obiect nou();

bob.name = "Bob Smith";

Cu toate acestea, acesta nu este întregul arsenal de posibilități. În js, vă puteți crea propriile constructori și apoi îi puteți folosi pentru a declara obiecte noi.

Deci, vreau să „realizez” un constructor personalizat pentru mașinile deja existente. Vă rugăm să rețineți că numele trebuie scris cu litere mari. Acesta este semnul distinctiv al funcțiilor. Pentru a face acest lucru, scriu următoarea implementare software:

funcția Auto (nume, preț) (

this.name = nume;

this.price = pret;

Acum, când creați un număr nelimitat de obiecte și le aplicați acest constructor, toate vor aparține aceleiași clase. De exemplu:

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

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

În plus, puteți crea metode în interiorul constructorului.

Caracteristici ale moștenirii în JavaScript

De obicei, în multe limbi, moștenirea se bazează pe clase care se pot moșteni unele de la altele. Apoi puteți auzi expresii precum „clasa strămoșilor”, „clasa copiilor”, etc.

Cu toate acestea, în js totul este diferit. Aici sunt moștenite obiectele.

Toată moștenirea se bazează pe o referință internă între obiecte, care este cunoscută sub numele de „prototip”. Dacă adăugați „.prototype” la o metodă folosind un punct și apoi introduceți numele prototipului, atunci toate obiectele metodei selectate vor fi moștenite de la acest prototip.

Să trecem la un exemplu.

function Transport (name) ( this.name = name this.canDrive = true ) var transport = new Transport ("avto") // a creat un obiect de transport function Bike (name) ( this.name = name ) Bike.prototype = transport // specificați că toate obiectele noi din această clasă vor folosi transport bike1 = bicicletă nouă ("for_sport") bike2= bicicletă nouă ("pentru_copil") console.log(bike1.name) console.log(bike2.name) console .log (bike1.canDrive)

Presupun că voi încheia aici. V-am spus despre aspectele fundamentale ale unui limbaj de scripting. Cu toate acestea, aceasta este doar cunoștințe superficiale. În continuare vom merge mai adânc. Între timp, nu uitați să vă alăturați rândurilor abonaților mei și să distribuiți prietenilor tăi linkul către articol. Noroc!

Pa! Pa!

Cu stima, Roman Chueshov

Citește: de 97 de ori