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


11 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?




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.




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;
}



Qualcosa che ho appena trovato:

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




Stavo usando questa linea di codice:

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



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




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]'; 
}



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






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.




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




Related