オブジェクトが配列かどうかを確認する方法は？

文字列のリストまたは単一の文字列を受け入れる関数を記述しようとしています。文字列の場合は、1つのアイテムだけを含む配列に変換したいので、エラーを心配することなくループできます。

では、変数が配列かどうかを確認するにはどうすればよいですか？

以下のさまざまなソリューションを切り上げて、jsperfテストを作成しました。彼らはこれだけ使い、すべての高速だArray.isArray-それはだ、よく支えになりましたし、フレームにまたがって動作します。

最近のブラウザでは、次のことができます

Array.isArray(obj)

（Chrome 5、Firefox 4.0、IE 9、Opera 10.5、Safari 5でサポート）

下位互換性のために、以下を追加できます

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

jQueryを使用する場合は、jQuery.isArray(obj)またはを使用できます$.isArray(obj)。アンダースコアを使用する場合、使用できます_.isArray(obj)

異なるフレームで作成された配列を検出する必要がない場合は、単に使用することもできます instanceof

obj instanceof Array

Objectのクラスを見つけるためにECMAScript標準で指定されているtoStringメソッドは、fromメソッドを使用することですObject.prototype。

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

またはtypeof、それが文字列かどうかをテストするために使用できます。

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

または、パフォーマンスを気にしない場合はconcat、新しい空の配列に対してaを実行できます。

someVar = [].concat( someVar );

直接クエリできるコンストラクタもあります。

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

以下のコメントに投稿されているように、@ TJ Crowderのブログから完全な扱いを確認してください。

このベンチマークをチェックして、どちらの方法がより優れたパフォーマンスを発揮するかを確認してください：http : //jsben.ch/#/QgYAV

@Bharathから、質問にEs6を使用して文字列を配列に変換します。

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

と仮定します：

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

まず、実装が以下をサポートしているかどうかを確認しますisArray。

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

instanceof演算子を使用して試すこともできます

v instanceof Array

jQueryも$.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>

これは、すべての方法の中で最速です（すべてのブラウザーがサポートされています）。

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

あなたは、この持っている想像して、以下の配列を：

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

Javascript（新旧のブラウザ）：

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

または

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

または

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

次に、次のように呼び出します。

isArray(arr);

Javascript（IE9 +、Ch5 +、FF4 +、Saf5 +、Opera10.5 +）

Array.isArray(arr);

jQuery：

$.isArray(arr);

角度：

angular.isArray(arr);

アンダースコアとロダッシュ：

_.isArray(arr);

Array.isArrayは高速に動作しますが、ブラウザのすべてのバージョンでサポートされているわけではありません。だからあなたは他の人のために例外を作り、普遍的な方法を使うことができます：

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

これをチェックする簡単な関数：

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

MDN がここで言うように：

Array.isArrayまたはObject.prototype.toString.callを使用して、通常のオブジェクトと配列を区別します

このような：

• Object.prototype.toString.call(arr) === '[object Array]'、または

• Array.isArray(arr)

この質問には1行のソリューションしかありません

x instanceof Array

ここで、xは変数です。xが配列の場合はtrueを返し、そうでない場合はfalseを返します。

変数の型が配列かどうかを確認できます。

var myArray=[];

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

私はあなたが扱っているオブジェクトのタイプをテストする関数を作ります...

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

次に、単純なifステートメントを記述できます...

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

これは非常に簡単な方法で行います。私のために働く。欠点はありますか？

Array.prototype.isArray = true;

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

これはコメントを考慮してこの回答を改善しようとする私の試みです：

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

それはif / elseを取り除き、配列がnullまたは未定義である可能性を説明します

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

jsperfフィドルを2つの代替方法とエラーチェックで更新しました。

'Object'および 'Array'プロトタイプで定数値を定義するメソッドは、他のどのメソッドよりも高速であることがわかります。それはやや驚くべき結果です。

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

これらの2つの方法は、変数が未定義の値をとる場合は機能しませんが、値が確実にある場合は機能します。値が配列であるか単一の値であるかをパフォーマンスを考慮して確認することに関して、2番目の方法は有効な高速メソッドのように見えます。Chromeの「instanceof」よりわずかに高速で、Internet Explorer、Opera、Safari（私のマシン）で2番目に優れた方法の2倍の速さです。

私は、人々が何らかの生のJavaScriptアプローチを探していることを知っています。しかし、もっと考えたくない場合は、こちらをご覧ください：http : //underscorejs.org/#isArray

_.isArray(object) 

オブジェクトが配列の場合はtrueを返します。

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

私が見た中で最高の解決策は、typeofのクロスブラウザーの置き換えです。Angus Crollのソリューションをここで確認してください。

TL; DRのバージョンは下にありますが、この記事はこの問題についての素晴らしい議論なので、時間があれば読んでください。

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

ここに私の怠惰なアプローチがあります：

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

// ...

var test = [],
    wat = {};

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

プロトタイプを「いじる」のは犠牲になることは承知していますが、推奨されるtoString方法よりもパフォーマンスが大幅に優れているようです。

注：このアプローチの落とし穴は、境界を越えiframeて機能しないことですが、私のユースケースではこれは問題ではありません。

Stoyan Stefanovの著書JavaScript Patternsには、考えられるすべての問題を処理し、ECMAScript 5のメソッドArray.isArray（）を利用することを想定した素晴らしい例があります。

だからここにあります：

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

ちなみに、jQueryを使用している場合は、メソッド$ .isArray（）を使用できます。

オブジェクトが配列かどうかを確認する最も簡単で最速の方法。

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

または

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

または、ユーティリティ関数を作成できます。

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

使用法：

isArray(arr); //return true

オブジェクトにconcatメソッドがないことがわかっている場合は、以下を使用できます。

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

あなたはisArrayメソッドであるかもしれませんが、私はチェックしたいと思います

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

この関数に渡される可能性のある2種類の値が文字列または文字列の配列のみである場合は、単純にしtypeofて、文字列の可能性のチェックを使用します。

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

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

ここで最短バージョンを探して、これが私が今までに得たものです。

常にすべての可能な組み合わせを検出する完璧な機能はありません。魔法のツールを期待するよりも、ツールのすべての能力と制限を知っている方が良いです。

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

入力値が配列かどうかをテストする簡単な関数は次のとおりです。

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

これはクロスブラウザーで動作し、古いブラウザーでも動作します。これはTJ Crowdersのブログ投稿から抜粋

あなたはこれを試すことができます：

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

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

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

この関数は、ほとんどすべてを配列に変換します。

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

いくつかの新しいブラウザー機能を使用しているため、最大限にサポートするためにこれをポリフィルすることができます。

例：

> 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文字列は、文字の配列ではなく、単一の要素を持つ配列に変換されます。isString逆にしたい場合は、チェックを削除します。

これはArray.isArray、最も堅牢で最も単純であるため、ここで使用しました。

あなたの場合、配列だけでなく単一のオブジェクトも受け入れることができる配列のconcatメソッドを使うことができます：

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 Arrayの最も古いメソッドの1つであるようです（IE 5.5でもそれをよく知っています）。