Cải thiện bài viết
Lưu bài viết
Tham số REST là một cách cải tiến để xử lý tham số chức năng, cho phép chúng tôi dễ dàng xử lý các đầu vào khác nhau như tham số trong một hàm. Cú pháp tham số REST cho phép chúng tôi biểu diễn một số lượng đối số không xác định dưới dạng một mảng. Với sự trợ giúp của tham số REST, một hàm có thể được gọi với bất kỳ số lượng đối số nào, bất kể nó được xác định như thế nào. Tham số REST được thêm vào trong ES2015 hoặc ES6, đã cải thiện khả năng xử lý tham số.note: Để chạy mã trong bài viết này, sử dụng bảng điều khiển do trình duyệt cung cấp hoặc sử dụng một công cụ trực tuyến như repl.it.syntax: & nbsp; & nbsp; is an improved way to handle function parameter, allowing us to more easily handle various input as parameters in a function. The rest parameter syntax allows us to represent an indefinite number of arguments as an array. With the help of a rest parameter a function can be called with any number of arguments, no matter how it was defined. Rest parameter
is added in ES2015 or ES6 which improved the ability to handle parameter.
Note: In order to run the code in this article make use of the console provided by the browser or use an online tool like repl.it.
Syntax:
function functionname[...parameters] //... is the rest parameter [triple dots] { statement; }
Lưu ý: Khi ở cuối tham số chức năng, đó là tham số còn lại. Nó lưu trữ n số tham số dưới dạng một mảng. Hãy để xem cách tham số phần còn lại hoạt động: & nbsp; & nbsp; When … is at the end of function parameter, it is the rest parameter. It stores n number of parameters as an
array. Let’s see how the rest parameter works:
JavaScript
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
7 function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
8function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
0 function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
1function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
2function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
3function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
4Output:
Trong mã trên, sẽ không có lỗi nào được ném ngay cả khi chúng ta chuyển các đối số nhiều hơn các tham số, nhưng chỉ có hai đối số đầu tiên sẽ được đánh giá. Nó khác nhau trong trường hợp với tham số REST. Với việc sử dụng tham số REST, chúng tôi có thể thu thập bất kỳ số lượng đối số nào vào một mảng và thực hiện những gì chúng tôi muốn với chúng.
Javascript code demonstrating addition of numbers using rest parameter.
JavaScript
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
7 function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
8function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
8function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
0function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
1function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
2function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
3function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
2function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
0 function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
1function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
2function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
0function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
1function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
2Output:
Trong mã trên, sẽ không có lỗi nào được ném ngay cả khi chúng ta chuyển các đối số nhiều hơn các tham số, nhưng chỉ có hai đối số đầu tiên sẽ được đánh giá. Nó khác nhau trong trường hợp với tham số REST. Với việc sử dụng tham số REST, chúng tôi có thể thu thập bất kỳ số lượng đối số nào vào một mảng và thực hiện những gì chúng tôi muốn với chúng.
Note: The rest parameter have to be the last argument, as its job is to collect all the remaining arguments into an array. So having a function definition like the code below doesn’t make any sense and will throw an error.
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
7 function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
6
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
0 function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
8function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
5function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
0function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
7function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
2Chúng tôi đã có thể nhận được tổng của tất cả các yếu tố mà chúng tôi nhập vào đối số khi chúng tôi gọi hàm fun []. Chúng tôi nhận được tổng của tất cả các phần tử trong mảng bằng cách sử dụng vòng lặp for..of được sử dụng để đi qua các phần tử có thể lặp lại bên trong một mảng. & Nbsp; Lưu ý: tham số còn lại phải là đối số cuối cùng, vì công việc của nó là thu thập tất cả các đối số còn lại thành một mảng. Vì vậy, có một định nghĩa hàm như mã bên dưới không có ý nghĩa gì và sẽ gây ra lỗi. & Nbsp; & nbsp;
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
7 function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
6
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
0 function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
8function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function showName[] {
alert[ arguments.length ];
alert[ arguments[0] ];
alert[ arguments[1] ];
// it's iterable
// for[let arg of arguments] alert[arg];
}
// shows: 2, Julius, Caesar
showName["Julius", "Caesar"];
// shows: 1, Ilya, undefined [no second argument]
showName["Ilya"];
2function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function showName[] {
alert[ arguments.length ];
alert[ arguments[0] ];
alert[ arguments[1] ];
// it's iterable
// for[let arg of arguments] alert[arg];
}
// shows: 2, Julius, Caesar
showName["Julius", "Caesar"];
// shows: 1, Ilya, undefined [no second argument]
showName["Ilya"];
4function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function showName[] {
alert[ arguments.length ];
alert[ arguments[0] ];
alert[ arguments[1] ];
// it's iterable
// for[let arg of arguments] alert[arg];
}
// shows: 2, Julius, Caesar
showName["Julius", "Caesar"];
// shows: 1, Ilya, undefined [no second argument]
showName["Ilya"];
6function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function showName[] {
alert[ arguments.length ];
alert[ arguments[0] ];
alert[ arguments[1] ];
// it's iterable
// for[let arg of arguments] alert[arg];
}
// shows: 2, Julius, Caesar
showName["Julius", "Caesar"];
// shows: 1, Ilya, undefined [no second argument]
showName["Ilya"];
8function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
9function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
0function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
1function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
2function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
2function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
4function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
5function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
6function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
7function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
6function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
1function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
6alert[ Math.max[3, 5, 1] ]; // 5
1function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
6alert[ Math.max[3, 5, 1] ]; // 5
3alert[ Math.max[3, 5, 1] ]; // 5
4Output:
Chúng tôi đã có thể nhận được tổng của tất cả các yếu tố mà chúng tôi nhập vào đối số khi chúng tôi gọi hàm fun []. Chúng tôi nhận được tổng của tất cả các phần tử trong mảng bằng cách sử dụng vòng lặp for..of được sử dụng để đi qua các phần tử có thể lặp lại bên trong một mảng. & Nbsp; Lưu ý: tham số còn lại phải là đối số cuối cùng, vì công việc của nó là thu thập tất cả các đối số còn lại thành một mảng. Vì vậy, có một định nghĩa hàm như mã bên dưới không có ý nghĩa gì và sẽ gây ra lỗi. & Nbsp; & nbsp;
Nhiều chức năng tích hợp JavaScript hỗ trợ một số lượng đối số tùy ý.
Ví dụ:
5 - Trả về các đối số lớn nhất.alert[ Math.max[3, 5, 1] ]; // 5
6 - Bản sao thuộc tính từalert[ Math.max[3, 5, 1] ]; // 5
7 vàoalert[ Math.max[3, 5, 1] ]; // 5
8.alert[ Math.max[3, 5, 1] ]; // 5
- …và như thế.
Trong chương này, chúng tôi sẽ học cách làm điều tương tự. Và ngoài ra, làm thế nào để chuyển các mảng đến các hàm như tham số.
Thông số phần còn lại alert[ Math.max[3, 5, 1] ]; // 5
9
alert[ Math.max[3, 5, 1] ]; // 5
Một hàm có thể được gọi với bất kỳ số lượng đối số, bất kể nó được xác định như thế nào.
Như ở đây:
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
Sẽ không có lỗi vì các đối số quá mức của người Viking. Nhưng tất nhiên trong kết quả chỉ có hai cái đầu tiên sẽ được tính, vì vậy kết quả trong mã trên là
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
0.Phần còn lại của các tham số có thể được bao gồm trong định nghĩa hàm bằng cách sử dụng ba dấu chấm
alert[ Math.max[3, 5, 1] ]; // 5
9 theo sau là tên của mảng sẽ chứa chúng. Các dấu chấm có nghĩa đen là tập hợp các tham số còn lại thành một mảng.Chẳng hạn, để thu thập tất cả các đối số vào mảng
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
2:function sumAll[...args] { // args is the name for the array
let sum = 0;
for [let arg of args] sum += arg;
return sum;
}
alert[ sumAll[1] ]; // 1
alert[ sumAll[1, 2] ]; // 3
alert[ sumAll[1, 2, 3] ]; // 6
Chúng ta có thể chọn để có được các tham số đầu tiên làm biến và chỉ thu thập phần còn lại.
Ở đây hai đối số đầu tiên đi vào các biến và phần còn lại đi vào mảng
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
3:function showName[firstName, lastName, ...titles] {
alert[ firstName + ' ' + lastName ]; // Julius Caesar
// the rest go into titles array
// i.e. titles = ["Consul", "Imperator"]
alert[ titles[0] ]; // Consul
alert[ titles[1] ]; // Imperator
alert[ titles.length ]; // 2
}
showName["Julius", "Caesar", "Consul", "Imperator"];
Các tham số còn lại phải ở cuối
Các tham số còn lại thu thập tất cả các đối số còn lại, vì vậy những điều sau đây không có ý nghĩa và gây ra lỗi:
function f[arg1, ...rest, arg2] { // arg2 after ...rest ?!
// error
}
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
4 phải luôn luôn là cuối cùng.Các đối số của "biến" biến
Ngoài ra còn có một đối tượng giống như mảng đặc biệt có tên
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
5 chứa tất cả các đối số bằng chỉ mục của chúng.Ví dụ:
function showName[] {
alert[ arguments.length ];
alert[ arguments[0] ];
alert[ arguments[1] ];
// it's iterable
// for[let arg of arguments] alert[arg];
}
// shows: 2, Julius, Caesar
showName["Julius", "Caesar"];
// shows: 1, Ilya, undefined [no second argument]
showName["Ilya"];
alert[ Math.max[3, 5, 1] ]; // 5
5 - Trả về các đối số lớn nhất.alert[ Math.max[3, 5, 1] ]; // 5
6 - Bản sao thuộc tính từ alert[ Math.max[3, 5, 1] ]; // 5
7 vào alert[ Math.max[3, 5, 1] ]; // 5
8.…và như thế.
Trong chương này, chúng tôi sẽ học cách làm điều tương tự. Và ngoài ra, làm thế nào để chuyển các mảng đến các hàm như tham số.
Thông số phần còn lại
9alert[ Math.max[3, 5, 1] ]; // 5
Một hàm có thể được gọi với bất kỳ số lượng đối số, bất kể nó được xác định như thế nào.
Như ở đây:
function f[] {
let showArg = [] => alert[arguments[0]];
showArg[];
}
f[1]; // 1
Sẽ không có lỗi vì các đối số quá mức của người Viking. Nhưng tất nhiên trong kết quả chỉ có hai cái đầu tiên sẽ được tính, vì vậy kết quả trong mã trên là
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
0.Phần còn lại của các tham số có thể được bao gồm trong định nghĩa hàm bằng cách sử dụng ba dấu chấm alert[ Math.max[3, 5, 1] ]; // 5
9 theo sau là tên của mảng sẽ chứa chúng. Các dấu chấm có nghĩa đen là tập hợp các tham số còn lại thành một mảng.
alert[ Math.max[3, 5, 1] ]; // 5
Chẳng hạn, để thu thập tất cả các đối số vào mảng
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
2:Chúng ta có thể chọn để có được các tham số đầu tiên làm biến và chỉ thu thập phần còn lại.
Ở đây hai đối số đầu tiên đi vào các biến và phần còn lại đi vào mảng
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
3:alert[ Math.max[3, 5, 1] ]; // 5
Các tham số còn lại phải ở cuối
Các tham số còn lại thu thập tất cả các đối số còn lại, vì vậy những điều sau đây không có ý nghĩa và gây ra lỗi:
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
4 phải luôn luôn là cuối cùng.Các đối số của "biến" biến
Ngoài ra còn có một đối tượng giống như mảng đặc biệt có tên
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
5 chứa tất cả các đối số bằng chỉ mục của chúng.Vào thời xưa, các tham số REST không tồn tại trong ngôn ngữ và sử dụng
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
5 là cách duy nhất để có được tất cả các đối số của hàm. Và nó vẫn hoạt động, chúng ta có thể tìm thấy nó trong mã cũ.let arr = [3, 5, 1];
alert[ Math.max[...arr] ]; // 5 [spread turns array into a list of arguments]
Nhưng nhược điểm là mặc dù
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
5 vừa giống như mảng vừa được lặp lại, nhưng nó không phải là một mảng. Nó không hỗ trợ các phương thức mảng, vì vậy chúng tôi có thể gọi let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
8 chẳng hạn.function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
0Ngoài ra, nó luôn chứa tất cả các đối số. Chúng tôi có thể bắt giữ chúng một phần, giống như chúng tôi đã làm với các tham số REST.
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
1Vì vậy, khi chúng ta cần các tính năng này, thì các tham số REST được ưa thích.
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
2Các chức năng mũi tên không có
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
9Chẳng hạn, ở đây chúng tôi sử dụng cú pháp lan truyền để biến chuỗi thành mảng của các ký tự:
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
3Cú pháp lây lan bên trong sử dụng các trình lặp lại để thu thập các yếu tố, giống như
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
01.Vì vậy, đối với một chuỗi,
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
01 trả về các ký tự và function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
03 trở thành function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
04. Danh sách các ký tự được chuyển đến Bộ khởi tạo mảng function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
05.Đối với nhiệm vụ cụ thể này, chúng tôi cũng có thể sử dụng
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
06, bởi vì nó chuyển đổi một thứ có thể lặp lại [như một chuỗi] thành một mảng:function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
4Kết quả giống như
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
05.Nhưng có một sự khác biệt tinh tế giữa
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
08 và function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
09:
06 hoạt động trên cả hai mảng và vòng lặp.function sum[a, b] { return a + b; } alert[ sum[1, 2, 3, 4, 5] ];
- Cú pháp lây lan chỉ hoạt động với Iterables.
Vì vậy, đối với nhiệm vụ biến một cái gì đó thành một mảng,
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
06 có xu hướng phổ biến hơn.Sao chép một mảng/đối tượng
Bạn có nhớ khi chúng ta nói về
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
12 trong quá khứ không?
Có thể làm điều tương tự với cú pháp lan truyền.
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
5Lưu ý rằng có thể làm điều tương tự để tạo một bản sao của một đối tượng:
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
6Cách sao chép một đối tượng này ngắn hơn nhiều so với
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
13 hoặc đối với một mảng function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
14 vì vậy chúng tôi thích sử dụng nó bất cứ khi nào chúng tôi có thể.Bản tóm tắt
Khi chúng ta thấy
function sum[a, b] {
return a + b;
}
alert[ sum[1, 2, 3, 4, 5] ];
15 trong mã, đó là các tham số REST hoặc cú pháp lan truyền.Có một cách dễ dàng để phân biệt giữa chúng:
- Khi
9 ở cuối các tham số chức năng, thì các tham số phần còn lại của nó và tập hợp phần còn lại của danh sách các đối số thành một mảng.alert[ Math.max[3, 5, 1] ]; // 5
- Khi
9 xảy ra trong một cuộc gọi chức năng hoặc giống nhau, nó được gọi là một cú pháp lan truyền trên mạng và mở rộng một mảng thành một danh sách.alert[ Math.max[3, 5, 1] ]; // 5
Sử dụng các mẫu:
- Các tham số REST được sử dụng để tạo các hàm chấp nhận bất kỳ số lượng đối số nào.
- Cú pháp lan truyền được sử dụng để truyền một mảng cho các chức năng thường yêu cầu một danh sách nhiều đối số.
Họ cùng nhau giúp di chuyển giữa một danh sách và một loạt các tham số một cách dễ dàng.
Tất cả các đối số của một cuộc gọi chức năng cũng có sẵn trong kiểu cũ kiểu cũ
let arr = [3, 5, 1];
alert[ Math.max[arr] ]; // NaN
5: đối tượng có thể lặp lại giống như mảng.