JavaScript. Tipuri de date și operatori

Există reguli de sintaxă pentru crearea numelor de variabile în JavaScript:

• Următoarele simboluri sunt folosite pentru numele variabilelor: a-z, A-Z, numere, $, liniuță de subliniere (_).
• Numele variabilelor nu pot începe cu o cifră.
• JavaScript este sensibil la majuscule și minuscule, așa că țineți cont de acest lucru atunci când programați. itcounter și it C externe sunt variabile diferite.
• JavaScript nu are nicio limitare cu privire la lungimea unui nume de variabilă.

Exemple de nume de variabile valide:

• itcounter
• $ _itcounter
• it_counter

Nume de variabile greșite:

• 9 camera
• it-counter
• #itcounter
• & itcounter

Variabilele sunt declarate cu comanda var.

Variabilele pot stoca șiruri și numere. De fapt, puteți stoca și alte tipuri de date, dar despre ele vom vorbi mai târziu.

Variabile șir

Pentru a scrie un șir într-o variabilă, trebuie să includeți valoarea acestuia între ghilimele, duble sau simple.

Var $ stroka_1 = "Bună ziua!"; var $ stroka_2 = "Atenție!";

În șirul creat ghilimele unice, puteți include ghilimele duble și invers.

Var $ stroka_1 = "" Bună ziua! "Este un salut."; var $ stroka_2 = "" Atenție! "este un avertisment."; document.write ($ stroka_1); document.write ("

Pentru a imprima un ghilimele de același tip, acesta trebuie să fie eliminat cu un caracter backslash. E simplu:

"); document.write ($ stroka_2);

Valorile variabilelor pot fi atribuite altor variabile:

Var $ stroka_1 = "\" Bună ziua! \ "Este un salut."; var $ stroka_2 = "\" Atenție! \ "este un avertisment."; document.write ($ stroka_1); document.write ("
"); document.write ($ stroka_2); $ stroka_2 = $ stroka_1; document.write ("
"); document.write ($ stroka_2);

În acest exemplu, am atribuit mai întâi o valoare șir variabilei $ stroka_2, dar apoi i-am atribuit valoarea variabilei $ stroka_1.

Concatenarea șirurilor

Este foarte comun să concatenezi mai multe linii într-una singură. De exemplu, ultimul nostru exemplu este prea greoi.

Concatenarea (concatenarea) șirurilor de caractere în JavaScript se face folosind semnul + .

Pentru a afișa 2 variabile șir separate printr-o etichetă
variabile, puteți utiliza o singură comandă document.write ().

Var $ stroka_1 = "" Bună ziua! "Este un salut."; var $ stroka_2 = "" Atenție! "este un avertisment."; document.write ($ stroka_1 + "
„+ $ stroka_2);

Operator de concatenare + poate fi folosit și în variabile:

Var $ stroka_1 = "" Bună ziua! "Este un salut."; var $ stroka_2 = "" Atenție! "este un avertisment."; var $ stroka_3 = $ stroka_1 + "
"+ $ stroka_2; document.write ($ stroka_3);

Variabile numerice

Pentru a crea o variabilă numerică, trebuie doar să îi atribui o valoare numerică.

Var $ count_1 = 23; var $ count_2 = 10,34; document.write ($ count_1 - $ count_2);

Acum un alt exemplu:

Var $ count_1 = 23; // Variabilă numerică. var $ stroka_1 = "57"; // Variabilă șir. document.write ($ stroka_1 + $ count_1);

Vedeți, valoarea variabilei $ stroka_1 este cuprinsă între ghilimele, deci este o variabilă text. Apoi adăugăm variabila text și numerică și obținem șirul „5723”, așa funcționează JavaScript în astfel de cazuri - transformă numărul într-un șir și îl adaugă la șirul însumat.

Variabile booleene

Există un astfel de tip de variabile - boolean. E simplu, sunt doar două valori: adevărat și fals, adică adevărat și fals.

Acest tip de date este utilizat în operațiuni de comparare. Iată câteva exemple simple:

• 9> 1 este adevărat.
• 2> 5 este o minciună.

var $ count = 2

Acum să încercăm să înlocuim valorile booleene în operații aritmetice. Să rezumam cele două operații de comparare:

Var $ count = (3> 2) + (4> 2); document.write (număr de dolari);

Aceasta este o înregistrare ciudată, știu. Dar variabila $ count va fi 2. În context matematic, adevărat = 1 și fals = 0.

Operatorii de comparație sunt utilizați în declarația if folosită în mod obișnuit în JavaScript. Cuvântul dacă în engleză înseamnă - dacă.

Var $ count = 100; if ($ count == 100) document.write ("Variabila $ count este 100.");

În acest exemplu, mesajul va fi afișat deoarece condiția declarației if ($ count == 100) este adevărată. Dacă modificați valoarea variabilei $ count la 99, atunci condiția ($ count == 100) va deveni falsă și nimic nu va fi afișat pe ecran.

Tipuri de variabile simple

În JavaScript, variabilele sunt clasificate în mai multe tipuri. Am acoperit deja tipurile șir, numerice și booleene (logice). Iată o listă mai largă de tipuri simple:

• șir este o variabilă șir.
• numărul este o variabilă numerică.
• boolean este o variabilă booleană.
• null este valoarea specială „nimic”.
• undefined - tastați „valoare nealocată”.

Valoarea variabilei null formează propriul tip distinct, null, constând din singura valoare nulă posibilă. null este o valoare specială care are sensul de „nimic” sau „valoare necunoscută”.

Var $ pret = nul; // asta înseamnă că prețul nu este cunoscut.

În JavaScript, puteți afla tipul de variabile folosind instrucțiunea typeof.

Var $ count; document.write (tip de $ count + "
"); var $ count = adevărat; document.write (tip de $ count +"
"); var $ count =" true "; document.write (tip de $ count +"
"); var $ count = 100; document.write (tip de $ count +"
"); var $ count = null; document.write (tip de $ count +"
");

Sintaxa pentru instrucțiunea typeof poate fi:

• tip de număr $
• tip de (număr de dolari)

Deci, rulați codul din ultimul exemplu și vedeți rezultatul. Tipul de variabilă nulă va fi obiect. Aceasta este o eroare în limbaj și probabil că nu va fi remediată niciodată din cauza necesității de a menține compatibilitatea scripturilor JavaScript deja scrise cu noile versiuni ale limbii.

Tipul obiect nu mai este un tip primitiv, despre el vom vorbi în alte lecții.

Șir, număr, boolean, matrice, obiect.

Tipuri de date JavaScript

Variabilele JavaScript pot conține multe tipuri de date: numere, șiruri, matrice, obiecteși mult mai mult:

var lungime = 16; // Număr
var lastName = "Johnson"; // șir
var mașini = ["Saab", "Volvo", "BMW"]; // Matrice
var x = (prenume: „Ioan”, prenume: „Doe”); // Obiect

Conceptul tipului de date

În programare, tipurile de date sunt un concept important.

Pentru a putea lucra cu variabile, este important să știți ceva despre tip.

Fără tipuri de date, computerul nu poate rezolva în siguranță această problemă:

Var x = 16 + "Volvo";

Are sens să adăugați „Volvo” la șaisprezece? Va arunca o eroare sau va produce un rezultat?

JavaScript ar trata exemplul de mai sus ca:

Var x = "16" + "Volvo";

Când adăugați un număr și un șir, JavaScript va trata numărul ca pe un șir.

JavaScript evaluează expresiile de la stânga la dreapta. Secvențe diferite pot duce la rezultate diferite:

În primul exemplu, JavaScript tratează 16 și 4 ca numere până când ajunge la „Volvo”.

În al doilea exemplu, deoarece primul operand este un șir, toți operanzii sunt tratați ca șiruri.

JavaScript are tipuri dinamice

JavaScript are tipuri dinamice. Aceasta înseamnă că aceeași variabilă poate fi utilizată ca tipuri diferite:

exemplu

var x; // Acum x este nedefinit
var x = 5; // Acum x este un număr
var x = „Ioan”; // Acum x este un șir

Șiruri JavaScript

Un șir (sau șir de text) este o serie de caractere, cum ar fi „John Doe”.

Rândurile sunt scrise între ghilimele. Puteți folosi single sau ghilimele duble:

exemplu

var carName = "Volvo XC60"; // Folosind ghilimele duble
var carName = "Volvo XC60"; // Folosind ghilimele simple

Puteți folosi ghilimele în interiorul unui șir, atâta timp cât acestea nu se potrivesc cu ghilimele din jurul șirului:

exemplu

var răspuns = „Este în regulă”; // ghilimele simple între ghilimele duble
var answer = "Se numește" Johnny ""; // Ghilimele simple în ghilimele duble
var answer = "Se numește" Johnny ""; // Ghilimele duble în ghilimele simple

Incearca-l tu insuti "

Veți afla mai multe despre șiruri mai târziu în acest tutorial.

Numere JavaScript

JavaScript are un singur tip de numere.

Numerele pot fi scrise sau fără zecimale:

exemplu

var x1 = 34,00; // Scris cu zecimale
var x2 = 34; // Scris fără zecimale

Numerele foarte mari sau foarte mici pot fi scrise cu notație științifică (exponențială):

Veți afla mai multe despre numere mai târziu în acest ghid.

Booleeni JavaScript

Booleanul poate avea doar două valori: adevărat sau fals.

exemplu

var x = adevărat;
var y = fals;

Valorile booleene sunt adesea folosite în testarea condiționată.

Veți afla mai multe despre testarea condiționată mai târziu în acest tutorial.

Matrice JavaScript

Matricele JavaScript sunt scrise folosind paranteze drepte.

elementele matricei sunt separate prin virgule.

Următorul cod declară (creează) o matrice numită mașini, care conține trei elemente (nume de mașini):

Indicii de matrice încep de la zero, ceea ce înseamnă primul element, al doilea și așa mai departe.

Veți afla mai multe despre matrice mai târziu în acest tutorial.

obiecte JavaScript

Obiectele JavaScript sunt incluse între acolade.

Proprietățile obiectului sunt scrise ca nume: perechi valori, separate prin virgule.

Obiectul (persoana) din exemplul de mai sus are 4 proprietăți: prenume, prenume, vârstă și eyeColor.

Veți afla mai multe despre obiecte mai târziu în acest tutorial.

Tip de operator

Puteți utiliza codul JavaScript tip de operator pentru a găsi tipul unei variabile JavaScript:

exemplu

typeof "John" // Returnează șirul
typeof 3.14 // Returnează numărul
typeof false // Returnează boolean
typeof // Returnează obiectul
typeof (nume: „John”, vârsta: 34) // Returnează obiectul

O variabilă este un identificator căruia i-a fost atribuită o valoare. O variabilă poate fi accesată într-un program, lucrând astfel cu valoarea care i-a fost atribuită.

În sine, o variabilă JavaScript nu conține informații despre tipul de valori care vor fi stocate în ea. Aceasta înseamnă că scriind într-o variabilă, de exemplu, un șir, puteți scrie ulterior un număr în aceasta. O astfel de operațiune nu va provoca o eroare în program. Acesta este motivul pentru care JavaScript este uneori numit limbaj „netipizat”.

Înainte de a utiliza o variabilă, aceasta trebuie declarată folosind cuvânt cheie var sau let. Când vine vorba de o constantă, se folosește cuvântul cheie const. Puteți declara o variabilă și îi puteți atribui o valoare fără a utiliza aceste cuvinte cheie, dar acest lucru nu este recomandat.

▍Cuvântul cheie var

Înainte de ES2015, utilizarea cuvântului cheie var era singura modalitate de a declara variabile.

Var a = 0
Dacă var este omis în această construcție, valoarea va fi atribuită unei variabile nedeclarate. Rezultatul acestei operațiuni depinde de modul în care este executat programul.

Deci, dacă așa-numitul mod strict este activat, aceasta va provoca o eroare. Dacă modul strict nu este activat, variabila va fi implicit declarată și atribuită obiectului global. În special, aceasta înseamnă că o variabilă care este implicit declarată în acest fel într-o funcție va fi disponibilă după ce funcția își finalizează activitatea. De obicei, se așteaptă ca variabilele declarate în funcții să nu „iasă” din limitele lor. Arata cam asa:

Funcția notVar () (bNotVar = 1 // mai bine să nu faci asta) notVar () console.log (bNotVar)
Consola va primi 1, nimeni nu se așteaptă de obicei la un astfel de comportament de la program, expresia bNotVar = 1 nu arată ca o încercare de a declara și inițializa o variabilă, ci ca o încercare de a accesa o variabilă care se află în afara domeniului funcției ( acest lucru este destul de normal). Ca rezultat, declarațiile implicite de variabile sunt confuze pentru cititor și pot duce la un comportament neașteptat al programului. Vom vorbi mai târziu despre funcții și domenii, dar deocamdată încercați să folosiți cuvinte cheie specializate ori de câte ori sensul unei expresii este declararea unei variabile. Dacă în acest exemplu corpul funcției este rescris ca var bNotVar = 1, atunci o încercare de a rula fragmentul de cod de mai sus va avea ca rezultat un mesaj de eroare ( îl puteți vedea în consola browserului).

De exemplu, poate arăta astfel: Uncaught ReferenceError: bNotVar nu este definit. Semnificația sa se rezumă la faptul că programul nu poate funcționa cu o variabilă inexistentă. Este mult mai bine să vedeți un astfel de mesaj de eroare prima dată când rulați un program decât să scrieți cod de neînțeles care se poate comporta neașteptat.

Dacă, la declararea unei variabile, nu i se inițializează sau nu i se atribuie nicio valoare, i se va atribui automat valoarea nedefinită.

Var a // tip de a === „nedefinit”
Variabilele declarate cu cuvântul cheie var pot fi re-declarate de mai multe ori, atribuindu-le noi valori (dar acest lucru poate fi confuz pentru cititor).

Var a = 1 var a = 2
Mai multe variabile pot fi declarate într-o singură expresie:

Var a = 1, b = 2
Sfera de aplicare a unei variabile este zona programului în care această variabilă este disponibilă (vizibilă).

O variabilă inițializată cu cuvântul cheie var în afara unei funcții este atribuită obiectului global. Are un domeniu de aplicare global și este accesibil de oriunde în program. Dacă o variabilă este declarată folosind cuvântul cheie var în interiorul unei funcții, atunci este vizibilă doar în interiorul acestei funcții, fiind o variabilă locală pentru aceasta.

Dacă o variabilă este declarată într-o funcție folosind var, al cărei nume coincide cu numele unei variabile din domeniul global, aceasta se va „suprapune” variabilei globale. Adică, la accesarea unei astfel de variabile în cadrul unei funcții, se va folosi versiunea locală a acesteia.

Este important să înțelegeți că blocurile (zonele de cod închise între acolade) nu creează noi domenii. Un nou domeniu este creat atunci când funcția este apelată. Cuvântul cheie var are ceea ce se numește domeniu funcțional, nu domeniul bloc.

Dacă o variabilă este declarată în codul funcției, aceasta este vizibilă pentru întregul cod al funcției. Chiar dacă o variabilă este declarată folosind var la sfârșitul codului funcției, vă puteți referi la ea și la începutul codului, deoarece JavaScript folosește mecanismul de ridicare. Acest mecanism „aruncă” declarațiile de variabile, dar nu și operațiile de inițializare ale acestora. Aceasta poate fi o sursă de confuzie, așa că faceți o regulă să declarați variabile la începutul funcției dvs.

▍Cuvântul cheie let

Cuvântul cheie let a fost introdus în ES2015 și poate fi numit pur și simplu o versiune „bloc” a var. Variabilele declarate cu cuvântul cheie let sunt acoperite de blocul, instrucțiunea sau expresia în care este declarată și blocurile imbricate.

Dacă cuvântul „lasă” în sine pare confuz, îți poți imagina că folosești în schimb cuvântul „lasă”. Apoi, expresia let color = „roșu” poate fi tradusă în engleză astfel: „lasă culoarea să fie roșie”, iar în rusă - astfel: „lasă culoarea să fie roșie”.

Folosind cuvântul cheie let, puteți scăpa de ambiguitățile asociate cu cuvântul cheie var (de exemplu, nu puteți declara aceeași variabilă de două ori folosind let). Folosirea let în afara unei funcții, de exemplu la inițializarea buclelor, nu creează variabile globale.

De exemplu, un cod ca acesta va genera o eroare:

Pentru (fie i = 0; i< 5; i++) { console.log(i) } console.log(i)
Dacă, în timpul inițializării buclei, contorul i este declarat folosind cuvântul cheie var, atunci i va fi disponibil în afara buclei după ce își va finaliza activitatea.

În zilele noastre, atunci când dezvoltați programe JS bazate pe standarde moderne, este foarte posibil să abandonați complet var și să folosiți doar cuvintele cheie let și const.

▍Cuvântul cheie const

Variabilele declarate folosind cuvintele cheie var sau let pot fi suprascrise. Dacă se folosește const în locul acestor cuvinte cheie, atunci unei constante declarate și inițializate cu ajutorul ei nu i se poate atribui o nouă valoare.

Const a = "test"
În acest exemplu, constantei a nu i se poate atribui o nouă valoare. Dar trebuie remarcat faptul că, dacă a nu este o valoare primitivă, cum ar fi un număr, ci un obiect, utilizarea cuvântului cheie const nu protejează acel obiect de modificări.

Când spun că un obiect este scris într-o variabilă, ceea ce înseamnă cu adevărat este că variabila stochează o referință la obiect. Această legătură nu poate fi schimbată, iar obiectul în sine, la care duce legătura, poate fi schimbat.

Cuvântul cheie const nu face obiectele imuabile. Pur și simplu protejează referințele la ele scrise în constantele corespunzătoare de modificări. Așa arată:

Const obj = () console.log (obj.a) obj.a = 1 // rulează console.log (obj.a) // obj = 5 // generează o eroare
În timpul inițializării, un nou obiect gol este scris în constanta obj. O încercare de a accesa proprietatea sa inexistentă a nu provoacă o eroare. Consola devine nedefinită. După aceea, adăugăm o nouă proprietate obiectului și încercăm să o accesăm din nou. De data aceasta, valoarea acestei proprietăți este trimisă la consolă - 1. Dacă decomentați ultima linie a exemplului, atunci o încercare de a executa acest cod va duce la o eroare.

Cuvântul cheie const este foarte asemănător cu let, în special, este blocat.

În condiții moderne, este destul de acceptabil să folosiți cuvântul cheie const pentru a declara toate entitățile ale căror valori nu sunt planificate a fi modificate, recurgând la let doar în cazuri speciale. De ce? Ideea este că cel mai bine este să te străduiești să folosești cele mai simple constructe disponibile pentru a nu complica programele și a evita greșelile.

Tipuri de date

JavaScript este uneori denumit limbaj „netipizat”, dar nu este cazul. Este adevărat că puteți scrie valori de diferite tipuri în variabile, dar există tipuri de date în JavaScript, până la urmă. În special, vorbim despre tipuri de date primitive și obiect.

Pentru a determina tipul de date al unei valori, puteți utiliza operatorul typeof. Returnează un șir care indică tipul operandului.

▍Tipuri de date primitive

Iată o listă tipuri primitive Date JavaScript:

• număr (număr)
• șir (șir)
• boolean (valoare booleană)
• null (valoarea specială null)
• nedefinit (valoare specială nedefinită)
• simbol (simbol, folosit în cazuri speciale, introdus în ES6)

Aici, numele tipurilor de date sunt afișate în forma în care sunt returnate de operatorul typeof.

Să vorbim despre tipurile de date cele mai frecvent utilizate din această listă.

Tip de număr

Valorile numerelor JavaScript sunt reprezentate ca numere cu virgulă mobilă cu precizie dublă de 64 de biți.

Literale numerice sunt reprezentate în cod ca numere întregi și numere fracționaleîn notație zecimală. Puteți folosi alte metode pentru a scrie numere. De exemplu, dacă există un prefix 0x la începutul unui literal numeric, acesta este interpretat ca un număr scris în notație hexazecimală. Numerele pot fi scrise și în notație exponențială (în astfel de numere puteți găsi litera e).

Iată exemple de scriere a numerelor întregi:

10 5354576767321 0xCC // număr hexazecimal
Iată numerele fracționale.

3.14 .1234 5.2e4 //5.2 * 10 ^ 4
Literale numerice (acest comportament este tipic și pentru alte tipuri primitive), atunci când încercați să vă referiți la ele ca obiecte, automat, în timp ce operația este efectuată, sunt convertite în obiectele corespunzătoare, care sunt numite „învelișuri de obiecte”. În acest caz, vorbim despre învelișul de obiect Number.

De exemplu, iată cum arată o încercare de a accesa variabila a, în care un literal numeric este scris, ca obiect, în consola Google Chrome.

Sugestie de înfășurare a obiectului număr

Dacă, de exemplu, utilizați metoda toString () a unui obiect de tip Number, acesta va returna reprezentarea în șir a numărului. Comanda corespunzătoare arată astfel, care poate fi executată în consola browserului (și în codul obișnuit) astfel:

A.toString ()
Observați parantezele duble după numele metodei. Dacă nu sunt furnizate, sistemul nu va genera o eroare, dar în loc de rezultatul așteptat, consola va afișa ceva care nu seamănă deloc cu reprezentarea în șir a numărului 5.

Obiectul global Number poate fi folosit ca constructor, creând noi numere cu ajutorul lui (deși aproape niciodată nu este folosit în această formă), poate fi folosit și ca entitate independentă fără a-și crea instanțe (adică unele numere reprezentate prin ajută). De exemplu, proprietatea sa Number.MAX_VALUE conține valoarea numerică maximă reprezentabilă în JavaScript.

Tipul șirului

Valorile șirurilor sunt secvențe de caractere. Asemenea valori sunt specificate ca șir literale închise între ghilimele simple sau duble.

„Un șir” „Un alt șir”
Valorile șirurilor pot fi împărțite în mai multe părți folosind caracterul backslash.

"O sfoară"
Șirul poate conține așa-numitele secvențe de escape, care sunt interpretate atunci când șirul este imprimat pe consolă. De exemplu, secvența \ n înseamnă un caracter de avans de linie. Caracterul backslash poate fi folosit și pentru a adăuga ghilimele la șirurile de caractere cuprinse între ghilimele. Evadarea caracterului ghilimeleu cu \ face ca sistemul să nu îl interpreteze ca caracter special.

„Sunt un dezvoltator”
Șirurile pot fi concatenate folosind operatorul +.

„A” + „șir”

Literale șablon

ES2015 a introdus așa-numitele literale de șablon sau șiruri de șabloane. Sunt șiruri închise în backticks (`) și au câteva proprietăți interesante.

`un șir`
De exemplu, puteți înlocui unele valori în literalele șablon care sunt rezultatul evaluării expresiilor JavaScript.

`un șir cu $ (ceva)` `un șir cu $ (ceva + cevaElse)` `un șir cu $ (obj.ceva ())`
Utilizarea backtick-urilor facilitează scrierea literalelor șiruri de mai multe linii:

`un șir cu $ (ceva)`

tip boolean

JavaScript are câteva cuvinte rezervate folosite atunci când lucrați cu booleeni - adevărat și fals. Operații de comparare, cum ar fi ==, ===,< , >, returnează adevărat sau fals.

Expresiile booleene sunt folosite în constructe precum if și while pentru a ajuta la controlul fluxului unui program.

Trebuie remarcat faptul că acolo unde se așteaptă o valoare adevărată sau falsă, puteți utiliza alte valori care sunt interpretate automat de limbaj ca fiind adevărate (adevărate) sau false (fals).

În special, următoarele sunt valori false:

0 -0 NaN nedefinit null "" // șir gol
Toate celelalte valori sunt adevărate.

Tip nul

JavaScript are o valoare specială, nulă, care indică faptul că nu există nicio valoare. Semnificații similare sunt folosite în alte limbi.

Tip nedefinit

Valoarea nedefinită scrisă într-o variabilă indică faptul că această variabilă nu este inițializată și nu există nicio valoare pentru ea.

Această valoare este returnată automat de la funcțiile care nu returnează în mod explicit rezultatul folosind cuvântul cheie return. Dacă funcția preia un parametru care nu este specificat atunci când este apelată, este, de asemenea, setată la nedefinit.

Pentru a verifica o valoare pentru undefined, puteți utiliza următoarea construcție.

Tip de variabilă === „nedefinit”

▍Obiecte

Toate valorile non-primitive sunt de tip obiect. Vorbim despre funcții, tablouri, ceea ce numim „obiecte” și multe alte entități. Toate aceste tipuri de date se bazează pe tipul de obiect și, deși diferă în multe privințe, au și multe în comun.

Expresii

Expresiile sunt fragmente de cod care pot fi procesate și obținute, pe baza calculelor efectuate, o anumită valoare. Există mai multe categorii de expresii în JavaScript.

Expresii aritmetice

Expresiile care se evaluează la numere se încadrează în această categorie.

1/2 i ++ i - = 2 i * 2

Expresii în șir

Rezultatul evaluării unor astfel de expresii sunt șiruri.

"A" + "șir" "A" + = "șir"

Expresii primare

Literale, constantele, referințele de identificare se încadrează în această categorie.

2 0.02 „ceva” adevărat fals acest // context de execuție, referința la obiectul curent este nedefinită i // unde i este o variabilă sau constantă
Aceasta include, de asemenea, câteva cuvinte cheie și constructe JavaScript.

Funcție clasă de funcții * // generator de randament // comandă pentru a întrerupe / relua activitatea generatorului de randament * // delegați unui alt iterator sau generator funcție asincronă * // expresie funcțională asincronă aștept // așteptați execuția funcției asincrone / model / eu // expresie uzuala() // grupare

Expresii de inițializare a matricei și a obiectelor

// literal matrice () // literal obiect (a: 1, b: 2) (a: (b: 1))

Expresii booleene

Expresiile booleene folosesc operatori booleeni, rezultatul evaluării lor sunt valori booleene.

A && b a || b!a

Expresii de acces la proprietate

Aceste expresii vă permit să accesați proprietățile și metodele obiectelor.

Object.property // accesarea proprietății (sau a metodei) obiectului obiect obiect [„proprietate”]

Expresii de creare a obiectelor

obiect nou () nou a (1) nou MyRectangle ("nume", 2, (a: 4))

Expresii de declarare a funcției

funcția () () funcția (a, b) (întoarce a * b) (a, b) => a * b a => a * 2 () => (întoarce 2)

Expresii de provocare

Astfel de expresii sunt folosite pentru a apela funcții sau metode ale obiectelor.

A.x (2) window.resize ()

Lucrul cu obiecte

Mai sus, am întâlnit deja obiecte, vorbind despre literali obiect, despre apelarea metodelor lor, despre accesarea proprietăților lor. Aici vom vorbi mai detaliat despre obiecte, în special, ne vom uita la mecanismul de moștenire prototipală și la utilizarea cuvântului cheie de clasă.

▍ Moștenirea prototipală

JavaScript se remarcă printre limbajele de programare moderne prin faptul că acceptă moștenirea prototipală. Majoritatea limbajelor orientate pe obiecte folosesc un model de moștenire bazat pe clasă.

Fiecare obiect JavaScript are o proprietate specială (__proto__) care indică un alt obiect care este prototipul său. Obiectul moștenește proprietățile și metodele prototipului.

Să presupunem că avem un obiect creat folosind un obiect literal.

Const mașină = ()
Sau am creat un obiect folosind constructorul Object.

Const car = obiect nou ()
În ambele cazuri, prototipul pentru mașină va fi Object.prototype.

Dacă creați o matrice care este și un obiect, prototipul său va fi obiectul Array.prototype.

Const list = // sau cam asa const list = nou Array ()
Puteți verifica acest lucru după cum urmează.

Car .__ proto__ == Object.prototype // adevărată mașină .__ proto__ == obiect nou () .__ proto__ // adevărată listă .__ proto__ == Object.prototype // false list .__ proto__ == Array.prototype / / listă adevărată .__ proto__ == nou Array () .__ proto__ // adevărat
Aici am folosit proprietatea __proto__, nu trebuie să fie disponibilă dezvoltatorului, dar de obicei vă puteți referi la ea. Trebuie remarcat faptul că o modalitate mai fiabilă de a obține prototipul unui obiect este utilizarea metodei getPrototypeOf () a metodei globale. Obiect obiect.

Object.getPrototypeOf (Obiect nou ())
Toate proprietățile și metodele unui prototip sunt disponibile pentru un obiect care are acest prototip. De exemplu, iată cum arată lista lor pentru o matrice.

Sugestie de matrice

Prototipul de bază pentru toate obiectele este Object.prototype.

Array.prototype .__ proto__ == Obiect.prototip
Object.prototype nu are prototip.

Ceea ce am văzut mai sus este un exemplu de lanț prototip.

Când se încearcă accesul la o proprietate sau o metodă a unui obiect, dacă obiectul în sine nu are o astfel de proprietate sau metodă, acestea sunt căutate în prototipul său, apoi în prototipul prototipului și așa mai departe până când este găsit cel dorit. , sau până când lanțul de prototipuri nu se termină.

Pe lângă crearea de obiecte folosind operatorul nou și utilizarea literalelor obiect sau a literalelor matrice, puteți instanția un obiect folosind metoda Object.create (). Primul argument transmis acestei metode este un obiect care va fi prototipul obiectului pe care îl creează.

Const car = Object.create (Object.prototype)
Puteți verifica dacă un obiect face parte din lanțul de prototipuri al altui obiect folosind metoda isPrototypeOf ().

Const list = Array.prototype.isPrototypeOf (listă)

Funcții de constructor

Mai sus, am creat obiecte noi folosind funcțiile de constructor deja disponibile în limbaj (când le apelăm, se folosește noul cuvânt cheie). Puteți crea singur astfel de funcții. Să ne uităm la un exemplu.

Funcție Persoană (nume) (this.name = nume) Person.prototype.hello = funcție () (console.log (this.name)) let person = new Person ("Flavio") person.hello () console.log ( Person.prototype.isPrototypeOf (persoană))
Aici creăm o funcție de constructor. Când îl apelați, este creat un nou obiect, care este indicat de cuvântul cheie this din corpul constructorului. Adăugăm o proprietate nume acestui obiect și scriem ceea ce este transmis constructorului în el. Acest obiect este returnat automat de la constructor. Folosind o funcție de constructor, puteți crea multe obiecte ale căror proprietăți de nume vor conține ceea ce a fost transmis constructorului când au fost create.

După crearea constructorului, adăugăm la prototipul său o funcție care va imprima pe consolă valoarea proprietății nume a obiectului creat folosind această funcție. Toate obiectele create folosind acest constructor vor avea același prototip și, prin urmare, vor folosi aceeași funcție hello (). Acest lucru este ușor de verificat prin crearea unui alt obiect de tip Person și comparând funcția sa hello () cu funcția obiectului deja din exemplu (în acest caz, numele funcției este scris fără paranteze).

▍Clasuri

În standardul ES6, JavaScript a devenit cunoscut drept „clasă”.

Înainte de aceasta, JavaScript putea folosi doar mecanismul de moștenire prototip descris mai sus. Acest mecanism părea neobișnuit pentru programatorii care au venit la JS din alte limbi. Prin urmare, în limbaj au apărut clase care, de fapt, sunt „zahăr sintactic” pentru mecanismul de moștenire prototipal. Adică, atât obiectele create folosind metoda tradițională, cât și obiectele create folosind clase au prototipuri.

Declarație de clasă

Așa arată declarația de clasă.

Persoană de clasă (constructor (nume) (this.name = name) hello () (return "Hello, I am" + this.name + "."))
Clasa are un identificator care poate fi folosit pentru a crea obiecte noi folosind noul construct ClassIdentifier ().

Când se creează un obiect nou, se apelează la metoda constructorului, îi sunt trecuți parametrii.

Metodele pot fi declarate în clasă. În cazul nostru, hello () este o metodă care poate fi apelată de toate obiectele create din clasă. Acesta este modul în care arată crearea unui nou obiect folosind clasa Person.

Const flavio = Persoană nouă ("Flavio") flavio.hello ()

Moștenirea pe bază de clasă

Clasele pot extinde alte clase. Obiectele create din astfel de clase vor moșteni atât metodele clasei originale, cât și metodele definite în clasa extinsă.

Dacă o clasă care extinde o altă clasă (moștenind din această clasă) are o metodă al cărei nume este același cu cel al clasei părinte, această metodă are prioritate față de cea originală.

Class Programmer extinde Person (hello () (return super.hello () + „Sunt un programator.”)) Const flavio = nou programator („Flavio”) flavio.hello ()
Apelarea metodei hello () din exemplul de mai sus va returna șirul Hello, I am Flavio. Sunt programator.

Clasele nu prevăd prezența variabilelor (proprietăți), proprietățile obiectelor create cu ajutorul claselor trebuie configurate în constructor.

În cadrul unei clase, vă puteți referi la clasa părinte folosind cuvântul cheie super.

Metode statice

Metodele descrise într-o clasă pot fi apelate prin referire la obiectele create pe baza acestei clase, dar nu și la clasa în sine. Metodele statice pot fi apelate prin referire direct la clasă.

Metode private

JavaScript nu are un mecanism încorporat care vă permite să declarați metode private (private, private). Această limitare poate fi ocolită, de exemplu, prin utilizarea dispozitivelor de închidere.

Getters și Setters

Într-o clasă, puteți descrie metode precedându-le cu cuvintele cheie get sau set. Acest lucru vă permite să creați așa-numitele getters și setters - funcții care sunt utilizate pentru a controla accesul la proprietățile obiectelor create dintr-o clasă. Un getter este apelat atunci când se încearcă să citească valoarea unei pseudo-proprietăți, iar un setter este apelat când se încearcă să fie scrisă o nouă valoare în ea.

Clasa Persoană (constructor (nume) (this.userName = nume) set name (value) (this.userName = value) get name () (return this.userName))

Rezultate

În acest articol, am vorbit despre variabile, tipuri de date, expresii și lucrul cu obiecte în JavaScript. Funcțiile vor fi subiectul următorului nostru articol.

Dragi cititori! Dacă ați scris în JS de mult timp, vă rugăm să ne spuneți ce părere aveți despre aspectul cuvântului cheie clasă în limbă.

Am decis să scriu o serie de articole numite „Dificul despre simplu”. Această serie se va concentra pe limbajul JavaScript. De ce este „dificil la simplu”? Pentru că tot ceea ce vă voi spune vă voi spune ținând cont de particularitățile muncii interpretului, începând cu tipurile de date. Toate acestea vor fi făcute pentru a putea spune doar despre complex, de exemplu, despre metodele de moștenire în JavaScript și alte modele.

JavaScript este un limbaj de programare orientat pe obiecte cu o organizare prototipică.
Ce înseamnă „cu o organizație prototip”, vom vorbi în articolul următor (cu siguranță va fi), dar de ce este „orientat pe obiect” și dacă totul în JS este un obiect, vom afla astăzi.
JS are nevoie doar de 9 tipuri pentru a-și îndeplini obiectivele. Mai mult decât atât, doar 6 dintre ele sunt disponibile programului, restul de 3 sunt disponibile doar la nivel de implementare și sunt utilizate de caietul de sarcini. La prima vedere (și aceasta este prima concepție greșită), totul în JS sunt obiecte. Deci cinci dintre cele șase tipuri disponibile pentru program sunt așa-numitele primitive și nu sunt obiecte (mai jos voi explica de ce și cum sunt confundate cu obiectele). Aceste cinci primitive sunt:

- șir (s = „str”)
- Număr (n = 10)
- boolean (b = adevărat)
Și așa cum le numesc „tipuri filozofice”:
- nul (v = nul)
- nedefinit (u = nedefinit)

Filosofic în acest sens nul înseamnă că nu i s-a atribuit nimic variabilei, iar nedefinit înseamnă că nu a fost atribuit variabilei. Care este diferența dintre „nimic” și „gold” în acest caz - reflectați pe îndelete. Nu vom face asta acum.

Al șaselea tip (obiect) disponibil programului este:
-Obiect(a nu se confunda cu constructorul Object, acum vorbim doar despre tipuri abstracte!) este singurul tip care reprezintă obiecte în JavaScript.
Un obiect este o structură de date (un întreg set al acestora), reprezentată ca un set de perechi cheie-valoare. Valoarea poate fi oricare dintre tipurile de date - atunci va fi o proprietate a obiectului, sau chiar o funcție - atunci va fi o metodă a obiectului.

Există o multitudine de moduri de a lucra cu primitivi. Începând cu faptul că pot fi alocate variabilelor prin literale sau prin constructori și terminând cu faptul că primitivele nu pot fi deloc declarate în variabile, lucrând direct cu ele. Aceleași primitive pot fi în variabilele globale și în cele locale.

Aici sunt cateva exemple:

Var v1; // variabilă locală nedefinită (vide) var v2 = "2"; // șir variabilă literală locală var v3 = new String (2); // șir variabilă locală declarată prin constructor. Va crea un nou obiect de tip String v4 = String (2); // șir variabilă globală apelată prin constructor. Va crea o fereastră variabilă.v4 „2” .lungime; // șirul nu va deveni o variabilă, dar poate fi deja folosit ca obiect 34..toString (); // numărul nu va deveni o variabilă, dar poate fi deja folosit ca obiect 12. toString (); // numărul nu va deveni variabilă, dar poate fi folosit deja ca obiect (22) .toString (); // numărul nu va deveni variabilă, dar poate fi deja folosit ca obiect

În ultimele 4 comenzi, puteți vedea clar cum o primitivă este confundată cu un obiect - până la urmă, numim o metodă, printr-un punct - la fel ca un obiect. Chiar se pare că aceste primitive sunt obiecte.

Concepția greșită este agravată atunci când verificăm tipul unei variabile, de exemplu

Var v = nul; tip de v;

Și primim „obiect” ca răspuns.

Și dacă scriem:
var v = nul; v instanceof Object;

Atunci va apărea o mizerie în capul meu, pentru că rezultatul ultimei rânduri va fi „fals”. Adică, variabila v este de tip obiect, dar nu este moștenită de la tipul Object. Ce naiba?!

Mai întâi, voi explica trucul cu typeof null. Acest operator returnează tipul obiectului. Și adevărul este că operatorul typeof returnează o valoare șir luată dintr-un tabel hard-coded, unde este scris: „for null, return” obiect „”. Operatorul instanceof - verifică dacă ceva aparține tipului de date specificat. Vă voi spune cum face acest lucru în articolul următor, dar vă asigur că în acest caz a funcționat corect, nulul primitiv nu este în niciun caz moștenit de la tipul Object - el însuși, un primitiv, este cel mai jos stadiu de dezvoltare. .

Bine, ne-am dat seama cu typeof și instanceof, dar metodele sunt numite pentru primitive - la fel cum obiectele sunt drepte! Cum dacă nu este un obiect?

Iată chestia. Există așa ceva ca funcțiile wrapper (constructori) (și vor fi clarificate din nou în al doilea articol). Sunt disponibile pentru toate primitivele (Number (), Boolean (), String ()), precum și pentru altele. Esența lor este de a crea un obiect dintr-o primitivă, care va avea metode auxiliare pentru lucrul cu acest tip de primitiv.
De exemplu, o variabilă poate fi creată astfel:

Var num = Număr nou (23.456);

În acest caz, obținem un obiect din primitiva 23.456.
Pentru tipul de număr, constructorul Number () are o metodă de ajutor pentru Precision () - determină numărul de cifre semnificative pentru număr. De exemplu, dacă numărul de cifre semnificative este setat la 23,456, atunci obținem numărul 23,45.
Și iată când încercăm să ne referim la primitiv ca obiect:

(23.456). la Precizie (4);

Interpretul înfășoară temporar primitivul într-un obiect apelând un număr nou (23.456) și apoi apelează metoda toPrecision () a acestui obiect, pe care o are acum. Astfel, mulți oameni cred în mod eronat că totul în JS este un obiect.

Există, de asemenea, un alt exemplu de înșelăciune și înțelegere greșită a ceea ce se întâmplă. Iată codul:

Var str = ‘str’; str.test = ‘test’; // nu va fi nicio eroare, programul va continua să ruleze, dar console.log (str.test); // nedefinit

Dacă am presupune, ca și înainte, că str este un obiect, am fi surprinși de ce nu și-a amintit noul test de proprietate. Dar acum știm că atunci când ne referim la o primitivă ca obiect, acesta este temporar învelit într-un obiect de tip String. Dar după ce operația este finalizată, acest înveliș dispare și, odată cu el, noul test de proprietate. Asta e, fără magie.

De fapt, privind în față, în timp ce înfășurați o primitivă într-un obiect, se construiește un întreg lanț de moștenire (așa cum vom vorbi despre el mai târziu), dar de fapt se dovedește o astfel de „matryoshka”:

Obiect (număr (<примитив>)). Părintele oricărui obiect din JS, într-un fel sau altul, va fi Object. Când apelați o proprietate într-un obiect, căutarea trece prin toată această „matryoshka” până când găsește această proprietate într-unul dintre obiecte sau returnează nedefinit, sau dacă căutați o metodă, aruncă o excepție. Astfel, primitivul are și proprietățile obiectului Object disponibile. Vom vorbi despre modul în care funcționează moștenirea prototipală și complexitățile sale în al doilea articol.

Pentru intriga celui de-al doilea articol pe care vreau să-l lansez, voi vorbi despre încă un lucru legat de funcțiile constructorului - aceasta este conversia de tip. JS nu este un limbaj puternic tipizat. Aceasta înseamnă că în momentul declarării unei variabile nu suntem obligați să indicăm de ce tip este aceasta și, în plus, în timpul funcționării programului, în această variabilă pot fi introduse date de orice tip absolut. Și, de asemenea, putem folosi, de exemplu, variabile șir în operații matematice sau invers, numere în operațiuni de concatenare. Exemplu:

Var str = "abc"; str + 1; // "abc1"

Aici, o primitivă de tip număr - 1 va fi convertită într-o primitivă șir. În obiecte, această caracteristică este disponibilă prin apelul la metoda toString (), în obiectele de tip number, există o metodă valueOf () care va returna o primitivă de tip number. Dar am cam spus că doar obiectele pot avea metode. Deci, în procesul de conversie a unei primitive de la un tip la altul, există și împachetare într-un obiect? Vă asigur că nu. Această metodă este apelată implicit atunci când funcția constructor este apelată de interpret fără noul operator. Ce fel de operator magic este nou și ce se întâmplă atunci când o funcție de constructor este numită fără el și ce dracu este o astfel de funcție de constructor, vom vorbi în articolul următor. Deocamdată, credeți-mă pe cuvânt - conversia tipului are loc imediat - de la primitiv la primitiv.

Până acum, desigur, există mai multe întrebări decât răspunsuri, totuși, credeți-mă, totul va deveni mult mai transparent după citirea celui de-al doilea articol. Aici, în principal, am intrigat și am ridicat o serie de întrebări - ca să spunem așa, am entuziasmat mințile. Dar totuși, se poate învăța ceva din acest articol:
1. În ciuda înțelepciunii convenționale că „totul în JS sunt obiecte” nu este așa, am aflat că din 6 tipuri de date disponibile programatorului, 5 sunt primitive și doar unul reprezintă un tip de obiect.
2. Despre obiecte, am aflat că aceasta este o structură de date care conține perechi cheie-valoare. Când valoarea poate fi oricare dintre tipurile de date (și aceasta va fi o proprietate a obiectului) sau o funcție (și aceasta va fi o metodă a obiectului).
3. Dar primitivele nu sunt obiecte. Deși puteți lucra cu ele ca și cu un obiect (și acest lucru provoacă concepția greșită că un primitiv este un obiect), dar ...
4. Variabilele pot fi declarate atât într-un mod simplu (literal) (var a = ‘str’), cât și printr-o funcție de constructor (wrapper) (var a = new String (‘str’)). În al doilea caz, nu vom mai primi o primitivă, ci un obiect creat de funcția de wrapper String (). (ce fel de operator magic nou și ce este o funcție de constructor, vom afla mai târziu).
5. Am învățat că prin crearea unui wrapper peste o primitivă (noul String (‘str’)) puteți lucra cu el ca obiect. Acest înveliș este pe care interpretul îl creează în jurul primitivului atunci când încercăm să lucrăm cu el ca cu un obiect, dar după ce operația este finalizată, acesta este distrus (prin urmare, primitivul nu va putea niciodată să-și amintească proprietatea pe care o atribuim. it a.test = 'test' - proprietatea testului va dispărea cu wrapper-ul).
6. Am aflat că obiectele au o metodă toString () care returnează o reprezentare șir a unui obiect (pentru tipul number valueOf (), va returna o valoare numerică).
7. Ne-am dat seama că atunci când se efectuează operații de concatenare sau matematică, primitivele își pot redefini tipul la cel dorit. Pentru a face acest lucru, ei folosesc funcții wrapper de tipul lor, dar fără noul operator (str = String (str)). (Care este diferența și cum funcționează, hai să vorbim mai departe)
8. În cele din urmă, am aflat că typeof preia valori dintr-un tabel hard-coded (de aici provine o altă concepție greșită bazată pe tipul de obiect null //).

Toate limbajele de programare au structuri de date încorporate, dar acestea diferă adesea de la o limbă la alta. Acest articol încearcă să enumere structurile de date încorporate disponibile în JavaScript și ce proprietăți au acestea; acestea pot fi folosite pentru a construi alte structuri de date. Ori de câte ori este posibil, se fac comparații cu alte limbi.

Tastare dinamică

JavaScript este un scris vag sau a dinamic limba. Variabilele din JavaScript nu sunt asociate direct cu niciun tip de valoare anume și oricărei variabile i se pot atribui (și reatribui) valori de toate tipurile:

Let foo = 42; // foo este acum un număr foo = "bar"; // foo este acum un șir foo = true; // foo este acum un boolean

Tipuri de date

Cel mai recent standard ECMAScript definește opt tipuri de date:

• Șapte tipuri de date care sunt:

Valori primitive

Toate tipurile, cu excepția obiectelor, definesc valori imuabile (valori care nu pot fi modificate). De exemplu, spre deosebire de C, șirurile sunt imuabile. Ne referim la valorile acestor tipuri ca „valori primitive”.

tip boolean

Booleanul reprezintă o entitate logică și poate avea două valori: adevărat și fals. Consultați Boolean și Boolean pentru mai multe detalii.

Tip nul

Proprietăți

În JavaScript, obiectele pot fi văzute ca o colecție de proprietăți. Cu sintaxa literală a obiectului, un set limitat de proprietăți este inițializat; apoi proprietățile pot fi adăugate și eliminate. Valorile proprietăților pot fi valori de orice tip, inclusiv alte obiecte, ceea ce permite construirea de structuri complexe de date. Proprietățile sunt identificate folosind valorile cheie. O valoare cheie este fie un String, fie o valoare Symbol.

Există două tipuri de proprietăți ale obiectelor care au anumite atribute: proprietatea de date și proprietatea accesoriului.

Proprietatea datelor

Asociază o cheie cu o valoare și are următoarele atribute:

Atributele unei proprietăți de date

Atribut	Tip	Descriere	Valoare implicită
[]	Orice tip JavaScript	Valoarea obținută de către un get access la proprietate.	nedefinit
[]	boolean	Dacă este fals, proprietatea „s [] nu poate fi modificată.	fals
[]	boolean	pentru... în bucle. A se vedea, de asemenea, Enumerabilitatea și proprietatea proprietăților	fals
[]	boolean	Dacă este fals, proprietatea „nu poate fi ștearsă, nu poate” fi schimbată într-o proprietate de accesare și alte atribute decât [] și [] nu pot fi modificate.	fals

Atribute învechite (începând cu ECMAScript 3, redenumit în ECMAScript 5)

Atribut	Tip	Descriere
Numai citire	boolean	Stare inversată a atributului ES5 [].
DontEnum	boolean	Stare inversată a atributului ES5 [].
Nu șterge	boolean	Stare inversată a atributului ES5 [].

Proprietatea accesoriilor

Asociază o cheie cu una sau două funcții accesorii (get și set) pentru a prelua sau stoca o valoare și are următoarele atribute:

Atributele unei proprietăți accesorii

Atribut	Tip	Descriere	Valoare implicită
[]	Obiectul funcției sau nedefinit	Funcția este apelată cu o listă de argumente goală și preia valoarea proprietății ori de câte ori se efectuează un acces la valoare. Vezi și obține.	nedefinit
[]	Obiectul funcției sau nedefinit	Funcția este apelată cu un argument care conține valoarea atribuită și este executată ori de câte ori se încearcă modificarea unei proprietăți specificate. Vezi și set.	nedefinit
[]	boolean	Dacă este adevărată, proprietatea va fi enumerată în for... în bucle.	fals
[]	boolean	Dacă este fals, proprietatea „nu poate fi ștearsă și nu poate” fi schimbată într-o proprietate de date.	fals

Notă: Atributul este folosit de obicei de motorul JavaScript, așa că nu îl puteți accesa direct (vezi mai multe despre Object.defineProperty ()). De aceea, atributul este pus între paranteze pătrate duble în loc de simplu.

Obiecte și funcții „normale”.

Un obiect JavaScript este o mapare între chei și valori. Cheile sunt șiruri de caractere (sau simboluri) iar valorile pot fi orice. Acest lucru face obiectele o potrivire naturală pentru hărți hash.

Funcțiile sunt obiecte obișnuite cu capacitatea suplimentară de a fi apelabile.

Datele

Când reprezentați datele, cea mai bună alegere este să utilizați utilitarul Data încorporat în JavaScript.

Colecții indexate: Arrays și Arrays tipizate

Matricele sunt obiecte obișnuite pentru care există o relație specială între proprietățile cu chei întregi și proprietatea „lungime”. În plus, matricele moștenesc de la Array.prototype, care le oferă o mână de metode convenabile de a manipula matrice. De exemplu, indexOf (căutarea unei valori în matrice) sau push (adăugarea unui element în matrice), etc. Acest lucru face ca Arrays să fie candidatul perfect pentru a reprezenta liste sau seturi.

Matricele tipizate sunt noi pentru JavaScript cu ECMAScript 2015 și prezintă o vizualizare asemănătoare matricei a unui buffer de date binare subiacent. Următorul tabel vă ajută să găsiți tipurile de date C echivalente:

Obiecte TypedArray

Tip	Interval de valori	Dimensiunea în octeți	Descriere	Web IDL tip	Tipul C echivalent
Int8Array	-128 până la 127	1	Număr întreg cu semn complement pe 8 biți	octet	int8_t
Uint8Array	de la 0 la 255	1	întreg fără semn pe 8 biți	octet	uint8_t
Uint8ClampedArray	de la 0 la 255	1	întreg fără semn pe 8 biți (fixat)	octet	uint8_t
Int16Array	-32768 până la 32767	2	Număr întreg cu semn complement pe 16 biți	mic de statura	int16_t
Uint16Array	0 la 65535	2	întreg fără semn pe 16 biți	scurt nesemnat	uint16_t
Int32Array	-2147483648 până la 2147483647	4	Număr întreg cu semn complement pe 32 de biți	lung	int32_t
Uint32Array	0 până la 4294967295	4	întreg fără semn pe 32 de biți	nesemnat lung	uint32_t
Float32Array	1,2x10 -38 până la 3,4x10 38	4	Număr în virgulă mobilă IEEE pe 32 de biți (7 cifre semnificative, de exemplu 1.1234567)	plutire nerestricționată	pluti
Float64Array	5,0x10 -324 până la 1,8x10 308	8	Număr în virgulă mobilă IEEE pe 64 de biți (16 cifre semnificative, de exemplu, 1,123 ... 15)	dublu nerestricționat	dubla
BigInt64Array	-2 63 la 2 63 -1	8	Număr întreg cu semn complementar pe 64 de biți	bigint	int64_t (semnat lung lung)
BigUint64Array	0 la 2 64 -1	8	întreg fără semn pe 64 de biți	bigint	uint64_t (nesemnat lung lung)

Colecții cu cheie: Hărți, Seturi, Hărți slabe, Seturi slabe

Aceste structuri de date iau referințe la obiect ca chei și sunt introduse în ECMAScript Edition 6. Set și WeakSet reprezintă un set de obiecte, în timp ce Map și WeakMap asociază o valoare unui obiect. Diferența dintre Maps și WeakMaps este că, în primul, cheile obiectelor pot fi enumerate. Acest lucru permite optimizările colectării gunoiului în ultimul caz.

S-ar putea implementa Hărți și Seturi în ECMAScript 5 pur. Cu toate acestea, deoarece obiectele nu pot fi comparate (în sensul „mai puțin decât”, de exemplu), performanța căutării ar fi neapărat liniară. Implementările native ale acestora (inclusiv WeakMaps) pot avea performanțe de căutare care sunt aproximativ logaritmice în timp constant.

De obicei, pentru a lega date la un nod DOM, se pot seta proprietăți direct asupra obiectului sau se pot folosi atribute data-*. Acest lucru are dezavantajul că datele sunt disponibile pentru orice script care rulează în același context. Maps și WeakMaps facilitează legarea privată a datelor la un obiect.

Date structurate: JSON

JSON (JavaScript Object Notation) este un format ușor de schimb de date, derivat din JavaScript, dar folosit de multe limbaje de programare. JSON construiește structuri de date universale. Consultați JSON și JSON pentru mai multe detalii.

Mai multe obiecte în biblioteca standard

JavaScript are o bibliotecă standard de obiecte încorporate. Vă rugăm să aruncați o privire la referință pentru a afla mai multe obiecte.

Determinarea tipurilor folosind operatorul typeof

Operatorul typeof vă poate ajuta să găsiți tipul variabilei dvs. Vă rugăm să citiți pentru mai multe detalii și cazuri marginale.

Specificații

Specificație	stare	cometariu
ECMAScript prima ediție (ECMA-262)	Standard	Definiție inițială.
ECMAScript 5.1 (ECMA-262) Definiția „Tipurilor” din specificația respectivă.	Standard
ECMAScript 2015 (ediția a 6-a, ECMA-262)	Standard	Simbol adăugat.
Ultima versiune ECMAScript (ECMA-262) Definiția „Tipurilor și valorilor de date ECMAScript” din specificația respectivă.	Proiect