--- title: Array slug: Web/JavaScript/Reference/Global_Objects/Array tags: - Array - JavaScript translation_of: Web/JavaScript/Reference/Global_Objects/Array ---
{{JSRef}}

Đối tượng Array trong JavaScript là đối tượng toàn cục được dùng để xây dựng nên các mảng; là những đối tượng cấp cao và giống một dạng danh sách.

Tạo một Mảng

var fruits = ['Apple', 'Banana'];

console.log(fruits.length);
// 2

Truy cập (bằng chỉ mục) đến một phần tử của Mảng

var first = fruits[0];
// Apple

var last = fruits[fruits.length - 1];
// Banana

Lặp qua một Mảng

fruits.forEach(function(item, index, array) {
  console.log(item, index);
});
// Apple 0
// Banana 1

Thêm phần tử vào cuối Mảng

var newLength = fruits.push('Orange');
// ["Apple", "Banana", "Orange"]

Xóa phần tử từ cuối Mảng

var last = fruits.pop(); // xoá bỏ Orange (từ vị trí cuối)
// ["Apple", "Banana"];

Xóa phần tử từ đầu Mảng

var first = fruits.shift(); // xoá bỏ Apple từ vị trí đầu
// ["Banana"];

Thêm phần tử vào đầu Mảng

var newLength = fruits.unshift('Strawberry') // thêm vào vị trí đầu
// ["Strawberry", "Banana"];

Tìm chỉ mục của một phần tử trong Mảng

fruits.push('Mango');
// ["Strawberry", "Banana", "Mango"]

var pos = fruits.indexOf('Banana');
// 1

Xóa một phần tử bằng chỉ mục của nó

var removedItem = fruits.splice(pos, 1); // đây là cách để xoá bỏ một phần tử

// ["Strawberry", "Mango"]

Xóa các phần tử bắt đầu từ vị trí của chỉ mục

var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
console.log(vegetables);
// ["Cabbage", "Turnip", "Radish", "Carrot"]

var pos = 1, n = 2;

var removedItems = vegetables.splice(pos, n);
// đây là cách để xoá các phần tử, n định nghĩa số phần tử cần xoá bỏ,
// từ vị trí đó (pos) trở đi đến cuối mảng.

console.log(vegetables);
// ["Cabbage", "Carrot"] (mảng ban đầu đã bị thay đổi)

console.log(removedItems);
// ["Turnip", "Radish"]

Sao chép một Mảng

var shallowCopy = fruits.slice(); // đây là cách để tạo một bản sao
// ["Strawberry"]

Cú pháp

[ element0 , element1 , ..., elementN ]
new Array(element0 , element1 [, ... [, elementN ]])
new Array(arrayLength)
nguyên tố N
Một mảng JavaScript được khởi tạo với các yếu tố nhất định, ngoại trừ trong trường hợp một đối số duy nhất được truyền vào mảng xây dựng và lập luận đó là một con số. (Xem bên dưới). Lưu ý rằng trường hợp đặc biệt này chỉ áp dụng cho các mảng JavaScript tạo ra với các mảng xây dựng, không mảng literals tạo ra với cú pháp khung.
arrayLength
Nếu đối số duy nhất được truyền cho các mảng constructor là một số nguyên giữa 0 và 2 32 -1 (bao gồm), điều này trả về một mảng JavaScript mới với chiều dài thiết lập để con số đó. Nếu đối số là số nào khác, một {{jsxref ("Global_Objects / RangeError", "RangeError")}} ngoại lệ được ném ra.

Miêu tả

Mảng là đối tượng danh sách giống như nguyên mẫu mà có phương pháp để thực hiện traversal và đột biến hoạt động. Cả chiều dài của một mảng JavaScript hay các loại của các yếu tố của nó được cố định. Vì chiều dài kích thước của một mảng lớn hoặc thu nhỏ bất cứ lúc nào, các mảng JavaScript là không đảm bảo được dày đặc. Nói chung, đây là những đặc điểm thuận tiện; nhưng nếu các tính năng này không được mong muốn sử dụng cụ thể của bạn, bạn có thể xem xét sử dụng các mảng gõ.

Một số người nghĩ rằng bạn không nên sử dụng một mảng như là một mảng kết hợp . Trong mọi trường hợp, bạn có thể sử dụng đồng bằng {{jsxref ("Global_Objects / Object", "đối tượng")}} thay vào đó, mặc dù làm như vậy đi kèm với hãy cẩn thận của mình. Xem các bài viết từ điển JavaScript nhẹ với các phím tùy ý như là một ví dụ.

Truy cập vào các phần tử mảng

Mảng JavaScript được zero-lập chỉ mục: phần tử đầu tiên của mảng là lúc chỉ số 0 , và các yếu tố cuối cùng là chỉ số tương đương với giá trị của của mảng {{jsxref ("Array.length", "chiều dài")}} tài sản trừ đi 1.

var arr = ['đây là yếu tố đầu tiên "," đây là yếu tố thứ hai'];
console.log(arr[0]); // Nhật ký này là yếu tố đầu tiên '
console.log(arr[1]); // Nhật ký này là yếu tố thứ hai '
console.log(arr[arr.length - 1]); // Nhật ký này là yếu tố thứ hai '

Các phần tử mảng là thuộc tính đối tượng trong cùng một cách mà toString là một thuộc tính, nhưng cố gắng để truy cập vào một phần tử của mảng như sau ném một lỗi cú pháp, bởi vì tên sở hữu là không hợp lệ:

console.log(arr.0); // Một lỗi cú pháp

Có gì đặc biệt về mảng JavaScript và các thuộc tính gây ra điều này là. Tính JavaScript bắt đầu bằng một chữ số không thể được tham chiếu với ký hiệu dấu chấm; và phải được truy cập bằng cách sử dụng ký hiệu khung. Ví dụ, nếu bạn đã có một đối tượng với một thuộc tính có tên '3D' , nó chỉ có thể được tham chiếu bằng cách sử dụng ký hiệu khung. Ví dụ như:

var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0); // Một lỗi cú pháp
console.log(years[0]); // Đúng cú pháp

renderer.3d.setTexture (model, 'character.png'); // Một lỗi cú pháp
renderer['3D']setTexture (model, 'character.png.'); // Đúng cú pháp

Lưu ý rằng trong ví dụ 3d , '3D' đã được trích dẫn. Có thể trích dẫn các chỉ số mảng JavaScript cũng như (ví dụ, năm ['2'] thay vì năm [2] ), mặc dù nó không cần thiết. 2 trong năm [2] là bị cưỡng chế vào một chuỗi các công cụ JavaScript thông qua một tiềm ẩn toString chuyển đổi. Chính vì lý do này mà '2' và '02' sẽ chỉ đến hai khe cắm khác nhau trên năm đối tượng và các ví dụ sau đây có thể là sự thật :

console.log(years['2'] = years['02']!);

Tương tự, thuộc tính đối tượng đó xảy ra để được dành riêng chỉ có thể được truy cập như các chuỗi trong ký hiệu khung:

var promise = {
  'Var': 'text',
  'Array': [1, 2, 3, 4]
};

console.log(promise['Array']);

Mối quan hệ giữa chiều dài và số thuộc tính

Một mảng của JavaScript {{jsxref ("Array.length", "chiều dài")}} tài sản và tính toán được kết nối. Một số phương pháp mảng xây dựng trong (ví dụ, {{jsxref ("Array.join", "tham gia")}}, {{jsxref ("Array.slice", "lát cắt")}}, {{jsxref (" Array.indexOf "," indexOf ")}}, vv) có tính đến các giá trị của một mảng {{jsxref (" Array.length "," chiều dài ")}} tài sản khi chúng được gọi. Các phương pháp khác (ví dụ, {{jsxref ("Array.push", "đẩy")}}, {{jsxref ("Array.splice", "mối nối")}}, vv) cũng cho kết quả trong bản cập nhật tới một mảng của { {jsxref ("Array.length", "chiều dài")}} thuộc tính.

var fruits = [];
fruits.push('banana', 'apple', 'peach');

console.log(fruits.length); // 3

Khi thiết lập một thuộc tính trên một mảng JavaScript khi tài sản là một chỉ số mảng hợp lệ và chỉ số đó là ngoài giới hạn hiện tại của mảng, engine sẽ cập nhật thuộc tính {{jsxref ("Array.length", "chiều dài")}} của mảng cho phù hợp:

fruits[5] = 'mango';
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits));  // ['0', '1', '2', '5']
console.log(fruits.length); // 6

Tăng {{jsxref ("Array.length", "chiều dài")}}.

fruits.length = 10;
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10

Giảm thuộc tính {{jsxref ("Array.length", "chiều dài")}} , tuy nhiên, xóa các phần tử.

fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

Điều này được giải thích thêm về {{jsxref ("Array.length")}} trang.

Tạo một mảng bằng cách sử dụng kết quả của một trận đấu

Kết quả của một trận đấu giữa một biểu hiện thường xuyên và một chuỗi có thể tạo ra một mảng JavaScript. Mảng này có các tính chất và các yếu tố trong đó cung cấp thông tin về trận đấu. Một mảng đó được trả về bởi {{jsxref ("RegExp.exec")}}, {{jsxref ("String.match")}} và {{jsxref ("string.Replace")}}. Để giúp giải thích các thuộc tính và các yếu tố, nhìn vào ví dụ sau đây và sau đó tham khảo bảng dưới đây:

// Trận đấu một d theo sau bởi một hoặc nhiều b theo sau bởi một d
// Ghi phù hợp của b và d sau
// Bỏ qua trường hợp

var Myre = / d (b +) (d) / i;
var myArray = myRe.exec('cdbBdbsbz');

Các tính chất và các yếu tố trở về từ trận đấu này như sau:

Bất động sản / tử Miêu tả Thí dụ
đầu vào Một thuộc tính chỉ đọc phản ánh các chuỗi ban đầu dựa vào đó các biểu thức chính quy được kết hợp. cdbBdbsbz
mục lục Một thuộc tính chỉ đọc mà là chỉ số không dựa trên các trận đấu trong chuỗi. 1
[0] Một yếu tố chỉ đọc mà xác định các ký tự tương ứng cuối cùng. dbBd
[1], ... [n] Chỉ đọc các yếu tố đó chỉ định các trận đấu substring parenthesized, nếu có trong các biểu hiện thường xuyên. Số lượng các chuỗi con trong ngoặc có thể là không giới hạn. [1]: bB
[2]: d

Thuộc tính

{{Jsxref ("Array.length")}}
Thuộc tính chiều dài của Array trong constructor (hàm dựng) có giá trị là 1.
{{Jsxref ("Array.prototype")}}
Cho phép bổ sung các thuộc tính cho tất cả các đối tượng mảng.

Phương thức

{{Jsxref ("Array.from()")}} {{experimental_inline}}
Tạo ra một Mảng mới từ một đối tượng giống mảng hoặc iterable.
{{Jsxref ("Array.isArray()")}}
Trả về true nếu một biến là một mảng, ngược lại false nếu không phải là mảng.
{{Jsxref ("Array.of()")}} {{experimental_inline}}
Tạo ra một Array mới với một số lượng các đối số, bất kể số hoặc loại của các đối số.

Array instances

Tất cả instance Array kế thừa từ {{jsxref ("Array.prototype")}}. Các đối tượng nguyên mẫu của Array constructor có thể được sửa đổi để ảnh hưởng đến tất cả các instance Array.

Thuộc tính

{{Page ('/ en-US / docs / Web / JavaScript / Reference / Global_Objects / Array / mẫu', 'Properties')}}

Phương thức

Phương thức mutator

{{Page ('en-US / docs / Web / JavaScript / Reference / Global_Objects / Array / mẫu', 'Mutator_methods')}}

Phương thức accessor

{{Page ('en-US / docs / Web / JavaScript / Reference / Global_Objects / Array / mẫu', 'Accessor_methods')}}

Phương thức lặp đi lặp lại

{{Page ('en-US / docs / Web / JavaScript / Reference / Global_Objects / Array / mẫu', 'Iteration_methods')}}

Array phương thức chung

Đôi khi bạn muốn áp dụng phương thức mảng các chuỗi hoặc các đối tượng mảng giống khác (chẳng hạn như chức năng {{jsxref ("Chức năng / lập luận", "lý luận", "", 1)}}). Bằng cách này, bạn đối xử với một chuỗi như là một mảng kí tự (hoặc nếu không điều trị một phi mảng như là một mảng). Ví dụ, để kiểm tra xem tất cả các nhân vật trong biến str là một lá thư, bạn có thể viết:

function isLetter (person) {
  return person >= 'a' && person <= 'z';
}

if (Array.prototype.every.call (str, isLetter)) {
  console.log("The string " + str + " contains only letters!");
}

Ký hiệu này là khá lãng phí và JavaScript 1.6 giới thiệu một cách viết tắt chung:

if (Array.every (str, isLetter)) {
  console.log("The string " + str + " contains only letters!");
}

{{Jsxref ("Global_Objects / String", "Generics", "#String_generic_methods", 1)}} cũng có sẵn trên {{jsxref ("Global_Objects / String", "String")}}.

Đây không phải là một phần của tiêu chuẩn ECMAScript và chúng không được hỗ trợ bởi các trình duyệt không phải là Gecko. Như một thay thế tiêu chuẩn, bạn có thể chuyển đổi đối tượng của bạn thành một mảng bằng cách sử dụng ({{jsxref ("Array.from ()")}}, mặc dù phương pháp này có thể không được hỗ trợ trong các trình duyệt cũ:

if (Array.from(str).every(isLetter)) {
  console.log("The string " + str + " contains only letters!");
}

Ví dụ

Tạo một mảng

Ví dụ sau tạo một mảng, msgArray , với chiều dài 0, sau đó gán giá trị cho [0] msgArray và msgArray [99] , thay đổi độ dài của mảng đến 100.

var msgArray = [];
msgArray [0] = "Hello";
msgArray [99] = 'World';

if (msgArray.length === 100) {
  console.log('Chiều dài là 100');
}

Tạo một mảng hai chiều

Sau đây tạo ra một bàn cờ như là một mảng hai chiều của chuỗi. Động thái đầu tiên được thực hiện bằng cách sao chép 'p' trong (6,4) đến (4,4). Các vị trí cũ (6,4) được làm trống.

var board = [
  ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r'] ];

console.log(board.join('\n') + '\n\n');

// Di chuyển King's Pawn về phía trước 2
board[4][4] = board[6][4];
board[6][4] = ' ';
console.log(board.join('\n'));

Đây là kết quả:

R, N, B, Q, K, B, N, R
P, P, P, P, P, P, P, P
 ,,,,,,,
 ,,,,,,,
 ,,,,,,,
 ,,,,,,,
p, p, p, p, p, p, p, p
r, n, b, q, k, b, n, r

R, N, B, Q, K, B, N, R
P, P, P, P, P, P, P, P
 ,,,,,,,
 ,,,,,,,
 ,,,, P,,,
 ,,,,,,,
p, p, p, p,, p, p, p
r, n, b, q, k, b, n, r

Sử dụng một mảng để sắp xếp một tập các giá trị

values = [];
for (var x = 0; x < 10; x++){
 values.push([
  2 ** x,
  2 * x ** 2
 ])
};
console.table(values)

Kết quả là:

0	1	0
1	2	2
2	4	8
3	8	18
4	16	32
5	32	50
6	64	72
7	128	98
8	256	128
9	512	162

(Cột đầu tiên là index (chỉ mục))

Thông số kỹ thuật

Đặc điểm kỹ thuật Trạng thái Chú thích
{{SpecName('ES1')}} {{Spec2('ES1')}} Định nghĩa ban đầu.
{{SpecName("ES5.1", "#sec-15.4", "Array")}} {{Spec2("ES5.1")}} Phương thức mới được thêm vào: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf ")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array. prototype.forEach","forEach")}}, {{jsxref("Array.prototype.map","map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}
{{SpecName("ES6", "#sec-array-objects", "Array")}} {{Spec2 ("ES6")}} Phương thức mới được thêm vào: {{jsxref ("Array.from")}}, {{jsxref ("Array.of")}}, {{jsxref ("Array.prototype.find", "find")}}, {{jsxref ("Array.prototype.findIndex", "findIndex")}}, {{jsxref ("Array.prototype.fill", "fill")}}, {{jsxref ("Array.prototype.copyWithin", "copyWithin")}}

Khả năng tương thích trình duyệt

{{Compat("javascript.builtins.Array")}}

Xem thêm