วิธีการตรวจสอบว่าวัตถุเป็นอาร์เรย์?

ฉันพยายามเขียนฟังก์ชั่นที่ยอมรับรายการสตริงหรือสตริงเดียว ถ้าเป็นสตริงฉันก็อยากแปลงมันเป็นอาเรย์ที่มีเพียงหนึ่งไอเท็มดังนั้นฉันสามารถวนซ้ำมันได้โดยไม่ต้องกลัวว่าจะเกิดข้อผิดพลาด

ดังนั้นฉันจะตรวจสอบว่าตัวแปรเป็นอาร์เรย์ได้อย่างไร

ผมเคยปัดเศษขึ้นการแก้ปัญหาต่าง ๆ ดังต่อไปนี้และสร้างการทดสอบ 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

วิธีการที่กำหนดในมาตรฐาน ECMAScript เพื่อหาระดับของวัตถุคือการใช้วิธีการจากtoStringObject.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 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);

ขีดล่างและ Lodash:

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

มีวิธีแก้ปัญหาหนึ่งบรรทัดสำหรับคำถามนี้

x instanceof Array

โดยที่ x คือตัวแปรมันจะคืนค่าจริงถ้า x เป็นอาร์เรย์และเท็จถ้าไม่ใช่

คุณสามารถตรวจสอบประเภทของตัวแปรของคุณไม่ว่าจะเป็นอาเรย์ด้วย

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(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 และบัญชีสำหรับความเป็นไปได้ของอาร์เรย์ที่เป็นโมฆะหรือไม่ได้กำหนด

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 แล้วด้วยวิธีการสองทางเลือกรวมถึงการตรวจสอบข้อผิดพลาด

ปรากฎว่าวิธีการกำหนดค่าคงที่ในต้นแบบ '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/>");

วิธีการทั้งสองนี้ใช้ไม่ได้หากตัวแปรใช้ค่าที่ไม่ได้กำหนด แต่จะทำงานหากคุณมั่นใจว่าพวกเขามีค่า สำหรับการตรวจสอบโดยคำนึงถึงประสิทธิภาพว่าค่าเป็นอาร์เรย์หรือค่าเดียววิธีที่สองจะดูเหมือนวิธีรวดเร็วที่ถูกต้อง มันเร็วกว่า 'instanceof' บน Chrome เล็กน้อยเร็วเป็นสองเท่าของวิธีที่ดีที่สุดอันดับสองใน Internet Explorer, Opera และ Safari (บนเครื่องของฉัน)

ฉันรู้ว่าคนกำลังมองหาวิธีการจาวาสคริปต์ดิบบางชนิด แต่ถ้าคุณต้องการคิดให้น้อยลงลองดูที่นี่: http://underscorejs.org/#isArray

_.isArray(object) 

ผลตอบแทนจริงถ้าวัตถุเป็นแบบอาร์เรย์

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

ทางออกที่ดีที่สุดที่ฉันเคยเห็นคือการแทนที่ข้ามเบราว์เซอร์สำหรับประเภทของ ตรวจสอบวิธีการแก้ปัญหาของ 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ขอบเขตได้ แต่สำหรับกรณีการใช้งานของฉันนี่ไม่ใช่ปัญหา

มีตัวอย่างที่ดีในรูปแบบ JavaScriptของหนังสือ Stoyan Stefanov ซึ่งคาดว่าจะจัดการกับปัญหาที่เป็นไปได้ทั้งหมดรวมถึงใช้วิธี ECMAScript 5 Array.isArray ()()

ดังนั้นนี่คือ:

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

โดยวิธีการถ้าคุณใช้ jQuery คุณสามารถใช้มันเป็นวิธี$ .isArray ()

วิธีที่ง่ายที่สุดและเร็วที่สุดในการตรวจสอบว่า Object เป็น Array หรือไม่

 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

คุณสามารถใช้วิธีการต่อไปนี้หากคุณรู้ว่าวัตถุของคุณไม่มีวิธีการเชื่อมต่อ

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

คุณสามารถเป็นวิธี isArray แต่ฉันต้องการตรวจสอบด้วย

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

หากมีเพียงสองประเภทของค่าที่สามารถส่งผ่านไปยังฟังก์ชันนี้เป็นสตริงหรืออาร์เรย์ของสตริงให้ใช้งานง่ายและใช้การ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 (แม้แต่ IE 5.5 ก็รู้ดี)