Operatori

Lista de operatori

Numărul de operanzi

• operatori unari (+x)
• operatori binari (x + 5)
• operator terțar (x ? x + 1 : x - 1)

Prioritatea operațiilor

Dacă avem mai multe operații într-o singură expresie, ele vor fi interpretate câte una în ordinea priorităților. Tabela de mai sus este ordonată crescător, cele de la început de tabelă având prioritate în mare parte.

Regula priorităților e simplă: mai întâi se execută operatorii unari, apoi înmulțirea/împărțirea, apoi adunarea/scăderea, apoi restul.

Pentru a modifica ordinea operațiilor se folosesc paranteze () pentru a izola operațiile prioritare.

Asociativitatea operatorilor

Coloana A din tabelă reprezintă asociativitatea operatorilor și are valoarea S (stânga) pentru a specifica asociativitatea stânga spre dreapta, și D (dreapta) pentru a specifica asociativitatea dreapta spre stânga.

• Stânga spre dreapta: s = a - b - c e la fel cu s = ((a - b) - c)
• Dreapta spre stânga: d = a = b = c e la fel cu d = (a = (b = c))

Operatori aritmetici

În JS avem operațiile aritmetice de bază: +, -, *, /, %

• ambii operanzi sunt transformați în numere, NaN dacă nu are valoare numerică (excepție +)
• atunci când se face adunarea / concatenarea (+)
  • dacă oricare dintre operanzi este un obiect, atunci este transformat într-o primitivă (folosind valueOf() sau toString())
  • apoi se verifică dacă cel puțin unul din operanzi este un string, atunci și celălalt este transformat în string și se face concatenarea
  • dacă nu, ambii operanzi sunt transformați în numere (NaN dacă nu are valoare numerică) și se face adunarea
• dacă oricare dintre operanzi este NaN, atunci rezultatul operației va fi NaN

Operatorul modulo (%)

Operatorul modulo întoarce restul împărțirii.

A / B = C + R => C * B + R = A => A % B = R

unde C este un număr întreg. Altfel zis, modulo ne va zice cât anume ne rămâne dacă vrem să incadrăm pe B în A de un număr (indiferent de valoarea acelui număr) întreg de ori.

Două lucruri importante de știut:

• modulo funcționează și cu numere cu virgulă (floating-point)
• semnul rezultatului este semnul primului operand

Egalitatea și egalitatea strictă (==, ===)

Egalitatea simplă (==) sau egalitatea abstractă. Comparația x == y va întoarce true sau false, urmând următoarele verificări:

1. dacă Type(x) și Type(y) sunt la fel => se face egalitatea strictă x === y
2. dacă xeste null și y este undefined (sau invers) => true
3. dacă Type(x) este Number și Type(y) este String (sau invers) => x == ToNumber(y)
4. dacă Type(x) este Boolean (sau invers) => ToNumber(x) == y
5. dacă Type(x) este String, Number sau Symbol și Type(y) este Obiect (sau invers) => x == ToPrimitive(y)
6. => false

! Specificațiile ECMA

Egalitatea strictă (===). Comparația x === y va întoarce true sau false, urmând urmatoarele verificări:

1. dacă Type(x) este diferit de Type(y) => false
2. dacă Type(x) este Number, atunci:
   1. dacă x este NaN (sau invers) => false
   2. dacă x și y au aceeași valoare numerică => true
   3. dacă x este +0 și y este -0 (sau invers) => true
   4. => false
3. dacă Type(x) este Undefined sau Null => true
4. dacă Type(x) este String, Boolean sau Symbol și x și y au aceeași valoare => true
5. dacă x și y indică către același obiect => true
6. => false

Operatorii condiționali (<, >, <=, >=)

Compararea se poate face doar pe numere sau strings (alfabetic), dar operanzii pot avea orice tip de date. Astfel, se aplică următoarele verificări:

1. dacă oricare din operanzi este un obiect, atunci el se transformă în primitivă și se trece la următorul pas
2. dacă ambii operanzi sunt strings, atunci se compară valoarea lor aflabetic
3. altfel, ambii operanzi sunt transformați în numere și se face comparația numerică
   1. Infinity este cel mai mare număr
   2. -Infinity este cel mai mic număr
   3. dacă unul din operanzi este NaN => false

Operatorii in și instanceof

const x = { a: 'first', b: 'second' };
'a' in x; // true
'c' in x; // false
'toString' in x; // true, prototypes

const date = new Date();
date instanceof Date; // true
date instanceof Object; // true
date instanceof Number; // false

Truthy / Falsy

Orice expresie evaluată ca și adevăr este considerată truthy, altfel, este falsy.

Oricare din aceste valori este falsy: false, null, undefined, 0, NaN, ""

Restul, sunt considerate truthy.

Operatori logici

Operatorul ȘI && logic va întoarce true dacă ambii operanzi sunt true. Dacă cel puțin un operand este false, înseamnă că și rezultatul va fi false.

Operatorul SAU || logic va întoarce true dacă cel puțin un operand este true. Dacă ambii operanzi sunt false, înseamnă că și rezultatul va fi false.

Operatorii ȘI și SAU au un comportament foarte interesant în JS: datorită faptului că orice valoarea poate fi evaluată ca și truthy sau falsy, acești operatori pot întoarce o valoare truthy sau falsy (nu neapărat true sau false), astfel, putem decide rezultatul acestor operații simplu evaluând primul operand. Fie operanzii x și y, avem:

• ȘI - dacă x este truthy => y, altfel => x
• SAU - dacă x este truthy => x, altfel => y

Astfel, în cazul ȘI al doilea operand nu va fi evaluat dacă primul este falsy, iar în cazul SAU al doilea nu va fi evaluat dacă primul este truthy.

Operatorul de negare ! va inversa o valoare booleana, transformând o valoare falsy în true și o valoare truthy în false. Dacă îl aplicăm de două ori pe o variabilă, vom transforma acea variabilă în true sau false: !!x

Operatorii booleani pot fi descriși și prin următoarele tabele (unde a și b sunt datele de intrare și r este răspunsul):

ȘI / AND

SAU / OR

Negare / NOT