In questo tutorial imparerai a conoscere i diversi operatori disponibili in JavaScript e come usarli con l'aiuto di esempi.
Cos'è un operatore?
In JavaScript, un operatore è un simbolo speciale utilizzato per eseguire operazioni su operandi (valori e variabili). Per esempio,
2 + 3; // 5
Ecco +un operatore che esegue l'addizione e 2e 3sono operandi.
Tipi di operatori JavaScript
Ecco un elenco di diversi operatori che imparerai in questo tutorial.
- Operatori di assegnazione
- Operatori aritmetici
- Operatori di confronto
- Operatori logici
- Operatori bit per bit
- Operatori di stringa
- Altri operatori
Operatori di assegnazione JavaScript
Gli operatori di assegnazione vengono utilizzati per assegnare valori alle variabili. Per esempio,
const x = 5;
Qui, l' =operatore viene utilizzato per assegnare un valore 5alla variabile x.
Ecco un elenco di operatori di assegnazione comunemente usati:
| Operatore | Nome | Esempio |
|---|---|---|
= | Operatore di assegnazione | a = 7; // 7 |
+= | Assegnazione di addizione | a += 5; // a = a + 5 |
-= | Assegnazione di sottrazione | a -= 2; // a = a - 2 |
*= | Assegnazione di moltiplicazione | a *= 3; // a = a * 3 |
/= | Assegnazione della divisione | a /= 2; // a = a / 2 |
%= | Assegnazione resto | a %= 2; // a = a % 2 |
**= | Assegnazione esponenziale | a **= 2; // a = a**2 |
Nota: l'operatore di assegnazione comunemente utilizzato è =. Capirai altri operatori di assegnazione, come +=, -=, *=ecc una volta impariamo operatori aritmetici.
Operatori aritmetici JavaScript
Gli operatori aritmetici vengono utilizzati per eseguire calcoli aritmetici . Per esempio,
const number = 3 + 5; // 8
Qui, l' +operatore viene utilizzato per aggiungere due operandi.
| Operatore | Nome | Esempio |
|---|---|---|
+ | Aggiunta | x + y |
- | Sottrazione | x - y |
* | Moltiplicazione | x * y |
/ | Divisione | x / y |
% | Resto | x % y |
++ | Incremento (incrementi di 1) | ++x o x++ |
-- | Decremento (decrementi di 1) | --x o x-- |
** | Esponenziazione (potenza) | x ** y |
Esempio 1: operatori aritmetici in JavaScript
let x = 5; let y = 3; // addition console.log('x + y = ', x + y); // subtraction console.log('x - y = ', x - y); // multiplication console.log('x * y = ', x * y); // division console.log('x / y = ', x / y); // remainder console.log('x % y = ', x % y); // increment console.log('++x = ', ++x); // x is now 6 console.log('x++ = ', x++); // x returns 6 and then increases by 1 console.log('x = ', x); // decrement console.log('--x = ', --x); // x is now 6 console.log('x-- = ', x--); // x returns 6 and then increases by 1 console.log('x = ', x); //exponentiation console.log('x ** y =', x ** y);
Visita ++ e - operator per saperne di più.
Produzione
x + y = 8 x - y = 2 x * y = 15 x / y = 1,66666666666666667 x% y = 2 ++ x = 6 x ++ = 6 x = 7 --x = 6 x-- = 6 x = 5 x ** y = 125
Nota : l'operatore ** è stato introdotto in EcmaScript 2016 e alcuni browser potrebbero non supportarli. Per saperne di più, visita il supporto del browser per l'esponenziazione JavaScript.
Operatori di confronto JavaScript
Gli operatori di confronto confrontano due valori e restituiscono un valore booleano, trueo false. Per esempio,
const a = 3, b = 2; console.log(a> b); // true
Qui, l'operatore di confronto >viene utilizzato per confrontare se a è maggiore di b.
| Operatore | Descrizione | Esempio |
|---|---|---|
== | Uguale a : restituisce truese gli operandi sono uguali | x == y |
!= | Non uguale a : restituisce truese gli operandi non sono uguali | x != y |
=== | Rigoroso uguale a : truese gli operandi sono uguali e dello stesso tipo | x === y |
!== | Strict not equal to : truese gli operandi sono uguali ma di tipo diverso o non sono affatto uguali | x !== y |
> | Maggiore di : truese l'operando sinistro è maggiore dell'operando destro | x> y |
>= | Maggiore o uguale a : truese l'operando sinistro è maggiore o uguale all'operando destro | x>= y |
< | Minore di : truese l'operando sinistro è minore dell'operando destro | x < y |
<= | Minore o uguale a : truese l'operando sinistro è minore o uguale all'operando destro | x <= y |
Esempio 2: operatori di confronto in JavaScript
// equal operator console.log(2 == 2); // true console.log(2 == '2'); // true // not equal operator console.log(3 != 2); // true console.log('hello' != 'Hello'); // true // strict equal operator console.log(2 === 2); // true console.log(2 === '2'); // false // strict not equal operator console.log(2 !== '2'); // true console.log(2 !== '2'); // false
Output
true true true true true false false true
Comparison operators are used in decision making and loops. You will learn about the use of comparison operators in detail in later tutorials.
JavaScript Logical Operators
Logical operators perform logical operations and return a boolean value, either true or false. For example,
const x = 5, y = 3; (x < 6) && (y < 5); // true
Here, && is the logical operator AND. Since both x < 6 and y < 5 are true, the result is true.
| Operator | Description | Example |
|---|---|---|
&& | Logical AND: true if both the operands are true, else returns false | x && y |
|| | Logical OR: true if either of the operands is true; returns false if both are false | x || y |
! | Logical NOT: true if the operand is false and vice-versa. | !x |
Example 3: Logical Operators in JavaScript
// logical AND console.log(true && true); // true console.log(true && false); // false // logical OR console.log(true || false); // true // logical NOT console.log(!true); // false
Output
true false true false
Logical operators are used in decision making and loops. You will learn about the use of logical operators in detail in later tutorials.
JavaScript Bitwise Operators
Bitwise operators perform operations on binary representations of numbers.
| Operator | Description |
|---|---|
& | Bitwise AND |
| | Bitwise OR |
^ | Bitwise XOR |
~ | Bitwise NOT |
<< | Left shift |
>> | Sign-propagating right shift |
>>> | Zero-fill right shift |
Bitwise operators are rarely used in everyday programming. If you are interested, visit JavaScript Bitwise Operators to learn more.
JavaScript String Operators
In JavaScript, you can also use the + operator to concatenate (join) two or more strings.
Example 4: String operators in JavaScript
// concatenation operator console.log('hello' + 'world'); let a = 'JavaScript'; a += ' tutorial'; // a = a + ' tutorial'; console.log(a);
Output
helloworld JavaScript tutorial
Nota: quando +viene utilizzato con le stringhe, esegue la concatenazione. Tuttavia, quando +viene utilizzato con i numeri, esegue l'addizione.
Altri operatori JavaScript
Ecco un elenco di altri operatori disponibili in JavaScript. Imparerai a conoscere questi operatori nei tutorial successivi.
| Operatore | Descrizione | Esempio |
|---|---|---|
, | valuta più operandi e restituisce il valore dell'ultimo operando. | let a = (1, 3 , 4); // 4 |
?: | restituisce il valore in base alla condizione | (5> 3) ? 'success' : 'error'; // "success" |
delete | elimina la proprietà di un oggetto o un elemento di un array | delete x |
typeof | restituisce una stringa che indica il tipo di dati | typeof 3; // "number" |
void | scarta il valore restituito dall'espressione | void(x) |
in | restituisce truese la proprietà specificata è nell'oggetto | prop in object |
instanceof | restituisce truese l'oggetto specificato è del tipo di oggetto specificato | object instanceof object_type |
