Operatore di assegnazione (=)
L’operatore = memorizza il valore di un’espressione in una variabile o in una proprietà di un oggetto e restituisce il valore assegnato. Non confronta i valori e non dichiara variabili.
CKTIS / JavaScript
Sintassi, operatori e concetti di programmazione. Trova una spiegazione, consulta un esempio e torna a imparare.
L’operatore = memorizza il valore di un’espressione in una variabile o in una proprietà di un oggetto e restituisce il valore assegnato. Non confronta i valori e non dichiara variabili.
Un’espressione await sospende l’esecuzione corrente di una funzione asincrona o di un modulo finché il valore atteso non si risolve. Restituisce il valore di realizzazione di una promise oppure genera il motivo del suo rifiuto, senza bloccare l’intero thread.
L’operatore & conserva i bit impostati a 1 in entrambi gli operandi. Si usa per applicare maschere e verificare flag; con Number opera su interi con segno a 32 bit, mentre i risultati BigInt non sono limitati a 32 bit.
L’operatore &= calcola l’AND bit a bit tra il valore corrente del target e l’operando a destra, quindi memorizza il risultato nello stesso target. È utile per conservare solo i bit selezionati da una maschera. Supporta Number e BigInt, ma non una loro combinazione.
L’operatore unario ~ inverte i bit di un valore numerico. Con Number opera su un intero con segno a 32 bit; con BigInt non limita il valore a 32 bit. Non va confuso con il NOT logico (!).
L’operatore | combina i bit di due valori: un bit del risultato vale 1 se almeno uno dei bit corrispondenti degli operandi vale 1. Supporta Number e BigInt, ma non consente di mescolare questi tipi.
L’operatore |= esegue un OR bit a bit tra il valore corrente del target e l’operando destro, quindi assegna il risultato al target. Consente di impostare i bit selezionati da una maschera senza azzerare gli altri e supporta Number e BigInt.
L’operatore ^ esegue un OR esclusivo bit a bit: un bit del risultato è 1 quando i bit corrispondenti degli operandi sono diversi. Supporta Number e BigInt, ma non consente di mescolare questi tipi numerici.
L’operatore ^= calcola l’OR esclusivo bit a bit tra il valore corrente del target e l’operando destro, quindi assegna il risultato allo stesso target. Può, per esempio, invertire bit usando una maschera. Supporta Number e BigInt, ma non consente di mescolare questi tipi.
L’operatore virgola valuta le espressioni da sinistra a destra e restituisce il valore dell’ultima. Gli effetti collaterali delle espressioni precedenti vengono mantenuti. Non va confuso con le virgole che separano argomenti, elementi di un array o dichiarazioni.
L’operatore condizionale `?:` seleziona uno di due valori in base a una condizione. È un’espressione: valuta la condizione e poi soltanto il ramo selezionato, il cui valore diventa il risultato.
L’operatore -- sottrae uno e riscrive il risultato nel proprio operando. La forma x-- restituisce il valore numerico precedente, mentre --x restituisce il nuovo valore. Entrambe supportano Number e BigInt.
L’operatore delete rimuove una proprietà propria di un oggetto, non l’oggetto stesso né una variabile. Scopri il suo risultato booleano, le limitazioni in modalità strict e i vuoti che lascia negli array.
L’operatore / calcola il quoziente di due operandi. Con Number il risultato può avere una parte frazionaria; con BigInt la parte frazionaria viene scartata verso zero. Mescolare questi tipi e dividere un BigInt per zero genera eccezioni.
L’operatore /= divide il valore corrente di una variabile o proprietà per l’operando destro e memorizza il risultato nella stessa posizione. Supporta Number e BigInt, ma non consente di mescolare questi tipi.
L’operatore == confronta i valori applicando regole di conversione definite quando i tipi degli operandi sono diversi. Scopri in cosa differisce da ===, come tratta null e undefined e perché gli oggetti vengono confrontati per identità.
L’operatore ** eleva una base a una potenza specificata. Scopri la sua associatività a destra, le regole di sintassi per le basi negative e le differenze tra i calcoli con Number e BigInt.
L’operatore **= eleva il valore corrente di un obiettivo a una potenza specificata e memorizza il risultato nella stessa posizione. L’obiettivo viene valutato una sola volta. Supporta Number e BigInt, ma non consente di mescolare questi tipi.
L’operatore >= verifica se l’operando a sinistra è maggiore o uguale a quello a destra. Il confronto può convertire i tipi, quindi stringhe, null e NaN richiedono particolare attenzione.
L’operatore > verifica se l’operando a sinistra è maggiore di quello a destra. Restituisce un valore booleano, ma può prima convertire gli operandi. Due stringhe vengono confrontate lessicograficamente, non numericamente.
L’operatore `in` verifica la presenza di una proprietà in base alla chiave, non al valore. Se l’oggetto e quelli nella sua catena dei prototipi sono ordinari, considera sia le proprietà proprie sia quelle ereditate. La trap `has` di un `Proxy` può modificare il risultato. L’operando destro deve essere un oggetto; un valore primitivo provoca un `TypeError`.
L’operatore ++ aggiunge uno a un valore numerico e tenta di scrivere il risultato nell’operando. La forma count++ restituisce il valore numerico precedente, mentre ++count restituisce il nuovo valore.
L’operatore != verifica la disuguaglianza usando regole di confronto che consentono la conversione implicita dei tipi. È la negazione di ==, quindi valori di tipi diversi non producono necessariamente true. L’operatore !== non esegue queste conversioni.
Se l’operando destro è una funzione ordinaria non vincolata, l’operatore instanceof verifica per impostazione predefinita se il suo `prototype` compare nella catena dei prototipi di un oggetto. Tiene conto dell’ereditarietà, ma non dimostra come è stato creato un oggetto né che siano presenti determinati campi.