Espressioni e operatori

  • Revision slug: Web/JavaScript/Guide/Expressions_and_Operators
  • Revision title: Espressioni e operatori
  • Revision id: 484827
  • Created:
  • Creator: EdoPut
  • Is current revision? No
  • Comment

Revision Content

Questo capitolo descrive le espressioni e gli operatori Javascript includendo anche gli assegnamenti, i confronti, l'aritmetica, le stringhe e gli operatori speciali-

Espressioni

Un'espressione è un'unità di codice valido che restituisce un valore.

Teroicamente ci sono due tipi di espressioni, quelle che assegnano un valore ad una variabile e quelle che sono un valore.

x = 7 è l'esempio del primo tipo. Questa espressione usa l'operatore This =  per assegnare il valore 7 alla variabile x.

Il codice 3 + 4 è l'esempio del secondo tipo di espressione. Questa espressione usa l'operatore + per sommare i valori 3 e 4 senza assegnare i valore finale (7) ad una varibile.

In JavaScript esistono delle categorie per dividere le espressioni:

  • Aritmetiche: Restituiscono un numero come ad esempio3.14159. (Generally uses {{ web.link("#Arithmetic_operators", "arithmetic operators") }}.)
  • Stringhe: Restituiscono una stringa di caratteri come "Fred" o "234". (Generally uses {{ web.link("#String_operators", "string operators") }}.)
  • Logiche: Restituiscono Vero o Falso. (Often involves {{ web.link("#Logical_operators", "logical operators") }}.)
  • Oggetto: Restituiscono un oggetto. (See {{ web.link("#Special_operators", "special operators") }} for various ones that evaluate to objects.)

Operatori

In JavaScript sono presenti i seguenti operatori. Questa sezione descrive gli operatori e le priorità.

  • {{ web.link("#Assignment_operators", "Assignment operators") }}
  • {{ web.link("#Comparison_operators", "Comparison operators") }}
  • {{ web.link("#Arithmetic_operators", "Arithmetic operators") }}
  • {{ web.link("#Bitwise_operators", "Bitwise operators") }}
  • {{ web.link("#Logical_operators", "Logical operators") }}
  • {{ web.link("#String_operators", "String operators") }}
  • {{ web.link("#Special_operators", "Special operators") }}

In JavaScript esistono sia operatori unari che binari ed esiste anche un operatore ternario, l'operatore condizionale.

operando1 operatore operando2


Per esempio 3+4 o x*y.

Un operatore unario richiede un singolo operando e può essere sinistro o destro.

operatore operando

o

operando operatore

Ad esempio, ++x o x++.

Operatori di assegnamento

Un operatore di assegnamento assegna all'operando sinstro un valore basato sull'operando destro. Il più basilare è l'uguale e serve ad assegnare il valore dell'operando destro al sinistro. Ad esempio x = 4; assegna alla x il valore 4.

Ecco una tabella riassuntiva degli operatori di assegnamento disponibili.

Table 3.1 Assignment operators
Operatore Significato
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
x <<= y x = x << y
x >>= y x = x >> y
x >>>= y x = x >>> y
x &= y x = x & y
x ^= y x = x ^ y
x |= y x = x | y

Operatori di confronto

This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="... Un operatore di confronto compara i due operandi e restituisce un valore logico basato sul confronto tra gli operandi.  Gli operandi possono essere numeri, stringhe, logici o degli oggetti. Le stringhe sono comparate usando l'ordine alfanumerico dando ad ogni carattere un valore unicode. Due operandi possono essere di due tipi diversi e quando accade JavaScript cerca di convertirli in qualcosa di comparabile. Questo comportamento finisce per comparare i due operandi numericamente dopo averli convertiti. L'unica eccezione è data dagli operatori ===  e !== che non fanno conversioni. Ecco una tabella riassuntiva per gli operatori di confronto, i valori sono riferiti all'assegnamento seguente:

var var1 = 3, var2 = 4;
Table 3.2 Operatori di confronto
Operatore Descrizione Esempio vero
Ugualel (==) Vero se gli operandi sono uguali. 3 == var1

"3" == var1

3 == '3'
Non uguale(!=) Vero se gli operandi sono diversi. var1 != 4
var2 != "3"
Strettamente uguale (===) Vero se gli operandi sono uguali e dello stesso tipo. Vedi anche Object.is e sameness in JS. 3 === var1
Strettamente non uguale (!==) Vero se gli operandi sono diversi e dello stesso tipo. var1 !== "3"
3 !== '3'
Più grande di(>) Vero se l'operando sinistro è più grande del destro. var2 > var1
"12" > 2
Più grande o uguale (>=) Vero se l'operando sinistro è più grande o ugale al destro. var2 >= var1
var1 >= 3
Più piccolo (<) Vero se l'operando sinistro è più piccolo del destro. var1 < var2
"2" < "12"
Più piccolo o uguale(<=) Vero se l'operando sinistro è più piccolo o uguale al destro. var1 <= var2
var2 <= 5

Operatori aritmetici

Gli operatori aritmetici prendono valori numerici (sotto forma di variabili o valori) e restituiscono un singolo valore numerico.  Gli operatori basilari sono l'addizione (+), La sottrazione (-), la moltiplicazione (*) e la divisione (/). Questi operatori si comportano corerentemente con lo standard a virgola mobile e gestiscono casi limite come la divisione per zero, restituendo un valore non numerico Infinity. Ad esempio:

console.log(1 / 2); /* prints 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* also this is true */

Inoltre esistono in JavaScript gli operatori aritmerici elencati nella tabella seguente:

Table 3.3 Operatori aritmetici
Operatore Descrzione Esempio
%
(Modulo)
Operatore binario. Restituisce il resto della divisione eucildea degli operandi. 12 % 5 returns 2.
++
(Incremento)
Operatore unario. Incrementa l'operando di un'unità. Se prefisso prima somma e poi restituisce il valore, viceversa se post-fisso. Sia x=3, ++x incrementa x a 4 e restituisce 4, invece x++ restituisce 3 e, solo dopo, incrementa x a 4.
--
(Decremento)
Operatore unario. Decrementa l'operando di un'unità. Se prefisso prima sottrae e poi restituisce il valore, viceversa se post-fisso. Sia x=3, --x sottrae 1 a x  e restituisce 2, invece x-- restituisce 3 e, solo dopo, sottrae 1 a x.
-
(Negazione)
Operatore unario. Restituisce l'opposto del suo operando. Se x=3, -x restituisce -3.

Operatori Bitwise

Gli operatori Bitwise trattano i loro operandi come insiemi di 32 bit. La rappresentazione dei numeri viene convertita in base 2, viene applicato l'operatore e quindi viene restituito un valore numerico standard di JavaScript.

Questi sono gli operatori Bitwise presenti in JavaScript

Table 3.4 Bitwise operators
Operatore Uso Descrizione
Bitwise AND a & b Restituisce 1 per ogni posizione in cui a e b sono entrambi 1, 0 altrimenti.
Bitwise OR a | b Restituisce 1 per ogni posizione in cui a o b è 1, 0 se entrambi 0.
Bitwise XOR a ^ b Restituisce 1 per ogni posizione in cui a e b sono diversi e almeno uno dei due è1.
Bitwise NOT ~ a Inverte la rappresentazione binaria dell'operando.
Left shift a << b Sposta b bit della rappresentazione binaria a sinistra, aggiungendo zeri a destra.
Sign-propagating right shift a >> b Sposta b bit della rappresentazione binaria a destra scartando i bit esclusi.
Zero-fill right shift a >>> b Sposta b bit della rappresentazione binaria a destra scartando i bit esclusi e aggiungendo zeri da sinistra.

Operatori logici Bitwise

Gli operatori logici Bitwise funzionano così:

  • Gli operandi sono convertiti in binario a 32 bit.
  • I bit vengono accoppiati con il loro corrispondente dell'altro operando. Ciò avviene bit per bit partendo dalla stessa posizione.
  • L'operatore viene applicato ad ogni coppia e il risultato viene creato ricomponendo i bit ottenuti.

Ad esempio la rappresentazione binaria di 9 è 1001, e 15 è 1111. Quando gli operatori Bitwise vengono applicati ai due valori questi sono i risultati:

Table 3.5 Esempi per operatori Bitwise
Expressione Risultato Descrizione binaria
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

Osserva che i 32 bit vengono invertiti usando l'operatore Bitwise NOT e che i valori con la quantità maggiore di 1 a sinistra sono numeri negativi, come in accordo allo standard del complemento a due.

Bitwise shift operators

L'operatore Bitwise shift prende 2 operandi: il primo è il numero di bit che devono essere mossi e il secondo specifica il numero relativo alla posizione del primo bit da spostare. Il simbolo dell'operatore indica la direzione dello spostamento.

Questi operatori convertono i loro operandi in interi a 32 bit e restituiscono il risultato nel formato dell'operando sinistro.

Nella tabella segue la descrizione degli operatori di spostamento.

Table 3.6 Bitwise shift operators
Operator Description Example
<<
(Left shift)
Questo operatore sposta i bit dell'operando sinistro a sinistra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a destra vengono inseriti zeri. 9<<2 yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36.
>>
(Sign-propagating right shift)
Questo operatore sposta i bit dell'operando sinistro a destra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a sinstra vengono inseriti bit coerenti con il segno per preservarlo. 9>>2 yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, -9>>2 yields -3, because the sign is preserved.
>>>
(Zero-fill right shift)
Questo operatore sposta i bit dell'operando sinistro a destra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a destra vengono inseriti zeri senza curarsi del segno. 19>>>2 yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result.

Operatori logici

Gli operatori logici vengono applicati solitamente a valori Booleani e restituiscono valori Booleani. Gli operatori || e && invece restituiscono uno dei due valori passatili e quindi non sempre restituiscono valori Booleani. La tabella descrive gli operatori logici.

Table 3.6 Operatori logici
Operatore Uso Descrizione
&& expr1 && expr2 (Logical AND) Returns expr1 if it can be converted to false; otherwise, returns expr2. Thus, when used with Boolean values, && returns true if both operands are true; otherwise, returns false.
|| expr1 || expr2 (Logical OR) Returns expr1 if it can be converted to true; otherwise, returns expr2. Thus, when used with Boolean values, || returns true if either operand is true; if both are false, returns false.
! !expr

(Logical NOT) Returns false if its single operand can be converted to true; otherwise, returns true.

Elementi che vengono valutati come Falso quando convertiti sono quelli che vengono valutati null, 0, NaN, le stringhe vuote ("") e gli oggetti indefiniti.

Ecco degli esempi su come usare gli operatori logici.

L'operatore &&

var a1 =  true && true;     // t && t returns true
var a2 =  true && false;    // t && f returns false
var a3 = false && true;     // f && t returns false
var a4 = false && (3 == 4); // f && f returns false
var a5 = "Cat" && "Dog";    // t && t returns Dog
var a6 = false && "Cat";    // f && t returns false
var a7 = "Cat" && false;    // t && f returns false

L'operatore ||

var o1 =  true || true;     // t || t returns true
var o2 = false || true;     // f || t returns true
var o3 =  true || false;    // t || f returns true
var o4 = false || (3 == 4); // f || f returns false
var o5 = "Cat" || "Dog";    // t || t returns Cat
var o6 = false || "Cat";    // f || t returns Cat
var o7 = "Cat" || false;    // t || f returns Cat

L'operatore !

var n1 = !true;  // !t returns false
var n2 = !false; // !f returns true
var n3 = !"Cat"; // !t returns false

Short-circuit evaluation

Le espressioni logiche vengono valutate da sinistra a destra e quindi è possibile creare delle "scorciatoie".

  • false && anything viene valutato come false
  • true || anything viene valutato come true.

Le regole della logica binaria garantiscono la correttezza delle valutazioni. Le espressioni a destra degli operatori non vengono valutate quindi anche se dovessere portare a qualche cambiamento questo non avrà effetto.

Operatori delle stringhe

Operatori speciali

In JavaScript esistono i seguenti operatori speciali:

  • {{ web.link("#Conditional_operator", "Operatori condizionali") }}
  • {{ web.link("#Comma_operator","Operatore virgola") }}
  • {{ web.link("#delete", "delete") }}
  • {{ web.link("#in", "in") }}
  • {{ web.link("#instanceof", "instanceof") }}
  • {{ web.link("#new", "new") }}
  • {{ web.link("#this", "this") }}
  • {{ web.link("#typeof", "typeof") }}
  • {{ web.link("#void", "void") }}

Opearatori condizionali

L'operatore condizionale è l'unico operatore ternario. Questo può averte uno o due valori basati su una condizione. La sintassi da usare è:

condition ? val1 : val2

Se condition è vero,l'operatore ha il valore val1. Altrimenti ha il valore val2. Puoi usare l'operatore condizionale dovunque useresti un operatore standard.

Ad esempio,

var status = (age >= 18) ? "adult" : "minor";

Questo assegnamento restituisce adult se l'età è maggiore o uguale di 18, minor altrimenti.

Operatore virgola (comma)

L'operatore virgola valuta entrambi gli operandi e restituisce il secondo. Puoi usarlo in un ciclo for per far si che più variabili vengano aggiornate all'inizio di ogni loop.

Ad esempio potresti usarlo per iterare attraverso gli elementi della diagoanle di un array 10x10. Il codice seguente stampa a video il valore degli elementi della diagonale di un array 10x10.

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

delete

L'operatore delete elimina un oggeto, una proprietò di un oggetto, un elemento specifico di una array. La sintassi corretta è:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement

Dove objectName è il nome di un oggetto, property è un suo valore e index è un'intero che rapresenta la posizione di un elemento in un array.

La quarta formulazione è valida solamente se usata con with per eliminare una proprietà da un oggetto.

Inoltre puoi usare delete solo per cancellare variabili implicite, non globali.

Se l'operazione ha successo delete assegna alla proprietà o all'oggeto il tipo undefined. Inoltre l'operatore restituisce true se l'operazione è possibile e l'operando è eliminabile, altrimenti restituisce falso.

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)
Elimnare elementi di un array

Eliminare elementi da un array non influisce sulla sua lunghezza, per esempio se elimino a[3] l'elemento a[4] rimane se stesso e non passa al terzo posto.

Quando viene rimosso un elemento da un array l'elemento non esiste più e cercarlo restituisce undefined

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed
}

Se vuoi invece preservare l'elemento ma fare in modo che abbia valore undefined usa l'operatore undefined invece di delete.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed
}

in

L'operatore in restituisce vero se la proprietà specificata è nell'operando. La sintassi da usare è:

propNameOrNumber in objectName

dove propNameOrNumbe è una stringa o un valore numerico che rappresenti una probrietò di un oggetto e objectName è il nome dell'oggeto in questione in cui voglio cercare propNameOrNumber.

Ecco alcuni esempi su come utilizzare in

// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true

instanceof

L'operatore instanceof restituisce true se l'operando oggetto è del tipo operando tipoOggetto. La sintassi è:

objectName instanceof objectType

dove objectName è il nome dell'oggetto e objectType è un valore della lista dei tipi di dato.

Usa instanceof quando hai bisogno di conferme sul tipo di un oggetto. Per esempio, quando hai catturato un'eccezione, puoi diversificare il comportamente del codice in base al tipo di oggetto eccezzione che hai ricevuto.

For example, the following code uses instanceof to determine whether theDay is a Date object. Because theDay is a Date object, the statements in the if statement execute.

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute
}

new

You can use the new operator to create an instance of a user-defined object type or of one of the predefined object types Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, or String. On the server, you can also use it with DbPool, Lock, File, or SendMail. Use new as follows:

var objectName = new objectType([param1, param2, ..., paramN]);

You can also create objects using object initializers, as described in {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }}.

See the new operator page in the Core JavaScript Reference for more information.

this

Usa questo comando per riferirti all'oggetto corrente. Generalmente lo puoi usare per chiamare il metodo di un oggetto.

this["propertyName"]
this.propertyName

Example 1.
Suppose a function called validate validates an object's value property, given the object and the high and low values:

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Invalid Value!");
}

You could call validate in each form element's onChange event handler, using this to pass it the form element, as in the following example:

<B>Enter a number between 18 and 99:</B>
<INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);">

Example 2.
When combined with the form property, this can refer to the current object's parent form. In the following example, the form myForm contains a Text object and a button. When the user clicks the button, the value of the Text object is set to the form's name. The button's onClick event handler uses this.form to refer to the parent form, myForm.

<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga"/>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;"/>
</FORM>

typeof

The typeof operator is used in either of the following ways:

  1. typeof operand
    
  2. typeof (operand)
    

The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.

Suppose you define the following variables:

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

The typeof operator returns the following results for these variables:

typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"

For the keywords true and null, the typeof operator returns the following results:

typeof true; // returns "boolean"
typeof null; // returns "object"

For a number or string, the typeof operator returns the following results:

typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"

For property values, the typeof operator returns the type of value the property contains:

typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"

For methods and functions, the typeof operator returns results as follows:

typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"

For predefined objects, the typeof operator returns results as follows:

typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"

void

The void operator is used in either of the following ways:

  1. void (expression)
    
  2. void expression
    

The void operator specifies an expression to be evaluated without returning a value. expression is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.

You can use the void operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.

The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, void(0) evaluates to undefined, which has no effect in JavaScript.

<A HREF="javascript:void(0)">Click here to do nothing</A>

The following code creates a hypertext link that submits a form when the user clicks it.

<A HREF="javascript:void(document.form.submit())">
Click here to submit</A>

Priorità degli operatori

The precedence of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.

The following table describes the precedence of operators, from highest to lowest.

In accordance with relevant discussion, this table was reversed to list operators in decreasing order of priority.

Table 3.7 Operator precedence
Operator type Individual operators
member . []
call / create instance () new
negation/increment ! ~ - + ++ -- typeof void delete
multiply/divide * / %
addition/subtraction + -
bitwise shift << >> >>>
relational < <= > >= in instanceof
equality == != === !==
bitwise-and &
bitwise-xor ^
bitwise-or |
logical-and &&
logical-or ||
conditional ?:
assignment = += -= *= /= %= <<= >>= >>>= &= ^= |=
comma ,

A more detailed version of this table, complete with links to additional details about each operator, may be found in JavaScript Reference.

{{ autoPreviousNext("JSGChapters") }}

Revision Source

<p>Questo capitolo descrive le espressioni e gli operatori Javascript includendo anche gli assegnamenti, i confronti, l'aritmetica, le stringhe e gli operatori speciali-</p>
<h2 id="Espressioni">Espressioni</h2>
<p>Un'<em>espressione</em> è un'unità di codice valido che restituisce un valore.</p>
<p>Teroicamente ci sono due tipi di espressioni, quelle che assegnano un valore ad una variabile e quelle che sono un valore.</p>
<p><code>x = 7</code> è l'esempio del primo tipo. Questa espressione usa l'operatore This =<em>&nbsp;</em> per assegnare il valore 7 alla variabile x.</p>
<p>Il codice <code>3 + 4</code> è l'esempio del secondo tipo di espressione. Questa espressione usa l'operatore + per sommare i valori 3 e 4 senza assegnare i valore finale (7) ad una varibile.<br />
 <br />
 In JavaScript esistono delle categorie per dividere le espressioni:</p>
<ul>
 <li>Aritmetiche: Restituiscono un numero come ad esempio3.14159. (Generally uses {{ web.link("#Arithmetic_operators", "arithmetic operators") }}.)</li>
 <li>Stringhe: Restituiscono una stringa di caratteri come "Fred" o "234". (Generally uses {{ web.link("#String_operators", "string operators") }}.)</li>
 <li>Logiche: Restituiscono Vero o Falso. (Often involves {{ web.link("#Logical_operators", "logical operators") }}.)</li>
 <li>Oggetto: Restituiscono un oggetto. (See {{ web.link("#Special_operators", "special operators") }} for various ones that evaluate to objects.)</li>
</ul>
<h2 id="Operatori">Operatori</h2>
<p>In JavaScript sono presenti i seguenti operatori. Questa sezione descrive gli operatori e le <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">priorità.</a></p>
<ul>
 <li>{{ web.link("#Assignment_operators", "Assignment operators") }}</li>
 <li>{{ web.link("#Comparison_operators", "Comparison operators") }}</li>
 <li>{{ web.link("#Arithmetic_operators", "Arithmetic operators") }}</li>
 <li>{{ web.link("#Bitwise_operators", "Bitwise operators") }}</li>
 <li>{{ web.link("#Logical_operators", "Logical operators") }}</li>
 <li>{{ web.link("#String_operators", "String operators") }}</li>
 <li>{{ web.link("#Special_operators", "Special operators") }}</li>
</ul>
<p>In JavaScript esistono sia operatori unari che binari ed esiste anche un operatore ternario, l'operatore condizionale.</p>
<pre>
<em>operando1</em> <em>operatore</em> <em>operando2</em>
</pre>
<p><br />
 Per esempio <code>3+4</code> o <code>x*y</code>.</p>
<p>Un operatore unario richiede un singolo operando e può essere sinistro o destro.</p>
<pre>
<em>operatore</em> <em>operand</em>o
</pre>
<p>o</p>
<pre>
<em>operand</em>o <em>operator</em>e
</pre>
<p>Ad esempio, <code>++x</code> o <code>x++</code>.</p>
<h3 id="Operatori_di_assegnamento">Operatori di assegnamento</h3>
<p>Un operatore di assegnamento assegna all'operando sinstro un valore basato sull'operando destro. Il più basilare è l'<em>uguale</em> e serve ad assegnare il valore dell'operando destro al sinistro. Ad esempio <code>x = 4;</code> assegna alla x il valore 4.</p>
<p>Ecco una tabella riassuntiva degli operatori di assegnamento disponibili.</p>
<table class="standard-table">
 <caption style="text-align: left;">
  Table 3.1 Assignment operators</caption>
 <thead>
  <tr>
   <th scope="col" width="50%">Operatore</th>
   <th scope="col" width="50%">Significato</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>x += y</code></td>
   <td><code>x = x + y</code></td>
  </tr>
  <tr>
   <td><code>x -= y</code></td>
   <td><code>x = x - y</code></td>
  </tr>
  <tr>
   <td><code>x *= y</code></td>
   <td><code>x = x * y</code></td>
  </tr>
  <tr>
   <td><code>x /= y</code></td>
   <td><code>x = x / y</code></td>
  </tr>
  <tr>
   <td><code>x %= y</code></td>
   <td><code>x = x % y</code></td>
  </tr>
  <tr>
   <td><code>x &lt;&lt;= y</code></td>
   <td><code>x = x &lt;&lt; y</code></td>
  </tr>
  <tr>
   <td><code>x &gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><code>x &gt;&gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><code>x &amp;= y</code></td>
   <td><code>x = x &amp; y</code></td>
  </tr>
  <tr>
   <td><code>x ^= y</code></td>
   <td><code>x = x ^ y</code></td>
  </tr>
  <tr>
   <td><code>x |= y</code></td>
   <td><code>x = x | y</code></td>
  </tr>
 </tbody>
</table>
<h3 id="Operatori_di_confronto">Operatori di confronto</h3>
<p><span class="comment">This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="...</span> Un operatore di confronto compara i due operandi e restituisce un valore logico basato sul confronto tra gli operandi.&nbsp; Gli operandi possono essere numeri, stringhe, logici o degli oggetti. Le stringhe sono comparate usando l'ordine alfanumerico dando ad ogni carattere un valore unicode. Due operandi possono essere di due tipi diversi e quando accade JavaScript cerca di convertirli in qualcosa di comparabile. Questo comportamento finisce per comparare i due operandi numericamente dopo averli convertiti. L'unica eccezione è data dagli operatori <code>===</code>&nbsp; e <code>!== che non fanno conversioni</code>. Ecco una tabella riassuntiva per gli operatori di confronto, i valori sono riferiti all'assegnamento seguente:</p>
<pre class="brush: js">
var var1 = 3, var2 = 4;
</pre>
<table class="standard-table">
 <caption style="text-align: left;">
  Table 3.2 Operatori di confronto</caption>
 <thead>
  <tr>
   <th scope="col">Operatore</th>
   <th scope="col">Descrizione</th>
   <th scope="col">Esempio vero</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>Ugualel (<code>==</code>)</td>
   <td>Vero se gli operandi sono uguali.</td>
   <td><code>3 == var1</code><br />
    <p><code>"3" == var1</code></p>
    <code>3 == '3'</code></td>
  </tr>
  <tr>
   <td>Non uguale(<code>!=</code>)</td>
   <td>Vero se gli operandi sono diversi.</td>
   <td><code>var1 != 4<br />
    var2 != "3"</code></td>
  </tr>
  <tr>
   <td>Strettamente uguale (<code>===</code>)</td>
   <td>Vero se gli operandi sono uguali e dello stesso tipo. Vedi anche <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> e <a href="/en-US/docs/Web/JavaScript/Guide/Sameness" title="/en-US/docs/Web/JavaScript/Guide/Sameness">sameness in JS</a>.</td>
   <td><code>3 === var1</code></td>
  </tr>
  <tr>
   <td>Strettamente non uguale (<code>!==</code>)</td>
   <td>Vero se gli operandi sono diversi e dello stesso tipo.</td>
   <td><code>var1 !== "3"<br />
    3 !== '3'</code></td>
  </tr>
  <tr>
   <td>Più grande di(<code>&gt;</code>)</td>
   <td>Vero se l'operando sinistro è più grande del destro.</td>
   <td><code>var2 &gt; var1<br />
    "12" &gt; 2</code></td>
  </tr>
  <tr>
   <td>Più grande o uguale (<code>&gt;=</code>)</td>
   <td>Vero se l'operando sinistro è più grande o ugale al destro.</td>
   <td><code>var2 &gt;= var1<br />
    var1 &gt;= 3</code></td>
  </tr>
  <tr>
   <td>Più piccolo (<code>&lt;</code>)</td>
   <td>Vero se l'operando sinistro è più piccolo del destro.</td>
   <td><code>var1 &lt; var2<br />
    "2" &lt; "12"</code></td>
  </tr>
  <tr>
   <td>Più piccolo o uguale(<code>&lt;=</code>)</td>
   <td>Vero se l'operando sinistro è più piccolo o uguale al destro.</td>
   <td><code>var1 &lt;= var2<br />
    var2 &lt;= 5</code></td>
  </tr>
 </tbody>
</table>
<h3 id="Operatori_aritmetici">Operatori aritmetici</h3>
<p>Gli operatori aritmetici prendono valori numerici (sotto forma di variabili o valori) e restituiscono un singolo valore numerico.&nbsp; Gli operatori basilari sono l'addizione (+), La sottrazione (-), la moltiplicazione (*) e la divisione (/). Questi operatori si comportano corerentemente con lo standard a virgola mobile e gestiscono casi limite come la divisione per zero, restituendo un valore non numerico <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity"><code>Infinity</code></a>. Ad esempio:</p>
<pre class="brush: js">
console.log(1 / 2); /* prints 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* also this is true */
</pre>
<p>Inoltre esistono in JavaScript gli operatori aritmerici elencati nella tabella seguente:</p>
<table class="fullwidth-table">
 <caption style="text-align: left;">
  Table 3.3 Operatori aritmetici</caption>
 <thead>
  <tr>
   <th scope="col">Operatore</th>
   <th scope="col">Descrzione</th>
   <th scope="col">Esempio</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>%</code><br />
    (Modulo)</td>
   <td>Operatore binario. Restituisce il resto della divisione eucildea degli operandi.</td>
   <td>12 % 5 returns 2.</td>
  </tr>
  <tr>
   <td><code>++</code><br />
    (Incremento)</td>
   <td>Operatore unario. Incrementa l'operando di un'unità. Se prefisso prima somma e poi restituisce il valore, viceversa se post-fisso.</td>
   <td>Sia <code>x</code>=3, <code>++x</code> incrementa <code>x</code> a 4 e restituisce 4, invece <code>x++</code> restituisce 3 e, solo dopo, incrementa x a 4.</td>
  </tr>
  <tr>
   <td><code>--</code><br />
    (Decremento)</td>
   <td>Operatore unario. Decrementa l'operando di un'unità. Se prefisso prima sottrae e poi restituisce il valore, viceversa se post-fisso.</td>
   <td>Sia <code>x</code>=3, <code>--x</code> sottrae <code>1 a x&nbsp;</code> e restituisce 2, invece <code>x-- </code>restituisce 3 e, solo dopo, sottrae 1 a x.</td>
  </tr>
  <tr>
   <td><code>-</code><br />
    (Negazione)</td>
   <td>Operatore unario. Restituisce l'opposto del suo operando.</td>
   <td>Se x=3, -x restituisce -3.</td>
  </tr>
 </tbody>
</table>
<h3 id="Operatori_Bitwise">Operatori Bitwise</h3>
<p>Gli operatori Bitwise trattano i loro operandi come insiemi di 32 bit. La rappresentazione dei numeri viene convertita in base 2, viene applicato l'operatore e quindi viene restituito un valore numerico standard di JavaScript.</p>
<p>Questi sono gli operatori Bitwise presenti in JavaScript</p>
<table class="standard-table">
 <caption style="text-align: left;">
  Table 3.4 Bitwise operators</caption>
 <thead>
  <tr>
   <th scope="col">Operatore</th>
   <th scope="col">Uso</th>
   <th scope="col">Descrizione</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>Bitwise AND</td>
   <td><code>a &amp; b</code></td>
   <td>Restituisce 1 per ogni posizione in cui a e b sono entrambi 1, 0 altrimenti.</td>
  </tr>
  <tr>
   <td>Bitwise OR</td>
   <td><code>a | b</code></td>
   <td>Restituisce 1 per ogni posizione in cui a o b è 1, 0 se entrambi 0.</td>
  </tr>
  <tr>
   <td>Bitwise XOR</td>
   <td><code>a ^ b</code></td>
   <td>Restituisce 1 per ogni posizione in cui a e b sono diversi e almeno uno dei due è1.</td>
  </tr>
  <tr>
   <td>Bitwise NOT</td>
   <td><code>~ a</code></td>
   <td>Inverte la rappresentazione binaria dell'operando.</td>
  </tr>
  <tr>
   <td>Left shift</td>
   <td><code>a &lt;&lt; b</code></td>
   <td>Sposta b bit della rappresentazione binaria a sinistra, aggiungendo zeri a destra.</td>
  </tr>
  <tr>
   <td>Sign-propagating right shift</td>
   <td><code>a &gt;&gt; b</code></td>
   <td>Sposta b bit della rappresentazione binaria a destra scartando i bit esclusi.</td>
  </tr>
  <tr>
   <td>Zero-fill right shift</td>
   <td><code>a &gt;&gt;&gt; b</code></td>
   <td>Sposta b bit della rappresentazione binaria a destra scartando i bit esclusi e aggiungendo zeri da sinistra.</td>
  </tr>
 </tbody>
</table>
<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">Operatori logici Bitwise</h4>
<p>Gli operatori logici Bitwise funzionano così:</p>
<ul>
 <li>Gli operandi sono convertiti in binario a 32 bit.</li>
 <li>I bit vengono accoppiati con il loro corrispondente dell'altro operando. Ciò avviene bit per bit partendo dalla stessa posizione.</li>
 <li>L'operatore viene applicato ad ogni coppia e il risultato viene creato ricomponendo i bit ottenuti.</li>
</ul>
<p>Ad esempio la rappresentazione binaria di 9 è 1001, e 15 è 1111. Quando gli operatori Bitwise vengono applicati ai due valori questi sono i risultati:</p>
<table class="standard-table">
 <caption style="text-align: left;">
  Table 3.5 Esempi per operatori Bitwise</caption>
 <thead>
  <tr>
   <th scope="col">Expressione</th>
   <th scope="col">Risultato</th>
   <th scope="col">Descrizione binaria</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>15 &amp; 9</code></td>
   <td><code>9</code></td>
   <td><code>1111 &amp; 1001 = 1001</code></td>
  </tr>
  <tr>
   <td><code>15 | 9</code></td>
   <td><code>15</code></td>
   <td><code>1111 | 1001 = 1111</code></td>
  </tr>
  <tr>
   <td><code>15 ^ 9</code></td>
   <td><code>6</code></td>
   <td><code>1111 ^ 1001 = 0110</code></td>
  </tr>
  <tr>
   <td><code>~15</code></td>
   <td><code>-16</code></td>
   <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td>
  </tr>
  <tr>
   <td><code>~9</code></td>
   <td><code>-10</code></td>
   <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td>
  </tr>
 </tbody>
</table>
<p>Osserva che i 32 bit vengono invertiti usando l'operatore Bitwise NOT e che i valori con la quantità maggiore di 1 a sinistra sono numeri negativi, come in accordo allo standard del complemento a due.</p>
<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">Bitwise shift operators</h4>
<p>L'operatore Bitwise shift prende 2 operandi: il primo è il numero di bit che devono essere mossi e il secondo specifica il numero relativo alla posizione del primo bit da spostare. Il simbolo dell'operatore indica la direzione dello spostamento.</p>
<p>Questi operatori convertono i loro operandi in interi a 32 bit e restituiscono il risultato nel formato dell'operando sinistro.</p>
<p>Nella tabella segue la descrizione degli operatori di spostamento.</p>
<table class="fullwidth-table">
 <caption style="text-align: left;">
  Table 3.6 Bitwise shift operators</caption>
 <thead>
  <tr>
   <th scope="col">Operator</th>
   <th scope="col">Description</th>
   <th scope="col">Example</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>&lt;&lt;</code><br />
    (Left shift)</td>
   <td>Questo operatore sposta i bit dell'operando sinistro a sinistra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a destra vengono inseriti zeri.</td>
   <td><code>9&lt;&lt;2</code> yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36.</td>
  </tr>
  <tr>
   <td><code>&gt;&gt;</code><br />
    (Sign-propagating right shift)</td>
   <td>Questo operatore sposta i bit dell'operando sinistro a destra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a sinstra vengono inseriti bit coerenti con il segno per preservarlo.</td>
   <td><code>9&gt;&gt;2</code> yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, <code>-9&gt;&gt;2</code> yields -3, because the sign is preserved.</td>
  </tr>
  <tr>
   <td><code>&gt;&gt;&gt;</code><br />
    (Zero-fill right shift)</td>
   <td>Questo operatore sposta i bit dell'operando sinistro a destra. Il numero di spostamenti è dato dal valore dell'operando destro. I bit eccedenti vengono scartati mentre a destra vengono inseriti zeri senza curarsi del segno.</td>
   <td><code>19&gt;&gt;&gt;2</code> yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result.</td>
  </tr>
 </tbody>
</table>
<h3 id="Operatori_logici">Operatori logici</h3>
<p>Gli operatori logici vengono applicati solitamente a valori Booleani e restituiscono valori Booleani. Gli operatori || e &amp;&amp; invece restituiscono uno dei due valori passatili e quindi non sempre restituiscono valori Booleani. La tabella descrive gli operatori logici.</p>
<table class="fullwidth-table">
 <caption style="text-align: left;">
  Table 3.6 Operatori logici</caption>
 <thead>
  <tr>
   <th scope="col">Operatore</th>
   <th scope="col">Uso</th>
   <th scope="col">Descrizione</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>&amp;&amp;</code></td>
   <td><code>expr1 &amp;&amp; expr2</code></td>
   <td>(Logical AND) Returns <code>expr1</code> if it can be converted to false; otherwise, returns <code>expr2</code>. Thus, when used with Boolean values, <code>&amp;&amp;</code> returns true if both operands are true; otherwise, returns false.</td>
  </tr>
  <tr>
   <td><code>||</code></td>
   <td><code>expr1 || expr2</code></td>
   <td>(Logical OR) Returns <code>expr1</code> if it can be converted to true; otherwise, returns <code>expr2</code>. Thus, when used with Boolean values, <code>||</code> returns true if either operand is true; if both are false, returns false.</td>
  </tr>
  <tr>
   <td><code>!</code></td>
   <td><code>!expr</code></td>
   <td>
    <p>(Logical NOT) Returns false if its single operand can be converted to true; otherwise, returns true.</p>
   </td>
  </tr>
 </tbody>
</table>
<p>Elementi che vengono valutati come Falso quando convertiti sono quelli che vengono valutati null, 0, NaN, le stringhe vuote ("") e gli oggetti indefiniti.</p>
<p>Ecco degli esempi su come usare gli operatori logici.</p>
<p>L'operatore &amp;&amp;</p>
<pre class="brush: js">
var a1 =  true &amp;&amp; true;     // t &amp;&amp; t returns true
var a2 =  true &amp;&amp; false;    // t &amp;&amp; f returns false
var a3 = false &amp;&amp; true;     // f &amp;&amp; t returns false
var a4 = false &amp;&amp; (3 == 4); // f &amp;&amp; f returns false
var a5 = "Cat" &amp;&amp; "Dog";    // t &amp;&amp; t returns Dog
var a6 = false &amp;&amp; "Cat";    // f &amp;&amp; t returns false
var a7 = "Cat" &amp;&amp; false;    // t &amp;&amp; f returns false
</pre>
<p>L'operatore ||</p>
<pre class="brush: js">
var o1 =  true || true;     // t || t returns true
var o2 = false || true;     // f || t returns true
var o3 =  true || false;    // t || f returns true
var o4 = false || (3 == 4); // f || f returns false
var o5 = "Cat" || "Dog";    // t || t returns Cat
var o6 = false || "Cat";    // f || t returns Cat
var o7 = "Cat" || false;    // t || f returns Cat
</pre>
<p>L'operatore !</p>
<pre class="brush: js">
var n1 = !true;  // !t returns false
var n2 = !false; // !f returns true
var n3 = !"Cat"; // !t returns false
</pre>
<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Short-circuit evaluation</h4>
<p>Le espressioni logiche vengono valutate da sinistra a destra e quindi è possibile creare delle "scorciatoie".</p>
<ul>
 <li><code>false</code> &amp;&amp; <em>anything</em> viene valutato come false</li>
 <li><code>true</code> || <em>anything</em> viene valutato come true.</li>
</ul>
<p>Le regole della logica binaria garantiscono la correttezza delle valutazioni. Le espressioni a destra degli operatori non vengono valutate quindi anche se dovessere portare a qualche cambiamento questo non avrà effetto.</p>
<h3 id="Operatori_delle_stringhe">Operatori delle stringhe</h3>
<h3 id="Operatori_speciali">Operatori speciali</h3>
<p>In JavaScript esistono i seguenti operatori speciali:</p>
<ul>
 <li>{{ web.link("#Conditional_operator", "Operatori condizionali") }}</li>
 <li>{{ web.link("#Comma_operator","Operatore virgola") }}</li>
 <li><code>{{ web.link("#delete", "delete") }}</code></li>
 <li><code>{{ web.link("#in", "in") }}</code></li>
 <li><code>{{ web.link("#instanceof", "instanceof") }}</code></li>
 <li><code>{{ web.link("#new", "new") }}</code></li>
 <li><code>{{ web.link("#this", "this") }}</code></li>
 <li><code>{{ web.link("#typeof", "typeof") }}</code></li>
 <li><code>{{ web.link("#void", "void") }}</code></li>
</ul>
<h4 id="conditional_operator" name="conditional_operator">Opearatori condizionali</h4>
<p>L'operatore condizionale è l'unico operatore ternario. Questo può averte uno o due valori basati su una condizione. La sintassi da usare è:</p>
<pre>
<em>condition</em> ? <em>val1</em> : <em>val2</em>
</pre>
<p>Se <code>condition</code> è vero,l'operatore ha il valore <code>val1</code>. Altrimenti ha il valore <code>val2</code>. Puoi usare l'operatore condizionale dovunque useresti un operatore standard.</p>
<p>Ad esempio,</p>
<pre class="brush: js">
var status = (age &gt;= 18) ? "adult" : "minor";
</pre>
<p>Questo assegnamento restituisce <code>adult</code> se l'età è maggiore o uguale di 18, <code>minor</code> altrimenti.</p>
<h4 id="comma_operator" name="comma_operator">Operatore virgola (comma)</h4>
<p>L'operatore virgola valuta entrambi gli operandi e restituisce il secondo. Puoi usarlo in un ciclo <code>for</code> per far si che più variabili vengano aggiornate all'inizio di ogni loop.</p>
<p>Ad esempio potresti usarlo per iterare attraverso gli elementi della diagoanle di un array 10x10. Il codice seguente stampa a video il valore degli elementi della diagonale di un array 10x10.</p>
<pre class="brush: js">
for (var i = 0, j = 9; i &lt;= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
</pre>
<h4 id="delete" name="delete"><code>delete</code></h4>
<p>L'operatore <code>delete</code> elimina un oggeto, una proprietò di un oggetto, un elemento specifico di una array. La sintassi corretta è:</p>
<pre class="brush: js">
delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement
</pre>
<p>Dove <code>objectName</code> è il nome di un oggetto, <code>property</code> è un suo valore e <code>index</code> è un'intero che rapresenta la posizione di un elemento in un array.</p>
<p>La quarta formulazione è valida solamente se usata con <code>with</code> per eliminare una proprietà da un oggetto.</p>
<p>Inoltre puoi usare <code>delete</code> solo per cancellare variabili implicite, non globali.</p>
<p>Se l'operazione ha successo <code>delete</code> assegna alla proprietà o all'oggeto il tipo <code>undefined</code>. Inoltre l'operatore restituisce <code>true</code> se l'operazione è possibile e l'operando è eliminabile, altrimenti restituisce falso.</p>
<pre class="brush: js">
x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)
</pre>
<h5 id="Elimnare_elementi_di_un_array">Elimnare elementi di un array</h5>
<p>Eliminare elementi da un array non influisce sulla sua lunghezza, per esempio se elimino <code>a[3]</code> l'elemento <code>a[4]</code> rimane se stesso e non passa al terzo posto.</p>
<p>Quando viene rimosso un elemento da un array l'elemento non esiste più e cercarlo restituisce <code>undefined</code></p>
<pre class="brush: js">
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed
}
</pre>
<p>Se vuoi invece preservare l'elemento ma fare in modo che abbia valore <code>undefined</code> usa l'operatore <code>undefined</code> invece di <code>delete</code>.</p>
<pre class="brush: js">
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed
}
</pre>
<h4 id="in" name="in"><code>in</code></h4>
<p>L'operatore <code>in</code> restituisce <code>vero</code> se la proprietà specificata è nell'operando. La sintassi da usare è:</p>
<pre class="brush: js">
propNameOrNumber in objectName
</pre>
<p>dove <code>propNameOrNumbe</code> è una stringa o un valore numerico che rappresenti una probrietò di un oggetto e <code>objectName</code> è il nome dell'oggeto in questione in cui voglio cercare <code>propNameOrNumber</code>.</p>
<p>Ecco alcuni esempi su come utilizzare <code>in</code></p>
<pre class="brush: js">
// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true
</pre>
<h4 id="instanceof" name="instanceof"><code>instanceof</code></h4>
<p>L'operatore <code>instanceof</code> restituisce <code>true</code> se l'operando oggetto è del tipo operando tipoOggetto. La sintassi è:</p>
<pre class="brush: js">
objectName instanceof objectType
</pre>
<p>dove <code>objectName</code> è il nome dell'oggetto e <code>objectType</code> è un valore della lista dei tipi di dato.</p>
<p>Usa <code>instanceof</code> quando hai bisogno di conferme sul tipo di un oggetto. Per esempio, quando hai catturato un'eccezione, puoi diversificare il comportamente del codice in base al tipo di oggetto eccezzione che hai ricevuto.</p>
<p>For example, the following code uses <code>instanceof</code> to determine whether <code>theDay</code> is a <code>Date</code> object. Because <code>theDay</code> is a <code>Date</code> object, the statements in the <code>if</code> statement execute.</p>
<pre class="brush: js">
var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute
}
</pre>
<h4 id="new" name="new"><code>new</code></h4>
<p>You can use the <code>new</code> operator to create an instance of a user-defined object type or of one of the predefined object types <code>Array</code>, <code>Boolean</code>, <code>Date</code>, <code>Function</code>, <code>Image</code>, <code>Number</code>, <code>Object</code>, <code>Option</code>, <code>RegExp</code>, or <code>String</code>. On the server, you can also use it with <code>DbPool</code>, <code>Lock</code>, <code>File</code>, or <code>SendMail</code>. Use <code>new</code> as follows:</p>
<pre class="brush: js">
var objectName = new objectType([param1, param2, ..., paramN]);
</pre>
<p>You can also create objects using object initializers, as described in {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }}.</p>
<p>See the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> page in the Core JavaScript Reference for more information.</p>
<h4 id="this" name="this"><code>this</code></h4>
<p>Usa questo comando per riferirti all'oggetto corrente. Generalmente lo puoi usare per chiamare il metodo di un oggetto.</p>
<pre class="brush: js">
this["propertyName"]
</pre>
<pre class="brush: js">
this.propertyName
</pre>
<p><strong>Example 1.</strong><br />
 Suppose a function called <code>validate</code> validates an object's <code>value</code> property, given the object and the high and low values:</p>
<pre class="brush: js">
function validate(obj, lowval, hival){
  if ((obj.value &lt; lowval) || (obj.value &gt; hival))
    alert("Invalid Value!");
}
</pre>
<p>You could call <code>validate</code> in each form element's <code>onChange</code> event handler, using <code>this</code> to pass it the form element, as in the following example:</p>
<pre class="brush: html">
&lt;B&gt;Enter a number between 18 and 99:&lt;/B&gt;
&lt;INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);"&gt;
</pre>
<p><strong>Example 2.</strong><br />
 When combined with the <code>form</code> property, <code>this</code> can refer to the current object's parent form. In the following example, the form <code>myForm</code> contains a <code>Text</code> object and a button. When the user clicks the button, the value of the <code>Text</code> object is set to the form's name. The button's <code>onClick</code> event handler uses <code>this.form</code> to refer to the parent form, <code>myForm</code>.</p>
<pre class="brush: html">
&lt;FORM NAME="myForm"&gt;
Form name:&lt;INPUT TYPE="text" NAME="text1" VALUE="Beluga"/&gt;
&lt;INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;"/&gt;
&lt;/FORM&gt;
</pre>
<h4 id="typeof" name="typeof"><code>typeof</code></h4>
<p>The <code>typeof</code> operator is used in either of the following ways:</p>
<ol>
 <li>
  <pre class="brush: js">
typeof operand
</pre>
 </li>
 <li>
  <pre class="brush: js">
typeof (operand)
</pre>
 </li>
</ol>
<p>The <code>typeof</code> operator returns a string indicating the type of the unevaluated operand. <code>operand</code> is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.</p>
<p>Suppose you define the following variables:</p>
<pre class="brush: js">
var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();
</pre>
<p>The <code>typeof</code> operator returns the following results for these variables:</p>
<pre class="brush: js">
typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"
</pre>
<p>For the keywords <code>true</code> and <code>null</code>, the <code>typeof</code> operator returns the following results:</p>
<pre class="brush: js">
typeof true; // returns "boolean"
typeof null; // returns "object"
</pre>
<p>For a number or string, the <code>typeof</code> operator returns the following results:</p>
<pre class="brush: js">
typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"
</pre>
<p>For property values, the <code>typeof</code> operator returns the type of value the property contains:</p>
<pre class="brush: js">
typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"
</pre>
<p>For methods and functions, the <code>typeof</code> operator returns results as follows:</p>
<pre class="brush: js">
typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"
</pre>
<p>For predefined objects, the <code>typeof</code> operator returns results as follows:</p>
<pre class="brush: js">
typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"
</pre>
<h4 id="void" name="void"><code>void</code></h4>
<p>The <code>void</code> operator is used in either of the following ways:</p>
<ol>
 <li>
  <pre class="brush: js">
void (expression)
</pre>
 </li>
 <li>
  <pre class="brush: js">
void expression
</pre>
 </li>
</ol>
<p>The <code>void</code> operator specifies an expression to be evaluated without returning a value. <code>expression</code> is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.</p>
<p>You can use the <code>void</code> operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.</p>
<p>The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, <code>void(0)</code> evaluates to undefined, which has no effect in JavaScript.</p>
<pre class="brush: html">
&lt;A HREF="javascript:void(0)"&gt;Click here to do nothing&lt;/A&gt;
</pre>
<p>The following code creates a hypertext link that submits a form when the user clicks it.</p>
<pre class="brush: html">
&lt;A HREF="javascript:void(document.form.submit())"&gt;
Click here to submit&lt;/A&gt;</pre>
<h3 id="Priorit.C3.A0_degli_operatori">Priorità degli operatori</h3>
<p>The <em>precedence</em> of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.</p>
<p>The following table describes the precedence of operators, from highest to lowest.</p>
<p><small><em>In accordance with <a href="/en-US/docs/Talk:JavaScript/Guide/Obsolete_Pages/Operators#Precedence_Tablerators#Precedence_Table">relevant discussion</a>, this table was reversed to list operators in <strong>decreasing</strong> order of priority.</em></small></p>
<table class="standard-table">
 <caption style="text-align: left;">
  Table 3.7 Operator precedence</caption>
 <thead>
  <tr>
   <th scope="col">Operator type</th>
   <th scope="col">Individual operators</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>member</td>
   <td><code>. []</code></td>
  </tr>
  <tr>
   <td>call / create instance</td>
   <td><code>() new</code></td>
  </tr>
  <tr>
   <td>negation/increment</td>
   <td><code>! ~ - + ++ -- typeof void delete</code></td>
  </tr>
  <tr>
   <td>multiply/divide</td>
   <td><code>* / %</code></td>
  </tr>
  <tr>
   <td>addition/subtraction</td>
   <td><code>+ -</code></td>
  </tr>
  <tr>
   <td>bitwise shift</td>
   <td><code>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
  </tr>
  <tr>
   <td>relational</td>
   <td><code>&lt; &lt;= &gt; &gt;= in instanceof</code></td>
  </tr>
  <tr>
   <td>equality</td>
   <td><code>== != === !==</code></td>
  </tr>
  <tr>
   <td>bitwise-and</td>
   <td><code>&amp;</code></td>
  </tr>
  <tr>
   <td>bitwise-xor</td>
   <td><code>^</code></td>
  </tr>
  <tr>
   <td>bitwise-or</td>
   <td><code>|</code></td>
  </tr>
  <tr>
   <td>logical-and</td>
   <td><code>&amp;&amp;</code></td>
  </tr>
  <tr>
   <td>logical-or</td>
   <td><code>||</code></td>
  </tr>
  <tr>
   <td>conditional</td>
   <td><code>?:</code></td>
  </tr>
  <tr>
   <td>assignment</td>
   <td><code>= += -= *= /= %= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=</code></td>
  </tr>
  <tr>
   <td>comma</td>
   <td><code>,</code></td>
  </tr>
 </tbody>
</table>
<p>A more detailed version of this table, complete with links to additional details about each operator, may be found in <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table">JavaScript Reference</a>.</p>
<div>
 {{ autoPreviousNext("JSGChapters") }}</div>
Revert to this revision