obj - javascript typeof array




Controlla se l'oggetto è un array? (20)

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 .


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

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 è.


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)


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

So che è un sacrilegio "confondersi" con il prototipo, ma sembra funzionare in modo significativamente migliore rispetto al metodo toString raccomandato .

Nota: un trabocchetto di questo approccio è che non funzionerà sui confini iframe , ma per il mio caso di utilizzo questo non è un problema.


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

Immagina di avere questa matrice qui sotto:

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 chiamalo così:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Angolare:

angular.isArray(arr);

Underscore e Lodash:

_.isArray(arr);

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)

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

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

var myArray=[];

if(myArray instanceof 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");
}


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.


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

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

Se gli unici due tipi di valori che possono essere passati a questa funzione sono una stringa o un array di stringhe, mantienilo semplice e usa un controllo typeof per la possibilità della stringa:

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

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

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


Vorrei innanzitutto verificare se la tua implementazione supporta isArray :

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

Puoi anche provare a utilizzare l'operatore instanceof

v instanceof Array

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>


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)

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.





arrays