javascript obj Controlla se l'oggetto è un array?




javascript typeof array (24)

Sto cercando di scrivere una funzione che accetta o un elenco di stringhe o una singola stringa. Se si tratta di una stringa, quindi voglio convertirlo in un array con solo un elemento. Quindi posso passarci sopra senza paura di un errore.

Quindi, come posso controllare se la variabile è un array?

Ho arrotondato le varie soluzioni di seguito e ho creato un test jsperf .


So che le persone stanno cercando un qualche tipo di approccio javascript crudo. Ma se vuoi riflettere meno, dai un'occhiata qui: http://underscorejs.org/#isArray

_.isArray(object) 

Restituisce true se object è una matrice.

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

Ho aggiornato il jsperf fiddle con due metodi alternativi e il controllo degli errori.

Risulta che il metodo che definisce un valore costante nei prototipi 'Object' e 'Array' è più veloce di qualsiasi altro metodo. È un risultato piuttosto 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 non definito, ma funzionano se si è certi che hanno un valore. Per quanto riguarda il controllo delle prestazioni, se un valore è un array o un singolo valore, il secondo metodo sembra un metodo veloce valido. È leggermente più veloce di "instanceof" su Chrome, due volte più veloce del secondo metodo migliore in Internet Explorer, Opera e Safari (sulla mia macchina).


Vorrei fare una funzione per testare il tipo di oggetto con cui hai a che fare ...

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 puoi scrivere una semplice dichiarazione if ...

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

jQuery offre anche un metodo $.isArray() :

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>


Lo faccio in un modo molto semplice. Per me va bene. Qualche inconveniente?

Array.prototype.isArray = true;

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

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

Utilizza alcune funzionalità del browser più recenti, quindi è consigliabile eseguire il polyfill per ottenere il massimo supporto.

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

Le stringhe NB verranno convertite in una matrice con un singolo elemento invece di una matrice di caratteri. Elimina il controllo isString se preferisci il contrario.

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


Il metodo fornito nello standard ECMAScript per trovare la classe di Object consiste nell'utilizzare il metodo toString da Object.prototype .

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

Oppure puoi usare typeof per testare se è una stringa:

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

Oppure, se non ti preoccupi delle prestazioni, puoi semplicemente concat una nuova matrice vuota.

someVar = [].concat( someVar );

C'è anche il costruttore che puoi interrogare direttamente:

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

Scopri un trattamento completo dal blog di @TJ Crowder , pubblicato nel suo commento qui sotto.

Dai un'occhiata a questo jsben.ch/#/QgYAV di jsben.ch/#/QgYAV per avere un'idea del metodo migliore: jsben.ch/#/QgYAV

Da @Bharath converti stringa in array usando Es6 per la domanda posta:

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

supponiamo:

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

Array.isArray

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

Quanto segue potrebbe essere usato se sai che il tuo oggetto non ha un metodo concat.

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


modo più semplice e veloce per verificare se un oggetto è una matrice o no.

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

o

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

oppure puoi fare una funzione di utilità:

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

utilizzo:

isArray(arr); //return true

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

Nella ricerca della versione più breve ecco quello che ho ottenuto finora.

Nota, non esiste una funzione perfetta che rilevi sempre tutte le possibili combinazioni. È meglio conoscere tutte le abilità e le limitazioni dei tuoi strumenti piuttosto che aspettarti uno strumento magico.


Array.isArray funziona velocemente, ma non è supportato da tutte le versioni dei browser. Quindi potresti fare un'eccezione per gli altri e usare il metodo universale:

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

Semplice funzione per verificare questo:

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

Nei browser moderni puoi farlo

Array.isArray(obj)

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

Per compatibilità con le versioni precedenti è possibile aggiungere quanto segue

# 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 usi jQuery puoi usare jQuery.isArray(obj) o $.isArray(obj) . Se usi il carattere di sottolineatura puoi usare _.isArray(obj)

Se non hai bisogno di rilevare array creati in frame diversi puoi anche solo usare instanceof

obj instanceof Array

C'è solo una soluzione per questa domanda

x instanceof Array

dove x è la variabile restituirà true se x è una matrice e false se non lo è.


Potresti usare il metodo isArray ma preferirei controllare con

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


C'è un bell'esempio nel libro JavaScript Pattern di Stoyan Stefanov che suppone di gestire tutti i possibili problemi e di utilizzare il metodo ECMAScript 5 Array.isArray () .

Quindi eccolo qui:

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

A proposito, se stai usando jQuery, puoi usare il suo metodo $.isArray()


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

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

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

Puoi controllare il tipo di variabile se è un array con;

var myArray=[];

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

Puoi 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

Come dice MDN qui :

utilizzare Array.isArray o Object.prototype.toString.call per differenziare oggetti regolari dagli array

Come questo:

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

  • Array.isArray(arr)


Una semplice funzione per verificare se un valore di input è una matrice è la seguente:

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

Funziona su browser multiplo e con browser più vecchi. Questo viene estratto dal post del blog di TJ Crowders


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

La versione TL; DR è sotto, ma l'articolo è una grande discussione sul problema quindi dovresti leggerlo se hai 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 */};




arrays