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

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 in ein Array mit nur einem Element konvertieren, damit ich sie ohne Angst vor einem Fehler durchlaufen kann.

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

Ich habe die verschiedenen Lösungen unten zusammengefasst und einen jsperf-Test erstellt . Sie sind alle schnell, also verwenden Sie Array.isArraysie einfach - sie werden jetzt gut unterstützt und funktionieren rahmenübergreifend .

In modernen Browsern können Sie dies tun

Array.isArray(obj)

( Unterstützt von Chrome 5, Firefox 4.0, IE 9, Opera 10.5 und Safari 5)

Aus Gründen der Abwä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 jQuery.isArray(obj)oder verwenden $.isArray(obj). Wenn Sie Unterstrich verwenden, können Sie verwenden_.isArray(obj)

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

obj instanceof Array

Die im ECMAScript-Standard angegebene Methode zum Ermitteln der Objektklasse besteht darin, die toStringMethode von zu verwenden Object.prototype.

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

Oder Sie können typeoftesten, ob es sich um einen String handelt:

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

Wenn Sie sich keine Gedanken über die Leistung machen, können Sie auch concatein neues leeres Array bearbeiten.

someVar = [].concat( someVar );

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

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

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

Schauen Sie sich diesen Benchmark an, um eine Vorstellung davon zu bekommen, welche Methode eine bessere Leistung erbringt: http://jsben.ch/#/QgYAV

Konvertieren Sie von @Bharath einen String mit Es6 in ein Array für die gestellte Frage:

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

annehmen:

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 prüfen, ob Ihre Implementierung Folgendes unterstützt isArray:

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

Sie können auch versuchen, den instanceofOperator zu verwenden

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 die schnellste unter allen Methoden (alle Browser werden unterstützt):

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

Stellen Sie sich vor, Sie haben dieses 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 nenne 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 jedoch nicht von allen Browserversionen unterstützt. Sie können also eine Ausnahme für andere machen und die universelle Methode 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)
{
    return object.constructor === Array;
}

Wie MDN sagt hier :

Verwenden Sie 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)

Für diese Frage gibt es nur eine einzeilige Lösung

x instanceof Array

Dabei ist x die Variable, die true zurückgibt, wenn x ein Array ist, und false, wenn dies nicht der Fall ist.

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

var myArray=[];

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

Ich würde eine Funktion erstellen, um den Objekttyp 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 if-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, diese Antwort unter Berücksichtigung der Kommentare zu verbessern :

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

Das if / else wird entfernt und die Möglichkeit berücksichtigt, 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 jsperf-Geige mit zwei alternativen Methoden sowie der Fehlerprüfung aktualisiert .

Es stellt sich heraus, dass die Methode, die einen konstanten Wert in den Prototypen 'Object' und 'Array' definiert, schneller ist als alle anderen Methoden. 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 annimmt, aber sie funktionieren, wenn Sie sicher sind, dass sie einen Wert haben. In Bezug auf die Überprüfung der Leistung, ob 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 "instanceof" in Chrome, doppelt so schnell wie die zweitbeste Methode in Internet Explorer, Opera und Safari (auf meinem Computer).

Ich weiß, dass die Leute nach einem rohen Javascript-Ansatz suchen. Wenn Sie jedoch weniger darüber nachdenken möchten, schauen Sie hier: http://underscorejs.org/#isArray

_.isArray(object) 

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

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

Die beste Lösung, die ich gesehen habe, ist ein browserübergreifender Ersatz für typeof. Überprüfen Sie hier die Lösung von Angus Croll .

Die TL; DR-Version ist unten aufgeführt, aber der Artikel enthält eine gute Diskussion des Problems. Sie sollten ihn daher 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ß, dass es ein Sakrileg ist, sich mit dem Prototyp "herumzuschlagen", aber es scheint deutlich besser zu funktionieren als die empfohlene toStringMethode .

Hinweis: Ein Nachteil dieses Ansatzes ist, dass er nicht über iframeGrenzen hinweg funktioniert , aber für meinen Anwendungsfall ist dies kein Problem.

In Stoyan Stefanovs Buch JavaScript Patterns gibt es ein schönes Beispiel, das alle möglichen Probleme behandelt und die ECMAScript 5-Methode Array.isArray () verwendet. .

Hier ist es also:

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

Übrigens, wenn Sie jQuery verwenden, können Sie die Methode $ .isArray () verwenden.

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 Dienstprogrammfunktion erstellen:

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

Verwendungszweck:

isArray(arr); //return true

Folgendes kann verwendet werden, wenn Sie wissen, dass Ihr Objekt keine Concat-Methode hat.

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

Sie könnten isArray-Methode, aber ich würde lieber mit überprüfen

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

Wenn die einzigen zwei Arten von Werten, die an diese Funktion übergeben werden können, eine Zeichenfolge oder ein Array von Zeichenfolgen sind, halten Sie es einfach und typeofüberprüfen Sie die Zeichenfolgenmöglichkeit:

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

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

Auf der Suche nach der kürzesten Version habe ich hier das 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 Werkzeuge zu kennen, als ein magisches Werkzeug 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, ob ein Eingabewert ein Array ist, ist die folgende:

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

Dies funktioniert browserübergreifend und mit älteren Browsern. Dies stammt aus dem Blog-Beitrag von TJ Crowders

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 diese möglicherweise für maximale Unterstützung mehrfach ausfü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-Zeichenfolgen werden in ein Array mit einem einzelnen Element anstelle eines Arrays von Zeichen konvertiert. Löschen Sie den isStringScheck, wenn Sie ihn umgekehrt bevorzugen.

Ich habe Array.isArrayhier verwendet , weil es das robusteste und auch einfachste ist.

In Ihrem Fall können Sie eine Array-concat Methode verwenden, die sowohl einzelne Objekte als auch Arrays (und sogar kombinierte) akzeptieren kann:

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 Methoden von Array zu sein (selbst IE 5.5 weiß es gut).