Array (mảng) trong ES6

Đối tượng Array

var arr_names = new Array(4)
for(var i = 0;i<arr_names.length;i++) {
arr_names[i] = i * 2
console.log(arr_names[i])
}
Kết quả:
$node main.js
0
2
4
6

Khai báo và khởi tạo một mảng

var nums = [1,2,3,3]
console.log(nums[0]);
console.log(nums[1]);
console.log(nums[2]);
console.log(nums[3]);
$node main.js
1
2
3
3

Mảng đơn giản

var alphas;
alphas = ["1","2","3","4"]
console.log(alphas[0]);
console.log(alphas[1]);
$node main.js
1
2

Phương thức pop() , push()

var numbers = [1, 4, 9];
var element = numbers.pop();
console.log("element is : " + element );

var element = numbers.pop();

console.log("element is : " + element );
$node main.js
element is : 9
element is : 4

Cú pháp: push(item)
Ý nghĩa: Hàm "push()" thêm một phần tử mới vào đỉnh của ngăn xếp (stack).
Ví dụ:
stack = [] # Khởi tạo một ngăn xếp rỗng
stack.push(1) # Thêm phần tử 1 vào đỉnh của ngăn xếp
stack.push(2) # Thêm phần tử 2 vào đỉnh của ngăn xếp
1
stack.push(3) # Thêm phần tử 3 vào đỉnh của ngăn xếp
print(stack) # Kết quả: [1, 2, 3]

Cú pháp: pop()
Ý nghĩa: Hàm "pop()" loại bỏ và trả về phần tử ở đỉnh của ngăn xếp (stack). Sau khi thực hiện "pop()",
ngăn xếp sẽ mất đi phần tử ở đỉnh.
Ví dụ:
stack = [1, 2, 3] # Khởi tạo một ngăn xếp với các phần tử
top_element = stack.pop() # Loại bỏ và lấy phần tử ở đỉnh
print(top_element) # Kết quả: 3
print(stack) # Kết quả: [1, 2]

Phương thức map()

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log("roots is : " + roots );
$node main.js
roots is : 1,2,3

Hàm map() là một phương thức của các mảng (Array) và được sử dụng để thực hiện một hàm hoặc phép
biến đổi lên từng phần tử của mảng và trả về một mảng mới chứa kết quả của các phép biến đổi đó.
Cú pháp: array.map(function(currentValue, index, arr), thisValue)
Ví dụ:
// Định nghĩa một hàm để tính bình phương của một số
function square(x) {
return x * x;
}

// Tạo một mảng các số nguyên

const numbers = [1, 2, 3, 4, 5];

// Sử dụng hàm map() để tính bình phương của mỗi số trong mảng
const squaredNumbers = numbers.map(square);

// In kết quả
console.log(squaredNumbers); // Kết quả: [1, 4, 9, 16, 25]

Phương thức lastIndexOf()

var index = [12, 5, 8, 130, 44].lastIndexOf(8);
console.log("index is : " + index );
$node main.js
index is : 2

2
Phương thức join()
var arr = new Array("First","Second","Third");
var str = arr.join();
console.log("str : " + str );
var str = arr.join(", ");
console.log("str : " + str );

var str = arr.join(" + ");

console.log("str : " + str );
$node main.js
str : First,Second,Third
str : First, Second, Third
str : First + Second + Third

Phương thức join() trong JavaScript được sử dụng để chuyển đổi các phần tử của một mảng thành một
chuỗi và nối chúng bằng một chuỗi ngăn cách (delimiter) được chỉ định.
Cú pháp: array.join(delimiter)
Ví dụ:
const fruits = ["apple", "banana", "cherry"];

// Sử dụng join() để nối các phần tử của mảng thành chuỗi, ngăn cách bằng dấu phẩy
const fruitString = fruits.join();
console.log(fruitString); // Kết quả: "apple,banana,cherry"

// Sử dụng join() với một delimiter tùy chỉnh (khoảng trắng và dấu gạch ngang)
const fruitStringCustomDelimiter = fruits.join(" - ");
console.log(fruitStringCustomDelimiter); // Kết quả: "apple - banana - cherry"

Phương thức indexOf()

var index = [12, 5, 8, 130, 44].indexOf(8);
console.log("index is : " + index )
$node main.js
index is : 2

Phương thức indexOf() trong JavaScript được sử dụng để tìm kiếm vị trí (chỉ số) của một phần tử trong
mảng và trả về vị trí đầu tiên mà phần tử đó được tìm thấy. Nếu phần tử không tồn tại trong mảng,
phương thức sẽ trả về -1.
Cú pháp: array.indexOf(searchElement[, fromIndex])
Ví dụ:
const fruits = ["apple", "banana", "cherry", "banana"];

// Tìm vị trí của phần tử "cherry" trong mảng

const indexCherry = fruits.indexOf("cherry");
console.log(indexCherry); // Kết quả: 2 (vị trí của "cherry" trong mảng)

// Tìm vị trí của phần tử "banana" trong mảng, bắt đầu từ chỉ số 1
const indexBanana = fruits.indexOf("banana", 1);
console.log(indexBanana); // Kết quả: 3 (vị trí của "banana" trong mảng, bắt đầu từ chỉ số 1)

3
// Tìm vị trí của phần tử "grape" trong mảng (không tồn tại)
const indexGrape = fruits.indexOf("grape");
console.log(indexGrape); // Kết quả: -1 (không tìm thấy "grape" trong mảng)

Phương thức forEach(), for…of, for…in

var nums = new Array(12,13,14,15)
console.log("Printing original array......")

nums.forEach(function(val,index) {
console.log(val)
})
nums.reverse() //reverses the array element
console.log("Printing Reversed array....")

nums.forEach(function(val,index){
console.log(val)
})
$node main.js
Printing original array......
12
13
14
15
Printing Reversed array....
15
14
13
12

Ý nghĩa: forEach() lặp qua từng phần tử của mảng và gọi một hàm callback cho mỗi phần tử.
Cú pháp: array.forEach(function(currentValue, index, array) {
// Code thực hiện với từng phần tử của mảng
});
Ví dụ:
const fruits = ["apple", "banana", "cherry"];

fruits.forEach(function(fruit, index) {
console.log(`Fruit at index ${index}: ${fruit}`);
});

// Kết quả:
// Fruit at index 0: apple
// Fruit at index 1: banana
// Fruit at index 2: cherry

Ý nghĩa: for...of lặp qua từng phần tử của một iterable (ví dụ: mảng, chuỗi) và thực hiện một loạt công
việc trên từng phần tử.
Cú pháp:
for (const element of iterable) {
// Code thực hiện với từng phần tử của iterable
4
}
Ví dụ:
const fruits = ["apple", "banana", "cherry"];

for (const fruit of fruits) {

console.log(fruit);
}

// Kết quả:
// apple
// banana
// cherry

Ý nghĩa: for...in lặp qua từng thuộc tính có thể liệt kê của một đối tượng và thực hiện một loạt công việc
trên từng thuộc tính.
Cú pháp:
for (const key in object) {
if (object.hasOwnProperty(key)) {
// Code thực hiện với từng thuộc tính của object
}
}
Ví dụ:
const person = {
name: "John",
age: 30,
job: "developer"
};

for (const key in person) {

if (person.hasOwnProperty(key)) {
console.log(`${key}: ${person[key]}`);
}
}

// Kết quả:
// name: John
// age: 30
// job: developer

Phương thức filter()

function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].filter(isBigEnough);
console.log("Test Value : " + passed );
$node main.js
Test Value : 12,130,44

5
Phương thức filter() lặp qua từng phần tử của mảng và gọi một hàm callback cho từng phần tử. Hàm
callback này sẽ xác định liệu phần tử đó có được giữ lại trong mảng mới hay không. Nếu hàm callback trả
về true, phần tử sẽ được bao gồm trong mảng mới, còn nếu trả về false, phần tử sẽ bị loại bỏ.

Cú pháp:
const newArray = array.filter(function(currentValue, index, arr) {
// Trả về true để giữ phần tử trong mảng mới, hoặc false để bỏ qua nó
});

Ví dụ:
const numbers = [1, 2, 3, 4, 5, 6];

// Sử dụng filter() để lọc các số chẵn từ mảng numbers

const evenNumbers = numbers.filter(function(number) {
return number % 2 === 0;
});

console.log(evenNumbers); // Kết quả: [2, 4, 6]

Phương thức every()

function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
console.log("Test Value : " + passed );
$node main.js
Test Value : false vì có phần tử nhỏ hơn 10. Nếu sửa element >= 4, trả về true

Phương thức concat()

var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);
console.log("alphaNumeric : " + alphaNumeric );
$node main.js
alphaNumeric : a,b,c,1,2,3

Array Constructor
var names = new Array("Mary","Tom","Jack","Jill")
for(var i = 0;i<names.length;i++) {
console.log(names[i])
}
$node main.js
Mary
Tom
Jack
Jill

Phương thức toString()

6
var arr = new Array("orange", "mango", "banana", "sugar");
var str = arr.toString();
console.log("Returned string is : " + str );
$node main.js
Returned string is : orange,mango,banana,sugar

Phương thức toString() trong JavaScript là một phương thức được sử dụng để chuyển đổi một đối tượng
thành một chuỗi. Cụ thể, nó trả về biểu diễn chuỗi của đối tượng hiện tại. Phương thức này thường được
kế thừa từ đối tượng cha của hầu hết các đối tượng trong JavaScript, vì nó là một phần của đối tượng cơ
bản Object.

Cú pháp:
object.toString()

Ví dụ:
const number = 42;
const stringNumber = number.toString();

console.log(stringNumber); // Kết quả: "42"

Phương thức splice(): add/remove

var arr = ["orange", "mango", "banana", "sugar", "tea"];
var removed = arr.splice(2, 0, "water");
console.log("After adding 1: " + arr );
console.log("removed is: " + removed);

removed = arr.splice(3, 1); //The number of items to be removed. If set to 0, no items will be removed
console.log("After adding 1: " + arr );
console.log("removed is: " + removed);
$node main.js
After adding 1: orange,mango,water,banana,sugar,tea
removed is: vi la 0 nên ko co pt nào bị remove

After adding 1: orange,mango,water, ,tea

removed is: banana

Phương thức splice() trong JavaScript được sử dụng để thay đổi nội dung của một mảng bằng cách thêm
hoặc loại bỏ các phần tử từ mảng gốc. Phương thức này có thể thêm phần tử mới vào mảng, loại bỏ
phần tử hiện có, hoặc cả hai.

Cú pháp:
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
-array: Mảng gốc mà bạn muốn thay đổi.
-start: Chỉ số (index) bắt đầu của vị trí mà bạn muốn thay đổi trong mảng.
-deleteCount (tùy chọn): Số lượng phần tử bạn muốn loại bỏ từ vị trí start. Nếu bạn không chỉ định giá
trị này hoặc chỉ định là 0, không có phần tử nào sẽ bị loại bỏ.
-item1, item2, ... (tùy chọn): Các phần tử bạn muốn thêm vào mảng từ vị trí start.

7
Ví dụ:
const fruits = ["apple", "banana", "cherry", "date"];

// Xóa phần tử "banana" khỏi mảng

fruits.splice(1, 1);
console.log(fruits); // Kết quả: ["apple", "cherry", "date"]

// Thêm các phần tử "lemon" và "grape" vào mảng, tại vị trí 2, và xóa 0 phần tử
fruits.splice(2, 0, "lemon", "grape");
console.log(fruits); // Kết quả: ["apple", "cherry", "lemon", "grape", "date"]

Phương thức sort()

var arr = new Array("orange", "mango", "banana", "sugar");
var sorted = arr.sort();
console.log("Returned string is : " + sorted );
$node main.js
Returned string is : banana,mango,orange,sugar

Phương thức sort() sắp xếp các phần tử trong mảng gốc theo thứ tự mới được xác định bởi hàm so sánh
hoặc theo thứ tự mặc định của chuỗi Unicode nếu không cung cấp hàm so sánh.

Cú pháp:
array.sort([compareFunction])

-array: Mảng bạn muốn sắp xếp.

-compareFunction (tùy chọn): Một hàm so sánh tùy chỉnh mà bạn có thể cung cấp để xác định cách sắp
xếp. Hàm này nhận hai tham số và trả về một giá trị số nguyên:
-Nếu compareFunction(a, b) trả về số âm (< 0), a sẽ được sắp xếp trước b.
-Nếu compareFunction(a, b) trả về số dương (> 0), b sẽ được sắp xếp trước a.
-Nếu compareFunction(a, b) trả về 0, thứ tự giữa a và b không thay đổi.

Ví dụ:
const fruits = ["apple", "banana", "cherry", "date"];

// Sắp xếp mảng fruits theo thứ tự tăng dần (mặc định)
fruits.sort();
console.log(fruits); // Kết quả: ["apple", "banana", "cherry", "date"]

// Sắp xếp mảng numbers theo thứ tự giảm dần sử dụng hàm so sánh tùy chỉnh
const numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
numbers.sort(function(a, b) {
return b - a;
});

8
console.log(numbers); // Kết quả: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

Phương thức some()

function isBigEnough(element, index, array) {
return (element >= 10);
}
var retval = [2, 5, 8, 1, 4].some(isBigEnough);
console.log("Returned value is : " + retval );

var retval = [12, 5, 8, 1, 4].some(isBigEnough);

console.log("Returned value is : " + retval );
$node main.js
Returned value is : false
Returned value is : true

Phương thức slice()

var arr = ["orange", "mango", "banana", "sugar", "tea"];
console.log("arr.slice( 1, 2) : " + arr.slice( 1, 2) ); //start: 1, end: 2
console.log("arr.slice( 1, 3) : " + arr.slice( 1, 3) ); //but does not include <=>(1, 2)
$node main.js
arr.slice( 1, 2) : mango
arr.slice( 1, 3) : mango,banana

Phương thức slice() tạo ra một mảng mới bằng cách sao chép các phần tử từ mảng gốc dựa trên chỉ số bạn
cung cấp. Mảng mới này là một bản sao của phần của mảng gốc, và không làm thay đổi mảng gốc.

Cú pháp:
array.slice([begin[, end]])

Ví dụ:
const fruits = ["apple", "banana", "cherry", "date", "fig"];

// Tạo bản sao của mảng từ vị trí 1 đến vị trí 3 (không bao gồm vị trí 3)
const slicedFruits = fruits.slice(1, 3);
console.log(slicedFruits); // Kết quả: ["banana", "cherry"]

// Tạo bản sao của mảng từ vị trí 2 đến hết mảng

const slicedFruitsToEnd = fruits.slice(2);
console.log(slicedFruitsToEnd); // Kết quả: ["cherry", "date", "fig"]

Phương thức shift(): lấy pt đầu tiên, unshift

var arr = [10, 1, 2, 3].shift();
console.log("Shifted value is : " + arr )
$node main.js
Shifted value is : 10

9
Phương thức shift() loại bỏ và trả về phần tử đầu tiên của mảng gốc, sau đó dịch các phần tử còn lại
trong mảng để điền vào vị trí trống. Do đó, độ dài của mảng giảm đi 1 và phần tử đầu tiên được lấy ra.

Cú pháp:
const firstElement = array.shift()
-array: Mảng bạn muốn lấy phần tử đầu tiên và loại bỏ nó.
-firstElement: Phần tử đầu tiên của mảng sau khi đã bị loại bỏ.

Ví dụ:
const fruits = ["apple", "banana", "cherry"];

// Lấy và loại bỏ phần tử đầu tiên của mảng

const firstFruit = fruits.shift();

console.log(firstFruit); // Kết quả: "apple"

console.log(fruits); // Kết quả: ["banana", "cherry"]

Phương thức reverse()

var arr = [0, 1, 2, 3].reverse();
console.log("Reversed array is : " + arr );
$node main.js
Reversed array is : 3,2,1,0

Phương thức reduceRight()

var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; });
console.log("total is : " + total );
$node main.js
total is : 6
Ko có giá trị khởi tạo, nên bđầu là 3.
3 + 2 = 5
5 + 1 = 6
6 + 0 = 6 => kq = 6
var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; }, 10);
console.log("total is : " + total );
giá trị khởi tạo: 10, nên bđầu là 10.
10 + 3 = 13
13 + 2 = 15
15 + 1 = 16
16 + 0 = 16 => kq = 16

Phương thức reduce(): giống pt trên, mặc định từ bên trái: thực thi
một hàm trên mỗi pt mảng, kqtv 1 gt
var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; });
console.log("total is : " + total );
$node main.js
total is : 6

Phương thức push()

var numbers = new Array(1, 4, 9);
var length = numbers.push(10);
console.log("new numbers is : " + numbers );

10
length = numbers.push(20);
console.log("new numbers is : " + numbers );
$node main.js
new numbers is : 1,4,9,10
new numbers is : 1,4,9,10,20

Phương thức Multidimensional

Arrayshttps://www.tutorialspoint.com/node_programming_examp
les/
var multi = [[1,2,3],[23,24,25]]
console.log(multi[0][0])
console.log(multi[0][1])
console.log(multi[0][2])
console.log(multi[1][0])
console.log(multi[1][1])
console.log(multi[1][2])
$node main.js
1
2
3
23
24
25

Tái cấu trúc Array

https://www.tutorialspoint.com/node_programming_examples/
var arr = [12,13]
var[x,y] = arr
console.log(x)
console.log(y)
$node main.js
12
13
Duyệt mảng (Array) bằng vòng
lặphttps://www.tutorialspoint.com/node_programming_examples/
"use strict"
var nums = [1001,1002,1003,1004]
for(let j in nums) {
console.log(nums[j])
}
$node main.js
1001
1002
1003
1004

Phương thức Array.prototype.keys(): lay chỉ số mảng

https://www.tutorialspoint.com/node_programming_examples/
console.log(Array.from(['a', 'b'].keys()))
$node main.js
[ 0, 1 ]

11
Phương thức Array.from: method returns an Array object from any object with a
length property or an iterable object
"use strict"
for (let i of Array.from('hello')) {
console.log(i)
}
$node main.js
h
e
l
l
o

Phương thức Array.prototype.entries trả về mảng mới có chứa các

cặp khóa / giá trị cho mỗi chỉ mục trong mảng
var numbers = [1, 2, 3];
var val= numbers.entries();
console.log([...val]);
$node main.js
[ [ 0, 1 ], [ 1, 2 ], [ 2, 3 ] ]

Phương thức Array.prototype.entries

var numbers = [1, 2, 3];
var val = numbers.entries();
console.log(val.next().value);
console.log(val.next().value);
console.log(val.next().value);
$node main.js
[ 0, 1 ]
[ 1, 2 ]
[ 2, 3 ]

Phương thức Array.prototype.findIndex trả về chỉ số (index) của phần

tử đầu tiên trong mảng thỏa mãn hàm truyền vào và không kiểm tra các
giá trị còn lại. Nếu không phần tử nào thỏa mãn, phương thức trả lại -
1
var numbers = [1, 2, 3];
var oddNumber = numbers.findIndex((x) => x % 2 == 1);
console.log(oddNumber); // 0
$node main.js
0

Phương thức Array.prototype.find trả về giá trị đầu tiên trong mảng
thỏa điều

12
kiệnhttps://www.tutorialspoint.com/node_programming_examples
/
var numbers = [1, 2, 3];
var oddNumber = numbers.find((x) => x % 2 == 1);
console.log(oddNumber); // 1
$node main.js
1

Phương thức unshift(): Add new items to the beginning of an array

var myBook = new book("Perl", "Mohtashim");
book.prototype.price = null;
myBook.price = 100;

console.log("Book title is : " + myBook.title + "<br>");

console.log("Book author is : " + myBook.author + "<br>");
console.log("Book price is : " + myBook.price + "<br>");
Live Demo Embed

Hàm trả về một mảng

https://www.tutorialspoint.com/node_programming_examples/
function disp() {
return new Array("Mary","Tom","Jack","Jill")
}
var nums = disp()
for(var i in nums) {
console.log(nums[i])
}
$node main.js
Mary
Tom
Jack
Jill

Truyền các mảng vào hàm

var names = new Array("Mary","Tom","Jack","Jill")
function disp(arr_names) {
for(var i = 0;i<arr_names.length;i++) {
console.log(names[i])
}
}
disp(names)
$node main.js
Mary
Tom
Jack
Jill

13