Un operator este un simbol care operează asupra unei valori sau date. Reprezintă o acțiune specifică în lucrul cu date. Datele cu care operează operatorii se numesc operand. Poate fi folosit cu una sau mai multe valori pentru a produce o singură valoare. Toți operatorii JavaScript standard sunt disponibili cu programul TypeScript.
Exemplu
10 + 10 = 20;
În exemplul de mai sus, valorile „10” și „20” sunt cunoscute ca operand, în timp ce „+” și „=” sunt cunoscuți ca operatori.
Operatori în TypeScript
În TypeScript, un operator poate fi clasificat în următoarele moduri.
- Operatori aritmetici
- Operatori de comparație (relaționali).
- Operatori logici
- Operatori pe biți
- Operatori de atribuire
- Operator ternar/condițional
- Operator de concatenare
- Tip Operator
Operatori aritmetici
Operatorii aritmetici iau valori numerice ca operanzi, efectuează o acțiune și apoi returnează o singură valoare numerică. Cei mai comuni operatori aritmetici sunt adunarea(+), scăderea(-), înmulțirea(*) și împărțirea(/).
| Operator | Nume_operator | Descriere | Exemplu |
|---|---|---|---|
| + | Plus | Returnează o adăugare a valorilor. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Scădere | Returnează diferența de valori. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Multiplicare | Returnează produsul valorilor. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Divizia | Efectuează operația de împărțire și returnează coeficientul. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Modulul | Efectuează operația de împărțire și returnează restul. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Creştere | Este folosit pentru a crește valoarea variabilei cu una. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Decrementează | Este folosit pentru a decrementa valoarea variabilei cu una. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Operatori (relaționali) de comparație
Operatorii de comparație sunt utilizați pentru a compara cei doi operanzi. Acești operatori returnează o valoare booleană adevărată sau falsă. Operatorii de comparație importanți sunt prezentați mai jos.
converti char în șir java
| Operator | Nume_operator | Descriere | Exemplu |
|---|---|---|---|
| == | Este egal cu | Verifică dacă valorile celor doi operanzi sunt egale sau nu. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identice (egale și de același tip) | Verifică dacă tipul și valorile celor doi operanzi sunt egale sau nu. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Nu este egal cu | Verifică dacă valorile celor doi operanzi sunt egale sau nu. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Nu identice | Verifică dacă tipul și valorile celor doi operanzi sunt egale sau nu. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Mai mare ca | Verifică dacă valoarea operanzilor din stânga este mai mare decât valoarea operandului din dreapta sau nu. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Mai mare sau egal cu | Verifică dacă valoarea operanzilor din stânga este mai mare sau egală cu valoarea operandului din dreapta sau nu. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Mai puțin decât | Verifică dacă valoarea operanzilor din stânga este mai mică decât valoarea operandului din dreapta sau nu. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Mai mic sau egal cu | Verifică dacă valoarea operanzilor din stânga este mai mică sau egală cu valoarea operandului din dreapta sau nu. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Operatori logici
Operatorii logici sunt utilizați pentru a combina două sau mai multe condiții într-o singură expresie și returnează rezultatul boolean adevărat sau fals. Operatorii logici sunt prezentați mai jos.
| Operator | Nume_operator | Descriere | Exemplu |
|---|---|---|---|
| && | ȘI logic | Returnează adevărat dacă ambii operanzi (expresie) sunt adevărate, în caz contrar returnează false. | let a = false; let b = true; console.log(a&&b); /false console.log(b&&true); //true console.log(b&&10); //10 which is also 'true' console.log(a&&'10'); //false |
| || | SAU logic | Returnează adevărat dacă oricare dintre operanzi (expresie) este adevărat, în caz contrar returnează false. | let a = false; let b = true; console.log(a||b); //true console.log(b||true); //true console.log(b||10); //true console.log(a||'10'); //'10' which is also 'true' |
| ! | NU logic | Returnează rezultatul invers al unui operand (expresie). | let a = 20; let b = 30; console.log(!true); //false console.log(!false); //true console.log(!a); //false console.log(!b); /false console.log(!null); //true |
Operatori pe biți
Operatorii pe biți efectuează operații pe biți pe operanzi. Operatorii pe biți sunt după cum urmează.
| Operator | Nume_operator | Descriere | Exemplu |
|---|---|---|---|
| & | ȘI pe biți | Returnează rezultatul unei operații booleene AND pe fiecare bit al argumentelor sale întregi. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | SAU pe biți | Returnează rezultatul unei operații booleene SAU pe fiecare bit al argumentelor sale întregi. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | XOR pe biți | Returnează rezultatul unei operații booleene exclusive OR pe fiecare bit al argumentelor sale întregi. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Pe bit NU | Acesta inversează fiecare bit din operanzi. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Shift la dreapta pe biți | Valoarea operandului din stânga este mutată la dreapta cu numărul de biți specificat în operandul din dreapta. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Shift la stânga pe biți | Valoarea operandului din stânga este mutată la stânga cu numărul de biți specificat în operandul din dreapta. Biții noi sunt umpluți cu zerouri în partea dreaptă. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Deplasare la dreapta pe biți cu zero | Valoarea operandului din stânga este mutată la dreapta cu numărul de biți specificat în operandul din dreapta și se adaugă zerouri în partea stângă. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Operatori de atribuire
Operatorii de atribuire sunt utilizați pentru a atribui o valoare variabilei. Partea stângă a operatorului de atribuire se numește variabilă, iar partea dreaptă a operatorului de atribuire se numește valoare. Tipul de date al variabilei și valoarea trebuie să fie aceleași, altfel compilatorul va arunca o eroare. Operatorii de atribuire sunt după cum urmează.
| Operator | Nume_operator | Descriere | Exemplu |
|---|---|---|---|
| = | Atribui | Atribuie valori din partea dreaptă spre partea stângă a operandului. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Adăugați și atribuiți | Acesta adaugă operandul din stânga cu operandul din dreapta și atribuie rezultatul operandului din partea stângă. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Scădeți și atribuiți | Scăde operandul din dreapta din operandul din stânga și atribuie rezultatul operandului din partea stângă. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Înmulțiți și atribuiți | Înmulțește operandul din stânga cu operandul din dreapta și atribuie rezultatul operandului din partea stângă. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Împărțiți și atribuiți | Împarte operandul din stânga cu operandul din dreapta și atribuie rezultatul operandului din partea stângă. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Modulul și atribuirea | Împarte operandul din stânga cu operandul din dreapta și atribuie rezultatul operandului din partea stângă. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Operator ternar/condițional
Operatorul condiționat ia trei operanzi și returnează o valoare booleană bazată pe condiție, indiferent dacă este adevărată sau falsă. Funcționarea sa este similară cu o declarație if-else. Operatorul condiționat are asociativitate de la dreapta la stânga. Sintaxa unui operator condiționat este dată mai jos.
expression ? expression-1 : expression-2;
Exemplu
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Ieșire:
True
Operator de concatenare
Operatorul de concatenare (+) este un operator care este folosit pentru a adăuga cele două șiruri. În operația de concatenare, nu putem adăuga un spațiu între șiruri. Putem concatena mai multe șiruri într-o singură instrucțiune. Următorul exemplu ne ajută să înțelegem operatorul de concatenare în TypeScript.
Exemplu
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Ieșire:
Result of String Operator: Welcome to JavaTpoint
Operatori de tip
Există o colecție de operatori disponibili care vă pot ajuta atunci când lucrați cu obiecte în TypeScript. Operatorii precum typeof, instanceof, in și delete sunt exemple de operator Type. Explicația detaliată a acestor operatori este dată mai jos.
| Nume_operator | Descriere | Exemplu |
|---|---|---|
| în | Este folosit pentru a verifica existența unei proprietăți pe un obiect. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| șterge | Este folosit pentru a șterge proprietățile din obiecte. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| tip de | Returnează tipul de date al operandului. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| instanță de | Este folosit pentru a verifica dacă obiectul este de un tip specificat sau nu. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |