Come ottenere il tipo di dati precisi di una variabile in JavaScript

Introduzione

Una delle più controverse funzionalità del linguaggio JavaScript è la sua digitatura morbida o dinamica di cui abbiamo già parlato occasionalmente. Ciò significa che, a differenza di altre lingue classiche come C o Java, quando dichiariamo le variabili, non abbiamo bisogno di specificare il tipo di dati che conterranno. Inoltre, la stessa variabile, può possedere diversi tipi in diversi momenti di esecuzione: può iniziare ad essere un intero, diventare un array e successivamente, ad esempio, finisci per essere un oggetto.

Questa flessibilità ha Vantaggi molto interessanti per lo sviluppo di applicazioni complesse poiché non ci sono limitazioni a priori rispetto a ciò che una variabile può memorizzare. Tuttavia, per coloro che provengono da altre lingue a punta dura, uno dei problemi di questo concetto è che è molto difficile identificare il tipo di dati specifico che una variabile ha un dato momento di esecuzione.

Identificazione Il tipo

in effetti, JavaScript non possiede un mezzo univocale per identificare il tipo di dati che contiene una variabile in un dato momento. Nativamente, abbiamo due istruzioni che possono darci un valore approssimativo ma che, sfortunatamente, non sono defini definitive: tipoof e Istanceof.

L’operatore Typeof

tipoof è un operatore unar, cosa Il che significa che accetta (e opera) solo su un singolo argomento; In questo caso una variabile:

 tipoof 2; // numpptypeof 'Hello World' // StringTypeof // Object 

Questo operatore non è una funzione; Tuttavia, le parentesi possono essere utilizzate per raggruppare i termini da valutare:

 tipoof (2); // Nubertypeof ('Hello World'); // stringypeof ('foo', 4); // Numero 

Nota: i gruppi di argomenti in JavaScript determinano il valore finale di un elemento attraverso l’uso di operatori interni. Questi operatori indicano l’ordine in cui vengono valutati i termini, come la virgola, che rende questa valutazione da sinistra a destra per restituire il valore del secondo operando. Per ulteriori informazioni su questo aspetto linguistico, viene raccomandato l’articolo dell’operatore Javascript Comma.

La seguente tabella mostra la corrispondenza degli oggetti JavaScript e il valore ottenuto con Typef:

Come possiamo vedere , Non vi è alcun riferimento nella tabella prima di elementi come array, date, espressioni regolari, ecc … Ciò significa che per tipo di tipo di, tali elementi sono un altro oggetto. Inoltre, vediamo alcuni risultati che possono sembrare confusi come nulla in cui otteniamo come un tipo di nuovo “oggetto”:

 tipoof nan; // Nubertypeof Infinity; // Nubertypeof (1/0); // Nubertypeof (TypeF); // String 

Sembra che non possiamo fidarsi di questo operatore troppo per determinare il tipo di dati che abbiamo valutato, quindi potrebbe essere interessante cercare un altro altro sicuro o completo Soluzione.

Object.prototype.String

La funzione di tostring, restituisce una stringa che rappresenta l’oggetto indicato come argomento:

 Object.prototipo.TRING (); // 

Vediamo il risultato: “”: Secondo la specifica di ECMascript5, Object.ProtoToToType.String restituisce come risultato la concatenazione della catena di “oggetto” più il Valore interno dell’oggetto Cosa viene superato (cosa chiamiamo classe di classe) …

]

Tutti gli oggetti JavaScript hanno un proprietario interno noto come] (la notazione con doppia chiusura è lo stesso usato nelle specifiche ES5). Secondo ES5,] è una catena con un singolo valore (non modificabile) che identifica ciascun oggetto. Quindi, un oggetto invocato con il costruttore e che non è stato modificato, restituisce come valore di questa proprietà il tipo di oggetto preciso a cui appartiene:

var o = nuovo oggetto (); o.pungere (); //

Tuttavia, vediamo che questo operatore è anche fragile quando lo applichiamo su oggetti comuni:

 .TRING (); // "foo, bar, 1" "hello mondo" .tostring (); // "Hello World" /a-z/.TeString (); // "/ A-Z /" 

Questo è così perché gli oggetti personalizzati sovrascrivono il metodo Object.ProtoToType.String con il tuo. Un modo per risolvere questo è quello di richiamare questo metodo direttamente dall’oggetto oggetto e utilizzare la funzione di chiamata per iniettare l’argomento desiderato:

 oggetto.prothotype.tring.call (); // Object.prototype.toscall ("Hello World"); // oggetto.prototipo.tring.call (/ A-Z /); // 

In questo modo, evitiamo sovrascritti qualsiasi cosa e il risultato ottenuto è previsto: abbiamo il tipo corretto di dati.

Creazione di una funzione a Determinare il tipo di dati

Estrati direttamente dall’articolo di Angus Croll, possiamo utilizzare la seguente funzione per ottenere il tipo corretto di dati di una variabile o oggetto:

 VAR TOTYPE = FUNCTION (OBJ) {RETURN ({}). TOSTRING.CALL (OBJ) .Match (/ \ S (+) /) . Tolowercase ()} 

Esaminiamolo in parti:

• ({}). Tostring è un’abbreviazione (una scorciatoia) di oggetti .Prototipype. Toasing poiché, in qualsiasi nuovo oggetto, il metodo di tostring si riferisce alla definizione data da oggetto. Protototipo come abbiamo visto sopra.
• chiamata lo usiamo qui in modo che il metodo precedente sia effettuato sull’argomento che indichiamo, in questo caso, un altro oggetto.
• corrisponde: utilizziamo un’espressione regolare per estrarre il tipo di dati senza Caden All’inizio ‘oggetto’ e le parentesi. Usiamo un’espressione regolare anziché una fetta o un altro metodo a causa della migliore prestazione che offre oltre il resto.
• tolowerase: passiamo per minuscolo per differenziare il tipo di quale sarebbe il riferimento all’istanza da Un oggetto e quello, di solito, è maiuscolo.

Vediamo come si comporta la funzione:

 TOTEPE ({A: 4}); // "oggetto" totype (); // "array" (funzione () {console.log (totype (argomenti))); // Argumentstotype (New ReferenceError); // "Errore" Totype (nuova data); // "data" totype (/ A-Z /); // "regexp" totype (matematica); // "matematica" Totyype (JSON); // "json" totype (nuovo numero (4)); // numero "numero" (nuova stringa ("ABC"); // "String" Totype (New Boolean (TRUE)); // "booleano" 

e lo confrontiamo con ciò che avremmo ottenuto con tipo di:

 tipoof {a: 4}; // "oggetto" Typef; // "oggetto" (funzione () {console.log (argomenti di tipoof)}) (); // ObjectTypeof New ReferenceError; // "Object" Typef New Date; // "oggetto" tipoof / a-z /; // "oggetto" tipo di matematica; // "oggetto" tipo di json; // "oggetto" tipo di nuovo numero (4); // "oggetto" Typef New String ("ABC"); // "oggetto" tipo di nuovo booleano (vero); // "Oggetto" 

La differenza nella maggior parte dei casi è importante: dall’improvviso di tipo di Typeo siamo andati avanti per ottenere tipi specifici.

Confronto con IstanceOf

L’operatore Istanceof controlla la stringa prototipica del primo operando che cerca la presenza della proprietà prototipica del secondo, che dovrebbe corrispondere con un costruttore:

 Nuova data Instanceof Data; // true istanceof array; // true 

Il problema di questo operatore è che alcuni oggetti in JavaScript non hanno un costruttore associato in modo da non poter essere valutati correttamente da Istanceof:

 Math Istanceof Math // TypeError 

C’è anche il problema di tali ambienti con fotogrammi multiple in cui la presenza di diversi contesti globali (uno per ciascun telaio) impedisce a garantire che un determinato oggetto sia un’istanza di un determinato costruttore:

 vaframe = document.createelement ('Iframe'); document.body.appendchild (Iframe); var iframearray = window.frames.array; var array = nuovo iframearray (); Array Istanceof Array; // falsearseray istanzef iframearray; // true; 

Limitazioni

La funzione totamyy non può essere prevenuta da errori contro tipi di dati sconosciuti:

 Object.Totype (FFF); // referencerror 

Specificamente, è la chiamata al totamype che avvia l’errore, non la funzione stessa. L’unico modo per impedire che ciò si utilizzerebbe il confronto implicito che ci consente il sistema di cortocircuito JavaScript:

 window.fff & & oggetto.Totype (FFFF); 

Se la prima condizione è soddisfatta, il successivo è continuato; In caso contrario, il circuito è tagliato e l’errore viene evitato.

Conclusione

In JavaCript, non possiamo determinare con precisione il tipo di dati di una variabile utilizzando i metodi nativi che fornisce la lingua si. Di solito, quando abbiamo bisogno di identificare i tipi, di solito ricordiamo a tecniche approssimative come la digitazione delle anatre. Tuttavia, nelle applicazioni in cui l’integrità è fondamentale, questa tecnica non consente al rigore richiesto.

Sia il tipo di e Istanceof non offrono un controllo rigoroso, affidabile e univoco sui tipi che potremmo aver bisogno durante uno sviluppo. Per cercare di risolvere questa mancanza, utilizziamo alcune delle peculiarità del linguaggio come il valore], per ottenere un risultato molto più accurato.

Questo articolo è una traduzione ampliata dell’originale di Angus Croll: fissa JavaScript Tipo di operatore.