Come rilevare se una variabile è un array

Qual è il miglior metodo cross-browser standard di fatto per determinare se una variabile in JavaScript è un array o meno?

Cercando sul web ci sono una serie di suggerimenti diversi, alcuni buoni e alcuni non validi.

Ad esempio, il seguente è un approccio di base:

function isArray(obj) {
    return (obj && obj.length);
}

Tuttavia, nota cosa succede se l'array è vuoto, o obj in realtà non è un array ma implementa una proprietà length, ecc.

Quindi quale implementazione è la migliore in termini di funzionamento effettivo, cross-browser e prestazioni ancora efficienti?

Il controllo del tipo di oggetti in JS viene eseguito tramite instanceof, ie

obj instanceof Array

Questo non funzionerà se l'oggetto viene passato attraverso i confini del frame poiché ogni frame ha il proprio Arrayoggetto. È possibile aggirare questo problema controllando la proprietà [[Class]] interna dell'oggetto. Per ottenerlo, usa Object.prototype.toString()(questo è garantito per funzionare da ECMA-262):

Object.prototype.toString.call(obj) === '[object Array]'

Entrambi i metodi funzioneranno solo per array effettivi e non per oggetti simili a array come gli argumentselenchi di oggetti o nodi. Poiché tutti gli oggetti simili a un array devono avere una lengthproprietà numerica , controllerei questi in questo modo:

typeof obj !== 'undefined' && obj !== null && typeof obj.length === 'number'

Tieni presente che le stringhe superano questo controllo, il che potrebbe causare problemi poiché IE non consente l'accesso ai caratteri di una stringa in base all'indice. Pertanto, potresti voler cambiare typeof obj !== 'undefined'in typeof obj === 'object'per escludere primitive e oggetti host con tipi distinti da 'object'alltogether. Ciò consentirà comunque il passaggio degli oggetti stringa, che dovrebbero essere esclusi manualmente.

Nella maggior parte dei casi, quello che vuoi veramente sapere è se puoi iterare sull'oggetto tramite indici numerici. Pertanto, potrebbe essere una buona idea controllare se l'oggetto ha invece una proprietà denominata 0, che può essere eseguita tramite uno di questi controlli:

typeof obj[0] !== 'undefined' // false negative for `obj[0] = undefined`
obj.hasOwnProperty('0') // exclude array-likes with inherited entries
'0' in Object(obj) // include array-likes with inherited entries

Il cast in object è necessario per funzionare correttamente per primitive tipo array (cioè stringhe).

Ecco il codice per controlli affidabili per gli array JS:

function isArray(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
}

e oggetti simili ad array iterabili (cioè non vuoti):

function isNonEmptyArrayLike(obj) {
    try { // don't bother with `typeof` - just access `length` and `catch`
        return obj.length > 0 && '0' in Object(obj);
    }
    catch(e) {
        return false;
    }
}

L'arrivo di ECMAScript 5a edizione ci offre il metodo più sicuro per testare se una variabile è un array, Array.isArray () :

Array.isArray([]); // true

Sebbene la risposta accettata qui funzionerà su frame e finestre per la maggior parte dei browser, non lo fa per Internet Explorer 7 e versioni precedenti , perché Object.prototype.toStringverrà richiamato un array da una finestra diversa [object Object], no [object Array]. Anche IE 9 sembra essere regredito a questo comportamento (vedere la correzione aggiornata di seguito).

Se desideri una soluzione che funzioni su tutti i browser, puoi utilizzare:

(function () {
    var toString = Object.prototype.toString,
        strArray = Array.toString(),
        jscript  = /*@cc_on @_jscript_version @*/ +0;

    // jscript will be 0 for browsers other than IE
    if (!jscript) {
        Array.isArray = Array.isArray || function (obj) {
            return toString.call(obj) == "[object Array]";
        }
    }
    else {
        Array.isArray = function (obj) {
            return "constructor" in obj && String(obj.constructor) == strArray;
        }
    }
})();

Non è del tutto indistruttibile, ma sarebbe rotto solo da qualcuno che cercava di romperlo. Funziona intorno ai problemi in IE7 e versioni precedenti e IE9. Il bug esiste ancora in IE 10 PP2 , ma potrebbe essere corretto prima del rilascio.

PS, se non sei sicuro della soluzione, ti consiglio di testarla sul contenuto del tuo cuore e / o di leggere il post del blog. Ci sono altre potenziali soluzioni se ti senti a disagio nell'usare la compilazione condizionale.

Crockford ha due risposte a pagina 106 di "The Good Parts". Il primo controlla il costruttore, ma darà falsi negativi su diversi frame o finestre. Ecco il secondo:

if (my_value && typeof my_value === 'object' &&
        typeof my_value.length === 'number' &&
        !(my_value.propertyIsEnumerable('length')) {
    // my_value is truly an array!
}

Crockford sottolinea che questa versione identificherà l' argumentsarray come array, anche se non ha nessuno dei metodi dell'array.

La sua interessante discussione sul problema inizia a pagina 105.

C'è un'ulteriore discussione interessante (post-Good Parts) qui che include questa proposta:

var isArray = function (o) {
    return (o instanceof Array) ||
        (Object.prototype.toString.apply(o) === '[object Array]');
};

Tutta la discussione mi fa desiderare di non sapere se qualcosa è o meno un array.

jQuery implementa una funzione isArray, che suggerisce che il modo migliore per farlo è

function isArray( obj ) {
    return toString.call(obj) === "[object Array]";
}

(frammento tratto da jQuery v1.3.2 - leggermente modificato per avere senso fuori contesto)

Rubare dal guru John Resig e jquery:

function isArray(array) {
    if ( toString.call(array) === "[object Array]") {
        return true;
    } else if ( typeof array.length === "number" ) {
        return true;
    }
    return false;
}

Cosa farai con il valore una volta deciso che è un array?

Ad esempio, se si intende enumerare i valori contenuti se sembra un array O se si tratta di un oggetto utilizzato come tabella hash, il codice seguente ottiene ciò che si desidera (questo codice si interrompe quando la funzione di chiusura restituisce qualcos'altro di "undefined". Si noti che NON itera su contenitori COM o enumerazioni; questo è lasciato come esercizio per il lettore):

function iteratei( o, closure )
{
    if( o != null && o.hasOwnProperty )
    {
        for( var ix in seq )
        {
            var ret = closure.call( this, ix, o[ix] );
            if( undefined !== ret )
                return ret;
        }
    }
    return undefined;
}

(Nota: "o! = Null" verifica sia null che undefined)

Esempi di utilizzo:

// Find first element who's value equals "what" in an array
var b = iteratei( ["who", "what", "when" "where"],
    function( ix, v )
    {
        return v == "what" ? true : undefined;
    });

// Iterate over only this objects' properties, not the prototypes'
function iterateiOwnProperties( o, closure )
{
    return iteratei( o, function(ix,v)
    {
        if( o.hasOwnProperty(ix) )
        {
            return closure.call( this, ix, o[ix] );
        }
    })
}

Se lo stai facendo in CouchDB (SpiderMonkey), usa

Array.isArray(array)

come array.constructor === Arrayo array instanceof Arraynon funzionano. L'utilizzo array.toString() === "[object Array]"funziona ma sembra piuttosto rischioso in confronto.

Se vuoi cross-browser, vuoi jQuery.isArray .

Su w3school c'è un esempio che dovrebbe essere abbastanza standard.

Per verificare se una variabile è un array, usano qualcosa di simile a questo

function arrayCheck(obj) { 
    return obj && (obj.constructor==Array);
}

testato su Chrome, Firefox, Safari, ie7

Una delle versioni di questa funzione meglio studiate e discusse può essere trovata sul sito PHPJS . Puoi collegarti ai pacchetti oppure puoi andare direttamente alla funzione . Consiglio vivamente il sito per equivalenti ben costruiti di funzioni PHP in JavaScript.

Riferimento insufficiente uguale dei costruttori. A volte hanno diversi riferimenti di costruttore. Quindi uso rappresentazioni di stringa di loro.

function isArray(o) {
    return o.constructor.toString() === [].constructor.toString();
}

Sostituisci Array.isArray(obj)conobj.constructor==Array

campioni :

Array('44','55').constructor==Array restituire vero (IE8 / Chrome)

'55'.constructor==Array return false (IE8 / Chrome)