Làm thế nào để kiểm tra nếu một đối tượng là một mảng?

Tôi đang cố gắng viết một hàm chấp nhận danh sách các chuỗi hoặc một chuỗi. Nếu đó là một chuỗi, thì tôi muốn chuyển đổi nó thành một mảng chỉ với một mục, vì vậy tôi có thể lặp qua chuỗi mà không sợ lỗi.

Vì vậy, làm thế nào để tôi kiểm tra nếu biến là một mảng?

Tôi đã làm tròn các giải pháp khác nhau bên dưới và tạo ra một bài kiểm tra jsperf . Tất cả đều nhanh, vì vậy chỉ cần sử dụng Array.isArray- hiện được hỗ trợ tốt và hoạt động trên các khung .

Trong các trình duyệt hiện đại, bạn có thể làm

Array.isArray(obj)

( Được hỗ trợ bởi Chrome 5, Firefox 4.0, IE 9, Opera 10.5 và Safari 5)

Để tương thích ngược, bạn có thể thêm vào như sau

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

Nếu bạn sử dụng jQuery, bạn có thể sử dụng jQuery.isArray(obj)hoặc $.isArray(obj). Nếu bạn sử dụng dấu gạch dưới, bạn có thể sử dụng_.isArray(obj)

Nếu bạn không cần phải phát hiện các mảng được tạo trong các khung khác nhau, bạn cũng có thể chỉ cần sử dụng instanceof

obj instanceof Array

Phương thức được đưa ra trong tiêu chuẩn ECMAScript để tìm lớp Object là sử dụng toStringphương thức từ đó Object.prototype.

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

Hoặc bạn có thể sử dụng typeofđể kiểm tra nếu đó là Chuỗi:

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

Hoặc nếu bạn không quan tâm đến hiệu suất, bạn có thể thực hiện một concatmảng trống mới.

someVar = [].concat( someVar );

Ngoài ra còn có hàm tạo mà bạn có thể truy vấn trực tiếp:

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

Kiểm tra một điều trị triệt để từ blog của @TJ Crowder , như được đăng trong bình luận của anh ấy bên dưới.

Kiểm tra điểm chuẩn này để có ý tưởng phương pháp nào hoạt động tốt hơn: http://jsben.ch/#/QgYAV

Từ @Bharath chuyển đổi chuỗi thành mảng bằng Es6 cho câu hỏi được hỏi:

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

giả sử:

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

Trước tiên tôi sẽ kiểm tra xem việc triển khai của bạn có hỗ trợ không isArray:

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

Bạn cũng có thể thử sử dụng instanceoftoán tử

v instanceof Array

jQuery cũng cung cấp một $.isArray()phương thức:

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>

Đây là cách nhanh nhất trong số tất cả các phương thức (tất cả các trình duyệt được hỗ trợ):

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

Hãy tưởng tượng bạn có mảng này bên dưới :

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

Javascript (trình duyệt mới và cũ hơn):

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

hoặc là

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

hoặc là

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

sau đó gọi nó như thế này:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Góc cạnh:

angular.isArray(arr);

Gạch dưới và gạch ngang:

_.isArray(arr);

Array.isArray hoạt động nhanh, nhưng nó không được hỗ trợ bởi tất cả các phiên bản trình duyệt. Vì vậy, bạn có thể tạo một ngoại lệ cho người khác và sử dụng phương pháp phổ quát:

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

Chức năng đơn giản để kiểm tra điều này:

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

Như MDN nói ở đây :

sử dụng Array.isArray hoặc Object.prototype.toString.call để phân biệt các đối tượng thông thường với các mảng

Như thế này:

• Object.prototype.toString.call(arr) === '[object Array]', hoặc là

• Array.isArray(arr)

Chỉ có một giải pháp cho câu hỏi này

x instanceof Array

Trong đó x là biến nó sẽ trả về true nếu x là mảng và false nếu không.

Bạn có thể kiểm tra loại biến của mình xem nó có phải là mảng không;

var myArray=[];

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

Tôi sẽ tạo một hàm để kiểm tra loại đối tượng bạn đang xử lý ...

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

sau đó bạn có thể viết một câu lệnh if đơn giản ...

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

Tôi làm điều này một cách rất đơn giản. Làm việc cho tôi. Bất kỳ nhược điểm?

Array.prototype.isArray = true;

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

Đây là nỗ lực của tôi để cải thiện câu trả lời này có tính đến các ý kiến:

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

Nó được loại bỏ if / other và tính đến khả năng của mảng là null hoặc không xác định

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

Tôi đã cập nhật fiddle jsperf với hai phương pháp thay thế cũng như kiểm tra lỗi.

Nó chỉ ra rằng phương thức xác định một giá trị không đổi trong các nguyên mẫu 'Đối tượng' và 'Mảng' nhanh hơn bất kỳ phương thức nào khác. Đó là một kết quả hơi ngạc nhiên.

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

Hai phương thức này không hoạt động nếu biến lấy giá trị không xác định, nhưng chúng hoạt động nếu bạn chắc chắn rằng chúng có giá trị. Liên quan đến việc kiểm tra hiệu năng trong đầu nếu một giá trị là một mảng hoặc một giá trị duy nhất, phương thức thứ hai trông giống như một phương thức nhanh hợp lệ. Nó nhanh hơn một chút so với 'thể hiện' trên Chrome, nhanh gấp đôi so với phương pháp tốt thứ hai trong Internet Explorer, Opera và Safari (trên máy của tôi).

Tôi biết rằng mọi người đang tìm kiếm một cách tiếp cận javascript thô. Nhưng nếu bạn muốn suy nghĩ ít hơn, hãy xem tại đây: http://underscorejs.org/#isArray

_.isArray(object) 

Trả về true nếu đối tượng là một mảng.

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

Giải pháp tốt nhất tôi từng thấy là thay thế trình duyệt chéo cho typeof. Kiểm tra giải pháp của Angus Croll tại đây .

Phiên bản TL; DR bên dưới, nhưng bài viết là một cuộc thảo luận tuyệt vời về vấn đề này vì vậy bạn nên đọc nó nếu bạn có thời gian.

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

Đây là cách tiếp cận lười biếng của tôi:

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

// ...

var test = [],
    wat = {};

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

Tôi biết đó là đặc quyền để "gây rối" với nguyên mẫu, nhưng nó dường như hoạt động tốt hơn đáng kể so với toStringphương pháp được đề xuất .

Lưu ý: Một điều đáng tiếc của phương pháp này là nó không hoạt động xuyên qua các iframeranh giới , nhưng đối với trường hợp sử dụng của tôi thì đây không phải là vấn đề.

Có một ví dụ hay trong cuốn sách Các mẫu JavaScript của Stoyan Stefanov , giả sử để xử lý tất cả các vấn đề có thể xảy ra cũng như sử dụng phương thức ECMAScript 5 Array.isArray () .

Vì vậy, đây là:

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

Nhân tiện, nếu bạn đang sử dụng jQuery, bạn có thể sử dụng phương thức $ .isArray ()

Cách dễ nhất và nhanh nhất để kiểm tra xem Object có phải là Mảng hay không.

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

hoặc là

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

hoặc bạn có thể tạo một chức năng tiện ích:

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

sử dụng:

isArray(arr); //return true

Những điều sau đây có thể được sử dụng nếu bạn biết rằng đối tượng của bạn không có phương thức concat.

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

Bạn có thể là phương thức isArray nhưng tôi muốn kiểm tra với

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

Nếu hai loại giá trị duy nhất có thể được truyền cho hàm này là một chuỗi hoặc một chuỗi các chuỗi, hãy giữ cho nó đơn giản và sử dụng typeofkiểm tra khả năng của chuỗi:

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

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

Trong tìm kiếm phiên bản ngắn nhất ở đây là những gì tôi đã nhận được cho đến nay.

Lưu ý, không có chức năng hoàn hảo sẽ luôn phát hiện tất cả các kết hợp có thể. Tốt hơn là nên biết tất cả các khả năng và giới hạn của các công cụ của bạn hơn là mong đợi một công cụ ma thuật.

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

Một hàm đơn giản để kiểm tra nếu một giá trị đầu vào là một mảng như sau:

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

Điều này hoạt động trên trình duyệt chéo, và với các trình duyệt cũ hơn. Điều này được lấy từ bài đăng trên blog của TJ Crowder

Bạn có thể thử điều này:

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

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

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

Hàm này sẽ biến hầu hết mọi thứ thành một mảng:

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

Nó sử dụng một số tính năng mới hơn của trình duyệt, do đó bạn có thể muốn điền vào phần này để được hỗ trợ tối đa.

Ví dụ:

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

Các chuỗi NB sẽ được chuyển đổi thành một mảng với một phần tử duy nhất thay vì một mảng ký tự. XóaisString kiểm tra nếu bạn muốn nó theo cách khác.

Tôi đã sử dụng Array.isArrayở đây vì nó mạnh mẽ nhất và cũng đơn giản nhất.

Trong trường hợp của bạn, bạn có thể sử dụng concatphương thức Array có thể chấp nhận các đối tượng đơn lẻ cũng như mảng (và thậm chí kết hợp):

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 dường như là một trong những phương thức lâu đời nhất của Array (ngay cả IE 5.5 cũng biết rõ về nó).