Biểu thức hàm mũi tên là một thay thế nhỏ gọn cho biểu thức hàm truyền thống, với một số khác biệt về ngữ nghĩa và hạn chế có chủ ý trong cách sử dụng
- Các hàm mũi tên không có ràng buộc riêng với
6,async param => expression async [param1, param2, ...paramN] => { statements }
7 hoặcasync param => expression async [param1, param2, ...paramN] => { statements }
8 và không được sử dụng làm phương thứcasync param => expression async [param1, param2, ...paramN] => { statements }
- Hàm mũi tên không thể được sử dụng làm hàm tạo. Gọi họ bằng
9 ném mộtasync param => expression async [param1, param2, ...paramN] => { statements }
0. Họ cũng không có quyền truy cập vào từ khóa// Traditional anonymous function [function [a] { return a + 100; }]; // 1. Remove the word "function" and place arrow between the argument and opening body bracket [a] => { return a + 100; }; // 2. Remove the body braces and word "return" — the return is implied. [a] => a + 100; // 3. Remove the parameter parentheses a => a + 100;
1// Traditional anonymous function [function [a] { return a + 100; }]; // 1. Remove the word "function" and place arrow between the argument and opening body bracket [a] => { return a + 100; }; // 2. Remove the body braces and word "return" — the return is implied. [a] => a + 100; // 3. Remove the parameter parentheses a => a + 100;
- Các hàm mũi tên không thể sử dụng
2 trong phần thân của chúng và không thể được tạo dưới dạng các hàm tạo// Traditional anonymous function [function [a] { return a + 100; }]; // 1. Remove the word "function" and place arrow between the argument and opening body bracket [a] => { return a + 100; }; // 2. Remove the body braces and word "return" — the return is implied. [a] => a + 100; // 3. Remove the parameter parentheses a => a + 100;
Thử nó
cú pháp
param => expression
[param] => expression
[param1, paramN] => expression
param => {
statements
}
[param1, paramN] => {
statements
}
Tham số còn lại, tham số mặc định và phá hủy trong tham số được hỗ trợ và luôn yêu cầu dấu ngoặc đơn
________số 8
Hàm mũi tên có thể là
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
3 bằng cách đặt trước biểu thức bằng từ khóa // Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
3async param => expression
async [param1, param2, ...paramN] => {
statements
}
Sự mô tả
Hãy phân tích từng bước một hàm ẩn danh truyền thống thành hàm mũi tên đơn giản nhất. Mỗi bước trên đường đi là một chức năng mũi tên hợp lệ
Ghi chú. Biểu thức hàm truyền thống và hàm mũi tên có nhiều điểm khác biệt hơn so với cú pháp của chúng. Chúng tôi sẽ giới thiệu sự khác biệt về hành vi của họ chi tiết hơn trong một số tiểu mục tiếp theo
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
Trong ví dụ trên, cả dấu ngoặc quanh tham số và dấu ngoặc xung quanh thân hàm đều có thể được bỏ qua. Tuy nhiên, chúng chỉ có thể được bỏ qua trong một số trường hợp nhất định.
Dấu ngoặc đơn chỉ có thể được bỏ qua nếu hàm có một tham số đơn giản. Nếu nó có nhiều tham số, không có tham số hoặc tham số mặc định, hủy cấu trúc hoặc còn lại, thì bắt buộc phải có dấu ngoặc đơn xung quanh danh sách tham số
async param => expression
async [param1, param2, ...paramN] => {
statements
}
3Dấu ngoặc nhọn chỉ có thể được bỏ qua nếu hàm trả về trực tiếp một biểu thức. Nếu phần thân có các dòng xử lý bổ sung, thì bắt buộc phải có dấu ngoặc nhọn — và từ khóa
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
5 cũng vậy. Các hàm mũi tên không thể đoán bạn muốn quay lại cái gì hoặc khi nàoasync param => expression
async [param1, param2, ...paramN] => {
statements
}
5Các chức năng mũi tên luôn được đặt tên. Nếu hàm mũi tên cần gọi chính nó, hãy sử dụng biểu thức hàm được đặt tên để thay thế. Bạn cũng có thể gán chức năng mũi tên cho một biến để nó có tên
async param => expression
async [param1, param2, ...paramN] => {
statements
}
6thân hàm
Các hàm mũi tên có thể có phần thân ngắn gọn hoặc phần thân khối thông thường
Trong phần nội dung ngắn gọn, chỉ một biểu thức duy nhất được chỉ định, biểu thức này trở thành giá trị trả về ngầm định. Trong phần thân khối, bạn phải sử dụng câu lệnh
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
5 rõ ràngasync param => expression
async [param1, param2, ...paramN] => {
statements
}
8Trả về đối tượng bằng cách sử dụng cú pháp cơ thể ngắn gọn
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
7 không hoạt động như mong đợiasync param => expression
async [param1, param2, ...paramN] => {
statements
}
0Điều này là do JavaScript chỉ xem hàm mũi tên có phần thân ngắn gọn nếu mã thông báo theo sau mũi tên không phải là dấu ngoặc nhọn bên trái, vì vậy mã bên trong dấu ngoặc nhọn [{}] được phân tích cú pháp dưới dạng một chuỗi các câu lệnh, trong đó
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
8 là nhãn, không phải Để khắc phục điều này, hãy bọc đối tượng bằng chữ trong ngoặc đơn
async param => expression
async [param1, param2, ...paramN] => {
statements
}
2Không thể được sử dụng như phương pháp
Các biểu thức hàm mũi tên chỉ nên được sử dụng cho các hàm không có phương thức vì chúng không có
async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 của riêng chúng. Hãy xem điều gì sẽ xảy ra khi chúng ta cố gắng sử dụng chúng như các phương thức[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
0Một ví dụ khác liên quan đến
async param => expression
async [param1, param2, ...paramN] => {
statements
}
30[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
1Bởi vì phần thân của lớp có ngữ cảnh
async param => expression
async [param1, param2, ...paramN] => {
statements
}
6, các chức năng của mũi tên khi các trường lớp đóng trên ngữ cảnh async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 của lớp và async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 bên trong phần thân của hàm mũi tên sẽ trỏ chính xác đến thể hiện [hoặc chính lớp đó, đối với các trường tĩnh]. Tuy nhiên, vì nó là một bao đóng, không phải ràng buộc riêng của hàm, nên giá trị của async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 sẽ không thay đổi dựa trên ngữ cảnh thực thi[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
2Các thuộc tính hàm mũi tên thường được cho là "phương thức tự động liên kết", bởi vì tương đương với các phương thức thông thường là
[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
3Ghi chú. Các trường lớp được xác định trên phiên bản chứ không phải trên nguyên mẫu, vì vậy mỗi lần tạo phiên bản sẽ tạo một tham chiếu hàm mới và phân bổ một bao đóng mới, có khả năng dẫn đến sử dụng nhiều bộ nhớ hơn so với phương thức không liên kết thông thường
Vì những lý do tương tự, các phương thức
async param => expression
async [param1, param2, ...paramN] => {
statements
}
35, async param => expression
async [param1, param2, ...paramN] => {
statements
}
36 và async param => expression
async [param1, param2, ...paramN] => {
statements
}
37 không hữu ích khi được gọi trên các hàm mũi tên, bởi vì các hàm mũi tên thiết lập async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 dựa trên phạm vi mà hàm mũi tên được xác định bên trong và giá trị async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 không thay đổi dựa trên cách hoạt động của hàm Không ràng buộc đối số
Các hàm mũi tên không có đối tượng
async param => expression
async [param1, param2, ...paramN] => {
statements
}
7 của riêng chúng. Do đó, trong ví dụ này, async param => expression
async [param1, param2, ...paramN] => {
statements
}
7 là một tham chiếu đến các đối số của phạm vi kèm theo[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
4Ghi chú. Bạn không thể khai báo một biến có tên là
async param => expression
async [param1, param2, ...paramN] => {
statements
}
7 ở chế độ nghiêm ngặt, vì vậy đoạn mã trên sẽ là một lỗi cú pháp. Điều này làm cho hiệu ứng phạm vi của async param => expression
async [param1, param2, ...paramN] => {
statements
}
7 dễ hiểu hơn nhiềuTrong hầu hết các trường hợp, sử dụng các tham số còn lại là một cách thay thế tốt cho việc sử dụng một đối tượng
async param => expression
async [param1, param2, ...paramN] => {
statements
}
7[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
5Không thể được sử dụng làm hàm tạo
Các hàm mũi tên không thể được sử dụng làm hàm tạo và sẽ báo lỗi khi được gọi với
async param => expression
async [param1, param2, ...paramN] => {
statements
}
9. Họ cũng không có tài sản async param => expression
async [param1, param2, ...paramN] => {
statements
}
56[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
6Không thể được sử dụng như máy phát điện
Không thể sử dụng từ khóa
// Traditional anonymous function
[function [a] {
return a + 100;
}];
// 1. Remove the word "function" and place arrow between the argument and opening body bracket
[a] => {
return a + 100;
};
// 2. Remove the body braces and word "return" — the return is implied.
[a] => a + 100;
// 3. Remove the parameter parentheses
a => a + 100;
2 trong phần thân của hàm mũi tên [ngoại trừ khi được sử dụng trong các hàm tạo được lồng thêm trong hàm mũi tên]. Do đó, các chức năng mũi tên không thể được sử dụng làm trình tạoNgắt dòng trước mũi tên
Một hàm mũi tên không thể chứa dấu ngắt dòng giữa các tham số và mũi tên của nó
[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
7Với mục đích định dạng, bạn có thể đặt dấu ngắt dòng sau mũi tên hoặc sử dụng dấu ngoặc đơn/dấu ngoặc quanh thân hàm, như minh họa bên dưới. Bạn cũng có thể đặt ngắt dòng giữa các tham số
[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
8Ưu tiên của mũi tên
Mặc dù mũi tên trong hàm mũi tên không phải là toán tử, nhưng hàm mũi tên có các quy tắc phân tích cú pháp đặc biệt tương tác khác với mức độ ưu tiên của toán tử so với các hàm thông thường
[a, b, ...r] => expression
[a = 400, b = 20, c] => expression
[[a, b] = [10, 20]] => expression
[{ a, b } = { a: 10, b: 20 }] => expression
9Bởi vì
async param => expression
async [param1, param2, ...paramN] => {
statements
}
58 có mức độ ưu tiên thấp hơn so với hầu hết các toán tử, dấu ngoặc đơn là cần thiết để tránh việc async param => expression
async [param1, param2, ...paramN] => {
statements
}
59 được phân tích thành danh sách đối số của hàm mũi tênasync param => expression
async [param1, param2, ...paramN] => {
statements
}
0ví dụ
Sử dụng chức năng mũi tên
async param => expression
async [param1, param2, ...paramN] => {
statements
}
1Sử dụng cuộc gọi, liên kết và áp dụng
Các phương thức
async param => expression
async [param1, param2, ...paramN] => {
statements
}
35, async param => expression
async [param1, param2, ...paramN] => {
statements
}
36 và async param => expression
async [param1, param2, ...paramN] => {
statements
}
37 hoạt động như mong đợi với các hàm truyền thống, bởi vì chúng tôi thiết lập phạm vi cho từng phương thứcasync param => expression
async [param1, param2, ...paramN] => {
statements
}
2Với các hàm mũi tên, vì hàm
async param => expression
async [param1, param2, ...paramN] => {
statements
}
63 của chúng ta về cơ bản được tạo trên phạm vi [toàn cầu] của async param => expression
async [param1, param2, ...paramN] => {
statements
}
64, nên nó sẽ giả sử async param => expression
async [param1, param2, ...paramN] => {
statements
}
6 là async param => expression
async [param1, param2, ...paramN] => {
statements
}
64async param => expression
async [param1, param2, ...paramN] => {
statements
}
3Có lẽ lợi ích lớn nhất của việc sử dụng hàm mũi tên là với các phương thức như
async param => expression
async [param1, param2, ...paramN] => {
statements
}
67 và async param => expression
async [param1, param2, ...paramN] => {
statements
}
68 thường yêu cầu một số kiểu đóng, async param => expression
async [param1, param2, ...paramN] => {
statements
}
35, async param => expression
async [param1, param2, ...paramN] => {
statements
}
36 hoặc async param => expression
async [param1, param2, ...paramN] => {
statements
}
37 để đảm bảo rằng hàm được thực thi trong phạm vi phù hợp