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

Die im ECMAScript-Standard angegebene Methode zum Suchen der Klasse von Object besteht darin, die toString-Methode aus Object.prototype zu verwenden.

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

Oder Sie können typeof verwenden, um zu testen, 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 einfach eine concat für ein neues leeres Array ausführen.

someVar = [].concat( someVar );

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

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

Schauen Sie sich ein gründliche Behandlung von @ T.J. Crowder's Blog an, wie in seinem Kommentar unten beschrieben.

Sehen Sie sich dieses Benchmark an, um eine Vorstellung davon zu bekommen, welche Methode besser ist: http://jsben.ch/#/QgYAV

Von @Bharath konvertieren Sie den String mit Es6 für die Frage in ein Array:

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 isArray unterstützt:

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

Sie können auch den Operator instanceof verwenden

v instanceof Array

jQuery bietet auch eine $.isArray() -Methode an:

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 aller 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 nennen Sie 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 zwar schnell, wird jedoch nicht von allen Browser-Versionen unterstützt .. __ Sie können für andere eine Ausnahme machen und eine 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)
{
    if (object.constructor === Array) return true;
    else return false;
}

Wie MDN sagt hier :

verwenden Sie Array.isArray oder Object.prototype.toString.call , um zu unterscheiden reguläre Objekte aus Arrays

So was:

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

• Array.isArray(arr)

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

x instanceof Array

wenn x die Variable ist, wird true zurückgegeben, wenn x ein Array ist, und false, wenn nicht.

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 kannst du 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
}

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

var myArray=[];

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

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;

Dadurch wird das if/else entfernt und die Möglichkeit des Arrays ist null oder undefiniert

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 Fehlerüberprü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 hat. Sie funktionieren jedoch, wenn Sie sicher sind, dass sie einen Wert haben. Bei der Überprüfung im Hinblick auf die 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 einer Art 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 je gesehen habe, ist ein Cross-Browser-Ersatz für Typeof. Ü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. Sie sollten sie also 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 */};

Es gibt ein schönes Beispiel in Stoyan Stefanovs Buch JavaScript Patterns , das alle möglichen Probleme behandeln und die ECMAScript 5-Methode Array.isArray () verwenden soll.

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 $ .isArray () verwenden.

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 Segen, den Prototyp "durcheinanderzubringen", aber er scheint deutlich besser zu sein als die empfohlene toString-Methode .

Anmerkung: Ein Fallstrick dieses Ansatzes ist, dass es funktioniert nicht über iframe-Grenzen hinweg , aber für meinen Anwendungsfall ist dies kein Problem.

Die folgenden Informationen können 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");
}

einfachste und schnellste Möglichkeit, zu prü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 Utility-Funktion erstellen:

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

verwendungszweck:

isArray(arr); //return true

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

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

Eine einfache Funktion zum Testen, ob ein Eingabewert ein Array ist, ist folgende:

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

Dies funktioniert browserübergreifend und mit älteren Browsern. Dies ist von T.J gezogen. Crowders 'Blogeintrag

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 verwendet einige neuere Browserfunktionen, so dass Sie diese für maximale Unterstützung polyfillern 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' ]

N.B. Zeichenfolgen werden in ein Array mit einem einzelnen Element anstelle eines Arrays von Zeichen umgewandelt. Löschen Sie die Variable isString, wenn Sie es lieber andersherum bevorzugen möchten.

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

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

In Ihrem Fall können Sie die concat-Methode von Array verwenden, die sowohl Einzelobjekte als auch Array (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 kennt es).

Wenn die einzigen zwei Arten von Werten, die an diese Funktion übergeben werden können, ein String oder ein Array von Strings ist, halten Sie es einfach und verwenden Sie eine typeof-Prüfung für die String-Mö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 hier, was ich bisher bekommen habe.

Beachten Sie, dass es keine perfekte Funktion gibt, die immer alle möglichen Kombinationen erkennt. Es ist besser alle Fähigkeiten und Grenzen 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))

Glücklicherweise hat ECMA 5 Array.isArray() bereits im Dezember 2009 eingeführt. Wenn Sie aus irgendeinem Grund eine ältere Version von JavaScript als ECMA 5 verwenden, aktualisieren Sie bitte.

Wenn Sie jedoch darauf bestehen, haben Arrays bestimmte Eigenschaften, die sie von anderen Typen unterscheiden. Eigenschaften, die ich in keiner der anderen Antworten gesehen habe. Kommen wir zu JavaScript-Politik.

Ein Array ist ein Objekt (typeof [] === "object"), aber im Gegensatz zu herkömmlichen Objekten haben sie eine length-Eigenschaft (typeof ( {} ).length === "undefined"). null ist also ein Objekt (typeof null === "object"), aber Sie können nicht auf eine Eigenschaft von null zugreifen, da null nicht ein Objekt ist. Dies ist ein Fehler in der Spezifikation, der bis zum Anfang von JavaScript zurückreicht, als Objekte den Typ tag 0 hatten und null als literaler Nullzeiger 0x00 dargestellt wurde, was dazu führte, dass der Interpreter ihn mit Objekten verwechselte. 

Leider berücksichtigt dies nicht [] vs {length:0}. Nun müssen wir uns der Prototypkette zuwenden.

( [] ).__proto__ === Array.prototype && ( [] ).__proto__ !== Object.prototype.

Ohne Array.isArray() ist dies ungefähr das, was wir erreichen können:

function is_array(array){
    return array !== null
        && typeof array === "object"
        && array.__proto__ === Array.prototype;
}

[ [], [1,2,3], {length: 0}, {},
  1, 0, Infinity, NaN, "1", "[1,2,3]",
  null, undefined, [null], [undefined], {a:[]},
  [{}], [{length: 0}], [Infinity], [NaN],
  {__proto__: Array.prototype}
].filter(is_array)
// Expected: [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN] ]
// Actual:   [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN], {__proto__: Array.prototype} ]

Das Objekt, das in böswilliger Absicht so aussieht, als würde ein Array tatsächlich den Turtest bestehen. Wenn Sie jedoch die Prototypkette durch die Array-Prototypkette ersetzen, genügt es, dass sie wie ein Array wirkt und effektiv zu einem Array wird. Die einzige Sache auf der Welt, die ein solches Objekt tatsächlich nicht als Array erkennen kann, ist Array.isArray(). Aber für die Zwecke, die Sie normalerweise prüfen, ob ein Objekt ein Array ist, sollte das Objekt mit Ihrem Code Nizza spielen. Selbst wenn Sie die Länge des Arrays künstlich ändern, ist das Verhalten dasselbe: Wenn die Länge länger als die Anzahl der Elemente im Array ist, haben Sie "leere Slots" dieses speziellen "impliziten undefinierten" Typs, der sich von dem unterscheidet undefined, während auch === undefined; Derselbe Typ, der der Grund ist, warum wir typeof obj !== "undefined" verwenden, um das Auslösen einer ReferenceError zu vermeiden, da obj === undefined only nicht - einen Fehler auslöst, wenn obj explizit als undefined definiert wurde.

a = {__proto__: Array.prototype}; // Array {}
a.Push(5)
a // [5]
a.length = 5
a // [5, empty x 4]
b = a.map(n => n*n) // [25, empty x 4]
b.Push(undefined)
b.Push(undefined)
b // [25, empty x 4, undefined, undefined]
b[1] // undefined
b[1] === b[5] // true
Array.isArray(a) // false
Array.isArray(b) // true

Verwenden Sie jedoch nicht is_array(). Es ist eine Sache, das Rad zu Lernzwecken neu zu erfinden. Es ist eine andere Sache, dies im Produktionscode zu tun. Verwenden Sie es nicht einmal als Polyfill. Die Unterstützung alter JS-Versionen bedeutet, dass die Unterstützung alter Browser bedeutet, die Verwendung unsicherer Software zu fördern, den Benutzer für Malware zu gefährden.

Es gibt auch andere Methoden zur Überprüfung, aber ich bevorzuge die folgende Methode , Da dies die beste Art ist, um zu überprüfen (da Sie leicht Typen anderer Objekte prüfen können).

> a = [1, 2]
[ 1, 2 ]
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>
> Object.prototype.toString.call([]).slice(8,-1) // best approach
'Array'

Erklärung (mit einfachen Beispielen zu Node REPL) »

> o = {'ok': 1}
{ ok: 1 }
> a = [1, 2]
[ 1, 2 ]
> typeof o
'object'
> typeof a
'object'
>
> Object.prototype.toString.call(o)
'[object Object]'
> Object.prototype.toString.call(a)
'[object Array]'
>

Objekt oder Array »

> Object.prototype.toString.call(o).slice(8,).replace(/\]$/, '')
'Object'
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>

Null oder undefiniert »

> Object.prototype.toString.call(undefined).slice(8,).replace(/\]$/, '')
'Undefined'
> Object.prototype.toString.call(null).slice(8,).replace(/\]$/, '')
'Null'
>

String »

> Object.prototype.toString.call('ok').slice(8,).replace(/\]$/, '')
'String'

Nummer "

> Object.prototype.toString.call(19).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.0).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.7).slice(8,).replace(/\]$/, '')
'Number'
>

Ich schätze den Vorschlag von @mpen, -1 anstelle des regulären Ausdrucks wie folgt zu verwenden.

> Object.prototype.toString.call(12).slice(8,-1)
'Number'
>
> Object.prototype.toString.call(12.0).slice(8,-1)
'Number'
>
> Object.prototype.toString.call([]).slice(8,-1)
'Array'
> Object.prototype.toString.call({}).slice(8,-1)
'Object'
>
> Object.prototype.toString.call('').slice(8,-1)
'String'
>

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

Diese Funktion wurde dem Buch "JS the good parts" entnommen und funktioniert perfekt für mich.

Sie können auch mit der length-Eigenschaft des Arrays überprüfen. Wenn Sie versuchen, auf die Längeneigenschaft eines Arrays zuzugreifen, wird eine Zahl zurückgegeben (0 für leeres Array). Wenn Sie versuchen, auf die Längeneigenschaft des Objekts zuzugreifen, wird undefined zurückgegeben.

if(Object.prototype.toString.call(arrayList) === '[object Array]') {
  console.log('Array!');
}

Ich weiß, dass dies eine alte Frage ist, aber ich habe jetzt die kürzeste Antwort gefunden:

var x = [1,2,3]
console.log(x.map?1:0)

Ich weiß, das ist eine alte Frage, aber hier ist eine Lösung, die ich für meine Projekte gefunden habe und verwendet habe ...

function isArray (o) {
    return typeof o === "object" && o.length !== undefined;
}

isArray({}); // false
isArray(1); // false
isArray("str"); // false
isArray(function(){}); // false

isArray([]); // true

Der einzige Nachteil ist, dass es ein falsch positives Ergebnis gibt, wenn Ihr Objekt zufällig eine length-Eigenschaft hat:

isArray({length:0}); // true

Wenn Sie mit diesem Nachteil einverstanden sind und wissen, dass Ihre reinen Objekte diese Eigenschaft nicht haben, ist dies eine saubere Lösung und sollte schneller als die Methode Object.prototype.toString.call sein.

zuerst können Sie die Datei console.log (typeof Object) überprüfen.

wenn die Ausgabe ein Objekt ist, dann ist var {data} = object, dh das Objekt wird nur gemäß den Objektschlüsseln zerstört. und die funktion kann so sein.

const abc=(str1,str2=null)=>{


     var result=[];
      result.Push(str1);result.Push(str2);
      return result.join("");

}

es gibt einen Unterschied zwischen dem Checkout der Kasse und Array.isArray:

function isArray(obj){
    return Object.getPrototypeOf(obj) === Array.prototype
}

diese Funktion prüft direkt, ob ein Objekt ein Array ist

aber für dieses Proxy-Objekt:

var arr = [1,2,3]

var proxy = new Proxy(arr,{})

console.log(Array.isArray(proxy)) // true

Array.isArray nimmt es als Array.

Die beste Methode ist, es mit constructor zu vergleichen

if(some_variable.constructor === Array){
  // do something
}

Sie können auch andere Methoden wie typeOf verwenden, sie in einen String konvertieren und dann vergleichen, aber den Vergleich mit dataType ist immer eine bessere Methode.

Mit dieser Funktion können Sie den Datentyp abrufen.

var myAr  = [1,2];

checkType(myAr);

function checkType(data){
  if(typeof data ==='object'){
    if(Object.prototype.toString.call(data).indexOf('Array')!==(-1)){
      return 'array';
    } else{
      return 'object';
    }
  } else {
    return typeof data;
  }
}

if(checkType(myAr) === 'array'){console.log('yes, It is an array')};

Da ich keine Object.prototype-Aufrufe mag, habe ich nach einer anderen Lösung gesucht. Insbesondere, weil die Lösungen von ChaosPandion nicht immer funktionieren und die Lösung von MidnightTortoise mit isArray() nicht mit Arrays aus dem DOM funktioniert (wie getElementsByTagName ). Und schließlich fand ich eine einfache und Cross-Browser-Lösung, die wahrscheinlich auch mit Netscape 4 funktioniert hätte;)

Es sind nur diese 4 Zeilen (prüfen jedes Objekt h):

function isArray(h){
    if((h.length!=undefined&&h[0]!=undefined)||(h.length===0&&h[0]===undefined)){
        return true;
    }
    else{ return false; }
}

Ich habe diese Arrays bereits getestet (alle geben true zurück):

1) array=d.getElementsByName('some_element'); //'some_element' can be a real or unreal element
2) array=[];
3) array=[10];
4) array=new Array();
5) array=new Array();
   array.Push("whatever");

Kann jemand bestätigen, dass dies für alle Fälle funktioniert? Oder findet jemand einen Fall, in dem meine Lösung nicht funktioniert?

Hier ist ein Code-Snippet, der eine wichtige Tatsache von Arrays erklärt, die beim Lernen von JS (anders als ich) früh bekannt sein sollte.

// this functions puts a string inside an array
var stringInsideArray = function(input) {
  if (typeof input === 'string') {
    return [input];
  }
  else if (Array.isArray(input)) {
    return input;
  } 
  else {
    throw new Error("Input is not a string!");
  }
}

var output = stringInsideArray('hello');
console.log('step one output: ', output); // ["hello"]

// use typeof method to verify output is an object
console.log('step two output: ', typeof output); // object

// use Array.isArray() method to verify output is an array
console.log('step three output: ', Array.isArray(output)); // true

Arrays sind in der Tat Objekte.

Mit dem Operator typeof beweist die Ausgabe von stringInsideArray('hello'), dass ["hello"]really ein Objekt ist. Dies hat mich lange Zeit verblüfft, weil ich davon ausgegangen bin, dass Arrays ein JavaScript-Datentyp wären ...

Es gibt nur 7 JS-Datentypen, und Arrays sind UND NICHT einer von ihnen.

Zur Beantwortung Ihrer Frage wird mit der Array.isArray () - Methode festgelegt, dass die output ein Array ist.

Array.isArray ist der Weg, dies zu tun. Zum Beispiel:

var arr = ['tuna', 'chicken', 'pb&j'];
var obj = {sandwich: 'tuna', chips: 'cape cod'};

// Returns true
Array.isArray(arr);

// Return false
Array.isArray(obj);

Sie können mit Push wie folgt finden:

function isArray(obj){
   return (typeof obj.Push=== 'function')?true:false;
}

var array=new Array();
or
var array=['a','b','c'];
console.log(isArray(array));