Próbuję napisać funkcję, która albo akceptuje listę ciągów lub pojedynczy ciąg. Jeśli jest to łańcuch, chcę przekonwertować go na tablicę z jednym przedmiotem, więc mogę się nad nim pętli bez obawy przed błędem.

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 - to Dobrze wspierany teraz i działa na ramkach.

2958
mpen 23 styczeń 2011, 21:53

29 odpowiedzi

Najlepsza odpowiedź

W nowoczesnych przeglądarkach możesz zrobić

Array.isArray(obj)

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

W przypadku kompatybilności wstecznej możesz dodać następujące informacje

# 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 wykryć tablic utworzonych w różnych ramkach, możesz również użyć instanceof

obj instanceof Array
1232
Huntro 20 październik 2020, 10:14

Ponieważ MDN mówi W tymczasie:

Użyj array.isarray lub object.prototype.tostring.call , aby rozróżnić regularne obiekty z tablic

Lubię to:

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

  • Array.isArray(arr)

17
ajax333221 14 wrzesień 2012, 21:02

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

var myArray=[];

if(myArray instanceof Array)
{
....
}
15
Ahmet DAL 15 styczeń 2013, 08:58

Wykonałbym funkcję do przetestowania rodzaju obiektu, które masz do czynienia z ...

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

Następnie możesz napisać proste, jeśli oświadczenie ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}
15
Al Foиce ѫ 17 sierpień 2016, 07:46

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

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)
13
rsbkk 4 kwiecień 2015, 06:58

To moja próba poprawy na Ta odpowiedź biorąc pod uwagę komentarze:

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

Pozbywa się if / inaczej i odpowiada za możliwość, że ma być null lub niezdefiniowany

12
Community 23 maj 2017, 12:34

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

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};
11
yckart 1 kwiecień 2013, 05:32

W twoim przypadku możesz użyć metody concat) Array, który może zaakceptować pojedyncze obiekty, a także tablicę (a nawet połączone):

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 tablicy (nawet IE 5.5 wie dobrze).

4
kolyaseg 15 wrzesień 2017, 09:41

Najpierw sprawdziłbym, czy twoja implementacja obsługuje isArray:

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

Możesz także spróbować użyć operatora instanceof

v instanceof Array
1294
ChaosPandion 23 styczeń 2011, 18:55

JQuery oferuje również $.isArray() Metoda:

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>
302
Al Foиce ѫ 17 sierpień 2016, 07:41

Jest to najszybsza wśród wszystkich metod (obsługa wszystkich przeglądarek):

function isArray(obj){
    return !!obj && obj.constructor === Array;
}
107
shinobi 19 luty 2017, 08:37

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

To nazwij to tak:

isArray(arr);

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

Array.isArray(arr);

JQuery:

$.isArray(arr);

Kątowy:

angular.isArray(arr);

Podnośnik i Lodash:

_.isArray(arr);
49
Alireza 21 sierpień 2019, 07:10

Array.isarray działa szybko, ale nie jest obsługiwana przez wszystkie wersje przeglądarek. Więc możesz dokonać wyjątku dla innych i użyć uniwersalnej metody:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }
34
CruorVult 18 luty 2013, 11:18

Prosta funkcja, aby sprawdzić to:

function isArray(object)
{
    return object.constructor === Array;
}
32
Remolten 27 styczeń 2020, 19:40

Jest tylko jedno rozwiązanie linii na to pytanie

x instanceof Array

Gdzie x jest zmienną zwróci true, jeśli x jest tablicą i fałsz, jeśli nie jest.

18
Vikash Kumar 8 czerwiec 2017, 12:48

Zaktualizowałem skrzypce JSPERF z dwiema metodami alternatywnymi, a także sprawdzanie błędów.

Okazuje się, że metoda określająca wartość stałą w prototypach "Obiekt" i "Array" jest szybsza niż jedna z pozostałych metod. Jest 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 podejmuje niezdefiniowaną wartość, ale działają, jeśli jesteś pewien, że mają wartość. Jeśli chodzi o sprawdzenie wydajności, jeśli wartość jest tablicą lub pojedynczą wartością, druga metoda wygląda jak ważna szybka metoda. Jest nieco szybszy niż "instanceof" na Chrome, dwa razy szybciej niż druga najlepsza metoda w programie Internet Explorer, Opera i Safari (na mojej maszynie).

11
le_top 1 sierpień 2015, 11:10

Wiem, że ludzie szukają jakiegoś surowego podejścia javaScript. Ale jeśli chcesz pomyśleć o tym, spójrz tutaj: http://underscorejs.org/#isarray

_.isArray(object) 

Zwraca true, jeśli obiekt jest tablicą.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true
10
Sridhar 28 wrzesień 2015, 13:27

Jeśli jedyne dwa rodzaje wartości, które można przekazać do tej funkcji, są ciągiem lub szereg ciągów, trzymaj go proste i użyj typeof Sprawdź możliwość łańcucha:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}
5
Tim Down 23 styczeń 2011, 19:51

Najlepszym rozwiązaniem, które widziałem, jest wymiana przeglądarki dla Typeof. Sprawdź rozwiązanie Angus Croll's Solution Oto.

TL; DR wersja jest poniżej, ale artykuł jest świetną dyskusją o tym, więc powinieneś przeczytać go, 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 */};
5
John Wundes 23 marzec 2012, 17:16

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 "bałagan z" prototypem, ale Wygląda na to, że działa znacznie lepsze niż zalecane {x0}} Metoda.

Uwaga: Pułapka tego podejścia jest to, że jest to, że Nie działa na granicach iframe, ale dla mojego przypadku użycia nie jest to problem.

5
namuol 6 grudzień 2013, 02:07

Jest ładny przykład w książce Stoyan Stefanova Wzory javascript, które mają sobie poradzić ze wszystkim Możliwe problemy, a także wykorzystanie metody ECMAScript 5 macierzy .Sarray ().

Więc oto jest:

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

Przy okazji, jeśli używasz jQuery, możesz użyć swojej metody $ .isarray () .

5
Salvador Dali 16 grudzień 2013, 22:27

Ta funkcja obróci 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]"
}

Wykorzystuje niektóre funkcje nowszej przeglądarki, dzięki czemu możesz chcieć, aby policjantować to maksymalne wsparcie.

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

N.B. Struny zostaną przekształcone w tablicę za pomocą jednego elementu zamiast tablicy znaków. Usuń isString Sprawdź, czy wolisz go na odwrót.

Użyłem tutaj Array.isArray, ponieważ jest to , a także najprostszy.

5
mpen 24 październik 2016, 16:01

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

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

Lub

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

Albo możesz wykonać funkcję użytkową:

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

Stosowanie:

isArray(arr); //return true
5
Sheelpriy 29 marzec 2017, 06:25

Poniżej można użyć, jeśli wiesz, że obiekt nie ma metody Concat.

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}
5
Jan Aagaard 26 kwiecień 2017, 07:00

Mógłbyś być metodą Isarray, ale wolałbym sprawdzić

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

5
STEEL 28 luty 2018, 17:21
A = [1,2,3]
console.log(A.map==[].map)

W wyszukiwaniu najkrótszej wersji tutaj jest to, co dogęło.

Uwaga, nie ma idealnej funkcji, która zawsze wykryje wszystkie możliwe kombinacje. Lepiej poznawać wszystkie umiejętności i ograniczenia swoich narzędzi niż oczekiwali magicznego narzędzia.

4
exebook 12 marzec 2013, 02:57
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))
4
RoboTamer 30 październik 2013, 09:56

Prosta funkcja testowania, jeśli wartość wejściowa jest tablicą, jest następujący:

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

Ta robsza przeglądarka i starsze przeglądarki. Jest to Wyciągnięty z T.J. Post na blogu Crowsers

4
Brad Parks 2 luty 2014, 00:29

Możesz spróbować tego:

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

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

obj.constructor.prototype.hasOwnProperty('push') // false
4
Michał Perłakowski 25 luty 2016, 15:54