Gli operatori aritmetici lavorano su operandi numerici (sia letterali che variabili) e ritornano un singolo valore numerico. Gli operatori aritmetici standard sono l'addizione (+), la sottrazione (-), la moltiplicazione (*) e la divisione (/).

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. var1var2 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 numero
var 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

We're converting our compatibility data into a machine-readable JSON format. This compatibility table still uses the old format, because we haven't yet converted the data it contains. Find out how you can help!

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Yes) (Yes) (Yes) (Yes) (Yes)
Exponentiation operator ? Nightly build ? ? ?
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Exponentiation operator ? ? Nightly build ? ? ?

Guarda anche

Tag del documento e collaboratori

Hanno collaborato alla realizzazione di questa pagina: wbamberg, ladysilvia, lazycesar, kdex, alberto.decaro
Ultima modifica di: wbamberg,