Un operatore è un simbolo che opera su un valore o dati. Rappresenta un'azione specifica sull'utilizzo dei dati. Il dato su cui opera l'operatore è detto operando. Può essere utilizzato con uno o più valori per produrre un singolo valore. Tutti gli operatori JavaScript standard sono disponibili con il programma TypeScript.
Esempio
10 + 10 = 20;
Nell'esempio precedente, i valori '10' e '20' sono noti come operando, mentre '+' e '=' sono noti come operatori.
attore rohit shetty
Operatori in TypeScript
In TypeScript, un operatore può essere classificato nei seguenti modi.
- Operatori aritmetici
- Operatori di confronto (relazionali).
- Operatori logici
- Operatori bit a bit
- Operatori di assegnazione
- Operatore ternario/condizionale
- Operatore di concatenazione
- Digitare Operatore
Operatori aritmetici
Gli operatori aritmetici accettano valori numerici come operandi, eseguono un'azione e quindi restituiscono un singolo valore numerico. Gli operatori aritmetici più comuni sono addizione(+), sottrazione(-), moltiplicazione(*) e divisione(/).
| Operatore | Nome_operatore | Descrizione | Esempio |
|---|---|---|---|
| + | Aggiunta | Restituisce un'addizione dei valori. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Sottrazione | Restituisce la differenza dei valori. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Moltiplicazione | Restituisce il prodotto dei valori. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Divisione | Esegue l'operazione di divisione e restituisce il quoziente. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Modulo | Esegue l'operazione di divisione e restituisce il resto. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Incremento | Viene utilizzato per incrementare di uno il valore della variabile. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Decremento | Viene utilizzato per decrementare di uno il valore della variabile. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Operatori (relazionali) di confronto
Gli operatori di confronto vengono utilizzati per confrontare i due operandi. Questi operatori restituiscono un valore booleano vero o falso. Di seguito sono riportati gli operatori di confronto importanti.
| Operatore | Nome_operatore | Descrizione | Esempio |
|---|---|---|---|
| == | È uguale a | Controlla se i valori dei due operandi sono uguali o meno. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identici (uguali e dello stesso tipo) | Controlla se il tipo e i valori dei due operandi sono uguali o meno. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Non uguale a | Controlla se i valori dei due operandi sono uguali o meno. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Non identico | Controlla se il tipo e i valori dei due operandi sono uguali o meno. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Più grande di | Controlla se il valore degli operandi di sinistra è maggiore del valore dell'operando di destra oppure no. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Maggiore o uguale a | Controlla se il valore degli operandi di sinistra è maggiore o uguale al valore dell'operando di destra oppure no. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Meno di | Controlla se il valore degli operandi di sinistra è inferiore al valore dell'operando di destra oppure no. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Minore o uguale a | Controlla se il valore degli operandi di sinistra è inferiore o uguale al valore dell'operando di destra oppure no. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Operatori logici
Gli operatori logici vengono utilizzati per combinare due o più condizioni in un'unica espressione e restituire il risultato booleano vero o falso. Gli operatori logici sono riportati di seguito.
| Operatore | Nome_operatore | Descrizione | Esempio |
|---|---|---|---|
| && | AND logico | Restituisce vero se entrambi gli operandi (espressione) sono veri, altrimenti restituisce falso. | 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 |
| || | OR logico | Restituisce vero se uno qualsiasi degli operandi (espressione) è vero, altrimenti restituisce falso. | 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' |
| ! | NON logico | Restituisce il risultato inverso di un operando (espressione). | 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 bit a bit
Gli operatori bit a bit eseguono le operazioni bit a bit sugli operandi. Gli operatori bit a bit sono i seguenti.
impilare in Java
| Operatore | Nome_operatore | Descrizione | Esempio |
|---|---|---|---|
| & | AND bit per bit | Restituisce il risultato di un'operazione booleana AND su ciascun bit dei suoi argomenti interi. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | OR bit per bit | Restituisce il risultato di un'operazione booleana OR su ciascun bit dei suoi argomenti interi. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | XOR bit a bit | Restituisce il risultato di un'operazione booleana OR esclusivo su ciascun bit dei suoi argomenti interi. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bit per bit NON | Inverte ogni bit negli operandi. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Shift destro bit per bit | Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificati nell'operando di destra. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Shift sinistro bit a bit | Il valore dell'operando di sinistra viene spostato a sinistra del numero di bit specificati nell'operando di destra. I nuovi bit vengono riempiti con zeri sul lato destro. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Shift destro bit per bit con zero | Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificati nell'operando di destra e gli zeri vengono aggiunti sul lato sinistro. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Operatori di assegnazione
Gli operatori di assegnazione vengono utilizzati per assegnare un valore alla variabile. La parte sinistra dell'operatore di assegnazione è chiamata variabile, mentre la parte destra dell'operatore di assegnazione è chiamata valore. Il tipo di dati della variabile e del valore devono essere gli stessi altrimenti il compilatore genererà un errore. Gli operatori di assegnazione sono i seguenti.
| Operatore | Nome_operatore | Descrizione | Esempio |
|---|---|---|---|
| = | Assegnare | Assegna valori dal lato destro all'operando del lato sinistro. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Aggiungi e assegna | Aggiunge l'operando di sinistra con l'operando di destra e assegna il risultato all'operando di sinistra. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Sottrai e assegna | Sottrae l'operando di destra dall'operando di sinistra e assegna il risultato all'operando di sinistra. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Moltiplica e assegna | Moltiplica l'operando di sinistra con l'operando di destra e assegna il risultato all'operando di sinistra. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Dividi e assegna | Divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Modulo e assegnazione | Divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Operatore ternario/condizionale
L'operatore condizionale accetta tre operandi e restituisce un valore booleano in base alla condizione, che sia vera o falsa. Il suo funzionamento è simile a un'istruzione if-else. L'operatore condizionale ha associatività da destra a sinistra. La sintassi di un operatore condizionale è riportata di seguito.
expression ? expression-1 : expression-2;
Esempio
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Produzione:
True
Operatore di concatenazione
L'operatore di concatenazione (+) è un operatore che viene utilizzato per aggiungere due stringhe. Nell'operazione di concatenazione, non possiamo aggiungere uno spazio tra le stringhe. Possiamo concatenare più stringhe in una singola istruzione. L'esempio seguente ci aiuta a comprendere l'operatore di concatenazione in TypeScript.
Esempio
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Produzione:
Result of String Operator: Welcome to JavaTpoint
Digitare Operatori
È disponibile una raccolta di operatori che possono assisterti quando lavori con oggetti in TypeScript. Operatori come tipodi, istanzadi, in ed elimina sono esempi di operatore Tipo. La spiegazione dettagliata di questi operatori è fornita di seguito.
| Nome_operatore | Descrizione | Esempio |
|---|---|---|
| In | Viene utilizzato per verificare l'esistenza di una proprietà su un oggetto. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| eliminare | Viene utilizzato per eliminare le proprietà dagli oggetti. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| tipo di | Restituisce il tipo di dati dell'operando. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| istanza di | Viene utilizzato per verificare se l'oggetto è di un tipo specificato o meno. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |