Vraag Hoe controleer je of een variabele een array in JavaScript is? [duplicaat]


Deze vraag heeft hier al een antwoord:

Ik zou willen controleren of een variabele in JavaScript een array of een enkele waarde is.

Ik heb een mogelijke oplossing gevonden ...

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

Is dit de beste manier om dit te doen?


1478
2018-04-20 09:02


oorsprong


antwoorden:


Er zijn verschillende manieren om te controleren of een variabele een array is of niet. De beste oplossing is degene die u hebt gekozen.

variable.constructor === Array

Dit is de snelste methode in Chrome en waarschijnlijk alle andere browsers. Alle arrays zijn objecten, dus het controleren van de constructor-eigenschap is een snel proces voor JavaScript-engines.

Als u problemen ondervindt met het achterhalen of een objecteneigenschap een array is, moet u eerst controleren of de eigenschap aanwezig is.

variable.prop && variable.prop.constructor === Array

Een aantal andere manieren zijn:

variable instanceof Array

Deze methode draait ongeveer 1/3 van de snelheid als het eerste voorbeeld. Nog steeds behoorlijk solide, ziet er schoner uit, als je het hebt over mooie code en niet zozeer over prestaties. Merk op dat het controleren op nummers niet werkt zoals variable instanceof Number keert altijd terug false. Bijwerken: instanceof nu gaat 2/3 de snelheid!

Array.isArray(variable)

Deze laatste is naar mijn mening de lelijkste en het is een van de langzaamste. Ongeveer 1/5 van de snelheid loopt als eerste voorbeeld. Array.prototype, is eigenlijk een array. je kunt hier meer over lezen https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

Dus nog een update

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

Deze gast is de langzaamste persoon die probeert te controleren op een array. Dit is echter een one-stop-shop voor elk type dat u zoekt. Omdat u echter een array zoekt, gebruikt u gewoon de snelste methode hierboven.

Ook heb ik een test gedaan: http://jsperf.com/instanceof-array-vs-array-isarray/33 Dus maak plezier en bekijk het.

Opmerking: @EscapeNetscape heeft een nieuwe test gemaakt omdat jsperf.com offline is. http://jsben.ch/#/QgYAV Ik wilde ervoor zorgen dat de originele link blijft bestaan ​​wanneer jsperf weer online komt.


1312
2017-10-29 15:07



Je zou ook kunnen gebruiken:

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

Dit lijkt me een vrij elegante oplossing, maar dan voor ieder van hem.

Bewerk:

Vanaf ES5 is er nu ook:

Array.isArray(value);

Maar dit zal breken in oudere browsers, tenzij je polyfills gebruikt (eigenlijk ... IE8 of iets dergelijks).


982
2018-04-20 09:05



Ik merkte dat iemand jQuery noemde, maar ik wist niet dat er een was isArray() functie. Het blijkt dat het in versie 1.3 is toegevoegd.

jQuery implementeert het zoals Peter suggereert:

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

Omdat ik al veel vertrouwen heb in jQuery (vooral hun technieken voor compatibiliteit tussen browsers), zal ik ofwel upgraden naar versie 1.3 en hun functie gebruiken (mits die upgrade niet teveel problemen veroorzaakt) of deze aanbevolen methode rechtstreeks in mijn code.

Hartelijk dank voor de suggesties.


72
2018-04-20 10:10



Er zijn meerdere oplossingen met al hun eigenaardigheden. Deze pagina geeft een goed overzicht. Een mogelijke oplossing is:

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

71
2018-04-20 09:08



In moderne browsers (en sommige oudere browsers), kunt u doen

Array.isArray(obj)

(Gesteund door Chrome 5, Firefox 4.0, IE 9, Opera 10.5 en Safari 5)

Als u oudere versies van IE wilt ondersteunen, kunt u gebruiken ES5-shim polyfill Array.isArray; of voeg het volgende toe

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

Als u jQuery gebruikt, kunt u gebruiken jQuery.isArray(obj) of $.isArray(obj). Als u een onderstrepingsteken gebruikt, kunt u gebruiken _.isArray(obj)

Als u geen arrays hoeft te detecteren die in verschillende kaders zijn gemaakt, kunt u deze ook gewoon gebruiken instanceof

obj instanceof Array

Notitie: de arguments sleutelwoord dat kan worden gebruikt om toegang te krijgen tot het argument van een functie is geen Array, hoewel het (meestal) zich als één gedraagt:

var func = function() {
  console.log(arguments)        // [1, 2, 3]
  console.log(arguments.length) // 3
  console.log(Array.isArray(arguments)) // false !!!
  console.log(arguments.slice)  // undefined (Array.prototype methods not available)
  console.log([3,4,5].slice)    // function slice() { [native code] } 
}
func(1, 2, 3)

54
2018-01-08 07:37



Dit is een oude vraag maar met hetzelfde probleem vond ik een zeer elegante oplossing die ik wil delen.

Het toevoegen van een prototype aan Array maakt het heel eenvoudig

Array.prototype.isArray = true;

Nu, als u eenmaal een object hebt dat u wilt testen om te zien of het een array is, hoeft u alleen maar naar de nieuwe eigenschap te zoeken

var box = doSomething();

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

isArray is alleen beschikbaar als het een array is


49
2017-10-24 21:12



Via Crockford:

function typeOf(value) {
    var s = typeof value;
    if (s === 'object') {
        if (value) {
            if (value instanceof Array) {
                s = 'array';
            }
        } else {
            s = 'null';
        }
    }
    return s;
}

De belangrijkste tekortkoming die Crockford vermeldt, is het onvermogen om arrays die in een andere context zijn gemaakt, bijvoorbeeld window. Die pagina heeft een veel geavanceerdere versie als dit onvoldoende is.


45
2018-04-20 09:07



Ik persoonlijk vind de suggestie van Peter leuk: https://stackoverflow.com/a/767499/414784 (voor ECMAScript 3. Gebruik voor ECMAScript 5 Array.isArray())

Opmerkingen op de post geven echter aan dat als toString() is helemaal veranderd, die manier om een ​​array te controleren mislukt. Als je echt specifiek wilt zijn en ervoor wilt zorgen toString() is niet gewijzigd en er zijn geen problemen met het kenmerk objects class ([object Array] is het klasse-attribuut van een object dat een array is), dan raad ik aan om iets als dit te doen:

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

Merk op dat in JavaScript de Definitieve gids 6e editie, 7.10, het zegt Array.isArray() is geïmplementeerd met Object.prototype.toString.call() in ECMAScript 5. Merk ook op dat als je je zorgen gaat maken toString()de implementatie verandert, je moet je ook zorgen maken over elke andere ingebouwde methode die ook verandert. Waarom gebruiken push()? Iemand kan het veranderen! Zo'n aanpak is dom. De bovenstaande controle is een aangeboden oplossing voor mensen die zich zorgen maken toString() veranderen, maar ik denk dat de controle niet nodig is.


26
2017-12-03 03:17