javascript - オブジェクトが配列であるかどうかを確認するにはどうすればよいですか？

Question

文字列のリストまたは単一の文字列を受け入れる関数を作成しようとしています。文字列の場合は、エラーを恐れずにループできるように、項目が1つだけの配列に変換したいと思います。

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

score 2007 · Accepted Answer

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

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

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

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

または、パフォーマンスを気にしない場合はconcat、新しい空のアレイに対して行うことができます。

someVar = [].concat(someVar);

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

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

以下の彼のコメントに投稿されているように、 TJクラウダーのブログから徹底的な治療をチェックしてください。

このベンチマークをチェックして、どちらの方法のパフォーマンスが優れているかを確認してください：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']

score 1461 · Accepted Answer

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

Array.isArray(obj)

（Chrome 5、Firefox 4.0、Internet Explorer 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)。Underscore.jsを使用する場合は、を使用できます_.isArray(obj)。

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

obj instanceof Array

score 1315 · Accepted Answer

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

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

instanceof演算子を使用することもできます

v instanceof Array

score 305 · Accepted Answer

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>

score 108 · Accepted Answer

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

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

score 50 · Accepted Answer

以下にこの配列があると想像してください：

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（Internet Explorer 9以降、Chrome 5以降、Firefox 4以降、Safari 5以降、Opera 10.5以降）

Array.isArray(arr);

jQuery：

$.isArray(arr);

Angular：

angular.isArray(arr);

Underscore.jsとLodash：

_.isArray(arr);

score 35 · Accepted Answer

Array.isArrayは高速に動作しますが、すべてのバージョンのブラウザーでサポートされているわけではありません。

したがって、他の人に例外を設けて、普遍的な方法を使用することができます。

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

score 32 · Accepted Answer

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

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

score 20 · Accepted Answer

MDNがここで言うように：

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

このような：

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

score 20 · Accepted Answer

この質問に対する解決策は1つだけです

x instanceof Array

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

score 18 · Accepted Answer

Array.isArray（）を使用できます。これがポリフィルです：

if (Array.isArray == null) {
  Array.isArray = (arr) => Object.prototype.toString.call(arr) === "[object Array]"
}

score 16 · Accepted Answer

扱っているオブジェクトの種類をテストする関数を作成します...

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
}

score 16 · Accepted Answer

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

var myArray=[];

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

score 14 · Accepted Answer

私はこれを非常に簡単な方法で行います。わたしにはできる。

Array.prototype.isArray = true;

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

score 13 · Accepted Answer

これは、コメントを考慮してこの回答を改善するための私の試みです。

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

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

score 12 · Accepted Answer

私は、人々が何らかの生のJavaScriptアプローチを探していることを知っています。しかし、それについてあまり考えたくない場合は、Underscore.jsの isArrayを見てください：

_.isArray(object)

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

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

score 12 · Accepted Answer

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倍の速度です。

score 11 · Accepted Answer

constructorベストプラクティスは、次のようなものを使用して比較することです。

if(some_variable.constructor === Array){
  // do something
}

文字列に変換してから比較するなど、他のメソッドを使用することもできますがtypeOf、dataTypeと比較する方が常に優れたアプローチです。

score 6 · Accepted Answer

私が見た中で最良の解決策は、typeofのクロスブラウザーの置き換えです。アンガス・クロルの解決策を確認してください。

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

score 5 · Accepted Answer

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

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

score 5 · Accepted Answer

これが私の怠惰なアプローチです：

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しないことですが、私のユースケースではこれは問題ではありません。

score 5 · Accepted Answer

Stoyan Stefanovの本JavaScriptパターンには、考えられるすべての問題を処理し、ECMAScript 5メソッドArray.isArray（）を使用することになっている良い例があります。

だからここにあります：

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

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

score 5 · Accepted Answer

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

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

score 5 · Accepted Answer

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

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

Array.isArrayここで使用したのは、最も堅牢で最も単純だからです。

score 5 · Accepted Answer

isArrayメソッドを使用することもできますが、次の点で確認したいと思います。

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

score 5 · Accepted Answer

var a = [], b = {};

console.log(a.constructor.name == "Array");
console.log(b.constructor.name == "Object");

score 4 · Accepted Answer

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

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

可能なすべての組み合わせを常に検出する完全な機能はないことに注意してください。魔法の道具を期待するよりも、道具のすべての能力と限界を知っている方が良いです。

score 4 · Accepted Answer

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

score 4 · Accepted Answer

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

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

これはクロスブラウザで、古いブラウザでも機能します。これはTJCrowdersのブログ投稿から抜粋したものです

score 4 · Accepted Answer

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

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

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

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

score 4 · Accepted Answer

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

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

また

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

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

const isArray = (obj) => !!obj && obj.constructor === Array;

使用法：

isArray(arr); // Returns true

score 4 · Accepted Answer

あなたの場合、配列だけでなく単一のオブジェクトも受け入れることができる配列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配列の最も古い方法の1つであるようです（IE 5.5でさえそれをよく知っています）。

score 4 · Accepted Answer

エキゾチックなもの

パラメータが文字列であるかどうかを確認したいので、試してみてください

x===x+''

let isStr = x=> x===x+'';

console.log( isStr([]) );
console.log( isStr(["aa","bb"]) );
console.log( isStr("") );
console.log( isStr("abc") );

score 3 · Accepted Answer

ありがたいことに、ECMAScript 5はArray.isArray()2009年12月に導入されました。何らかの理由で、ECMAScript 5より古いバージョンのJavaScriptを使用している場合は、アップグレードしてください。

ただし、それを主張する場合、配列には他のタイプと区別する特定のプロパティがあります。私が見たことがないプロパティは、他のどの回答にも言及されていません。JavaScriptの政治に取り掛かりましょう。

配列はオブジェクト（typeof [] === "object"）ですが、従来のオブジェクトとは異なり、長さプロパティ（typeof ( {} ).length === "undefined"）があります。nullもオブジェクト（）ですが、はオブジェクトではないためtypeof null === "object"、のプロパティにアクセスできません。nullnull

0これは仕様のバグであり、オブジェクトにtypeタグがありnull、リテラルnullポインターとして表されて0x00いたため、インタープリターがオブジェクトと混同していたJavaScriptの最初の部分にまでさかのぼります。

[]残念ながら、これは対を考慮していません{length:0}。したがって、プロトタイプチェーンに目を向ける必要があります。

( [] ).__proto__ === Array.prototype && ( [] ).__proto__ !== Object.prototype。

したがって、がなければArray.isArray()、これは私たちが得ることができるほぼ最も近いものです：

function is_array(array){
    return array !== null
        && typeof array === "object"
        && array.__proto__ === Array.prototype;
}

[ [], [1,2,3], {length: 0}, {},
  1, 0, Infinity, NaN, "1", "[1,2,3]",
  null, undefined, [null], [undefined], {a:[]},
  [{}], [{length: 0}], [Infinity], [NaN],
  {__proto__: Array.prototype}
].filter(is_array)
// Expected: [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN] ]
// Actual:   [ [], [1,2,3], [null], [undefined], [{}], [{length: 0}], [Infinity], [NaN], {__proto__: Array.prototype} ]

配列のように見えるように悪意を持って設計されたオブジェクトは、実際にチューリングテストに合格します。ただし、プロトタイプチェーンをアレイプロトタイプチェーンに置き換えるだけで、アレイのように機能し、効果的にアレイにすることができます。

そのようなオブジェクトが実際には配列ではないことを知ることができる世界で唯一のものは、ですArray.isArray()。しかし、オブジェクトが配列であるかどうかを通常チェックする目的のために、そのオブジェクトはコードでうまく機能するはずです。

配列の長さを人為的に変更した場合の動作も同じです。長さが配列内の要素の数よりも長い場合、その特別な「暗黙の未定義」タイプの「空のスロット」があります。未定義でありながら=== undefined; とまったく同じタイプです。これは、が明示的に定義されている場合にのみエラーをスローしないため、のスローtypeof obj !== "undefined"を回避するために使用する理由です。ReferenceErrorobj === undefinedobjundefined

a = {__proto__: Array.prototype}; // Array {}
a.push(5)
a // [5]
a.length = 5
a // [5, empty x 4]
b = a.map(n => n*n) // [25, empty x 4]
b.push(undefined)
b.push(undefined)
b // [25, empty x 4, undefined, undefined]
b[1] // undefined
b[1] === b[5] // true
Array.isArray(a) // false
Array.isArray(b) // true

ただし、使用しないでくださいis_array()。学習目的で車輪の再発明を行うことは1つのことです。本番コードでそれを行うのは別のことです。ポリフィルとしても使用しないでください。古いJavaScriptバージョンをサポートするということは、古いブラウザをサポートするということは、安全でないソフトウェアの使用を奨励するということは、ユーザーをマルウェアのリスクにさらすことを意味します。

score 3 · Accepted Answer

確かな答えはいくつかありますが、ファンクターを使用した機能的なアプローチをお勧めします。ファンクターは、関数を値に渡すことを言うための空想的な方法です。（私が見た提案は、関数に値を渡すことです。）

TypeOfヘルパーを作成する

const TypeOf = obj => Object.prototype.toString.call(obj).slice(8,-1);

これはtypeofに似ていますがArray、for[]とObjectforを返すようになりました{}。私はそれを厳密なタイプと考えるのが好きです。Gmailアプリケーションで作業していて、パフォーマンスが懸念される場合は、次のようにすることができます。

const TypeOf = obj => (
  Array.isArray(obj)
   ? "array"
    : obj === null // catch null edge case.  typeof null is an object :)
   ? null
    : typeof obj
)

ここで立ち止まって、1日と呼ぶことができます。ただし、コンポジションを使用すると、もう少し強力にすることができます。TypeBoxファンクターを作成すると、多くのメリットが得られます。これも、関数に値を渡すのではなく、関数を値に渡すためのファンシーな言葉です。

TypeBoxを作成する

const TypeBox = (predicate, defaultValue) => {
  const TypePredicate = value => ({
     value,
     map: cb => predicate(value)
                ? TypePredicate(cb(value))
                : TypePredicate(defaultValue)
  });
  return TypePredicate;
}

ここでは多くのことが起こっていますが、それは非常に強力です。TypeBox関数はクロージャを使用し、ファンクターを返します。クロージャーを使用すると、Lexical_Scopeにアクセスできます。後でアクセスしたいものを収納するバックパックと考えてください。

ArrayBoxを作成する

const ArrayBox = TypeOf(obj => TypeOf(obj) === 'Array' ? obj : [obj]);

ArrayBoxはとを渡してpredicateおりdefaultValue、TypeOf呼び出し/実行するときに使用可能になりますArrayBox（ユースケースに適した名前を付けてください）。

今楽しい部分

入力が配列の場合は、それを返します。

ArrayBox(["foo", "bar"]).value; // ['foo', 'bar']

入力が配列でない場合は、1つで返します

ArrayBox("foo").value // ["foo"]

このアプローチの優れている点は、スケーリングが可能で、テストが簡単で、構成を使用していることです。任意の方法で関数を作成して、目的の結果を得ることができます。

どちらかまたはモナドを使用してこれにアプローチできる方法は他にもたくさんあります。

score 2 · Accepted Answer

チェックする方法は他にもありますが、他のオブジェクトの種類を簡単にチェックできるので、次の方法をチェックするのが最善の方法です。

> a = [1, 2]
[ 1, 2 ]
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>
> Object.prototype.toString.call([]).slice(8,-1) // best approach
'Array'

説明（ノードREPLの簡単な例を使用）»

> o = {'ok': 1}
{ ok: 1 }
> a = [1, 2]
[ 1, 2 ]
> typeof o
'object'
> typeof a
'object'
>
> Object.prototype.toString.call(o)
'[object Object]'
> Object.prototype.toString.call(a)
'[object Array]'
>

オブジェクトまたは配列»

> Object.prototype.toString.call(o).slice(8,).replace(/\]$/, '')
'Object'
>
> Object.prototype.toString.call(a).slice(8,).replace(/\]$/, '')
'Array'
>

Nullまたは未定義»

> Object.prototype.toString.call(undefined).slice(8,).replace(/\]$/, '')
'Undefined'
> Object.prototype.toString.call(null).slice(8,).replace(/\]$/, '')
'Null'
>

弦 "

> Object.prototype.toString.call('ok').slice(8,).replace(/\]$/, '')
'String'

番号 "

> Object.prototype.toString.call(19).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.0).slice(8,).replace(/\]$/, '')
'Number'
> Object.prototype.toString.call(19.7).slice(8,).replace(/\]$/, '')
'Number'
>

@mpen次のように、正規表現の代わりに-1を使用することを提案していただきありがとうございます。

> Object.prototype.toString.call(12).slice(8,-1)
'Number'
>
> Object.prototype.toString.call(12.0).slice(8,-1)
'Number'
>
> Object.prototype.toString.call([]).slice(8,-1)
'Array'
> Object.prototype.toString.call({}).slice(8,-1)
'Object'
>
> Object.prototype.toString.call('').slice(8,-1)
'String'
>

score 2 · Accepted Answer

2

私は今、最短の答えを見つけました：

var x = [1,2,3]
console.log(x.map?1:0)

于 2019-04-23T13:01:20.567 に答える

score 1 · Accepted Answer

これが私が思いついた解決策であり、私のプロジェクトに使用しています...

function isArray (o) {
    return typeof o === "object" && o.length !== undefined;
}

isArray({}); // false
isArray(1); // false
isArray("str"); // false
isArray(function(){}); // false

isArray([]); // true

唯一の落とし穴は、オブジェクトに長さプロパティがある場合に誤検知が発生することです。

isArray({length:0}); // true

その欠点に問題がなく、純粋なオブジェクトにそのプロパティがないことがわかっている場合、これはクリーンなソリューションであり、Object.prototype.toString.callメソッドよりも高速である必要があります。

score 1 · Accepted Answer

使用する：

var is_array = function (value) {
   return value &&
     typeof value === 'object' &&
     typeof value.length === 'number' &&
     typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

この関数は「JavaScript：The Good Parts」の本から引用したもので、私にはぴったりです。

score 0 · Accepted Answer

Object.prototype-callsが好きではないので、別の解決策を探しました。特に、ChaosPandionのソリューションは常に機能するとは限らず、MidnightTortoise withのソリューションisArray()はDOMからの配列（getElementsByTagNameなど）では機能しないためです。そして最後に、簡単でクロスブラウザのソリューションを見つけました。これはおそらくNetscape4でも機能するでしょう。;）

これは、次の4行だけです（オブジェクトをチェックしますh）。

function isArray(h){
    if((h.length!=undefined&&h[0]!=undefined)||(h.length===0&&h[0]===undefined)){
        return true;
    }
    else{ return false; }
}

私はすでにこれらの配列をテストしました（すべてtrueを返します）：

1) array=d.getElementsByName('some_element'); //'some_element' can be a real or unreal element
2) array=[];
3) array=[10];
4) array=new Array();
5) array=new Array();
   array.push("whatever");

これはすべての場合に機能しますか？または、私のソリューションが機能しない場合がありますか？

score 0 · Accepted Answer

この関数を使用して、データ型を取得できます。

var myAr = [1,2];

checkType(myAr);

function checkType(data) {
  if(typeof data ==='object') {
    if(Object.prototype.toString.call(data).indexOf('Array') !== (-1)) {
      return 'array';
    } else {
      return 'object';
    }
  } else {
    return typeof data;
  }
}

if(checkType(myAr) === 'array') {
  console.log('yes, it is an array')
};

score 0 · Accepted Answer

あなたは以下のように見つけることができますpush：

function isArray(obj){
   return (typeof obj.push === 'function') ? true : false;
}

var array = new Array();

or

var array = ['a', 'b', 'c'];
console.log(isArray(array));

score 0 · Accepted Answer

プロトタイプとArray.isArrayのチェックアウトには違いがあります。

function isArray(obj){
    return Object.getPrototypeOf(obj) === Array.prototype
}

この関数は、objが配列であるかどうかを直接チェックします。

しかし、このプロキシオブジェクトの場合：

var arr = [1,2,3]

var proxy = new Proxy(arr,{})

console.log(Array.isArray(proxy)) // true

Array.isArray配列として受け取ります。

score 0 · Accepted Answer

これは、JavaScriptを学習する際に早い段階で知っておくべき配列の重要な事実を説明するコードスニペットです（私とは異なります）。

// this functions puts a string inside an array
var stringInsideArray = function(input) {
  if (typeof input === 'string') {
    return [input];
  }
  else if (Array.isArray(input)) {
    return input;
  }
  else {
    throw new Error("Input is not a string!");
  }
}

var output = stringInsideArray('hello');
console.log('step one output: ', output); // ["hello"]

// use typeof method to verify output is an object
console.log('step two output: ', typeof output); // object

// use Array.isArray() method to verify output is an array
console.log('step three output: ', Array.isArray(output)); // true

配列は、実際にはオブジェクトです。

typeof演算子を使用すると、の出力はそれが実際にオブジェクトであることをstringInsideArray('hello')証明します。配列はJavaScriptデータ型であると想定していたので、これは私を最も長い間困惑させました...["hello"]

JavaScriptデータ型は7つしかなく、配列はそのうちの1つではありません。

質問に答えるために、Array.isArray（）outputメソッドを使用すると、が配列であると判断されます。

score 0 · Accepted Answer

Array.isArrayこれについて行く方法です。例えば：

var arr = ['tuna', 'chicken', 'pb&j'];
var obj = {sandwich: 'tuna', chips: 'cape cod'};

// Returns true
Array.isArray(arr);

// Return false
Array.isArray(obj);

score 0 · Accepted Answer

まず、 console.log（typeof Object）を確認できます。

出力がオブジェクトの場合、var {data} = object、つまり、オブジェクトキーに従ってオブジェクトを分解します。

そして、関数は次のようになります。

const abc = (str1, str2=null) => {
    var result = [];
    result.push(str1);
    result.push(str2);
    return result.join("");
}

score 0 · Accepted Answer

//簡単な方法で

const arr = [1, 2, 3];
const obj = { message: 'nice' };
const str = 'nice';
const empty = null;

console.log(Array.isArray(arr));
console.log(Array.isArray(obj));
console.log(Array.isArray(str));
console.log(Array.isArray(empty));

score -1 · Accepted Answer

これが私が使用するものです：

function isArray(input) {
  if (input instanceof Array || Object.prototype.toString.call(input) === '[object Array]') {
        return true;
  } else return false;
}

score -1 · Accepted Answer

配列のlengthプロパティで確認することもできます。配列のlengthプロパティにアクセスしようとすると、数値（空の配列の場合は0）が返されますが、オブジェクトのlengthプロパティにアクセスしようとすると、undefinedが返されます。

if(Object.prototype.toString.call(arrayList) === '[object Array]') {
  console.log('Array!');
}

score -1 · Accepted Answer

Array.isArray（obj）は、非常に役立つ結果を提供しません。オブジェクトが配列であるかどうかを正しく判断するように見えるObjectのプロトタイプメソッドを作成しました。

失敗する場所を私が知っている唯一のエッジケースは、配列内の項目が未定義に設定されている場合です。

Object.prototype.isArrayLike = function()
{
    var length = this.length || Object.keys(this).length;
    if (length === 0 || this.constructor.name === "String")
        return false;
    for (i = 0; i < length; i++)
    {
        if (typeof this[i] === "undefined")
            return false;
    }
    return true;
};

var arr = ['aaa', 'bbb', 'ccc', 'ddd'];
var arr1 = {"0":'aaa', "1":'bbb', 2:'ccc', 3:'ddd'};
var arr2 = {"0":'aaa', "a":'bbb', 2:'ccc', 3:'ddd'};
var arr3 = "qwerty";
var arr4 = [];
var arr5 = {0:'aaa', 1:'bbb', 2:'ccc', 3:'ddd'};

console.log("arrayLike:" + arr.isArrayLike());
console.log("Array.isArray(arr):" + Array.isArray(arr));
// arrayLike: true
// Array.isArray(arr): true
console.log("arrayLike1:" + arr1.isArrayLike());
console.log("Array.isArray(arr1):" + Array.isArray(arr1));
// arrayLike1: true
// Array.isArray(arr1): false
console.log("arrayLike2:" + arr2.isArrayLike());
console.log("Array.isArray(arr2):" + Array.isArray(arr2));
// arrayLike2: false
// Array.isArray(arr2): false
console.log("arrayLike3:" + arr3.isArrayLike());
console.log("Array.isArray(arr3):" + Array.isArray(arr3));
// arrayLike3: false
// Array.isArray(arr3): false
console.log("arrayLike4:" + arr4.isArrayLike());
console.log("Array.isArray(arr4):" + Array.isArray(arr4));
// arrayLike4: false
// Array.isArray(arr4): true
console.log("arrayLike5:" + arr5.isArrayLike());
console.log("Array.isArray(arr5):" + Array.isArray(arr5));
// arrayLike5: false
// Array.isArray(arr5): true

score -4 · Accepted Answer

 var length = 16;                               // Number
 var lastName = "Johnson";                      // String
 var cars = ["Saab", "Volvo", "BMW"];           // Array
 var x = {firstName:"John", lastName:"Doe"};

 Object.prototype.myCheck= function(){
 if (this.constructor === Array){
          alert('array');
        }else if (this.constructor === Object)
       {
         alert('object');
        }else if (this.constructor === Number)
        {
          alert('number');
        }else if (this.constructor === String)
        {
          alert('string');
        }

 }
 cars.myCheck();
 lastName.myCheck();
 length.myCheck();

javascript - オブジェクトが配列であるかどうかを確認するにはどうすればよいですか？

51 に答える 51

エキゾチックなもの

Related

Reference