Operații aritmetice

Pentru a efectua diverse acțiuni asupra valorilor (cum ar fi adunare, scădere, etc.), limbajul JavaScript furnizează operații. Operațiile iau unul, doi sau trei operanzi și aplică asupra lor anumite acțiuni.

Ca operanzi, în funcție de tipul operației, se pot utiliza literali (numere, șiruri de caractere), variabile și constante sau rezultatele altor operații. Anterior, am folosit deja una dintre cele mai comune operații - operația de atribuire reprezentată de simbolul =, care atribuie unei variabile sau constante o anumită valoare.

const num = 4;    //operație de atribuire- atribuim constantei num cifra 4
console.log(num); // 4

Să examinăm ce operații aritmetice putem folosi în JavaScript.

JavaScript susține toate operațiile matematice de bază:

Adunare:

const x = 50 + 10;
console.log(x); // 60

Scădere:

const x = 50 - 10;
console.log(x); // 40

Înmulțire:

const x = 50 * 10;
console.log(x); // 500

Împărțire:

const x = 50 / 10;
console.log(x); // 5

const z = 50 / 4;
console.log(z); // 12.5

Divizia modulară (operatorul %) în JavaScript returnează restul împărțirii:

const x = 15 % 4;
console.log(x); // 3

Rezultatul va fi 3, deoarece cel mai mare număr întreg care este mai mic sau egal cu 15 și care se divide exact la 4 este 12, iar 15 - 12 = 3.

Puterea. Operatorul ridică un număr la o anumită putere:

cifra  putere

De exemplu:

const n = 2  3;
console.log(n);  // 8

const x = 3;
const y = 2;
const z = x  y;
console.log(z);  // 9

Incrementarea:

let x = 5;
x++; // x = 6

Operatorul de incrementare ++ crește valoarea variabilei cu 1. Există incrementare înainte (preincrementare), care mai întâi crește variabila cu 1 și apoi returnează valoarea ei. Există și incrementare după (postincrementare), care mai întâi returnează valoarea variabilei înainte de a o crește cu 1:

// incrementul prefixat
let x = 5;
let z = ++x;
console.log(x); // 6
console.log(z); // 6
   
// incrementul postfixat
let a = 5;
let b = a++;
console.log(a); // 6
console.log(b); // 5

Incrementarea este similară operației:

a = a + 1;

Decrementarea reduce valoarea variabilei cu 1. Există și decrementare înainte (predecrementare) și decrementare după (postdecrementare):

• - Predecrementarea: Operatorul este plasat înaintea variabilei și scade valoarea variabilei cu 1 înainte de a returna valoarea.
• - Postdecrementarea: Operatorul este plasat după variabilă și returnează valoarea variabilei înainte de a o scădea cu 1

În ambele cazuri, valoarea variabilei este modificată, fie înainte, fie după utilizare, în funcție de locația operatorului de decrementare.

// Predecrementarea
let x = 5;
let z = --x;
console.log(x); // 4
console.log(z); // 4
   
// Postdecrementarea
let a = 5;
let b = a--;
console.log(a); // 4
console.log(b); // 5

Asa cum este obișnuit în matematică, toate operațiile sunt efectuate de la stânga la dreapta și au priorități diferite: mai întâi operațiile de incrementare și decrementare, apoi înmulțirea și împărțirea, iar în final adunarea și scăderea. Pentru a modifica ordinea standard de executie a operatiilor, o parte din expresii poate fi plasată între paranteze:

let x = 10;
let y = 5 + (6 - 2) * --x;
console.log(y); //41

Operații aritmetice cu atribuire

În JavaScript există și alte operații care combină operațiile aritmetice cu atribuire:

• +=

Adunare cu atribuire ulterioară a rezultatului. De exemplu:

let a = 23;
a += 5; //aceeași a = a + 5
console.log(a); // 28

• -=

Scădere cu atribuire ulterioară a rezultatului. De exemplu:

let a = 28;
a -= 10; // aceeași a = a - 10
console.log(a); // 18

• *=

Înmulțire cu atribuire ulterioară a rezultatului:

let x = 20;
x *= 2; // aceeași x = x * 2
console.log(x); // 40

• =

Ridicare la putere cu atribuire ulterioară a rezultatului:

let x = 5;
x = 2;
console.log(x);  // 25

• /=

Împărțire cu atribuire ulterioară a rezultatului:

let x = 40;
x /= 4; // aceeași x = x / 4
console.log(x); // 10

• %=

Obținerea restului împărțirii cu atribuire ulterioară a rezultatului:

let x = 10;
x %= 3; // aceeași x = x % 3
console.log(x); // 1, deoarece 10 - 3*3 = 1