7 suggerimenti per gestire undefined in JavaScript

La maggior parte dei linguaggi moderni come Ruby, Python o Java hanno un singolo valore nullo (nil o null), che sembra un approccio ragionevole.

Ma JavaScript è diverso.

null, ma anche undefined, rappresentano valori vuoti in JavaScript. Allora qual è la differenza esatta tra loro?

La risposta breve è che linterprete JavaScript restituisce undefined quando si accede a una variabile o a una proprietà di un oggetto non ancora inizializzata. Ad esempio:

Dallaltro lato, null rappresenta un oggetto mancante riferimento. JavaScript non inizializza le variabili o le proprietà degli oggetti con null.

Alcuni metodi nativi come String.prototype.match() possono restituire null per denotare un oggetto mancante. Dai unocchiata allesempio:

Poiché JavaScript è permissivo, gli sviluppatori hanno la tentazione di accedere a valori non inizializzati. Anchio sono colpevole di una cattiva pratica.

Spesso tali azioni rischiose generano undefined errori correlati:

• TypeError: "undefined" is not a function
• TypeError: Cannot read property "<prop-name>" of undefined
• e simili errori di tipo.

Lo sviluppatore JavaScript può capire lironia di questo scherzo :

Per ridurre tali errori, devi comprendere i casi in cui undefined viene generato. Esploriamo undefined e il suo effetto sulla sicurezza del codice.

1. Cosa è indefinito

JavaScript ha 6 tipi primitivi:

E un tipo di oggetto separato: {name: "Dmitri"} , .

Da 6 tipi primitivi undefined è un valore speciale con il proprio tipo Undefined. Secondo la specifica ECMAScript:

Il valore primitivo non definito viene utilizzato quando a una variabile non è stato assegnato un valore.

Lo standard definisce chiaramente che riceverai undefined quando accedi a variabili non inizializzate, proprietà di oggetti inesistenti, elementi di array inesistenti e simili.

Alcuni esempi:

Lesempio precedente dimostra che laccesso a:

• una variabile non inizializzata number
• una proprietà oggetto non esistente movie.year
• o un elemento array non esistente movies

vengono valutati in undefined.

La specifica ECMAScript definisce il tipo di valore undefined:

Il tipo non definito è un tipo il cui unico valore è il undefined valore.

In questo senso, restituisce "undefined" stringa per un valore undefined:

Ovviamente typeof funziona bene per verificare se una variabile contiene un valore undefined:

2. Scenari che creano undefined

2.1 Variabile non inizializzata

Una variabile dichiarata ma non ancora assegnata con un valore (non inizializzato) è per impostazione predefinita undefined.

Chiaro e semplice:

myVariable è dichiarato e non ancora assegnato con un valore. Laccesso alla variabile restituisce undefined.

Un approccio efficiente per risolvere i problemi delle variabili non inizializzate è, quando possibile, assegnare un valore iniziale. Meno la variabile esiste in uno stato non inizializzato, meglio è.

Idealmente, dovresti assegnare un valore subito dopo la dichiarazione const myVariable = "Initial value". Ma non è sempre possibile.

Suggerimento 1. Aggiungi ai preferiti const, altrimenti utilizza let, ma saluta var

Secondo me, una delle migliori caratteristiche di ECMAScript 2015 è il nuovo modo di dichiarare le variabili usando const e let. È un grande passo avanti.

const e let hanno un ambito di blocco (contrariamente alla precedente funzione con ambito var) ed esistono in una zona morta temporale fino alla riga della dichiarazione.

Raccomando la variabile const quando il suo valore non cambierà. Crea unassociazione immutabile.

Una delle caratteristiche interessanti di const è che devi assegnare un valore iniziale alla variabile const myVariable = "initial". La variabile non è esposta allo stato non inizializzato e laccesso a undefined è impossibile.

Controlliamo la funzione che verifica se una parola è un palindromo:

length e half le variabili vengono assegnate con un valore una volta. Sembra ragionevole dichiararli come const poiché queste variabili non cambieranno.

Usa la dichiarazione let per le variabili il cui valore può cambiare. Quando possibile, assegnare subito un valore iniziale, ad es. let index = 0.

E la vecchia scuola var? Il mio suggerimento è di smettere di usarlo.

var Il problema di dichiarazione è la variabile che si solleva nellambito della funzione. Puoi dichiarare una variabile var da qualche parte alla fine dellambito della funzione, ma puoi comunque accedervi prima della dichiarazione: e otterrai un undefined.

myVariable è accessibile e contiene undefined anche prima della riga della dichiarazione: var myVariable = "Initial value".

Al contrario, non è possibile accedere a una variabile const o let prima della riga di dichiarazione: la variabile si trova in una zona morta temporale prima della dichiarazione. Ed è utile perché hai meno possibilità di accedere a un undefined.

Lesempio precedente aggiornato con let (invece di var) genera un ReferenceError perché la variabile nella zona morta temporale non è accessibile.

Incoraggiare luso di const per associazioni immutabili o let garantisce altrimenti una pratica che riduce laspetto di chi non è inizializzato variabile.

Suggerimento 2: aumentare la coesione

La coesione caratterizza il grado di appartenenza degli elementi di un modulo (spazio dei nomi, classe, metodo, blocco di codice). La coesione può essere alta o bassa.

Un modulo ad alta coesione è preferibile perché gli elementi di tale modulo si concentrano esclusivamente su un singolo compito. Rende il modulo:

• Focalizzato e comprensibile: più facile da capire cosa fa il modulo
• Gestibile e più facile da refactoring: la modifica nel modulo influisce su meno moduli
• Riutilizzabile: essendo concentrato su una singola attività, rende il modulo più facile da riutilizzare
• Testabile: testeresti più facilmente un modulo focalizzato su una singola attività

Lalta coesione accompagnata da un accoppiamento lento è la caratteristica di un sistema ben progettato.

Un blocco di codice può essere considerato un piccolo modulo. Per trarre vantaggio dai vantaggi di unelevata coesione, mantenere le variabili il più vicino possibile al blocco di codice che le utilizza.

Ad esempio, se una variabile esiste esclusivamente per formare la logica dellambito del blocco, dichiarare e rendere attiva la variabile solo allinterno di quel blocco (utilizzando const o let dichiarazioni). Non esporre questa variabile allambito del blocco esterno, poiché il blocco esterno non dovrebbe preoccuparsi di questa variabile.

Un classico esempio della durata inutilmente estesa delle variabili è luso di for ciclo allinterno di una funzione:

index, item e length le variabili vengono dichiarate allinizio del corpo della funzione. Tuttavia, vengono utilizzati solo verso la fine. Qual è il problema con questo approccio?

Tra la dichiarazione in alto e lutilizzo nellistruzione for le variabili index, item non sono inizializzati e sono esposti a undefined. Hanno un ciclo di vita irragionevolmente lungo nellintero ambito della funzione.

Un approccio migliore è spostare queste variabili il più vicino possibile al loro luogo di utilizzo:

index e esistono solo nellambito del blocco dellistruzione for. Non hanno alcun significato al di fuori di for.
length anche la variabile è dichiarata vicina alla fonte del suo utilizzo.

Perché la versione modificata è migliore di quella iniziale? Vediamo:

• Le variabili non sono esposte a uno stato non inizializzato, quindi non hai alcun rischio di accedere a undefined
• Spostando il variabili il più vicino possibile alla posizione di utilizzo aumenta la leggibilità del codice
• Pezzi di codice ad alta coesione sono più facili da refactoring ed estrarre in funzioni separate, se necessario

2.2 Accesso una proprietà non esistente

Quando si accede a una proprietà oggetto non esistente, JavaScript restituisce undefined.

Dimostriamolo in un esempio:

favoriteMovie è un oggetto con una singola proprietà title. Laccesso a una proprietà non esistente actors utilizzando una funzione di accesso alla proprietà favoriteMovie.actors restituisce undefined.

Laccesso a una proprietà non esistente non genera un errore. Il problema si verifica quando si tenta di ottenere dati dalla proprietà inesistente, che è la undefined trap più comune, riflessa nel noto messaggio di errore TypeError: Cannot read property <prop> of undefined.

Modifichiamo leggermente lo snippet di codice precedente per illustrare un TypeError lancio:

favoriteMovie non ha la proprietà actors, quindi favoriteMovie.actors restituisce undefined.

Di conseguenza, laccesso al primo elemento di un valore undefined utilizzando lespressione favoriteMovie.actors genera un TypeError.

La natura permissiva di JavaScript che consente di accedere a proprietà inesistenti è una fonte di non determinismo: la proprietà può essere impostata o meno. Il modo migliore per aggirare questo problema è limitare loggetto in modo che abbia sempre definito le proprietà che detiene.

Sfortunatamente, spesso non hai il controllo sugli oggetti. Tali oggetti possono avere un diverso insieme di proprietà in diversi scenari. Quindi devi gestire tutti questi scenari manualmente.

Implementiamo una funzione append(array, toAppend) che aggiunge allinizio e / o alla fine di un array di nuovi elementi. Il parametro toAppend accetta un oggetto con proprietà:

• first: elemento inserito allinizio di array
• last: elemento inserito alla fine di array.

La funzione restituisce una nuova istanza di array, senza alterare larray originale.

La prima versione di append(), un po ingenua, potrebbe avere questo aspetto:

Perché toAppend può omettere le proprietà first o last, è obbligatorio verificare se queste proprietà esistono in toAppend.

Una funzione di accesso alla proprietà restituisce undefined se la proprietà non esiste. La prima tentazione di verificare se sono presenti le proprietà first o last è verificarle con undefined. Questa operazione viene eseguita nei condizionali if(toAppend.first){} e if(toAppend.last){}…

Non così velocemente. Questo approccio ha uno svantaggio. undefined, nonché false, null, 0, NaN e "" sono valori falsi.

Nellattuale implementazione di append(), la funzione non consente di inserire elementi falsi:

I suggerimenti che seguono spiegano come controllare correttamente lesistenza della proprietà.

Suggerimento 3: controlla lesistenza della proprietà

Fortunatamente, JavaScript offre un sacco di modi per determinare se loggetto ha una proprietà specifica:

• obj.prop !== undefined: confronta con undefined direttamente
• typeof obj.prop !== "undefined": verifica il tipo di valore della proprietà
• obj.hasOwnProperty("prop"): verifica se il loggetto ha una proprietà propria
• "prop" in obj: verifica se loggetto ha una proprietà propria o ereditata

Il mio consiglio è di utilizza loperatore in. Ha una sintassi breve e dolce. La presenza delloperatore in suggerisce un chiaro intento di verificare se un oggetto ha una proprietà specifica, senza accedere al valore effettivo della proprietà.

obj.hasOwnProperty("prop") è anche una bella soluzione. È leggermente più lungo delloperatore in e viene verificato solo nelle proprietà delloggetto.

Miglioriamo la funzione append(array, toAppend) utilizzando in operatore:

"first" in toAppend (e "last" in toAppend) è true se esiste la proprietà corrispondente, false altrimenti.

Loperatore in risolve il problema con linserimento di elementi falsi 0 e false. Ora, aggiungendo questi elementi allinizio e alla fine di si ottiene il risultato atteso .

Suggerimento 4: destrutturazione per accedere alle proprietà degli oggetti

Quando si accede alla proprietà di un oggetto, a volte è necessario impostare un valore predefinito se la proprietà non esiste.

Puoi utilizzare in accompagnato da un operatore ternario per ottenere ciò:

La sintassi degli operatori ternari diventa scoraggiante quando il numero di proprietà da controllare aumenta. Per ogni proprietà, devi creare una nuova riga di codice per gestire i valori predefiniti, aumentando un brutto muro di operatori ternari dallaspetto simile.

Per utilizzare un approccio più elegante, familiarizziamo con una grande funzionalità di ES2015 chiamata destrutturazione degli oggetti.

La destrutturazione degli oggetti consente lestrazione in linea dei valori delle proprietà degli oggetti direttamente nelle variabili e limpostazione di un valore predefinito se la proprietà non esiste. Una sintassi comoda per evitare di trattare direttamente con undefined.

In effetti, lestrazione delle proprietà ora è precisa:

Per vedere le cose in azione, definiamo unutile funzione che racchiuda una stringa tra virgolette.

quote(subject, config) accetta il primo argomento come stringa da avvolgere. Il secondo argomento config è un oggetto con le proprietà:

Applicando i vantaggi della destrutturazione delloggetto, implementiamo quote():

const { char = """, skipIfQuoted = true } = config lassegnazione destrutturante in una riga estrae le proprietà char e skipIfQuoted dalloggetto config.
Se nelloggetto config mancano alcune proprietà, lassegnazione di destrutturazione imposta i valori predefiniti : """ per char e false per skipIfQuoted.

Fortunatamente, la funzione ha ancora margini di miglioramento.

Spostiamo lassegnazione destrutturante nella sezione dei parametri. E imposta un valore predefinito (un oggetto vuoto { }) per il parametro config, per saltare il secondo argomento quando le impostazioni predefinite sono sufficienti.

Lassegnazione destrutturante sostituisce il parametro config nella firma della funzione. Mi piace: quote() diventa una riga più corta.

= {} sul lato destro dellassegnazione di destrutturazione assicura che venga utilizzato un oggetto vuoto se il secondo argomento non è specificato affatto quote("Sunny day").

La destrutturazione degli oggetti è una potente funzionalità che gestisce in modo efficiente lestrazione delle proprietà dagli oggetti. Mi piace la possibilità di specificare un valore predefinito da restituire quando la proprietà a cui si accede non esiste. Di conseguenza, eviti undefined e il fastidio che lo circonda.

Suggerimento 5: riempire loggetto con proprietà predefinite

Se non è necessario creare variabili per ogni proprietà, come fa lassegnazione destrutturante, loggetto che manca di alcune proprietà può essere riempito con i valori predefiniti.

ES2015 Object.assign(target, source1, source2, ...) copia i valori di tutte le proprietà enumerabili da uno o più oggetti di origine nelloggetto di destinazione. La funzione restituisce loggetto di destinazione.

Ad esempio, devi accedere alle proprietà delloggetto unsafeOptions che non sempre contiene il suo set completo di proprietà.

Per evitare undefined quando si accede a una proprietà non esistente da unsafeOptions, apportiamo alcune modifiche:

• Definisci un oggetto defaults che contiene i valori di proprietà predefiniti
• Chiama Object.assign({ }, defaults, unsafeOptions) per creare un nuovo oggetto options. Il nuovo oggetto riceve tutte le proprietà da unsafeOptions, ma quelle mancanti vengono prese da defaults.

unsafeOptions contiene solo la proprietà fontSize. Loggetto defaults definisce i valori predefiniti per le proprietà fontSize e color.

Object.assign() accetta il primo argomento come oggetto di destinazione {}. Loggetto di destinazione riceve il valore della proprietà fontSize dalloggetto di origine unsafeOptions. E il valore della proprietà color dalloggetto sorgente defaults, perché unsafeOptions non contiene color.

Lordine in cui sono enumerati gli oggetti sorgente è importante: le proprietà successive delloggetto sorgente sovrascrivono quelle precedenti.

Ora puoi accedere in sicurezza a qualsiasi proprietà delloggetto options, incluso options.color che non era disponibile in unsafeOptions inizialmente.

Fortunatamente, esiste unalternativa più semplice per riempire loggetto con le proprietà predefinite.Consiglio di utilizzare le proprietà di diffusione negli inizializzatori di oggetti.

Invece di invocare Object.assign(), usa la sintassi di diffusione delloggetto per copiare nelloggetto di destinazione tutte le proprietà enumerabili dagli oggetti di origine:

linizializzatore di oggetti diffonde le proprietà dagli oggetti sorgente defaults e unsafeOptions. Lordine in cui vengono specificati gli oggetti di origine è importante: le proprietà degli oggetti di origine successive sovrascrivono quelle precedenti.

Riempire un oggetto incompleto con i valori di proprietà predefiniti è una strategia efficiente per rendere il tuo codice sicuro e durevole. Indipendentemente dalla situazione, loggetto contiene sempre il set completo di proprietà: e undefined non può essere generato.

Suggerimento bonus: coalescenza nullo

Loperatore coalescenza nullo restituisce un valore predefinito quando il suo operando è undefined o null:

Loperatore di coalescenza nullo è conveniente per accedere a una proprietà delloggetto pur avendo un valore predefinito quando questa proprietà è undefined o null:

styles oggetto non ha la proprietà color, quindi styles.color La funzione di accesso alla proprietà è undefined. styles.color ?? "black" restituisce il valore predefinito "black".

styles.fontSize è 18, quindi loperatore di coalescenza nullo restituisce il valore della proprietà 18.

2.3 Parametri della funzione

Limpostazione predefinita dei parametri della funzione è undefined.

Di solito una funzione definita con un numero specifico di parametri dovrebbe essere invocata con lo stesso numero di argomenti. Questo è il momento in cui i parametri ottengono i valori previsti:

Quando multiply(5, 3), i parametri a e b ricevono 5 e rispettivamente 3 valori. La moltiplicazione viene calcolata come previsto: 5 * 3 = 15.

Cosa succede quando ometti un argomento durante linvocazione? Il parametro corrispondente allinterno della funzione diventa undefined.

Modifichiamo leggermente lesempio precedente chiamando la funzione con un solo argomento:

Linvocazione multiply(5) viene eseguito con un singolo argomento: come risultato a parametro è 5, ma il Il parametro b è undefined.

Suggerimento 6: usa il valore predefinito del parametro

A volte una funzione non richiede il set completo di argomenti al momento dellinvocazione. Puoi impostare i valori predefiniti per i parametri che non hanno un valore.

Ricordando lesempio precedente, facciamo un miglioramento. Se il parametro b è undefined, lascia che il valore predefinito sia 2:

La funzione viene richiamata con un singolo argomento multiply(5). Inizialmente, il parametro a è 2 e b è undefined.
Listruzione condizionale verifica se b è undefined. In tal caso, lassegnazione b = 2 imposta un valore predefinito.

Sebbene il modo fornito per assegnare i valori predefiniti funzioni, non consiglio di confrontare direttamente con undefined. È dettagliato e sembra un hack.

Un approccio migliore consiste nellutilizzare la funzione dei parametri predefiniti di ES2015. È breve, espressivo e senza confronti diretti con undefined.

Laggiunta di un valore predefinito al parametro b = 2 ha un aspetto migliore:

b = 2 nella firma della funzione si assicura che se b è undefined, il valore predefinito del parametro è 2.

La funzione dei parametri predefiniti di ES2015 è intuitiva ed espressiva. Usalo sempre per impostare i valori predefiniti per i parametri opzionali.

2.4 Valore restituito dalla funzione

Implicitamente, senza return istruzione, una funzione JavaScript restituisce undefined.

Una funzione che non dispone di return restituisce implicitamente undefined:

non restituisce alcun risultato di calcolo. Il risultato del richiamo della funzione è undefined.

La stessa situazione si verifica quando è presente listruzione return, ma senza unespressione nelle vicinanze:

return; viene eseguita, ma non restituisce alcuna espressione. Anche il risultato della chiamata è undefined.

Ovviamente, indicando vicino a return lespressione da restituire funziona come previsto:

Ora il richiamo della funzione viene valutato in 4, che è 2 al quadrato.

Suggerimento 7: non fidarsi dellinserimento automatico del punto e virgola

Il seguente elenco di istruzioni in JavaScript deve terminare con punto e virgola (;) :

• istruzione vuota
• let, const, var, import, export dichiarazioni
• dichiarazione di espressione
• debugger istruzione
• continue istruzione, break istruzione
• throw istruzione
• return istruzione

Se utilizzi una delle istruzioni precedenti, assicurati di indicare un punto e virgola alla fine:

Alla fine di entrambi let dichiarazione e return viene scritto un punto e virgola obbligatorio.

Cosa succede se non si desidera indicarli punto e virgola? In una tale situazione ECMAScript fornisce un meccanismo di inserimento automatico del punto e virgola (ASI), che inserisce per te i punti e virgola mancanti.

Con laiuto dellASI, puoi rimuovere i punti e virgola dallesempio precedente:

Il testo sopra è un codice JavaScript valido. I punti e virgola mancanti vengono inseriti automaticamente.

A prima vista sembra piuttosto promettente. Il meccanismo ASI ti consente di saltare i punti e virgola non necessari. Puoi rendere il codice JavaScript più piccolo e più facile da leggere.

Cè una piccola, ma fastidiosa trappola creata dallASI. Quando una nuova riga si trova tra return e lespressione restituita return \n expression, ASI inserisce automaticamente un punto e virgola prima della nuova riga return; \n expression.

Cosa significa allinterno di una funzione avere listruzione return;? La funzione restituisce undefined. Se non conosci in dettaglio il meccanismo dellASI, il undefined restituito inaspettatamente è fuorviante.

Ad esempio, studiamo il valore restituito di getPrimeNumbers() invocazione:

Tra listruzione return e lespressione letterale di matrice esiste una nuova riga. JavaScript inserisce automaticamente un punto e virgola dopo return, interpretando il codice come segue:

Listruzione return; fa in modo che la funzione getPrimeNumbers() restituisca undefined invece dellarray previsto.

Il problema viene risolto rimuovendo la nuova riga tra return e larray literal:

La mia raccomandazione è di studiare come funziona esattamente linserimento automatico del punto e virgola per evitare tali situazioni.

Ovviamente, non inserire mai una nuova riga tra return e lespressione restituita.

2.5 operatore void

void <expression> valuta lespressione e restituisce undefined indipendentemente dal risultato della valutazione.

Un caso duso delloperatore void consiste nel sopprimere la valutazione dellespressione a undefined, basandosi su alcuni effetti collaterali della valutazione.

3. undefined in array

Ottieni undefined quando accedi a un elemento di array con un indice fuori limite.

colors array ha 3 elementi, quindi gli indici validi sono 0, 1 e 2.

Poiché non sono presenti elementi di matrice negli indici 5 e -1, le funzioni di accesso colors e colors sono undefined.

In JavaScript, potresti incontrare i cosiddetti array sparsi. Le tesi sono array che presentano spazi vuoti, ovvero in alcuni indici non sono definiti elementi.

Quando si accede a uno spazio vuoto (noto anche come slot vuoto) allinterno di un array sparso, si ottiene anche un undefined.

Lesempio seguente genera array sparsi e cerca di accedere ai loro slot vuoti:

sparse1 viene creato invocando un Array costruttore con un primo argomento numerico.Dispone di 3 slot vuoti.

sparse2 viene creato con un array letterale con il secondo elemento mancante.

In uno qualsiasi di questi array sparsi, laccesso a uno slot vuoto restituisce undefined.

Quando si lavora con gli array, per evitare undefined, assicurarsi di utilizzare indici di array validi e impedire la creazione di array sparsi.

4. Differenza tra undefined e null

Qual è la principale differenza tra undefined e null? Entrambi i valori speciali implicano uno stato vuoto.

undefined rappresenta il valore di una variabile che non è stata ancora inizializzata, mentre null rappresenta unassenza intenzionale di un oggetto.

Esploriamo la differenza in alcuni esempi.

La variabile number è definita , tuttavia, non è assegnato con un valore iniziale:

number variabile è undefined, che indica una variabile non inizializzata.

Lo stesso concetto non inizializzato si verifica quando si accede a una proprietà di un oggetto non esistente:

Perché lastName non esiste in obj, JavaScript restituisce obj.lastName a undefined.

Daltra parte, sai che una variabile si aspetta un oggetto. Ma per qualche motivo non puoi istanziare loggetto. In tal caso null è un indicatore significativo di un oggetto mancante.

Ad esempio, clone() è una funzione che clona un semplice oggetto JavaScript. La funzione dovrebbe restituire un oggetto:

Tuttavia clone() potrebbe essere invocato con un argomento non oggetto: 15 o null. In tal caso, la funzione non può creare un clone, quindi restituisce null – lindicatore di un oggetto mancante.

Loperatore typeof fa la distinzione tra undefined e null:

Anche loperatore di qualità rigorosa === distingue correttamente undefined da null:

5. Conclusione

undefined lesistenza è una conseguenza della natura permissiva di JavaScript che consente lutilizzo di:

• variabili non inizializzate
• proprietà o metodi di oggetti non esistenti
• indici fuori dai limiti per accedere agli elementi dellarray
• il risultato dellinvocazione di una funzione che non restituisce nulla

Il confronto diretto con undefined non è sicuro perché ti affidi a una pratica consentita ma sconsigliata menzionata sopra.

Una strategia efficiente consiste nel ridurre al minimo laspetto della parola chiave undefined nel codice applicando buone abitudini come:

• ridurre lutilizzo di variabili non inizializzate
• abbreviare il ciclo di vita delle variabili e avvicinarle alla fonte del loro utilizzo
• quando possibile assegnare valori iniziali alle variabili
• favor const, altrimenti utilizza let
• utilizza valori predefiniti per parametri di funzione non significativi
• verifica le proprietà esistenza o riempire gli oggetti non sicuri con proprietà predefinite
• evitare luso di array sparsi

È bene che JavaScript abbia entrambi undefined e null per rappresentare valori vuoti?