Come si controlla se una variabile è una matrice in JavaScript?


Answers

Puoi anche usare:

if (value instanceof Array) {
  alert('value is Array!');
} else {
  alert('Not an array');
}

Questa mi sembra una soluzione piuttosto elegante, ma a ciascuno la sua.

Modificare:

A partire da ES5 ora c'è anche:

Array.isArray(value);

Ma questo si interromperà sui browser più vecchi, a meno che non si utilizzino i polyfill (fondamentalmente ... IE8 o simili).

Question

Questa domanda ha già una risposta qui:

Vorrei verificare se una variabile è o un array o un singolo valore in JavaScript.

Ho trovato una possibile soluzione ...

if (variable.constructor == Array)...

È questo il modo migliore per farlo?







Qualcosa che ho appena trovato:

if (item.length) //This is an array else //not an array




Questa è una vecchia domanda, ma avendo lo stesso problema ho trovato una soluzione molto elegante che voglio condividere.

L'aggiunta di un prototipo alla matrice rende molto semplice

Array.prototype.isArray = true;

Ora una volta se hai un oggetto che vuoi testare per vedere se è un array tutto ciò che serve è controllare la nuova proprietà

var box = doSomething();

if (box.isArray) {
    // do something
}

isArray è disponibile solo se è un array




Personalmente mi piace il suggerimento di Peter: https://.com/a/767499/414784 (per ECMAScript 3. Per ECMAScript 5, usa Array.isArray() )

I commenti sul post indicano, tuttavia, che se toString() viene completamente modificato, questo modo di controllare un array fallirà. Se vuoi essere specifico e assicurarti che toString() non sia stato modificato, e non ci siano problemi con l'attributo della classe objects ( [object Array] è l'attributo di classe di un oggetto che è un array), allora ti consiglio di fare qualcosa come questo:

//see if toString returns proper class attributes of objects that are arrays
//returns -1 if it fails test
//returns true if it passes test and it's an array
//returns false if it passes test and it's not an array
function is_array(o)
{
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')
    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    }
    else
    {
        // may want to change return value to something more desirable
        return -1; 
    }
}

Si noti che in JavaScript, la Guida definitiva 6a edizione, 7.10, si dice che Array.isArray() è implementato usando Object.prototype.toString.call() in ECMAScript 5. Si noti inoltre che se si ha intenzione di preoccuparsi di toString() ' Cambiando l'implementazione di s, dovresti anche preoccuparti che anche gli altri metodi incorporati cambino. Perché usare push() ? Qualcuno può cambiarlo! Un simile approccio è sciocco. Il controllo di cui sopra è una soluzione offerta a chi è preoccupato per toString() , ma credo che il controllo non sia necessario.




Da w3schools :

function isArray(myArray) {
    return myArray.constructor.toString().indexOf("Array") > -1;
}



Ho pensato di aggiungere un'altra opzione per coloro che potrebbero già utilizzare la libreria Underscore.js nel loro script. Underscore.js ha una funzione isArray () (vedi http://underscorejs.org/#isArray ).

_.isArray(object) 

Restituisce true se object è una matrice.




Stavo usando questa linea di codice:

if (variable.push) {
   // variable is array, since AMAIK only arrays have push() method.
}



function isArray(x){
    return ((x != null) && (typeof x.push != "undefined"));
}



La soluzione universale è qui sotto:

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

A partire da ECMAScript 5, una soluzione formale è:

Array.isArray(arr)

Inoltre, per le vecchie librerie JavaScript, puoi trovare sotto la soluzione anche se non è abbastanza accurata:

var is_array = function (value) {
    return value &&
    typeof value === 'object' &&
    typeof value.length === 'number' &&
    typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

Le soluzioni sono da http://www.pixelstech.net/topic/85-How-to-check-whether-an-object-is-an-array-or-not-in-JavaScript




Ho creato questo piccolo codice, che può restituire tipi veri.

Non sono ancora sicuro delle prestazioni, ma si tratta di un tentativo di identificare correttamente il typeof.

https://github.com/valtido/better-typeOf anche scritto un po 'qui http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

funziona, in modo simile al tipo attuale.

var user = [1,2,3]
typeOf(user); //[object Array]

Pensa che potrebbe essere necessario un po 'di messa a punto e tenere conto delle cose, non ho incontrato o testato correttamente. quindi sono stati accolti ulteriori miglioramenti, sia che si tratti di prestazioni saggiate, sia che si tratti di re-porting errato di typeOf.




Ci sono più soluzioni con tutte le loro stranezze. Questa pagina offre una buona panoramica. Una possibile soluzione è:

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



Links