Cách truyền mảng trong javascript?

Truyền mảng dưới dạng đối số hàm

Ngày xưa, nếu chúng ta cần truyền mảng dưới dạng đối số hàm thì nên sử dụng apply() và null . Việc sử dụng null làm cho mã không sạch sẽ. Vì vậy, để làm cho mã rõ ràng và cũng để truyền một mảng dưới dạng đối số hàm, toán tử trải rộng xuất hiện trong bức tranh. Bằng cách sử dụng toán tử trải rộng, chúng ta không cần sử dụng hàm apply(). Hãy thảo luận về nó một cách ngắn gọn

Thí dụ

Trong ví dụ sau, chúng ta đã sử dụng null và apply() để truyền một mảng làm đối số của hàm. Đây là một phương pháp lỗi thời. Phương pháp này được thay thế bằng một phương pháp hiện đại trong đó sử dụng toán tử trải rộng

Bản thử trực tiếp

đầu ra

NSE
BSE
NIFTY

Nếu chúng ta quan sát ví dụ sau, hàm apply() và null không được sử dụng, thay vào đó, toán tử trải rộng ES6 đó được sử dụng. Việc sử dụng toán tử trải rộng làm cho mã trở nên tao nhã và không cần sử dụng giá trị null vô dụng

Trong Javascript, chúng ta thường lưu trữ dữ liệu dưới dạng mảng và các hàm chúng ta muốn gọi. Đôi khi, dữ liệu trong mảng của chúng ta chính xác là dữ liệu chúng ta muốn chuyển đến một hàm. May mắn thay, có nhiều cách trong Javascript để sử dụng mảng làm giá trị đầu vào cho các hàm. Hãy xem cách sử dụng mảng làm tham số hàm

Cách sử dụng mảng làm tham số hàm

Khi chúng ta có một hàm mà chúng ta muốn truyền một mảng vào, cách cơ bản nhất để làm điều đó sẽ như thế này

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(numbers[0], numbers[1], numbers[2]);

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Tất nhiên, điều này có thể khá khó chịu, đặc biệt khi làm việc với các hàm có danh sách thuộc tính rất dài. Như vậy Javascript đã cung cấp cho chúng ta 2 cách để sử dụng mảng làm tham số hàm trong Javascript - apply() và toán tử trải rộng

Truyền mảng cho hàm bằng toán tử trải rộng

Cách hiện đại và dễ dàng nhất để truyền một mảng cho một hàm là sử dụng toán tử trải rộng. Toán tử trải rộng (...) đơn giản được thêm vào trước mảng. Sử dụng ví dụ trước của chúng tôi, có vẻ như thế này

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Chúng ta cũng có thể thêm trực tiếp mảng vào hàm mà không cần biến. Ví dụ

let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...[ 1, 2, 3 ]);

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Nếu bạn muốn tìm hiểu mọi thứ mà toán tử trải rộng có thể làm, hãy xem hướng dẫn của tôi về điều đó tại đây

Truyền mảng cho hàm bằng apply()

Một cách khác để làm điều này, là sử dụng apply(). Nếu bạn không quen với trường hợp sử dụng chính của apply(), hãy xem hướng dẫn đầy đủ của tôi về đối tượng này của Javascript tại đây

Cuối cùng, apply() cho phép chúng ta lấy một hàm và truyền một mảng vào đó. Thuộc tính đầu tiên của apply() thực sự đề cập đến đối tượng

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

0 mà chúng ta muốn sử dụng trên hàm. Đối số thứ hai là một mảng gồm tất cả các tham số cho hàm đó. Điều đó có nghĩa là bạn có thể xác định cấu trúc của

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

0 cũng như chuyển một mảng vào chính hàm đó

Điều này rõ ràng có một số lợi ích cụ thể khi so sánh với toán tử chênh lệch (...), vì vậy nó có thể phù hợp hơn tùy thuộc vào những gì bạn muốn đạt được. Sử dụng ví dụ trước, chúng ta có thể truyền một mảng vào hàm của mình như vậy

let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction.apply({}, [ 1, 2, 3 ]);

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Ở đây, tôi đang để trống đối tượng

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

0, vì vậy nếu chúng ta sử dụng

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

0 trong

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

5, thì nó sẽ là một đối tượng trống - đó là điều mà đối số đầu tiên của apply() thực hiện. Thứ hai là mảng của chúng tôi

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

7, lần lượt đề cập đến

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

8,

let numbers = [ 1, 2, 3 ]
let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...numbers);

9 và

let myFunction = (x, y, z) => {
    return x + y + z;
}

// Returns 6
let getCalculation = myFunction(...[ 1, 2, 3 ]);

0

Các mảng được truyền trong JS như thế nào?

Làm cách nào để chuyển mảng đối tượng trong JavaScript?

Các mảng được truyền như thế nào?

Bạn có thể chuyển một mảng vào hàm JavaScript không?