Tipuri de date

Toată informația utilizată în JavaScript are un tip specific. În JavaScript există opt tipuri de date:

• String: reprezintă un șir de caractere
• Number: reprezintă o valoare numerică
• BigInt: este destinat reprezentării numerelor întregi foarte mari
• Boolean: reprezintă o valoare logică true sau false
• Undefined: reprezintă o valoare specială - undefined și indică că valoarea nu este setată
• Null: reprezintă o valoare specială - null și indică absența unei valori
• Symbol: reprezintă o valoare unică, adesea utilizată pentru a accesa proprietățile obiectelor complexe
• Object: reprezintă un obiect complex

Primele șapte tipuri reprezintă tipuri de date primitive. Ultimul tip - Object reprezintă un tip de date complex, care constă din valori de tipuri primitive sau alte obiecte. Să analizăm principalele tipuri de date primitive.

Date numerice

Tipul Number reprezintă numere în JavaScript, care pot fi întregi sau zecimale:

Numere întregi, de exemplu, 35. Putem utiliza atât numere pozitive, cât și negative. Intervalul de numere utilizate este de la -2^53 la 2^53.

Numere zecimale (numere cu virgulă mobilă). Punctul este folosit ca separator între partea întreagă și partea zecimală, de exemplu, 3.5575. La fel, se pot utiliza numere pozitive și negative. Pentru numerele cu virgulă mobilă, se aplică același interval: de la -2^53 la 2^53.

De exemplu:

const x = 45;
const y = 123.897;
const z = -0.123;

JavaScript oferă posibilitatea de a defini numere în sistem binar, octal și hexazecimal, ceea ce este foarte util atunci când trebuie să efectuăm operații pe biți cu biții individuali ai unui număr. Pentru a defini un număr în sistemul binar, se adaugă un prefix "0b" în fața numărului:

const num1 = 0b1011;    //cifra 11 în a sistemul zecimal
console.log(num1);      // 11

În acest caz, constanta num1 este egală cu 0b1011, ceea ce în sistemul zecimal este echivalent cu 11.

Pentru a defini un număr în sistemul octal, se adaugă un prefix "0o" în fața numărului:

const num1 = 0o11;    //cifra 9 în sistemul zecimal
console.log(num1);      // 9

Pentru a defini un număr în sistemul hexazecimal, se adaugă un prefix "0x" în fața numărului:

const num1 = 0xff;    // cifra 255 in sistemul zecimal
console.log(num1);      // 255
const num2 = 0x1A;    // cifra 26 in sistemul zecimal
console.log(num2);      // 26

Începând cu standardul ECMAScript 2021 în JavaScript, în scopul îmbunătățirii legibilității, se poate utiliza caracterul underscore _ ca separator între cifrele unui număr.

const num1 = 1234567;
const num2 = 123_4567;  //cifra egală cu num1

const num3 = 1234567890;
const num4 = 12_3456_7890;    // cifra egală cu num3

Tipul BigInt

Tipul BigInt a fost introdus în ultimele standarde JavaScript pentru a reprezenta numere întregi foarte mari, care depășesc intervalul tipului number. Aceasta nu înseamnă că nu putem lucra deloc cu numere mari folosind tipul number, dar lucrul cu ele în cazul tipului number poate întâmpina probleme. Să luăm în considerare un mic exemplu:

let num = 9007199254740991
console.log(num);       // 9007199254740991
console.log(num + 1);   // 9007199254740992
console.log(num + 2);   // 9007199254740992

Aici, variabilei num i se atribuie valoarea maximă. Apoi adăugăm la ea anumite valori și afișăm rezultatul pe consolă. Rezultatele pot fi confuze, în special în cazul adăugării valorii 2.

Trebuie să menționăm că tipul Number este limitat, chiar dacă permite manipularea unui interval destul de mare de numere. În particular, putem utiliza constantele speciale Number.MIN_VALUE și Number.MAX_VALUE pentru a verifica valorile minime și maxime posibile pentru tipul Number:

console.log(Number.MIN_VALUE);   // 5e-324
console.log(Number.MAX_VALUE);  // 1.7976931348623157e+308

În acest exemplu, să luăm în considerare următorul scenariu:

const num = 9223372036854775801;
console.log(num);   // 9223372036854776000

Datorită restricțiilor tipului Number, pe consolă vom vedea un număr ușor diferit față de cel atribuit constantei num. Acest lucru poate afecta negativ precizia în calcul. Și tocmai pentru astfel de scenarii este destinat tipul BigInt. Pentru a defini un număr ca valoare a tipului BigInt, la sfârșitul numărului se adaugă sufixul n:

let dimension = 19007n;
const value = 2545n;

De exemplu, să schimbăm tipul de la number la bigint în exemplul anterior:

const num = 9223372036854775801n;
console.log(num);   // 9223372036854775801n

Acum consola afișează rezultatul corect.

Tipul Boolean

Tipul Boolean reprezintă valori booleene sau logice: true (adevărat) și false (fals):

const isAlive = true;
const isDead = false;

Șirurile de caractere (String)

Tipul String reprezintă șiruri de caractere. Pentru a defini șiruri, se utilizează ghilimele, fie ele duble sau simple, sau ghilimele inversate. Singura restricție este că tipul ghilimelor de închidere trebuie să fie același cu tipul celor de deschidere, adică fie ambele ghilimele duble, fie ambele simple.

const user = "Tom";
const company = 'Microsoft';
const language = JavaScript;

console.log(user);
console.log(company);
console.log(language);

Dacă în interiorul șirului apar ghilimele, trebuie să le escapați cu o bară inversă. De exemplu, să presupunem că avem textul "Birou "Coarne и Copite"". Acum vom escapa ghilimelele:

const company = "Biroul \"Coarne și Copite\"";

De asemenea, putem utiliza un alt tip de ghilimele în interiorul șirului:

const company1 = "Biroul 'Coarne și Copite'";
const company2 = 'Biroul "Coarne și Copite"';

De asemenea, un șir poate conține caractere speciale - secvențe de control care sunt interpretate într-un mod specific. Cele mai comune secvențe sunt "\n" (trecere la o nouă linie) și "\t" (tabulare). De exemplu:

const text = "Hello FDC.COM\nHello\tWorld";
console.log(text);

Când se afișează textul din constanta text pe consolă, va fi interpretat în felul următor:

Hello FDC.COM
Hello        World

Interpolare și multiline

Utilizarea ghilimelor inverse () permite interpolarea, adică incorporarea datelor într-un șir. De exemplu:

const user = "Tom";
const text = Nume: ${user};
console.log(text);  // Nume: Tom

Pentru a încorpora valorile expresiilor (de exemplu, valorile altor variabile și constante) într-un șir, înaintea expresiei se pune simbolul dolar $, iar după acesta se specifică expresia între acolade. Astfel, în exemplul de mai sus, ${user} indică că la acest loc din șir trebuie încorporată valoarea variabilei user.

În același mod, se pot încorpora și mai multe date:

const user = "Tom";
const age = 37;
const isMarried = false;
const text = Name: ${user}   Age: ${age}   IsMarried: ${isMarried};
console.log(text);  // Name: Tom   Age: 37   IsMarried: false

De asemenea, ghilimelele inverse permit definirea de texte multiline:

const multilineText =
S-a întors cercetătoarea
Să le spuie la surori
Că-i deschisă toată floarea
Şi câmpia, de cu zori.;

console.log(multilineText);

Ieșirea în consolă a browser-ului.

S-a întors cercetătoarea
Să le spuie la surori
Că-i deschisă toată floarea
Şi câmpia, de cu zori.

Tipul null și undefined

undefined indică că o valoare nu este definită sau nu este atribuită. Pe de altă parte, null indică că o variabilă nu are o valoare.

let email;
console.log(email); // afișat undefined

Prin atribuirea valorii null, se indică că variabila nu are o valoare:

let email;
console.log(email); // undefined
email = null;
console.log(email);     // null

Merită de menționat că, deși în principiu se poate atribui variabilei valoarea undefined, așa cum se arată în următorul caz:

let email = "tome@mimimail.com";
email = undefined;      // setăm tipul undefined
console.log(email); // undefined

Dar semnificația principală a undefined constă în faptul că variabila nu este inițializată, ceea ce se întâmplă mai des înainte de a-i fi atribuită vreo valoare. De aceea, de obicei nu se presupune că unei variabile i se va atribui explicit valoarea undefined. În același timp, acest tip poate fi util - îl putem folosi pentru a verifica inițializarea variabilei. Dar dacă trebuie să indicăm că variabila nu are nicio valoare, atunci i se atribuie null, nu undefined.

Tipul object

Tipul Object reprezintă un obiect complex cu diferite proprietăți și metode. Cel mai simplu mod de a defini un obiect este prin intermediul acoladelor:

const user = {};

Un obiect poate avea diverse proprietăți și metode:

const user = {name: "Tom", age:24};
console.log(user.name);

În acest caz, obiectul este denumit user și are două proprietăți: name și age, care au ca valori date de alte tipuri. Aceasta este o descriere succintă a obiectelor; vom explora mai în detaliu obiectele în articolele viitoare.

Tipizarea slabă/dinamică

JavaScript are tipizare slabă și dinamică, ceea ce înseamnă că tipurile pot fi schimbate dinamic. De exemplu:

let id;  //tip undefined
console.log(id);
id = 45;  // tip number
console.log(id);
id = "45"; // tip string
console.log(id);

Chiar dacă în al doilea și al treilea caz consola va afișa numărul 45, în al doilea caz variabila id va reprezenta un număr, iar în al treilea caz va reprezenta un șir.

Operatorul typeof

Cu ajutorul operatorului typeof putem obține tipul unei variabile, ceea ce poate fi util atunci când, în funcție de tipul variabilei, trebuie să efectuăm anumite acțiuni:

let id;
console.log(typeof id);       // va afișa "undefined"
id = 45;
console.log(typeof id);   // va afișa "number"
id = 45n;
console.log(typeof id);     // va afișa "bigint"
id = "45";
console.log(typeof id);     // va afișa "string"

Trebuie de menționat că pentru valoarea null, operatorul typeof returnează "object", deși în mod teoretic, null reprezintă un tip separat.