Come controllare se un oggetto è un array?

Question

Sto cercando di scrivere una funzione che o accetta una lista di stringhe, o di una singola stringa. Se si tratta di una stringa, allora voglio convertirlo in un array con solo una voce. Allora posso ciclo sopra senza il timore di un errore.

Quindi, come si controlla se la variabile è un array?

---

Ho arrotondato le varie soluzioni di sotto e ha creato una jsperf prova .

Answer 1

Nel browser moderni si può fare

Array.isArray(obj)

( supportate da Chrome 5, Firefox 4.0, IE 9, Opera 10.5 e Safari 5)

Per garantire la compatibilità è possibile aggiungere il seguente

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

Se si utilizza jQuery è possibile utilizzare jQuery.isArray(obj) o $.isArray(obj). Se si utilizza sottolineatura è possibile utilizzare _.isArray(obj)

Se non è necessario per rilevare gli array creati in diversi fotogrammi si può anche semplicemente usare instanceof

obj instanceof Array

Answer 2

Il metodo indicato nello standard ECMAScript per trovare la classe di oggetto è quello di utilizzare il metodo toString da Object.prototype.

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

In alternativa è possibile utilizzare typeof per verificare se si tratta di una stringa:

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

Se non sei preoccupato per le prestazioni, si può solo fare un concat per un nuovo array vuoto.

someVar = [].concat( someVar );

C'è anche il costruttore, che è possibile interrogare direttamente:

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

---

Scopri un approfondita trattamento da @TJ il blog di Crowder , come ha scritto nel suo commento qui sotto.

riferimento per avere un'idea che metodo esegue meglio: http://jsben.ch/#/QgYAV

@Bharath stringa convertito al array utilizzando ES6 per la domanda posta:

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

supporre:

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

Answer 3

Vorrei in primo luogo verificare se i vostri supporti di implementazione isArray:

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

Si potrebbe anche provare a utilizzare l'operatore instanceof

v instanceof Array

Answer 4

jQuery offre anche un $.isArray() metodo:

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>

Answer 5

Questo è il più veloce tra tutti i metodi (tutti i browser supportati):

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

Answer 6

Immaginate di avere questo array seguente :

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

Javascript (nuovi e vecchi browser):

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

o

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

o

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

quindi chiamare in questo modo:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Angolare:

angular.isArray(arr);

sottolineatura e Lodash:

_.isArray(arr);

Answer 7

Array.isArray funziona veloce, ma non è supportato da tutte le versioni di browser. Così si potrebbe fare un'eccezione per gli altri e utilizzare metodo universale:

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

Answer 8

funzione semplice per verificare questo:

function isArray(object)
{
    if (object.constructor === Array) return true;
    else return false;
}

Answer 9

Come MDN dice qui :

utilizzo Array.isArray o Object.prototype.toString.call per differenziare oggetti regolari da array

In questo modo:

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

• Array.isArray(arr)

Answer 10

C'è solo una soluzione di linea per questa domanda

x instanceof Array

dove x è la variabile esso ritorna vero se x è un array e false se non lo è.

Answer 11

È possibile controllare il tipo della variabile che si tratti di una matrice con;

var myArray=[];

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

Answer 12

I farebbe una funzione per verificare il tipo di oggetto che si tratta di ...

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

allora si può scrivere una semplice istruzione if ...

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

Answer 13

I farlo in un modo molto semplice. Per me va bene. Eventuali inconvenienti?

Array.prototype.isArray = true;

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

Answer 14

Questo è il mio tentativo di migliorare il questa risposta tenendo conto delle osservazioni:

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

E si libera del if / else, e rappresenta la possibilità di matrice essere null o undefined

Answer 15

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

Answer 16

Ho aggiornato il jsperf violino con due metodi alternativi, così come il controllo degli errori.

Si scopre che il metodo che definisce un valore costante nel 'Oggetto' e prototipi 'allineamento' è più veloce di qualsiasi degli altri metodi. E 'un risultato un po' sorprendente.

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

Questi due metodi non funzionano se la variabile assume il valore indefinito, ma lo fanno di lavoro se si è certi che essi hanno un valore. Per quanto riguarda il controllo con prestazioni in mente se un valore è una matrice o un singolo valore, la seconda riguarda metodo come un metodo rapido valido. E 'leggermente più veloce di 'instanceof' su Chrome, due volte più veloce del secondo miglior metodo di Internet Explorer, Opera e Safari (sulla mia macchina).

Answer 17

Lo so, che le persone sono alla ricerca di un qualche tipo di approccio javascript crudo. Ma se si vuole pensare di meno, date un'occhiata qui: http://underscorejs.org/#isArray

_.isArray(object) 

Restituisce vero se l'oggetto è un array.

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

Answer 18

La soluzione migliore che ho visto è una sostituzione cross-browser per typeof. Controllare la soluzione di Angus Croll qui .

Il TL;. Versione DR è al di sotto, ma l'articolo è una grande discussione del problema così si dovrebbe leggerlo se avete tempo

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

Answer 19

Ecco il mio approccio pigro:

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

// ...

var test = [],
    wat = {};

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

Lo so che è un sacrilegio "pasticciare con" il prototipo, ma sembra svolgere significativamente migliore rispetto al metodo consigliato toString .

Nota: Un errore di questo approccio è che esso abituato lavoro attraverso i confini iframe , ma per il mio caso d'uso questo non è un problema.

Answer 20

C'è un bel esempio nel libro di Stoyan Stefanov Patterns JavaScript che supponiamo per gestire tutti i possibili problemi così come utilizzare ECMAScript 5 metodo Array.isArray () .

Così qui è:

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

A proposito, se si sta utilizzando jQuery, lo si può utilizzare del metodo $ .isArray ()

Answer 21

più semplice e veloce per controllare se un oggetto è un array o meno.

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

o

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

o si può fare una funzione di utilità:

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

utilizzo:

isArray(arr); //return true

Answer 22

Il seguente potrebbe essere utilizzato se si sa che l'oggetto non dispone di un metodo concat.

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

Answer 23

Si potrebbe è il metodo IsArray ma preferirei di controllare con il

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

Answer 24

Se le uniche due tipi di valori che potrebbero essere passati a questa funzione sono una stringa o un array di stringhe, mantenerlo semplice e utilizzare un controllo typeof la possibilità stringa:

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

Answer 25

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

Nella ricerca per la versione più corta qui è quello che ho ottenuto finora.

Nota, non esiste una funzione ideale che sarà sempre di rilevare tutte le possibili combinazioni. E 'meglio sapere tutte le abilità e le limitazioni dei vostri strumenti di aspettarsi uno strumento magico.

Answer 26

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

Answer 27

Una semplice funzione che verifica se un valore di ingresso è un array è il seguente:

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

Questo funziona cross browser, e con i vecchi browser. Questo è href="http://blog.niftysnippets.org/2010/09/say-what.html" tirato da T.J. Crowders' post sul blog

Answer 28

Si può provare questo:

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

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

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

Answer 29

Questa funzione si trasformerà quasi tutto in un 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]"
}

Si utilizza alcuni browser più recente dispone quindi si consiglia di polyfill questo per il massimo sostegno.

Esempi:

> 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. stringhe vengono convertiti in un array con un unico elemento invece che una matrice di caratteri. Eliminare il controllo isString se si preferisce che il contrario.

Ho usato Array.isArray qui perché è il più robusto e anche più semplice .

Answer 30

Nel tuo caso è possibile utilizzare il metodo di concat Array che può accettare oggetti singoli e array (anche in associazione):

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 sembra essere uno dei più antichi metodi di Array (anche IE 5.5 lo sa bene).