Jak sprawdzić, czy obiekt jest tablicą?

Próbuję napisać funkcję, która akceptuje listę ciągów lub pojedynczy ciąg. Jeśli jest to ciąg, to chcę przekonwertować go na tablicę za pomocą tylko jednego elementu, aby móc go zapętlać bez obawy o błąd.

Jak więc sprawdzić, czy zmienna jest tablicą?

Zaokrągliłem różne rozwiązania poniżej i stworzyłem test jsperf . Wszystkie są szybkie, więc po prostu użyj Array.isArray- jest teraz dobrze obsługiwane i działa w różnych ramkach .

W nowoczesnych przeglądarkach możesz to zrobić

Array.isArray(obj)

( Obsługiwane przez Chrome 5, Firefox 4.0, IE 9, Opera 10.5 i Safari 5)

Dla kompatybilności wstecznej możesz dodać następujące elementy

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

Jeśli używasz jQuery, możesz użyć jQuery.isArray(obj)lub $.isArray(obj). Jeśli używasz podkreślenia, możesz użyć_.isArray(obj)

Jeśli nie musisz wykrywać tablic utworzonych w różnych ramkach, możesz także użyć instanceof

obj instanceof Array

Metodą podaną w standardzie ECMAScript w celu znalezienia klasy Object jest użycie toStringmetody z Object.prototype.

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

Możesz też użyć typeofdo sprawdzenia, czy jest to ciąg znaków:

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

Lub jeśli nie martwisz się wydajnością, możesz po prostu zrobić concatnową pustą macierz.

someVar = [].concat( someVar );

Istnieje również konstruktor, do którego możesz bezpośrednio zapytać:

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

Sprawdź na dokładną obróbkę z @TJ Crowder na blogu, jak pisał w swoim komentarzu poniżej.

Sprawdź ten test porównawczy, aby dowiedzieć się, która metoda działa lepiej: http://jsben.ch/#/QgYAV

Z @Bharath przekonwertuj ciąg znaków na tablicę za pomocą Es6 dla zadanego pytania:

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

przypuszczać:

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

Najpierw sprawdzę, czy Twoja implementacja obsługuje isArray:

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

Możesz także spróbować użyć instanceofoperatora

v instanceof Array

jQuery oferuje również $.isArray()metodę:

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>

Jest to najszybszy spośród wszystkich metod (obsługiwane wszystkie przeglądarki):

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

Wyobraź sobie, że masz tę tablicę poniżej :

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

JavaScript (nowe i starsze przeglądarki):

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

lub

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

lub

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

nazwij to tak:

isArray(arr);

JavaScript (IE9 +, Ch5 +, FF4 +, Saf5 +, Opera10.5 +)

Array.isArray(arr);

jQuery:

$.isArray(arr);

Kątowy:

angular.isArray(arr);

Podkreślenie i Lodash:

_.isArray(arr);

Array.isArray działa szybko, ale nie jest obsługiwany przez wszystkie wersje przeglądarek. Możesz zrobić wyjątek dla innych i zastosować uniwersalną metodę:

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

Prosta funkcja, aby to sprawdzić:

function isArray(object)
{
    return object.constructor === Array;
}

Jak mówi tutaj MDN :

użyj Array.isArray lub Object.prototype.toString.call, aby odróżnić zwykłe obiekty od tablic

Lubię to:

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

• Array.isArray(arr)

Jest tylko jedno rozwiązanie liniowe dla tego pytania

x instanceof Array

gdzie x jest zmienną, zwróci true, jeśli x jest tablicą, a false, jeśli nie jest.

Możesz sprawdzić typ swojej zmiennej, czy jest to tablica;

var myArray=[];

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

Zrobiłbym funkcję, aby przetestować typ obiektu, z którym masz do czynienia ...

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

możesz napisać proste zdanie if ...

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

Robię to w bardzo prosty sposób. Pracuje dla mnie. Jakieś wady?

Array.prototype.isArray = true;

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

Oto moja próba ulepszenia tej odpowiedzi, biorąc pod uwagę komentarze:

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

Pozbywa się instrukcji if / else i uwzględnia możliwość, że tablica będzie pusta lub niezdefiniowana

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]";
};

Zaktualizowałem skrzypce jsperf dwiema alternatywnymi metodami oraz sprawdzaniem błędów.

Okazuje się, że metoda definiowania stałej wartości w prototypach „Object” i „Array” jest szybsza niż jakakolwiek inna metoda. To nieco zaskakujący wynik.

/* 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/>");

Te dwie metody nie działają, jeśli zmienna przyjmuje niezdefiniowaną wartość, ale działają, jeśli masz pewność, że mają wartość. Jeśli chodzi o sprawdzanie pod kątem wydajności, czy wartość jest tablicą czy pojedynczą wartością, druga metoda wygląda jak poprawna metoda szybka. Jest nieco szybszy niż „instanceof” w Chrome, dwa razy szybszy niż druga najlepsza metoda w Internet Explorerze, Operze i Safari (na moim komputerze).

Wiem, że ludzie szukają pewnego rodzaju surowego podejścia do javascript. Ale jeśli chcesz mniej myśleć, zajrzyj tutaj: http://underscorejs.org/#isArray

_.isArray(object) 

Zwraca true, jeśli obiekt jest tablicą.

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

Najlepszym rozwiązaniem, jakie widziałem, jest zamiennik przeglądarki typeof na przeglądarkę. Sprawdź rozwiązanie Angusa Crolla tutaj .

Wersja TL; DR znajduje się poniżej, ale artykuł stanowi świetną dyskusję na ten temat, dlatego powinieneś ją przeczytać, jeśli masz czas.

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

Oto moje leniwe podejście:

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

// ...

var test = [],
    wat = {};

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

Wiem, że świętokradztwo polega na „zepsuciu” prototypu, ale wydaje się, że działa znacznie lepiej niż zalecana toStringmetoda .

Uwaga: pułapką tego podejścia jest to, że nie zadziała ono ponad iframegranicami , ale w moim przypadku użycia nie stanowi to problemu.

Dobry przykład znajduje się w książce Stoyan Stefanov Patterns JavaScript Patterns, która ma obsługiwać wszystkie możliwe problemy, a także wykorzystywać metodę ECMAScript 5 Array.isArray () .

Oto on:

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

Nawiasem mówiąc, jeśli używasz jQuery, możesz użyć jego metody $ .isArray ()

najłatwiejszy i najszybszy sposób sprawdzenia, czy obiekt jest tablicą, czy nie.

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

lub

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

lub możesz zrobić funkcję narzędzia:

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

stosowanie:

isArray(arr); //return true

Poniższe informacje można zastosować, jeśli wiesz, że twój obiekt nie ma metody konkat.

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

Możesz użyć metody isArray, ale wolałbym to sprawdzić

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

Jeśli jedynymi dwoma rodzajami wartości, które można przekazać do tej funkcji, jest ciąg znaków lub tablica ciągów znaków, zachowaj prostotę i typeofsprawdź, czy istnieje ciąg znaków:

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

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

W poszukiwaniu najkrótszej wersji oto, co do tej pory mam.

Uwaga: nie ma idealnej funkcji, która zawsze wykryłaby wszystkie możliwe kombinacje. Lepiej poznać wszystkie umiejętności i ograniczenia swoich narzędzi, niż oczekiwać magicznego narzędzia.

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

Prosta funkcja do testowania, czy wartością wejściową jest tablica, jest następująca:

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

Działa to w różnych przeglądarkach i starszych przeglądarkach. Jest to pobierane z postu na blogu TJ Crowders

Możesz spróbować:

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

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

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

Ta funkcja zamieni prawie wszystko w tablicę:

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]"
}

Korzysta z niektórych nowszych funkcji przeglądarki, więc może być konieczne wypełnienie go polifillem w celu uzyskania maksymalnego wsparcia.

Przykłady:

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

Ciągi znaków NB zostaną przekonwertowane na tablicę z jednym elementem zamiast tablicy znaków. UsuńisString zaznaczenie, jeśli wolisz na odwrót.

Użyłem Array.isArraytutaj, ponieważ jest to najbardziej solidny, a także najprostszy.

W twoim przypadku możesz użyć concatmetody Array, która może akceptować pojedyncze obiekty, a także tablicę (a nawet kombinację):

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 wydaje się być jedną z najstarszych metod Array (nawet IE 5.5 dobrze o tym wie).