Wie überprüfe ich, ob ein Objekt ein Array ist?

StackOverflow https://stackoverflow.com/questions/4775722

Frage

Ich versuche eine Funktion zu schreiben, die entweder eine Liste von Zeichenfolgen oder eine einzelne Zeichenfolge akzeptiert. Wenn es sich um eine Zeichenfolge handelt, möchte ich sie mit nur dem einen Element in ein Array konvertieren. Dann kann ich ohne Angst vor einem Fehler darüber schauen.

Wie überprüfe ich, ob die Variable ein Array ist?

Ich habe die verschiedenen Lösungen unten zusammengefasst und a erstellt JSPERF -Test.

War es hilfreich?

Lösung

In modernen Browsern können Sie tun

Array.isArray(obj)

(Unterstützt durch Chrome 5, Firefox 4.0, dh 9, Opera 10.5 und Safari 5)

Für die Rückwärtskompatibilität können Sie Folgendes hinzufügen

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

Wenn Sie JQuery verwenden, können Sie verwenden jQuery.isArray(obj) oder $.isArray(obj). Wenn Sie Unterstrich verwenden, können Sie verwenden _.isArray(obj)

Wenn Sie keine Arrays erkennen müssen, die in verschiedenen Rahmen erstellt wurden, können Sie auch nur verwenden instanceof

obj instanceof Array

Andere Tipps

Die im ECMascript -Standard angegebene Methode, um die Objektklasse zu finden, besteht darin, die zu verwenden toString Methode von Object.prototype.

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

Oder Sie könnten verwenden typeof Um zu testen, ob es sich um eine Zeichenfolge handelt:

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

Oder wenn Sie sich nicht um Leistung besorgt haben, könnten Sie einfach eine machen concat zu einem neuen leeren Array.

someVar = [].concat( someVar );

Es gibt auch den Konstruktor, den Sie direkt abfragen können:

if (somevar.constructor.name == "Array") {
    // do something
}

Schauen Sie sich a an gründliche Behandlung aus @TJ Crowder Blog, wie in seinem Kommentar unten veröffentlicht.

Schau dir das an Benchmark Um eine Idee zu erhalten, welche Methode besser funktioniert: http://jsben.ch/#/qgyav

Aus @Bharath Konvertieren Sie die Zeichenfolge mit ES6 in ein Array für die gestellte Frage:

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

vermuten: 

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']

Ich würde zuerst überprüfen, ob Ihre Implementierung unterstützt wird isArray:

if (Array.isArray)
    return Array.isArray(v);

Sie können auch versuchen, die zu verwenden instanceof Operator

v instanceof Array

JQuery bietet auch eine $.isArray() Methode:

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Dies ist der schnellste unter allen Methoden (alle unterstützten Browser):

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

Stellen Sie sich vor, Sie haben das Array unten: 

var arr = [1,2,3,4,5];

JavaScript (neue und ältere Browser):

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

oder

function isArray(arr) {
  return arr instanceof Array;
}

oder 

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

Dann nenn es so:

isArray(arr);

JavaScript (IE9+, CH5+, FF4+, SAF5+, Opera10.5+) 

Array.isArray(arr);

JQuery:

$.isArray(arr);

Winkel:

angular.isArray(arr);

Unterstrich und Lodash:

_.isArray(arr);

Array.IsArray funktioniert schnell, wird aber nicht von allen Versionen von Browsern unterstützt. Sie können also eine Ausnahme für andere machen und universelle Methoden verwenden:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

Einfache Funktion, um dies zu überprüfen:

function isArray(object)
{
    if (object.constructor === Array) return true;
    else return false;
}

Wie Mdn sagt hier drin:

verwenden Array.IsArray oder Object.Prototype.toString.call Um reguläre Objekte von Arrays zu unterscheiden

So was:

  • Object.prototype.toString.call(arr) === '[object Array]', oder

  • Array.isArray(arr)

Es gibt nur eine Zeilenlösung für diese Frage

x instanceof Array

Wo x die Variable ist, wird true zurückgegeben, wenn x ein Array ist, und falsch, wenn dies nicht der Fall ist.

Sie können den Typ Ihrer Variablen überprüfen, ob es sich um ein Array handelt.

var myArray=[];

if(myArray instanceof Array)
{
....
}

Ich würde eine Funktion machen, um die Art des Objekts zu testen, mit dem Sie es zu tun haben ...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

Dann können Sie eine einfache Anweisung schreiben ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

Ich mache das auf sehr einfache Weise. Funktioniert bei mir. Irgendwelche Nachteile?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)

Dies ist mein Versuch, sich zu verbessern Diese Antwort Berücksichtigung der Kommentare:

var isArray = myArray && myArray.constructor === Array;

Es wird die if/else los und berücksichtigt die Möglichkeit, dass das Array null oder undefiniert ist

https://developer.mozilla.org/en-us/docs/javascript/reference/global_objects/array/isarray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};

Ich habe die aktualisiert JSPERF GIDLE mit zwei alternativen Methoden sowie Fehlerprüfung.

Es stellt sich heraus, dass die Methode, die einen konstanten Wert im "Objekt" und "Array" -Prototypen definiert, schneller als jede andere Methoden ist. Es ist ein etwas überraschendes Ergebnis.

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

Diese beiden Methoden funktionieren nicht, wenn die Variable den undefinierten Wert einnimmt, aber sie funktionieren, wenn Sie sicher sind, dass sie einen Wert haben. In Bezug auf die Überprüfung der Leistung, wenn ein Wert ein Array oder ein einzelner Wert ist, sieht die zweite Methode wie eine gültige schnelle Methode aus. Es ist etwas schneller als "Instanz" auf Chrome, doppelt so schnell wie die zweitbeste Methode in Internet Explorer, Opera und Safari (auf meiner Maschine).

Ich weiß, dass die Leute nach einer Art rohen JavaScript -Ansatz suchen. Aber wenn Sie weniger darüber nachdenken möchten, werfen Sie hier einen Blick darauf: http://underscorejs.org/#isarray

_.isArray(object)

Gibt true zurück, wenn Objekt ein Array ist.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

Die beste Lösung, die ich gesehen habe, ist ein Cross-Browser-Ersatz für Typof. Überprüfen Sie die Lösung von Angus Croll hier.

Die TL; DR -Version ist unten, aber der Artikel ist eine großartige Diskussion des Problems, also sollten Sie es lesen, wenn Sie Zeit haben.

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};

Hier ist mein fauler Ansatz:

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

Ich weiß, es ist ein Sakrileg, sich mit dem Prototyp zu "durcheinander bringen", aber Es scheint deutlich besser zu funktionieren als die empfohlenen toString Methode.

Notiz: Ein Fallstrick dieses Ansatzes ist, dass es Arbeiten Sie nicht durch iframe Grenzen, Aber für meinen Anwendungsfall ist dies kein Problem.

In Stoyan Stefanovs Buch gibt es ein schönes Beispiel JavaScript -Muster Dies geht davon aus Array.isArray ().

Hier ist es also:

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

Wenn Sie JQuery verwenden, können Sie übrigens die Methode verwenden $ .isArray ()

Der einfachste und schnellste Weg, um zu überprüfen, ob ein Objekt ein Array ist oder nicht.

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

oder 

arr.constructor ===Array //return true;

Oder Sie können eine Versorgungsfunktion erstellen:

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

Verwendungszweck:

isArray(arr); //return true

Das Folgende könnte verwendet werden, wenn Sie wissen, dass Ihr Objekt keine Konzernmethode hat.

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}

Sie könnten ISArray -Methode, aber ich würde es vorziehen, mich mit zu erkundigen

Object.getPrototypeOf(yourvariable) === Array.prototype

Wenn die einzigen zwei Arten von Werten, die an diese Funktion übergeben werden könnten typeof Überprüfen Sie die Möglichkeit der Zeichenfolge:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

A = [1,2,3]
console.log(A.map==[].map)

Auf der Suche nach kürzester Version hier habe ich bisher bekommen.

Beachten Sie, dass es keine perfekte Funktion gibt, die immer alle möglichen Kombinationen erkennt. Es ist besser, alle Fähigkeiten und Einschränkungen Ihrer Tools zu kennen, als ein magisches Tool zu erwarten.

function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))

Eine einfache Funktion zum Testen, wenn ein Eingangswert ein Array ist, ist Folgendes:

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

Dies funktioniert Cross Browser und mit älteren Browsern. Das ist Ziehen Sie aus dem Blog -Beitrag der TJ -Crowens

Sie können dies versuchen:

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false

Diese Funktion verwandelt fast alles in ein Array:

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

Es werden einige neuere Browserfunktionen verwendet, sodass Sie dies für eine maximale Unterstützung polyfüllen möchten.

Beispiele:

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

NB -Saiten werden in ein Array mit einem einzelnen Element anstelle eines Arrays von Zeichen umgewandelt. Löschen die isString Überprüfen Sie, ob Sie es umgekehrt vorziehen würden.

Ich habe verwendet Array.isArray hier, weil es das ist am robustesten und auch einfachste.

In Ihrem Fall können Sie verwenden concat Methode von Array Dies kann sowohl einzelne Objekte als auch Array akzeptieren (und sogar kombiniert):

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat Scheint eine der ältesten Array -Methoden zu sein (selbst IE 5.5 weiß es gut).

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top