Addizione (+)
L'operazione di addizione produce la somma di operandi numerici o la concatenzione di stringhe.
Sintassi
Operatore: x + y
Esempi
// Numero + Numero -> addizione
1 + 2 // 3
// Booleano + Numero -> addizione
true + 1 // 2
// Booleano + Booleano -> additione
false + false // 0
// Numero + Stringa -> concatenazione
5 + "foo" // "5foo"
// Stringa + Booleano -> concatenazione
"foo" + false // "foofalse"
// Stringa + Stringa -> concatenazione
"foo" + "bar" // "foobar"
Sottrazione (-)
L'operatore di sottrazione fa la sottrazione dei due operandi e produce la loro differenza.
Sintassi
Operatore: x - y
Esempi
5 - 3 // 2
3 - 5 // -2
"foo" - 3 // NaN
Divisione (/)
L'operatore di divisione produce il quoziente dei suoi operandi dove l'operando di sinistra è il dividendo e l'operando di destra è il divisore.
Sintassi
Operatore: x / y
Esempi
1 / 2 // restituisce 0.5 in JavaScript
1 / 2 // restituisce 0 in Java
// (nessuno degli operandi è un numero in virgola mobile esplicito)
1.0 / 2.0 // restituisce 0.5 in both JavaScript and Java
2.0 / 0 // restituisce Infinity in JavaScript
2.0 / 0.0 // restituisce Infinity too
2.0 / -0.0 // restituisce -Infinity in JavaScript
Moltiplicazione (*)
The multiplication operator produces the product of the operands.
Sintassi
Operatore: x * y
Esempi
2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"foo" * 2 // NaN
Resto (%)
L'operatore Resto o Modulo restituisce il “resto“ rimasto quando un operando viene diviso per un secondo operando. Calcola il resto della divisione fra il primo e il secondo operando. Porta sempre il segno del dividendo.
Sintassi
Operatore: var1 % var2
Esempi
12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
1 % 2 // 1
2 % 3 // 2
-4 % 2 // -0
Esponente (**)
L'operatore Esponente o esponenziale in JavaScript. Una delle funzionalità di questa versione è l'operatore di esponenziazione. Esponente restituisce il risultato dell'elevamento a potenza dal primo operando al secondo. Cioè var1
var2
, var2.
var1
e var2
sono variabili. L'operatore Esponente ha ragione associativa. a ** b ** c
equivale a a ** (b ** c)
.
Sintassi
Operatore: var1 ** var2
Note
Nella maggior parte dei linguaggi come PHP e Python e altri che usano l'operatore Esponente (**), ha precedenza rispetto agli altri operatori unari come + e -, salvo in alcune eccezioni. Ad esempio, in Bash l'operatore ** ha una minor importanza rispetto agli operatori unari. In JavaScript, è impossibile scrivere un'espressione Esponente ambigua, ovvero non è possibile inserire un operatore unario ( +/-/~/!/delete/void/typeof
) immediatamente prima del numero di base. Il calcolo della potenza può essere espresso più sinteticamente usando la notazione infissa. Simile ad altri linguaggi come Python o F#, **
è usato per indicare l'operatore.
-2 ** 2 // equals 4 in ES2016 or in Bash, equals -4 in other languages.
Accetta base sul lato sinistro ed esponente sul lato destro, rispettivamente.
let value = 5; value **= 2; // value: 25
Esempi
2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN
2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64
var a = 3;
var b = a ** 3;
alert("3x3x3 is = " + b); // 27
Per invertire il segno del risultato di un'espressione di Esponente:
-(2 ** 2) // -4
Per forzare la base di un'espressione di Esponente ad essere un numero negativo:
(-2) ** 2 // 4
Incremento (++)
L'operatore di incremento incrementa (aggiunge uno a) il suo operando e restituisce un valore.
- Se usato in post posizione, con operatore dopo operando (ad esempio, x ++), restituisce il valore prima di incrementare.
- Se usato come prefisso quindi prima dell'operando (ad esempio, ++ x), restituisce il valore dopo l'incremento.
Sintassi
Operatore: x++ or ++x
Esempi
// Postfix // post posizione
var x = 3;
y = x++; // y = 3, x = 4
// Prefix // Prefisso
var a = 2;
b = ++a; // a = 3, b = 3
Decremento (--)
L'operatore decrementa decrementa (sottrae uno da) il suo operando e restituisce un valore.
- Se usato in post posizione (ad esempio x--), restituisce il valore prima di decrementare.
- Se usato come prefisso (ad esempio, --x), restituisce il valore dopo la decrementazione.
Sintassi
Operatore: x-- or --x
Esempi
// Postfix // post posizione
var x = 3;
y = x--; // y = 3, x = 2
// Prefix // Prefisso
var a = 2;
b = --a; // a = 1, b = 1
Negazione unaria (-)
L'operatore di negazione unario precede il suo operando e lo nega.
Sintassi
Operatore: -x
Esempi
var x = 3; y = -x; // y = -3, x = 3 //
L'operatore di negazione unario può convertire numeri diversi in un numerovar x = "4"; y = -x; // y = -4
Unario più (+)
L'operatore unario più precede il suo operando e valuta il suo operando, ma tenta di convertirlo in un numero, se non lo è già. Anche se la negazione unaria (-) può anche convertire non numeri, unario è il modo più veloce e preferito per convertire qualcosa in un numero, perché non esegue altre operazioni sul numero. È in grado di convertire rappresentazioni di stringa di numeri interi e float, oltre ai valori non stringa true
, false
e null
. Sono supportati i numeri interi decimali ed esadecimali ("0x" -prefixed). I numeri negativi sono supportati (sebbene non per hex). Se non può analizzare un valore particolare, valuterà in NaN.
Sintassi
Operatore: +x
Esempi
+3 // 3
+'3' // 3
+true // 1
+false // 0
+null // 0
+function(val){ return val } // NaN
Specificazioni
Specificazioni | Stato | Commento |
---|---|---|
ECMAScript 1st Edition. | Standard | Definizione iniziale. |
ECMAScript 5.1 (ECMA-262) | Standard | Definito in diverse sezioni della specifica: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Definito in diverse sezioni della specifica: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
ECMAScript 2016 (ECMA-262) | Standard | Aggiunto Exponentiation operator. |
Compatibilità con i browser
No compatibility data found. Please contribute data for "javascript.operators.arithmetic" (depth: 1) to the MDN compatibility data repository.