From 30feb96f6084a2fb976a24ac01c1f4a054611b62 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:47:54 +0100 Subject: unslug it: move --- .../reference/global_objects/object/index.html | 215 +++++++++++++++ .../reference/global_objects/string/index.html | 179 +++++++++++++ .../web/javascript/reference/operators/index.html | 292 +++++++++++++++++++++ 3 files changed, 686 insertions(+) create mode 100644 files/it/conflicting/web/javascript/reference/global_objects/object/index.html create mode 100644 files/it/conflicting/web/javascript/reference/global_objects/string/index.html create mode 100644 files/it/conflicting/web/javascript/reference/operators/index.html (limited to 'files/it/conflicting/web/javascript') diff --git a/files/it/conflicting/web/javascript/reference/global_objects/object/index.html b/files/it/conflicting/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..568165d0be --- /dev/null +++ b/files/it/conflicting/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,215 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype +--- +
{{JSRef("Global_Objects", "Object")}}
+ +

Sommario

+ +

La proprietà Object.prototype rappresenta l'oggetto prototipo di {{jsxref("Global_Objects/Object", "Object")}}.

+ +

{{js_property_attributes(0, 0, 0)}}

+ +

Descrizione

+ +

In JavaScript, tutti gli oggetti sono discendenti di {{jsxref("Global_Objects/Object", "Object")}}; tutti gli oggetti ereditano metodi e proprietà di Object.prototype (tranne nel caso l'oggetto abbia il prototipo uguale a {{jsxref("Global_Objects/null", "null")}}, quindi creati con il metodo {{jsxref("Object.create", "Object.create(null)")}}), anche se questi possono essere sovrascritti. Per esempio, i prototipi degli altri costruttori sovrascrivono la proprietà constructor e forniscono un loro metodo {{jsxref("Object.prototype.toString", "toString()")}}. I cambiamenti al prototipo di Object vengono estesi a tutti gli oggetti, eccetto quelli che sovrascrivono le proprietà e i metodi cambiati.

+ +

Proprietà

+ +
+
{{jsxref("Object.prototype.constructor")}}
+
Specifica la funzione che ha creato l'oggetto a partire dal prototipo.
+
{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}
+
È un riferimento all'oggetto usato come prototipo quando l'oggetto è stato istanziato.
+
{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}
+
Permette di definire una funzione che venga chiamata quando viene chiamato un metodo non definito.
+
{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}
+
Rappresenta il numero di proprietà persenti in un oggetto, ma è stato rimosso.
+
{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}
+
Rappresenta il contesto di un oggetto, ma è stato rimosso.
+
+ +

Metodi

+ +
+
{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Associa una funzione a una proprietà di un oggetto. Quando si tenta di leggere il valore di tale proprietà, viene eseguita la funzione e restituito il valore che restituisce.
+
{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Associa una funzione a una proprietà di un oggetto. Quando si tenta di cambiare il valore di tale proprietà, viene eseguita la funzione.
+
{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Restituisce la funzione definita tramite {{jsxref("Object.prototype.defineGetter", "__defineGetter__()")}}.
+
{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Restituisce la funzione definita tramite {{jsxref("Object.prototype.defineSetter", "__defineSetter__()")}}.
+
{{jsxref("Object.prototype.hasOwnProperty()")}}
+
Determina se l'oggetto contiene direttamente una proprietà (non ereditata tramite il prototipo).
+
{{jsxref("Object.prototype.isPrototypeOf()")}}
+
Determina se un oggetto fa parte della catena dei prototipi dell'oggetto sul quale è richiamato questo metodo.
+
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
+
Determina se l'attributo DontEnum di ECMAScript interno è presente.
+
{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
+
Restituisce una stringa contenente il codice sorgente di un oggetto rappresentante l'oggetto sul quale questo metodo viene richiamato; puoi usare questo valore per creare un nuovo oggetto.
+
{{jsxref("Object.prototype.toLocaleString()")}}
+
Richiama {{jsxref("Object.prototype.toString", "toString()")}}.
+
{{jsxref("Object.prototype.toString()")}}
+
Restituisce la rappresentazione dell'oggetto sotto forma di stringa.
+
{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}
+
Termina di osservare i cambiamenti di una proprietà dell'oggetto.
+
{{jsxref("Object.prototype.valueOf()")}}
+
Ritorna il valore primitivo dell'oggetto.
+
{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}
+
Inizia a osservare i cambiamenti di una proprietà di un oggetto.
+
{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}
+
Esegue una stringa di codice JavaScript nel contesto dell'oggetto, ma è stato rimosso.
+
+ +

Esempi

+ +

Siccome in JavaScript gli oggetti non sono sub-classabili in modo "standard", il prototipo è una soluzione utile per creare un oggetto che funzioni da "classe di base" che contenga dei metodi comuni a più oggetti. Per esempio:

+ +
var Persona = function() {
+  this.saParlare = true;
+};
+
+Persona.prototype.saluta = function() {
+  if (this.saParlare) {
+    console.log('Ciao, mi chiamo ' + this.nome);
+  }
+};
+
+var Dipendente = function(nome, titolo) {
+  Persona.call(this);
+  this.nome = nome;
+  this.titolo = titolo;
+};
+
+Dipendente.prototype = Object.create(Persona.prototype);
+Dipendente.prototype.constructor = Dipendente;
+
+Dipendente.prototype.saluta = function() {
+  if (this.saParlare) {
+    console.log('Ciao mi chiamo ' + this.nome + ' e lavoro come ' + this.titolo);
+  }
+};
+
+var Cliente = function(nome) {
+  Persona.call(this);
+  this.nome = nome;
+};
+
+Cliente.prototype = Object.create(Persona.prototype);
+Cliente.prototype.constructor = Cliente;
+
+var Mimo = function(nome) {
+  Persona.call(this);
+  this.nome = nome;
+  this.saParlare = false;
+};
+
+Mimo.prototype = Object.create(Persona.prototype);
+Mimo.prototype.constructor = Mimo;
+
+var bob = new Dipendente('Bob', 'Architetto');
+var joe = new Cliente('Joe');
+var rg = new Dipendente('Red Green', 'Tuttofare');
+var mike = new Cliente('Mike');
+var mime = new Mimo('Mimo');
+bob.saluta();
+joe.saluta();
+rg.saluta();
+mike.saluta();
+mime.saluta();
+
+ +

Stamperà:

+ +
Ciao, mi chiamo Bob e lavoro come Architetto
+Ciao, mi chiamo Joe
+Ciao, mi chiamo Red Green, e lavoro come Tuttofare
+Ciao, mi chiamo Mike
+ +

Specifiche

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificaStatoCommenti
ECMAScript 1st Edition. Implemented in JavaScript 1.0.StandardDefinizione iniziale.
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} 
+ +

Compatibilità con i browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FunzionalitàChromeFirefox (Gecko)Internet ExplorerOperaSafari
Supporto di base{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FunzionalitàAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Supporto di base{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

See also

+ + diff --git a/files/it/conflicting/web/javascript/reference/global_objects/string/index.html b/files/it/conflicting/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..c83cec2a54 --- /dev/null +++ b/files/it/conflicting/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,179 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/String +translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype +--- +
{{JSRef}}
+ +

La proprietà String.prototyperappresenta l'oggetto prototipo {{jsxref("String")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Description

+ +

Tutte le istanze {{jsxref("String")}} ereditano da String.prototype . Le modifiche all'oggetto prototipo String vengono propagate a tutte le istanze {{jsxref("String")}}.

+ +

Properties

+ +
+
String.prototype.constructor
+
Specifica la funzione che crea il prototipo di un oggetto.
+
{{jsxref("String.prototype.length")}}
+
Riflette la lunghezza della stringa.
+
N
+
Utilizzato per accedere al carattere in N posizione in cui N è un numero intero positivo compreso tra 0 e uno inferiore al valore della {{jsxref("String.length", "length")}}. Queste proprietà sono di sola lettura.
+
+ +

Metodi

+ +

Metodi non correlati HTML

+ +
+
{{jsxref("String.prototype.charAt()")}}
+
Restituisce il carattere (esattamente un'unità di codice UTF-16) all'indice specificato
+
{{jsxref("String.prototype.charCodeAt()")}}
+
Restituisce un numero che corrisponde al valore dell'unità di codice UTF-16 nell'indice specificato.
+
{{jsxref("String.prototype.codePointAt()")}}
+
Restituisce un numero intero non negativo Numero che è il valore del punto di codice codificato UTF-16 che inizia con l'indice specificato.
+
{{jsxref("String.prototype.concat()")}}
+
Combina il testo di due stringhe e restituisce una nuova stringa.
+
{{jsxref("String.prototype.includes()")}}
+
Determina se una stringa può essere trovata all'interno di un'altra stringa.
+
{{jsxref("String.prototype.endsWith()")}}
+
Determina se una stringa termina con i caratteri di un'altra stringa.
+
{{jsxref("String.prototype.indexOf()")}}
+
Restituisce l'indice all'interno dell'oggetto {{jsxref("String")}} chiamante della prima occorrenza del valore specificato o -1 se non trovato.
+
{{jsxref("String.prototype.lastIndexOf()")}}
+
Restituisce l'indice all'interno dell'oggetto {{jsxref("String")}} chiamante della prima occorrenza del valore specificato o -1 se non trovato.
+
{{jsxref("String.prototype.localeCompare()")}}
+
Restituisce un numero che indica se una stringa di riferimento viene prima o dopo o è uguale alla stringa specificata in ordine di ordinamento.
+
{{jsxref("String.prototype.match()")}}
+
Utilizzato per abbinare un'espressione regolare a una stringa.
+
{{jsxref("String.prototype.normalize()")}}
+
Restituisce il modulo di normalizzazione Unicode del valore della stringa chiamante.
+
{{jsxref("String.prototype.padEnd()")}}
+
Riempie la stringa corrente dalla fine con una determinata stringa per creare una nuova stringa di una determinata lunghezza.
+
{{jsxref("String.prototype.padStart()")}}
+
Riempie la stringa corrente dall'inizio con una determinata stringa per creare una nuova stringa da una determinata lunghezza.
+
{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}
+
Avvolge la stringa tra virgolette (""").
+
{{jsxref("String.prototype.repeat()")}}
+
Restituisce una stringa composta da elementi dell'oggetto ripetuti i tempi indicati.
+
{{jsxref("String.prototype.replace()")}}
+
Utilizzato per trovare una corrispondenza tra un'espressione regolare e una stringa e per sostituire la sottostringa con corrispondenza con una nuova sottostringa.
+
{{jsxref("String.prototype.search()")}}
+
Esegue la ricerca di una corrispondenza tra un'espressione regolare e una stringa specificata.
+
{{jsxref("String.prototype.slice()")}}
+
Estrae una sezione di una stringa e restituisce una nuova stringa.
+
{{jsxref("String.prototype.split()")}}
+
Divide un oggetto  {{jsxref("Global_Objects/String", "String")}} in una matrice di stringhe separando la stringa in sottostringhe.
+
{{jsxref("String.prototype.startsWith()")}}
+
Determina se una stringa inizia con i caratteri di un'altra stringa.
+
{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}
+
Restituisce i caratteri in una stringa che inizia nella posizione specificata attraverso il numero specificato di caratteri.
+
{{jsxref("String.prototype.substring()")}}
+
Restituisce i caratteri in una stringa tra due indici nella stringa.
+
{{jsxref("String.prototype.toLocaleLowerCase()")}}
+
I caratteri all'interno di una stringa vengono convertiti in minuscolo rispettando le impostazioni locali correnti. Per la maggior parte delle lingue, questo restituirà lo stesso di {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.
+
{{jsxref("String.prototype.toLocaleUpperCase()")}}
+
I caratteri all'interno di una stringa vengono convertiti in maiuscolo rispettando le impostazioni locali correnti. Per la maggior parte delle lingue, ciò restituirà lo stesso di {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.
+
{{jsxref("String.prototype.toLowerCase()")}}
+
Restituisce il valore della stringa chiamante convertito in minuscolo.
+
{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}
+
Restituisce un oggetto letterale che rappresenta l'oggetto specificato; puoi usare questo valore per creare un nuovo oggetto. Sostituisce il metodo {{jsxref("Object.prototype.toSource()")}} method.
+
{{jsxref("String.prototype.toString()")}}
+
Restituisce una stringa che rappresenta l'oggetto specificato. Sostituisce il metodo {{jsxref("Object.prototype.toString()")}} .
+
{{jsxref("String.prototype.toUpperCase()")}}
+
Restituisce il valore della stringa chiamante convertito in maiuscolo.
+
{{jsxref("String.prototype.trim()")}}
+
Taglia gli spazi bianchi all'inizio e alla fine della stringa. Parte dello standard ECMAScript 5.
+
{{jsxref("String.prototype.trimStart()")}}
+ {{jsxref("String.prototype.trimLeft()")}}
+
Taglia gli spazi bianchi dall'inizio della stringa.
+
{{jsxref("String.prototype.trimEnd()")}}
+ {{jsxref("String.prototype.trimRight()")}}
+
Taglia gli spazi bianchi dalla fine della stringa.
+
{{jsxref("String.prototype.valueOf()")}}
+
Restituisce il valore primitivo dell'oggetto specificato. Sostituisce il metodo {{jsxref("Object.prototype.valueOf()")}}.
+
{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}
+
Restituisce un nuovo oggetto Iterator che itera sopra i punti di codice di un valore String, restituendo ogni punto di codice come valore String.
+
+ +

HTML metodi wrapper (involucro)

+ +

Questi metodi sono di uso limitato, in quanto forniscono solo un sottoinsieme dei tag e degli attributi HTML disponibili.

+ +
+
{{jsxref("String.prototype.anchor()")}} {{deprecated_inline}}
+
{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hypertext target)
+
{{jsxref("String.prototype.big()")}} {{deprecated_inline}}
+
{{HTMLElement("big")}}
+
{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}
+
{{HTMLElement("blink")}}
+
{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}
+
{{HTMLElement("b")}}
+
{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}
+
{{HTMLElement("tt")}}
+
{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}
+
{{htmlattrxref("color", "font", "<font color=\"color\">")}}
+
{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}
+
{{htmlattrxref("size", "font", "<font size=\"size\">")}}
+
{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}
+
{{HTMLElement("i")}}
+
{{jsxref("String.prototype.link()")}} {{deprecated_inline}}
+
{{htmlattrxref("href", "a", "<a href=\"url\">")}} (link to URL)
+
{{jsxref("String.prototype.small()")}} {{deprecated_inline}}
+
{{HTMLElement("small")}}
+
{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}
+
{{HTMLElement("strike")}}
+
{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}
+
{{HTMLElement("sub")}}
+
{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}
+
{{HTMLElement("sup")}}
+
+ +

Specificazioni

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificazioniStatoCommento
{{SpecName('ES1')}}{{Spec2('ES1')}}Definizione iniziale.
{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilità con il browser

+ + + +

{{Compat("javascript.builtins.String.prototype")}}

+ +

Guarda anche

+ + diff --git a/files/it/conflicting/web/javascript/reference/operators/index.html b/files/it/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..e49fe045ae --- /dev/null +++ b/files/it/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,292 @@ +--- +title: Operatori Aritmetici +slug: Web/JavaScript/Reference/Operators/Operatori_Aritmetici +tags: + - JavaScript + - Operatori + - Operatori Aritmetici +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +--- +
{{jsSidebar("Operators")}}
+ +
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. var1e 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.

+ + + +

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.

+ + + +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificazioniStatoCommento
ECMAScript 1st Edition.StandardDefinizione iniziale.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Definito in diverse sezioni della specifica: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES2015', '#sec-postfix-expressions')}}{{Spec2('ES2015')}}Definito in diverse sezioni della specifica: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES2016', '#sec-postfix-expressions')}}{{Spec2('ES2016')}}Aggiunto Exponentiation operator.
+ +

Compatibilità con i browser

+ + + +

{{Compat("javascript.operators.arithmetic")}}

+ +

Guarda anche

+ + -- cgit v1.2.3-54-g00ecf