Questo capitolo descrive le espressioni e gli operatori JavaScript come assegnazione, confronto, aritmetica, bit per bit, logica, stringa e vari operatori speciali.

In questo manuale è disponibile anche un elenco completo e dettagliato di operatori ed espressioni.

Operatori

JavaScript ha i seguenti tipi di operatori. Questa sottosezione descrive ogni tipo e contiene informazioni sulla loro precedenza l'una sull'altra.

JavaScript supporta operatori binari e unari, nonché un altro operatore ternario speciale, l'operatore condizionale. Un'operazione binaria utilizza due operandi, uno prima dell'operatore e uno dopo di esso:

operando1 operatore operando2

Ad esempio: 3+4 o x*y .

A sua volta, l'operatore unario utilizza un operando, prima o dopo l'operatore:

operatore operando operando operatore

Ad esempio: x++ o ++x .

Operatori di assegnamento

Come risultato dell'operazione di assegnazione, l'operando a sinistra dell'operatore di assegnazione (il segno "=") viene impostato sul valore preso dall'operando di destra. L'operatore di assegnazione di base è =, che assegna il valore dell'operando di destra all'operando di sinistra. Quindi l'espressione x = y significa che a x è assegnato il valore di y.

Esistono anche operatori di assegnazione composti che vengono utilizzati per abbreviare le operazioni descritte nella tabella seguente:

Elenco degli operatori di assegnazione

Nome	operatore di stenografia	Senso
Incarico	x=y	x=y
Assegnazione con addizione	x += a	x = x + y
Assegnazione con sottrazione	x -= i	x = x - y
Assegnazione con moltiplicazione	x *= a	x=x*y
Assegnazione con divisione	x /= i	x=x/a
Assegnazione modulo	x %= a	x = x % a
Assegnazione del turno di sinistra	X<<= y	x = x<< y
Assegnazione del turno di destra	x >>= i	x = x >> y
Assegnazione con spostamento a destra senza segno	x >>>= i	x = x >>> y
Assegnazione con AND bit a bit	x &= a	x=x&y
Assegnazione con XOR bit a bit	x^= a	x=x^y
Assegnazione con OR bit a bit	x |= i	x = x | si

Destrutturante

Per assegnazioni più complesse, JavaScript ha una sintassi destrutturante, che è un'espressione che consente di estrarre dati da matrici o oggetti utilizzando una sintassi che rispecchia costruttori di matrici e oggetti letterali.

var foo = ["uno", "due", "tre"]; // nessuna destrutturazione var one = foo; vartwo = pippo; var tre = foo; // con destrutturazione var = foo;

Operatori di confronto

È possibile utilizzare l'operatore delete per eliminare le variabili dichiarate implicitamente, ma non è possibile utilizzarlo per eliminare le variabili dichiarate con var .

Dopo aver applicato l'operatore delete, la proprietà dell'elemento viene modificata in undefined . L'operatore delete restituisce true se l'operazione è possibile; operator restituisce false se l'operazione non può essere eseguita.

X = 42; variare = 43; myobj = nuovo Numero(); myobj.h = 4; // crea proprietà h cancella x; // restituisce true (la variabile dichiarata implicitamente può essere cancellata) delete y; // restituisce false (impossibile eliminare una variabile dichiarata con var) delete Math.PI; // restituisce false (impossibile eliminare le proprietà integrate) delete myobj.h; // restituisce true (le proprietà personalizzate possono essere eliminate) delete myobj; // restituisce true (è possibile eliminare l'oggetto dichiarato implicitamente)

Rimozione di elementi dell'array

L'eliminazione di un elemento dell'array non influisce sulla lunghezza dell'array. Ad esempio, se rimuovi a , l'elemento a rimane a e a diventa indefinito.

Quando un elemento dell'array viene eliminato utilizzando l'operatore delete, il valore di quell'elemento viene rimosso dall'array. Nell'esempio seguente, l'elemento tree viene eliminato utilizzando l'operatore delete. Tuttavia, l'elemento trees rimane indirizzabile e restituisce undefined .

Var alberi = new Array("sequoia", "baio", "cedro", "quercia", "acero"); eliminare alberi; if (3 negli alberi) ( // la condizione fallisce )

Se si desidera che un elemento rimanga nell'array ma abbia il valore undefined, utilizzare la parola chiave undefined invece dell'operatore delete. Nell'esempio seguente, l'elemento trees è impostato su undefined , ma l'elemento rimane nell'array:

Var alberi = new Array("sequoia", "baio", "cedro", "quercia", "acero"); alberi = non definiti; if (3 negli alberi) ( // questo blocco di codice è in esecuzione )

tipo di operatore

Usa l'operatore instanceof quando è necessario confermare il tipo di un oggetto in fase di esecuzione. Ad esempio, quando si rilevano eccezioni, è possibile creare diversi salti di programmazione per la gestione delle eccezioni a seconda del tipo di eccezione gestita.

Ad esempio, il codice seguente utilizza l'operatore instanceof per verificare se Day è un oggetto Date. Poiché theDay è effettivamente un oggetto Date, il programma esegue il codice contenuto nell'istruzione if.

Var theDay = new Date(1995, 12, 17); if (theDay istanza di Date) ( // codice eseguibile )

Precedenza dell'operatore

Una priorità operatori determina l'ordine in cui vengono eseguiti quando viene valutata un'espressione. Puoi influenzare la precedenza degli operatori con le parentesi.

La tabella seguente descrive la precedenza degli operatori dal più alto al più basso.

Tabella 3.7 Precedenza degli operatori

Tipo di operatore	Operatori
proprietà dell'oggetto	.
chiamata, istanziazione di oggetti	() nuovo
negazione, incremento	! ~ - +++ -- typeof void delete
moltiplicazione, divisione	* / %
addizione, sottrazione	+ -
po' di spostamento	<< >> >>>
confronto, ingresso	< <= >>= istanza di
uguaglianza	== != === !==
bit-e	&
bit-esclusivo-o	^
bit-o	|
logico-e	&&
logico-o	||
operatore condizionale (ternario).	?:
Incarico	= += -= *= /= %= <<= >>= >>>= &= ^= |=
virgola	,

Di più versione dettagliata questa tabella contenente collegamenti e Informazioni aggiuntive per ogni operatore, è nel riferimento JavaScript.

Espressioni

Espressioneè qualsiasi blocco di codice valido che restituisce un valore.

Concettualmente esistono due tipi di espressioni: quelle che assegnano un valore a una variabile e quelle che valutano un valore senza assegnarlo.

L'espressione x = 7 è un esempio del primo tipo di espressione. Questa espressione utilizza operatore= assegnare alla variabile x il valore 7 . Anche l'espressione stessa è uguale a 7.

Il codice 3 + 4 è un esempio del secondo tipo di espressione. Questa espressione utilizza operatore"+" per sommare i numeri 3 e 4 senza assegnare il risultato risultante 7 a una variabile.

Tutte le espressioni in JavaScript rientrano nelle seguenti categorie:

Espressioni di base

Di base parole chiave ed espressioni di base in JavaScript.

questo operatore

Utilizzare la parola chiave this per fare riferimento all'oggetto corrente. In generale, questo punta all'oggetto chiamabile a cui appartiene questo metodo. Usa questo in questo modo:

This["propertyName"] this.propertyName

Diciamo che la funzione validate controlla la proprietà value di qualche oggetto; viene specificato l'oggetto, così come i limiti superiore e inferiore del valore di questa proprietà:

Funzione validate(obj, lowval, hival)( if ((obj.value< lowval) || (obj.value >hival)) alert("Valore non valido!"); )

È possibile chiamare la funzione validate sul gestore di eventi onChange per ogni elemento del modulo, utilizzando this per puntare all'elemento del modulo, come mostrato nell'esempio seguente:

Inserisci un numero da 18 a 99:

Operatore di raggruppamento

L'operatore di raggruppamento "parentesi" () controlla la priorità della valutazione dell'espressione. Ad esempio, puoi ridefinire l'ordine - "moltiplicazione e divisione, quindi addizione e sottrazione", in modo che, ad esempio, l'addizione venga eseguita prima della moltiplicazione:

Vara = 1; variabile b = 2; variabile c = 3; // ordine normale a + b * c // 7 // esegui come al solito, quindi a + (b * c) // 7 // ora inverti l'ordine // addizione alla moltiplicazione (a + b) * c // 9 // che equivale a a * c + b * c // 9

Sintassi semplificata per la creazione di array e generatori

La sintassi semplificata è una funzionalità JavaScript sperimentale che potrebbe essere aggiunta alle versioni future di ECMAScript. Esistono 2 versioni della sintassi:

Sintassi semplificata per gli array. (for (x of y) y) Sintassi semplificata per i generatori.

Le sintassi semplificate esistono in molti linguaggi di programmazione e consentono di creare rapidamente un nuovo array basato su uno esistente. Per esempio:

) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; ; // ["a", "b", "c"]

Espressioni mancine

Ai valori a sinistra vengono assegnati i valori a destra.

nuovo

È possibile utilizzare l'operatore new per creare un'istanza di un oggetto di un tipo definito dall'utente o uno degli oggetti incorporati. Usa l'operatore new in questo modo:

Var objectName = new objectType();

super

La parola chiave viene utilizzata per chiamare le funzioni dell'oggetto genitore. Questo è utile anche con le classi per chiamare il costruttore del genitore, per esempio.

Super(); // chiama il costruttore del genitore. super.funzioneSuParent();

Operatore di estensione

L'operatore spread consente a un'espressione di espandersi in posizioni con più argomenti (per le chiamate di funzione) o più elementi (per gli array).

Esempio: Oggi, se hai un array e vuoi crearne uno nuovo con la parte esistente del primo, allora la sintassi letterale dell'array non è più sufficiente e devi scrivere codice imperativo (senza varianti) usando una combinazione di push , splice , concat, ecc. Ma con questo operatore, il codice si accorcia:

Var parti = ["spalla", "ginocchia"]; var lyrics = ["testa", ...parti, "e", "dita dei piedi"];

L'operatore funziona in modo simile con le chiamate di funzione:

Funzione f(x, y, z) ( ) var args = ; f(...args);

Espressioni in JavaScript sono combinazioni operandi E operatori.

Operazioni in le espressioni vengono eseguite in sequenza in base al valore di priorità (più alto è il valore di priorità, maggiore è). Il risultato restituito non è sempre dello stesso tipo del tipo di dati in elaborazione. Ad esempio, gli operandi coinvolti nelle operazioni di confronto sono vari tipi, ma il risultato restituito sarà sempre un valore booleano.

Riso. 1. Struttura dell'espressione in JavaScript

operandi sono i dati elaborati dallo script JavaScript. Gli operandi possono essere tipi semplici dati e complessi, così come altre espressioni.

Operatori sono simboli del linguaggio che eseguono varie operazioni sui dati. Gli operatori possono essere scritti utilizzando caratteri di punteggiatura o parole chiave.

A seconda del numero di operandi, si distinguono i seguenti tipi di operatori:
unario- un operando è coinvolto nell'operazione;
binario— due operandi partecipano all'operazione;
ternario— combina tre operandi.

La forma più semplice di espressione è letterale— qualcosa che valuta se stesso, ad esempio il numero 100 , la stringa "Hellow world" . Una variabile può anche essere un'espressione, poiché valuta il valore ad essa assegnato.

Espressioni e operatori in JavaScript

1. Operatori aritmetici

Operatori aritmetici progettato per eseguire operazioni matematiche, operano su operandi numerici (o variabili che memorizzano valori numerici) e restituiscono un valore numerico come risultato.

Se uno degli operandi è una stringa, l'interprete JavaScript tenterà di convertirlo in un tipo numerico e quindi eseguirà l'operazione appropriata. Se la conversione del tipo fallisce, il risultato sarà NaN (non un numero).

Tabella 1. Operatori aritmetici

Operatore/Operazione	Descrizione	Una priorità
+ Aggiunta	Aggiunge operandi numerici. Se uno degli operandi è una stringa, il risultato dell'espressione è una stringa.	12
- Sottrazione	Sottrae il secondo operando dal primo.	12
- Unario meno	Converte un numero positivo in un numero negativo e viceversa.	14
* Moltiplicazione	Moltiplica due operandi.	13
/ divisione	Divide il primo operando per il secondo. Il risultato della divisione può essere un numero intero o in virgola mobile.	13
% Modulo (resto della divisione)	Calcola il resto della divisione intera del primo operando per il secondo. Si applica sia ai numeri interi che ai numeri in virgola mobile.	13

variabile x = 5, y = 8, z; z = x + y // restituisce 13 z = x - y; // restituisce -3 z = - y; // restituisce -8 z = x * y; // restituisce 40 z = x / y; // restituisce 0,625 z = y % x; // ritorna 3

2. Operatori di assegnazione

Operatori di assegnamento sono usati per assegnare valori alle variabili. Gli operatori combinati consentono di memorizzare il valore iniziale e successivo in una variabile.

var a = 5; // assegna il valore numerico 5 alla variabile a var b = "hellow"; // memorizza la stringa helow nella variabile b var m = n = z = 10; // assegna alle variabili m, n, z il valore numerico 10 x += 10; // equivalente a x = x + 10; x-= 10; // equivalente a x = x - 10; x*= 10; // equivalente a x = x * 10; x /= 10; // equivalente a x = x / 10; x%= 10; // equivalente a x = x % 10;

3. Operatori di incremento e decremento

Operazioni incremento e decremento sono unari e incrementano e decrementano il valore dell'operando di uno. L'operando può essere una variabile, un elemento di un array, una proprietà di un oggetto. Molto spesso, tali operazioni vengono utilizzate per incrementare il contatore in un ciclo.

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* come risultato dei calcoli restituirà il valore z = 12, x = 6, cioè il valore x viene prima incrementato di 1, quindi viene eseguita l'operazione di moltiplicazione */ s = y++ * 2; /* come risultato dei calcoli restituirà il valore s = 10, y = 6, cioè prima viene eseguita l'operazione di moltiplicazione, quindi il valore aumentato di 1 viene memorizzato nella variabile y */ k = --m * 2; // restituirà il valore k = 8, m = 4 l = n-- * 2; // restituirà il valore l = 10, n = 4

4. Operatori di confronto

Operatori di confronto vengono utilizzati per confrontare gli operandi, il risultato dell'espressione può essere uno dei due valori: true o false . Gli operandi possono essere non solo numeri, ma anche stringhe, booleani e oggetti. Tuttavia, il confronto può essere eseguito solo su numeri e stringhe, quindi gli operandi che non sono numeri o stringhe vengono convertiti.

Se entrambi gli operandi non possono essere convertiti correttamente in numeri o stringhe, gli operatori restituiscono sempre false .

Se entrambi gli operandi sono stringhe/numeri o possono essere convertiti in stringhe/numeri, verranno confrontati come stringhe/numeri.

Se un operando è una stringa/converte in una stringa e l'altro è un numero/converte in un numero, l'operatore tenterà di convertire la stringa in un numero ed eseguirà un confronto numerico. Se la stringa non è un numero, viene convertita in NaN e il confronto restituisce false .

Molto spesso, le operazioni di confronto vengono utilizzate durante l'organizzazione dei rami nei programmi.

Tabella 4. Operatori di confronto

Operatore/Operazione	Descrizione	Una priorità
== Uguaglianza	Verifica due valori per una corrispondenza, consentendo la conversione del tipo. Restituisce vero se gli operandi sono uguali e falso se sono diversi.	9
!= Disuguaglianza	Restituisce true se gli operandi non sono uguali	9
=== Identità	Verifica due operandi per "identità" utilizzando una definizione di corrispondenza rigorosa. Restituisce vero se gli operandi sono uguali senza conversione del tipo.	9
!== Non identico	Esegue un controllo di identità. Restituisce vero se gli operandi non sono uguali senza la conversione del tipo.	9
> Altro	Restituisce true se il primo operando è maggiore del secondo, altrimenti restituisce false .	10
>= Maggiore o uguale	Restituisce true se il primo operando non è minore del secondo, altrimenti restituisce false .	10
	Restituisce true se il primo operando è minore del secondo, altrimenti restituisce false .	10
	Restituisce true se il primo operando non è maggiore del secondo, altrimenti restituisce false .	10

5 == "5"; // restituisce true 5 != -5.0; // restituisce true 5 === "5"; // restituisce false false === false; // restituisce vero 1 !== vero; // restituisce vero 1 != vero; // restituirà false poiché true viene convertito in 1 3 > -3; // restituisce true 3 >= "4"; // restituirà false

5. Operatori logici

Operatori logici consentono di combinare condizioni che restituiscono valori booleani. Più comunemente usato in un'istruzione if.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // restituirà true se x è compreso tra 0 e 10 !false; // restituisce true

6. Operatori bit a bit

Operatori bit a bit operare sugli operandi come una sequenza di zeri e uno a 32 bit e restituire un valore numerico che indica il risultato dell'operazione, scritto in sistema decimale resa dei conti. Gli interi sono considerati come operandi, la parte frazionaria dell'operando viene scartata. Le operazioni bit per bit possono essere utilizzate, ad esempio, durante la crittografia dei dati, l'utilizzo di flag e la delimitazione dei diritti di accesso.

Tabella 6. Operatori bit a bit

Operatore/Operazione	Descrizione	Una priorità
& AND bit a bit	Se entrambi i bit sono 1 , il bit risultante sarà 1 . Altrimenti, il risultato è 0 .	8
| OR bit a bit	Se uno degli operandi contiene 1 in posizione, il risultato conterrà anche 1 in quella posizione, altrimenti il ​​risultato in quella posizione sarà 0 .	6
^ XOR	Se uno e solo un valore contiene 1 in qualsiasi posizione, il risultato conterrà 1 in quella posizione, altrimenti il ​​risultato in quella posizione sarà 0 .	7
~ Negazione	Viene eseguita un'operazione di negazione bit per bit rappresentazione binaria valori di espressione. Qualsiasi posizione contenente 1 nell'espressione originale viene sostituita con 0 . Qualsiasi posizione contenente 0 nell'espressione originale diventa 0 . I numeri positivi iniziano da 0 , i numeri negativi iniziano da -1 , quindi ~ n == -(n+1) .	14
	L'operatore sposta a sinistra i bit del primo operando del numero di posizioni di bit stabilito dal secondo operando. Gli zeri vengono utilizzati per riempire le posizioni a destra. Restituisce un risultato dello stesso tipo dell'operando sinistro.	11
>> Bit sposta a destra	L'operatore sposta a destra i bit del primo operando del numero di posizioni di bit impostate dal secondo operando. Le cifre fuori intervallo vengono rimosse. Il bit più significativo (32°) viene lasciato invariato per mantenere il segno del risultato. Se il primo operando è positivo, i bit alti del risultato vengono riempiti con zeri; se il primo operando è negativo, i bit alti del risultato vengono riempiti con uno. Spostare un valore a destra di una posizione equivale a dividere per 2 (con il resto scartato), e spostare a destra di due posizioni equivale a dividere per 4 e così via.	11
>>> Spostamento bit a destra senza segno	L'operatore sposta a destra i bit del primo operando del numero di posizioni di bit impostate dal secondo operando. Gli zeri vengono aggiunti a sinistra indipendentemente dal segno del primo operando. Le cifre fuori intervallo vengono rimosse.	11

var x = 9, y = 5, z = 2, s = -5, risultato; // 9 equivale a 1001, 5 equivale a 0101 result = x & y; // restituisce 1 (equivalente a 0001) risultato = x | y; // restituisce 13 (equivalente a 1101) risultato = x ^ y; // restituirà 12 (equivalente a 1100) risultato = ~ y; // restituisce -6 (equivalente a 1100) risultato = x<< y; // вернет 288 (эквивалентно 100100000) result = x >>z; // restituisce 2 (equivalente a 10) risultato = s >>> z; // restituisce 1073741822 (equivalente a 1111111111111111111111111110)

7. Operatori di stringa

Esistono diversi operatori che operano sulle stringhe in modo speciale.

"1" + "10"; // restituirà "110" "1" + 10; // restituisce "110" 2 + 5 + "matite colorate"; // restituisce "7 matite colorate" "Matite colorate" + 2 + 5; // restituisce "Matite colorate 25" "1" > "10"; // restituirà il falso "10"<= 10; // вернет true "СССР" == "ссср"; // вернет false x = "micro"; x+= "soft"; // вернет "microsoft"

8. Operatori Speciali

Tabella 8. Operatori speciali

Operatore/Operazione	Descrizione	Una priorità
. Accesso a una proprietà	Accede a una proprietà di un oggetto.	15
, Calcolo multiplo	Valuta più espressioni indipendenti scritte su una singola riga.	1
Indicizzazione dell'array	Accede agli elementi della matrice o alle proprietà dell'oggetto.	15
() Chiamata di funzione, raggruppamento	Raggruppa le operazioni o chiama una funzione.	15
typeof Definizione del tipo di dati	Operatore unario, restituisce il tipo di dati dell'operando.	14
instanceof Controlla il tipo di oggetto	L'operatore controlla se un oggetto è un'istanza di una particolare classe. L'operando di sinistra deve essere un oggetto, l'operando di destra deve contenere il nome della classe dell'oggetto. Il risultato sarà true se l'oggetto specificato a sinistra è un'istanza della classe specificata a destra, false in caso contrario.	10
in Verifica dell'esistenza di una proprietà	L'operando di sinistra deve essere una stringa e l'operando di destra deve essere un array o un oggetto. Se il valore a sinistra è una proprietà di un oggetto, il risultato sarà true .	10
nuova creazione di oggetti	L'operatore crea un nuovo oggetto con proprietà non definite, quindi chiama la funzione di costruzione per inizializzarlo (passa parametri). Può essere utilizzato anche per creare un array.	1
eliminare	L'operatore consente di rimuovere una proprietà da un oggetto o un elemento da un array. Restituisce true se l'eliminazione ha avuto successo, false in caso contrario. Quando un elemento dell'array viene rimosso, la sua lunghezza non cambia.	14
void Definizione di un'espressione senza valore restituito	Operatore unario, scarta il valore dell'operando e restituisce underfined .	14
?: operazione di espressione condizionale	L'operatore ternario consente di organizzare ramificazioni semplici. Ci sono tre operandi coinvolti nell'espressione, il primo deve essere un valore booleano o essere convertito in esso, e il secondo e il terzo devono essere qualsiasi valore. Se il primo operando è true , l'espressione condizionale assumerà il valore del secondo operando; se falso, allora il terzo.	3

document.write("ciao mondo"); // visualizza la stringa hello world i = 0, j = 1; // memorizza i valori nelle variabili function1(10, 5); // chiamata di funzione function1 con i parametri 10 e 5 var year = ; // crea un array con elementi typeof (a:1); // restituisce "oggetto" var d = new Date(); // crea un nuovo oggetto usando il costruttore Date() d instanceof Date; // restituisce true var mycar = (marca: "Honda", modello: "Accord", anno: 2005); "make" in mycar; // restituisce true var obj = new Object(); // crea un oggetto vuoto var food = ["milk", "bread", "meat", "olive oil", "cheese"]; eliminare il cibo; // rimuove il quarto elemento dall'array food x > 10 ? x*2:x/2; // restituisce x * 2 se x > 10, altrimenti x / 2

9. Commenti in JavaScript

Commento a riga singola: precedere il testo del commento con // caratteri.

Innanzitutto, brevemente sulle espressioni in JavaScript.

Espressioni JavaScript

JavaScript ha istruzioni ed espressioni.

Le istruzioni non restituiscono valori.

Espressioni Sempre restituire alcuni valori. Quando l'interprete vede un'espressione, ne valuta il valore e sostituisce l'espressione con il suo valore.

Le espressioni possono essere semplici o composte. Le espressioni semplici non includono altre espressioni.

Le espressioni semplici includono:

1. Identificatori: someVar (nome variabile);
2. Valori letterali: "stringa" o 675 (numero o valore letterale numerico);
3. Alcune parole chiave come questa ;

Quando il parser incontra un identificatore, deve prima calcolarne il valore, cioè, per esempio, sostituire il nome di una variabile con il suo valore.

Il valore del letterale sarà lo stesso che è scritto nel codice dello script.

Operatori ed Espressioni JavaScript Complesse

Gli operatori vengono utilizzati per combinare diverse espressioni semplici in una complessa.

Gli operatori sono:

• Unario (un operando).
• Binario (due operandi).
• Operatore ternario? in JavaScript (tre operandi, c'è solo un operatore ternario).

Un operando è una semplice espressione a cui viene applicato un operatore.

Ad esempio, l'operatore di addizione aritmetica "+" è un operatore binario. Somma l'operando sinistro e destro e restituisce la somma.

Vardigit = 4 + 7;

A proposito, l'assegnazione viene eseguita utilizzando l'operatore di assegnazione "=". Questo operatore valuta il valore dell'operando destro e lo assegna all'operando sinistro.

JavaScript ha un vantaggio unario, ha un solo operando. Unario più non lo è operatore aritmetico, converte l'operando in un numero.

Var miaVar = "7"; document.write(tipodi(miaVar) + "
"); // Stampa la stringa myVar = +myVar; document.write(typeof(myVar) + "
"); // Stampa il numero nel documento

All'inizio, myVar conteneva la stringa "7", che è un letterale di tipo stringa (stringa), non numerico (numero). Con l'aiuto dell'operatore unario più, abbiamo convertito il letterale stringa in uno numerico.

Operazioni aritmetiche

Le operazioni aritmetiche sono operazioni matematiche ben note.

Forse l'operatore % (resto) ha bisogno di chiarimenti. 9 è divisibile per 5 con resto di 4, ed è questo resto che restituisce questo operatore. Si chiama anche prendere modulo. Quando si utilizzano numeri interi, anche il risultato di questo operatore sarà un numero intero. Quando si opera su numeri in virgola mobile, il risultato sarà un numero in virgola mobile.

5.5 % 2.2 = 1.1

Quando si eseguono operazioni aritmetiche, va ricordato che se vengono eseguite in modo errato, possono portare a risultati:

• NaN (Not a Number) - non un numero.
• Infinito - infinito.

Ecco cosa si ottiene dividendo per zero:

Var miaVar = 0 / 0; document.write("Valore variabile: " + myVar + ", il suo tipo: " + typeof(myVar) + "
");

Operazioni di confronto

Gli operatori di confronto vengono utilizzati per confrontare le espressioni. Un'espressione con un operatore condizionale restituisce un valore booleano: vero o falso (vero/falso).

Le operazioni di confronto possono essere eseguite anche con le stringhe, questo sarà discusso in un'altra lezione. L'unica condizione per un risultato corretto è abbinare dati dello stesso tipo. In caso contrario, JavaScript proverà a convertire i dati da un tipo all'altro e ciò non è sempre possibile. Per evitare errori, confrontare solo dati dello stesso tipo.

Operazioni di affidamento

L'esempio più ovvio di operatore di assegnamento è il semplice assegnamento (=). Questo operatore (=) viene utilizzato per assegnare un valore a una variabile.

Ma ci sono un certo numero di operazioni di assegnazione che sono abbreviate.

Operazioni booleane

Le operazioni booleane sono spesso utilizzate con il costrutto if else in JS. È su esempi di questo progetto che verrà dimostrato il loro lavoro. Ma prima, un elenco di operatori logici.

Ora semplici esempi:

If (true && true) document.write("Funziona!
"); if (true || false) document.write("Funziona!
"); if (!false) document.write("Funziona!
");

Diamo un'occhiata a questi esempi:

L'operatore AND logico (&&) restituirà vero se entrambi gli operandi sono veri.

L'operatore OR logico (||) restituirà vero se almeno un operando è vero.

L'operatore NOT logico (!) accetta un operando e inverte il valore vero/falso.

Operatori unari

Gli operatori unari sono operatori con un operando. Ecco alcuni di questi operatori:

• ++ - aumenta di 1 (incremento). Può essere prefisso e postfisso, ne parleremo più avanti.
• -- - diminuire di 1 (decremento). Può essere prefisso e postfisso, ne parleremo più avanti.
• + - più unario.
• - - meno unario.

meno unario

Il meno unario inverte il segno dell'espressione. Ad esempio, quando si scrive -100 in un programma, si applica semplicemente un meno unario al letterale numerico 100.

Devi capire esattamente come funziona il meno unario: restituisce il valore dell'operando con il segno opposto. Ecco un esempio di come utilizzare correttamente il meno unario:

Var miaVar = -100; document.write(-myVar + " - il meno unario ha funzionato, ma anche la variabile = " + myVar + ".
"); miaVar = -miaVar; document.write("Ora variabile = " + miaVar + ".
");

Ecco un esempio senza senso di un doppio meno unario. Penso che sarà utile per scopi didattici:

Var miaVar = -100; document.write(--myVar + " è un incremento, non un doppio meno unario.
"); document.write("Ora variabile = " + miaVar + ".
"); document.write(-(-myVar) + " che è un doppio uso del meno unario.
");

più unario

Il più unario non esegue alcuna operazione matematica. Trasmette un valore letterale a un tipo numerico.

Var myVar = "78687"; document.write(typeof(myVar) + ".
"); miaVar = +miaVar; document.write(tipodi(miaVar) + ".
");

incremento e decremento

Nella programmazione è spesso necessario aumentare o diminuire di uno il valore di una variabile. Ci sono operatori unari per questo:

• ++ - aumenta di 1 (incremento).
• -- - diminuire di 1 (decremento).

A differenza di più e meno unari, l'incremento e il decremento modificano il valore della variabile quando vengono chiamati.

Var miaVar = 10; document.write(++myVar + ".
"); documento.write(myVar + ".
");

Il decremento (--) funziona in modo simile.

Consideriamo ora gli usi del prefisso e del postfisso di questi operatori.

• ++myVar - aumento del prefisso di 1.
• myVar++ - aumento della postfissa di 1.

La differenza è questa:

• L'uso del prefisso di questi operatori valuta prima il valore dell'operatore unario e quindi utilizza il risultato nell'espressione.
• L'utilizzo di Postfix prima valuta l'espressione e quindi esegue l'operatore unario (++ o -- ).

Un semplice esempio ti aiuterà a capirlo:

Var miaVar = 10; document.write((++myVar + 5) + ".

"); var miaVar = 10; document.write((miaVar++ + 5) + ".
"); document.write("Variabile = " + miaVar + ".
");

Incremento e decremento possono essere utilizzati solo con variabili, non possono essere applicati a valori letterali numerici. In poche parole, il codice ++7 ha dato un errore nello script.

Altri operatori

JavaScript ha altri operatori:

• Operatore ternario (con tre operandi).

Sommario del documento

JavaScript supporta un insieme compatto di operatori che possono essere utilizzati per creare pagine Web interattive. Questo capitolo fornisce una panoramica di questi operatori.

Questo capitolo contiene le seguenti sezioni che forniscono breve recensione ciascun operatore:

• Operatori di blocco: { }

• Dichiarazioni condizionali: se altro E interruttore

• Operatori di ciclo: for, while, do...while, label, break and continue (etichetta non è un'istruzione loop di per sé, ma è spesso usata con dette istruzioni)

• Operatori di manipolazione degli oggetti: per...in E con

• Commenti

• Istruzioni per la gestione delle eccezioni: prova a prendere E gettare

Qualsiasi espressione è anche un operatore. Vedere il Capitolo 3 nella sezione "Espressioni e operazioni" per tutti i dettagli sulle operazioni.

Utilizzare il carattere punto e virgola (;) per separare le istruzioni nel codice JavaScript.

Vedere JavaScript di base. Direttorio. dettagli sugli operatori da questo capitolo.

1. Blocco istruzioni

Un blocco istruzioni viene utilizzato per raggruppare le istruzioni. Il blocco è delimitato da parentesi graffe:

( dichiarazione1 dichiarazione2 . . . dichiarazionen )

2. Dichiarazioni condizionali

Un'istruzione condizionale è un insieme di comandi che vengono eseguiti se la condizione specificata è - VERO. JavaScript supporta due istruzioni condizionali: se altro E interruttore.

2.1. istruzione if...else

Questa istruzione viene utilizzata per eseguire determinate istruzioni se la condizione booleana VERO; utilizzare un blocco opzionale altro per eseguire altre istruzioni se la condizione falso. L'istruzione if è simile a questa:

if (condizione) (istruzioni1) [else (istruzioni2)]

La condizione può essere qualsiasi espressione JavaScript che restituisce VERO O falso. Le istruzioni da eseguire possono essere qualsiasi istruzione JavaScript, comprese le istruzioni nidificate. Se. Se è necessario eseguire più di un'istruzione dopo le istruzioni Se O altro, è necessario racchiudere queste istruzioni eseguibili tra parentesi graffe ().

Non dovresti usare assegnazioni semplici in un'istruzione condizionale. Ad esempio, NON utilizzare questo codice:

Se devi utilizzare un'assegnazione in un'istruzione condizionale, metti delle parentesi aggiuntive attorno all'istruzione di assegnazione. Per esempio, se((x = y)).

Non confondere primitivo Booleano-valori VERO E falso con valori VERO E falso oggetto Booleano. Qualsiasi oggetto il cui valore non è non definito, nullo, zero, **NaN** o la stringa vuota, incluso l'oggetto Booleano con significato falso, è calcolato in VERO quando passato all'operatore condizionale. Per esempio:

varb = new Boolean(false) ; se (b) // questa condizione restituisce true

Esempio.

In questo esempio, la funzione checkData ritorna VERO se il numero di caratteri in Testo-oggetto è uguale a tre; in caso contrario, stampa un avviso e restituisce falso.

function checkData () ( if (document . form1 . threeChar . value . length == 3 ) ( return true ) else ( alert (" Inserisci esattamente tre caratteri." + document . form1 . threeChar . value + " non è valido. " ) restituisce false ) )

2.2. dichiarazione di commutazione

Operatore interruttore consente al programma di valutare l'espressione e tenta di far corrispondere il valore dell'espressione al valore nell'etichetta case. Se viene trovata una corrispondenza, il programma esegue l'istruzione associata. Operatore interruttore sembra così:

switch (espressione)( case label : statement ; break ; case label : statement ; break ; ... default : statement ; )

Il programma prima cerca etichetta, che corrisponde al valore espressione e quindi esegue l'istruzione associata. Se corrispondente etichetta not found, il programma sta cercando un optional predefinito dichiarazione/ operator è l'impostazione predefinita e, se trovato, esegue l'operatore associato. Se predefinito dichiarazione non trovato, il programma continua ad eseguire l'istruzione dopo la fine dell'istruzione interruttore.

Operatore facoltativo rottura, associato all'etichetta caso etichetta, garantisce che il programma interromperà l'esecuzione dell'istruzione interruttore, non appena viene eseguita l'istruzione della corrispondenza trovata e continua l'esecuzione dall'istruzione successiva all'istruzione interruttore. Se rottura mancante, il programma continua a eseguire l'istruzione successiva all'interno dell'istruzione interruttore.

Esempio.

Ecco se espr restituisce Bananas , il programma confronta case Bananas ed esegue l'istruzione associata. Se viene trovata un'interruzione, il programma si interrompe interruttore ed esegue l'istruzione dopo il blocco di istruzioni interruttore. Se rottura mancante, operatore in caso Anche le ciliegie saranno fatte.

switch (expr ) ( case "Arance" : document . write (" Le arance costano 0,59 dollari la libbra.
" ); break ; case " Mele " : document . write (" Le mele costano $ 0,32 la libbra.
" ); break ; case "Banane" : document . write (" Le banane costano 0,48 dollari la libbra.
" ); break ; case " Ciliegie " : document . write (" Le ciliegie costano $ 3,00 al chilo.
" ); break ; default : document . write (" Siamo spiacenti, abbiamo esaurito " + i + " .
" ); ) documento.write(" C'è qualcos'altro che vorresti?
" ) ;

3. Istruzioni di ciclo

Ciclo/ ciclo continuoè un insieme di istruzioni che viene eseguito più volte finché non viene soddisfatta una condizione specificata. JavaScript supporta istruzioni cicliche per, fare durante E Mentre, E etichetta (etichetta non è di per sé un'istruzione loop, ma viene spesso utilizzata con tali istruzioni). In alternativa, puoi utilizzare gli operatori rottura E Continua istruzioni all'interno del ciclo.

Un'altra dichiarazione di ciclo per...in, esegue anche le sue istruzioni in un ciclo, ma viene utilizzato per operare sugli oggetti. Vedere Operatori di manipolazione degli oggetti.

3.1. per dichiarazione

Ciclo per si ripete fino al valore specificato falso. Ciclo Javascript per simile ai cicli per Operatore Java e C per sembra così:

for ([ Espressione iniziale ] ; [ condizione ] ; [ Espressione incremento ]) ( istruzioni )

Quando il ciclo per eseguito, accade quanto segue:

1. Inizializzazione dell'espressione espressione iniziale, se presente, viene eseguito. Questa espressione di solito inizializza uno o più contatori di loop e la sintassi consente espressioni di qualsiasi complessità. Questa espressione può anche dichiarare variabili.

2. L'espressione della condizione viene valutata. Se il valore condizione - vero, istruzioni/dichiarazioni di ciclo vengono eseguite. Se il valore condizione - falso, ciclo per smette di funzionare. Se l'espressione condizione completamente assente, si presume che condizione - vero.

3. Eseguito dichiarazioni.

4. Aggiorna espressione incrementExpression, se presente, viene eseguito e il controllo ritorna al passaggio 2.

Esempio.

Questa funzione contiene l'operatore per, che conta il numero di opzioni selezionate in un elenco scorrevole (object Selezionare, che consente di selezionare più elementi). Operatore per dichiara una variabile io e inizializzarlo a zero. Controlla se meno io numero di opzioni oggetto Selezionare, esegue l'istruzione Se e incremento variabile io di uno dopo ogni iterazione del ciclo.

Scegli alcuni tipi di musica, quindi fai clic sul pulsante in basso:
R&B Jazz Blues nuova era classico musica lirica

"alert("Numero di opzioni selezionate: " + howMany(document.selectForm.musicTypes))">

3.2. dichiarazione do...while

Operatore fare durante si ripete finché l'espressione specificata non è falso. Operatore fare durante sembra così:

do (istruzione) while (condizione)

dichiarazione viene eseguito una volta prima che la condizione venga verificata. Se condizione - vero, l'istruzione viene eseguita di nuovo. Alla fine di ogni esecuzione condizione controllato. Se condizione - falso, l'esecuzione si interrompe e il controllo viene trasferito all'operatore dopo fare durante.

Esempio.

In questo esempio, il ciclo Fare itera almeno una volta e itera fino a quando io meno 5 .

do ( i += 1 ; document . write (i ) ; ) while (i< 5 ) ;

3.3. dichiarazione while

Operatore Mentre esegue le sue istruzioni mentre la condizione specificata è VERO. Operatore Mentre sembra così:

while (condizione) (istruzioni)

Se condizione diventa falso, le istruzioni all'interno del ciclo interrompono l'esecuzione e il controllo viene trasferito all'istruzione che segue il ciclo.

Il controllo condizione/condizione avviene prima dell'esecuzione delle istruzioni all'interno del ciclo. Se condizione ritorna VERO, le istruzioni vengono eseguite e condizione ricontrollato. Se la condizione ritorna falso, l'esecuzione del ciclo viene terminata e il controllo viene trasferito all'operatore che segue l'operatore Mentre.

Esempio 1

Questo ciclo Mentre itera finché N meno 3 :

n = 0 x = 0 mentre (n< 3 ) { n ++; x += n ; }

Ad ogni iterazione, il ciclo aumenta N e aggiungi questo valore alla variabile X. Quindi, X E N assumere i seguenti valori:

• Dopo il primo passaggio: n=1 e x=1

• Dopo il secondo passaggio: n=2 e x=3

• Dopo il terzo passaggio: n=3 e x=6

Dopo tre iterazioni del ciclo, condizione N< 3 non è più vero, quindi il ciclo viene interrotto.

Esempio 2: ciclo infinito.

Assicurati che un giorno la condizione del loop diventi falso; altrimenti il ​​ciclo non si interromperà mai. Dichiarazioni del ciclo successivo Mentre vengono eseguiti indefinitamente, poiché la condizione non diventerà mai falso:

while (true ) ( alert (" Hello, world " ) )

3.4. dichiarazione di etichetta

Operatore etichettaè un identificatore a cui è possibile fare riferimento da qualsiasi punto del programma. Ad esempio, puoi usare etichetta per identificare il loop e quindi utilizzare le istruzioni rottura O Continua per interrompere il ciclo o continuare l'esecuzione.

Sintassi dell'operatore etichetta sembra così:

etichetta: dichiarazione

Senso etichetta può essere qualsiasi identificatore JavaScript valido che non sia una parola riservata. Dichiarazione identificata da etichetta, può essere qualsiasi operatore.

Esempio.

In questo esempio etichetta markLoop identifica un ciclo Mentre.

markLoop : while (theMark == true ) doQualcosa () ; )

3.5. dichiarazione di rottura

Usa l'operatore rottura per interrompere il ciclo interruttore o operatore etichettato etichetta.

• Se stai usando rottura senza etichetta, interrompe immediatamente il contenitore più vicino Mentre, fare durante, per O interruttore e passa il controllo all'operatore successivo.

• Se stai usando rottura Con etichetta, termina l'istruzione con etichetta specificata.

Sintassi dell'operatore rotturaÈ:

1 . rompere 2. etichetta di rottura

La prima opzione interrompe il ciclo contenitore più vicino, o interruttore; la seconda opzione interrompe l'istruzione specificata che ha l'etichetta.

Esempio.

Questo itera sugli elementi dell'array finché non viene trovato l'indice dell'elemento con il valore il valore:

per (i = 0 ; i< a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

3.6. continua dichiarazione

Operatore Continua utilizzato per riavviare le istruzioni Mentre, fare durante, per E etichetta.

• Se stai usando Continua senza etichetta, interrompe l'iterazione corrente del ciclo più vicino mentre, fai-mentre O per e continua l'esecuzione di questo ciclo con l'iterazione successiva. A differenza dell'operatore rompere, continuare non interrompe completamente il ciclo. In un ciclo Mentre va a condizione. Nel ciclo for espressione di incremento.

• Se usi continua con etichetta, si applica all'istruzione loop identificata da this etichetta.

Sintassi dell'operatore ContinuaÈ:

1 . continua 2. etichetta continua

Esempio 1

Questo è un esempio di ciclo Mentre con un operatore Continua, che viene eseguito se il valore io equivale 3 . Così, N ottiene i valori 1, 3, 7 e 12 .

io = 0 n = 0 mentre io< 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

Esempio 2

Operatore contrassegnato come checkiandj, contiene un'istruzione contrassegnata come checkj. Se rilevato Continua, il programma interrompe l'iterazione corrente checkj e inizia l'iterazione successiva. Ogni volta che si incontra un continue, checkj inizia di nuovo l'iterazione finché non ritorna la sua condizione falso. Se restituito falso, viene eseguito il resto dell'istruzione checkiandj E checkiandj itera finché la sua condizione non restituisce false. Se ritorna falso, il programma continua l'esecuzione dall'istruzione successiva a after checkiandj.

Se continua ha etichetta Per checkiandj, il programma continuerà l'esecuzione dall'inizio dell'istruzione checkiandj.

checkiandj : mentre (i< 4 ) { document . write (i + "
" ) ; i += 1 ; checkj : while (j > 4 ) ( document . write (j + "
" ); j ​​-= 1 ; if ((j % 2 ) == 0 ) continue checkj ; document . write (j + " è dispari.
" ) ; ) documento.write(" i = " + i + "
" ) ;document.write(" j = " + j + "
" ) ; }

4. Operatori di manipolazione degli oggetti

JavaScript utilizza gli operatori per...in E con per manipolare oggetti.

4.1. per...in dichiarazione

Operatore per...in itera la variabile specificata su tutte le proprietà dell'oggetto. Per ogni proprietà raggiunta, JavaScript esegue le istruzioni specificate. Operatore per...in sembra così:

For (variabile nell'oggetto) (

Esempio.

Questa funzione prende un oggetto e il nome dell'oggetto come argomento. Quindi itera su tutte le proprietà di quell'oggetto e restituisce una stringa, un elenco di nomi di proprietà e dei loro valori.

function dump_props (obj , obj_name ) ( var result = "" ; for (var i in obj ) ( result += obj_name + " . " + i + " = " + obj [ i ] + "
" ) risultato += "

---

"; restituisce il risultato;)

Per oggetto auto con proprietà Fare E modello il risultato sarà così:

auto. marca = auto Ford . modello = Mustang

4.2. con dichiarazione

Operatore con imposta l'oggetto predefinito per un set di blocchi di istruzioni. JavaScript esamina i nomi non qualificati all'interno di un blocco di istruzioni e determina se i nomi sono proprietà predefinite dell'oggetto. Se il nome non qualificato è una proprietà, tale proprietà viene utilizzata nell'istruzione; in caso contrario, viene utilizzata una variabile locale o globale.

L'istruzione with è simile a questa:

con (oggetto) (dichiarazioni)

Esempio.

Qui l'operatore con specifica che l'oggetto Matematicaè l'oggetto predefinito. Le istruzioni dopo l'istruzione with si riferiscono a una proprietà PI e metodi cos E peccato senza specifica dell'oggetto. JavaScript accetta un oggetto Matematica come oggetto per queste chiamate.

var a , x , y ;; var r = 10 con (Math ) ( a = PI * r * r ; x = r * cos (PI ) ; y = r * sin (PI / 2); )

Nota:

L'uso dell'istruzione with può rallentare notevolmente l'esecuzione del programma.

5. Commenti

I commenti di solito spiegano cosa fa il codice. I commenti vengono ignorati dall'interprete. JavaScript supporta i commenti in stile Java e C++:

• Un commento a riga singola con una doppia barra all'inizio della riga (//).

• Commento su più righe con /* all'inizio e */ alla fine.

Esempio.

Ecco un esempio di due commenti:

// Questo è un commento a riga singola. /* E questo è multilinea. Può essere di qualsiasi lunghezza e puoi mettere quello che vuoi qui. */

6. Istruzioni per la gestione delle eccezioni

Puoi lanciare un'eccezione con l'istruzione gettare ed elaborarlo con gli operatori prova a prendere.

Operatore prova a prendere utilizzato anche per la gestione delle eccezioni Java. Vedere "Gestione delle eccezioni Java in JavaScript" e "Gestione delle eccezioni JavaScript in Java".

6.1. dichiarazione di lancio

Operatore gettare utilizzato per generare un'eccezione. Se si lancia un'eccezione, si specifica un'espressione contenente il valore dell'eccezione:

gettare espressione

Il codice seguente genera diverse eccezioni.

lanciare "Errore2"; // genera un'eccezione con un valore stringa lanciare 42 ; // genera un'eccezione con valore 42 lanciare vero ; // genera un'eccezione con valore true

Quando si genera un'eccezione, è possibile specificare un oggetto. È quindi possibile accedere alle proprietà dell'oggetto nel blocco presa. L'esempio seguente crea un oggetto myUserException tipo UserException e usalo nella dichiarazione gettare.

// Viene creato un oggetto di tipo UserException function UserException (messaggio) ( this . message = message ; this . name = "UserException" ;) // Viene creata e richiamata un'istanza dell'oggetto myUserException = new UserException ("Valore troppo alto"); lancia myUserException ;

6.2. dichiarazione try...catch

Operatore prova a prendere contrassegna un blocco di istruzioni, tenta di eseguirle e specifica una o più risposte quando si verifica un'eccezione. Se si verifica un'eccezione, l'istruzione prova a prendere lo prende.

Operatore prova a prendereè costituito da un blocco Tentativo, che contiene una o più istruzioni e zero o più blocchi presa, contenente istruzioni che specificano azioni quando viene generata un'eccezione nel blocco Tentativo. Cioè, se vuoi eseguire un blocco Tentativo e non viene eseguito, passi il controllo al blocco presa. Se qualsiasi istruzione di blocco Tentativo(o l'operatore di una funzione richiamata da un blocco Tentativo) genera un'eccezione, il controllo viene immediatamente trasferito al blocco presa. Se non è stata generata alcuna eccezione, il blocco presa saltato. Bloccare Finalmente eseguito dopo l'esecuzione del blocco Tentativo E presa, ma prima dell'esecuzione dell'istruzione successiva al blocco di istruzioni prova a prendere.

L'esempio seguente utilizza l'operatore prova a prendere. Viene chiamata una funzione che interroga il nome del mese dall'array in base al valore passato alla funzione. Se il valore non corrisponde al numero del mese (1-12 ), viene generata un'eccezione con il valore "Mese non validoNo" e dichiarazioni di blocco presa impostare la variabile su meseNome Senso sconosciuto.

funzione getMonthName (mo) (mo = mo - 1; // Il numero del mese è specificato dall'indice dell'array (1=Gen, 12=Dic) var months = new Array (" Jan " , " Feb " , " Mar " , " Apr " , " May " , " Jun " , " Jul " , " Aug " , " Sep " , " Oct " , " Nov " , "dec"); if (months [mo] != null ) ( return months [mo ] ) else ( throw "InvalidMonthNo") ) try ( // tenta di eseguire queste istruzioni: nomemese = getNomeMese(mioMese) // la funzione può generare un'eccezione) catch (e ) ( monthName = " sconosciuto " logMyErrors (e ) // l'oggetto che ha generato l'eccezione viene passato al gestore delle eccezioni}

gettare; è possibile utilizzare questo identificatore per ottenere informazioni sull'eccezione generata. JavaScript crea questo ID quando si inserisce un blocco presa; identificatore esiste solo durante l'esecuzione del blocco presa; dopo il completamento del blocco presa ID non è più disponibile.

Ad esempio, il codice seguente genera un'eccezione. Se si verifica un'eccezione, il controllo viene trasferito al blocco presa.

try(throw "miaEccezione" // viene generata un'eccezione) cattura (e ) ( // istruzioni per gestire qualsiasi eccezione logMyErrors (e ) // l'eccezione viene passata al gestore degli errori}

Più blocchi di cattura

Operatore unico Tentativo può contenere diversi blocchi condizionali presa, ognuno dei quali gestisce un tipo specifico di eccezione. In questo caso, l'input al blocco condizionale appropriato presa eseguito solo quando viene generata l'eccezione specificata per questo blocco. È inoltre possibile includere facoltativamente un blocco separato presa per tutte le eccezioni non specificate come blocco finale presa nell'operatore.

Per esempio, prossima funzione chiama altre tre funzioni (dichiarate altrove) che testano i suoi argomenti. Se la funzione di test determina che il componente sottoposto a test non è valido, restituisce 0, facendo in modo che il chiamante generi l'eccezione specificata.

function getCustInfo (name , id , email ) ( var n , i , e ; if (! validate_name (name )) throw " InvalidNameException " else n = name ; if (! validate_id (id )) throw " InvalidIdException " else i = id ; if (! validate_email (email )) throw " InvalidEmailException " else e = email ; cust = (n + " " + i + " " + e ) ; return (cust ) ; )

Blocchi condizionali presa controllare l'invocazione del gestore di eccezioni appropriato.
" ) { // richiama il gestore di ID non validi bad_id_handler (e)) catch (e if e == "InvalidEmailException") ( // chiama il gestore di posta errato bad_email_handler (e ) ) cattura (e )( // viene registrata un'eccezione sconosciuta logError (e ) )

infine blocco

Il blocco finally contiene istruzioni che vengono eseguite dopo l'esecuzione dei blocchi Tentativo E presa, ma prima dell'esecuzione delle dichiarazioni che seguono la dichiarazione prova a prendere. Bloccare Finalmente eseguito indipendentemente dal fatto che sia stata generata un'eccezione. Se viene generata un'eccezione, blocca le istruzioni Finalmente eseguito anche se nessun blocco presa non ha gestito l'eccezione.

Puoi usare il blocco Finalmente per il corretto completamento dello script quando si verifica un'eccezione; ad esempio, potrebbe essere necessario rilasciare una risorsa associata a uno script. Nell'esempio seguente, viene aperto un file e gli operatori lavorano con esso (JavaScript lato server consente l'accesso ai file). Se viene generata un'eccezione quando apri il file, blocco Finalmente chiude il file prima che lo script fallisca.

apriMioFile(); prova ( writeMyFile (theData ) ) infine ( closeMyFile () // la risorsa è sempre chiusa}

Nidificazione delle istruzioni try...catch

Puoi nidificare una o più istruzioni prova a prendere l'uno nell'altro. Se l'operatore interno prova a prendere non ha blocco presa, viene verificata la corrispondenza del blocco presa operatore contenente prova a prendere.