empty - javascript typeof object




Prüfen Sie, ob das Objekt ein Array ist. (20)

Array.isArray arbeitet schnell, wird jedoch nicht von allen Browser-Versionen unterstützt. Sie können also eine Ausnahme für andere machen und eine universelle Methode verwenden:

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

Ich versuche, eine Funktion zu schreiben, die entweder eine Liste von Strings oder einen einzelnen String akzeptiert. Wenn es sich um einen String handelt, möchte ich ihn mit nur einem Element in ein Array konvertieren. Dann kann ich es ohne Fehler durchlaufen.

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

Ich habe die verschiedenen Lösungen unten aufgerundet und einen Jsperf-Test erstellt .


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

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

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

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

Oder Sie können typeof , 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 einen neuen leeren Array- concat .

someVar = [].concat( someVar );

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

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

Sehen Sie sich eine ausführliche Behandlung aus dem Blog von @TJ Crowder an , wie in seinem Kommentar unten beschrieben.

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

Konvertieren Sie aus @Bharath mit Es6 für die gestellte Frage einen String 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']

Dies ist die schnellste aller Methoden (alle Browser werden unterstützt):

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

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, 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' ]

NB-Zeichenfolgen werden in ein Array mit einem einzelnen Element anstelle eines Arrays von Zeichen umgewandelt. Löschen Sie die isString Prüfung, wenn Sie es lieber isString bevorzugen möchten.

Ich habe hier Array.isArray , weil es das robusteste und auch einfachste ist.


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 aus dem Blogeintrag von TJ Crowders entnommen


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


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 dies nicht der Fall ist.


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 mache das auf sehr einfache Weise. Funktioniert bei mir. Irgendwelche nachteile?

Array.prototype.isArray = true;

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

Ich würde zunächst prüfen, ob Ihre Implementierung isArray unterstützt:

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

Sie können auch versuchen, den Operator instanceof

v instanceof Array

Ich weiß, dass die Leute nach einer Art rohem Javascript 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

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

var myArray=[];

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

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

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

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


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

Wie MDN hier sagt:

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)


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

Array.isArray

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

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 Einschränkungen Ihrer Werkzeuge zu kennen, als ein magisches Werkzeug zu erwarten.





arrays