Các chức năng được khai báo không được thực thi ngay lập tức. Chúng được "lưu để sử dụng sau" và sẽ được thực thi sau, khi chúng được gọi [được gọi]
Dấu chấm phẩy được sử dụng để phân tách các câu lệnh JavaScript thực thi.
Vì một khai báo hàm không phải là một câu lệnh thực thi nên không thường kết thúc nó bằng dấu chấm phẩy.
Biểu thức hàm
Hàm JavaScript cũng có thể được xác định bằng biểu thức
Một biểu thức chức năng có thể được lưu trữ trong một biến
Sau khi một biểu thức hàm đã được lưu trữ trong một biến, biến đó có thể được sử dụng như một hàm
Chức năng trên thực sự là một chức năng ẩn danh [một chức năng không có tên]
Các hàm được lưu trữ trong các biến không cần tên hàm. Chúng luôn được gọi [được gọi] bằng cách sử dụng tên biến
Hàm trên kết thúc bằng dấu chấm phẩy vì nó là một phần của câu lệnh thực thi
Hàm xây dựng []
Như bạn đã thấy trong các ví dụ trước, các hàm JavaScript được định nghĩa bằng từ khóa
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
03Các hàm cũng có thể được xác định bằng hàm tạo hàm JavaScript tích hợp có tên là
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
04Ví dụ
const myFunction = new Function["a", "b", "return a * b"];
cho x = myFunction[4, 3];
Tự mình thử »Bạn thực sự không phải sử dụng hàm tạo. Ví dụ trên cũng giống như cách viết
Ví dụ
const myFunction = function[a,b] {return a*b};
cho x = myFunction[4, 3];
Tự mình thử »Hầu hết thời gian, bạn có thể tránh sử dụng từ khóa
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
05 trong JavaScriptcẩu chức năng
Trước đó trong hướng dẫn này, bạn đã học về "hoisting" [JavaScript Hoisting]
Nâng là hành vi mặc định của JavaScript để di chuyển các khai báo lên đầu phạm vi hiện tại
Hoisting áp dụng cho khai báo biến và khai báo hàm
Do đó, các hàm JavaScript có thể được gọi trước khi chúng được khai báo
chức năng của tôi [5];
function myFunction[y] {
return y * y;
}
Các chức năng được xác định bằng một biểu thức không được nâng lên
Chức năng tự gọi
Các biểu thức chức năng có thể được thực hiện "tự gọi"
Một biểu thức tự gọi được gọi [bắt đầu] tự động mà không được gọi
Các biểu thức hàm sẽ tự động thực thi nếu biểu thức được theo sau bởi []
Bạn không thể tự gọi khai báo hàm
Bạn phải thêm dấu ngoặc đơn xung quanh hàm để chỉ ra rằng đó là một biểu thức hàm
Ví dụ
[function [] {
let x = "Xin chào. "; // Tôi sẽ gọi chính mình
}][];
Chức năng trên thực sự là một chức năng tự gọi ẩn danh [hàm không có tên]
Hàm có thể được sử dụng làm giá trị
Các hàm JavaScript có thể được sử dụng làm giá trị
Ví dụ
function myFunction[a, b] {
return a * b;
}
cho x = myFunction[4, 3];
Tự mình thử »Các hàm JavaScript có thể được sử dụng trong các biểu thức
Ví dụ
function myFunction[a, b] {
return a * b;
}
đặt x = myFunction[4, 3] * 2;
Tự mình thử »Chức năng là đối tượng
Toán tử
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
06 trong JavaScript trả về "hàm" cho các hàmTuy nhiên, các hàm JavaScript tốt nhất có thể được mô tả dưới dạng các đối tượng
Hàm JavaScript có cả thuộc tính và phương thức
Thuộc tính
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
07 trả về số đối số nhận được khi hàm được gọiPhương thức
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
08 trả về hàm dưới dạng một chuỗiVí dụ
function myFunction[a, b] {
return a * b;
}
hãy để văn bản = myFunction. toString[];
Tự mình thử »Một hàm được định nghĩa là thuộc tính của một đối tượng, được gọi là một phương thức đối với đối tượng.
Một hàm được thiết kế để tạo đối tượng mới, được gọi là hàm tạo đối tượng.
Hàm mũi tên
Các hàm mũi tên cho phép một cú pháp ngắn để viết các biểu thức hàm
Bạn không cần từ khóa
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
03, từ khóa const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
10 và dấu ngoặc nhọnVí dụ
// ES5
var x = function[x, y] {
return x * y;
}
// ES6
const x = [x, y] => x * y;
Các hàm mũi tên không có
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
11 của riêng chúng. Chúng không phù hợp để xác định các phương thức đối tượngCác chức năng mũi tên không được nâng lên. Chúng phải được xác định trước khi chúng được sử dụng
Sử dụng ________ 2030 an toàn hơn sử dụng ________ 2031, vì biểu thức hàm luôn có giá trị không đổi
Bạn chỉ có thể bỏ qua từ khóa
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
10 và dấu ngoặc nhọn nếu hàm là một câu lệnh đơn. Vì điều này, có thể là một thói quen tốt để luôn giữ chúng Các hàm là một trong những khối xây dựng cơ bản trong JavaScript. Một hàm trong JavaScript tương tự như một thủ tục—một tập hợp các câu lệnh thực hiện một tác vụ hoặc tính toán một giá trị, nhưng để một thủ tục đủ điều kiện là một hàm, nó phải nhận một số đầu vào và trả về một đầu ra khi có một số mối quan hệ rõ ràng giữa . Để sử dụng một chức năng, bạn phải xác định nó ở đâu đó trong phạm vi mà bạn muốn gọi nó
Xem thêm chương tham khảo đầy đủ về các hàm JavaScript để biết chi tiết
Một định nghĩa hàm [còn được gọi là khai báo hàm hoặc câu lệnh hàm] bao gồm từ khóa
function myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
9, theo sau là- Tên của chức năng
- Danh sách các tham số của hàm, được đặt trong dấu ngoặc đơn và được phân tách bằng dấu phẩy
- Các câu lệnh JavaScript xác định hàm, được đặt trong dấu ngoặc nhọn,
0const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
Ví dụ, đoạn mã sau định nghĩa một hàm đơn giản có tên là
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
1function square[number] {
return number * number;
}
Hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
1 nhận một tham số, được gọi là const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
3. Hàm bao gồm một câu lệnh cho biết trả về tham số của hàm [tức là, const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
3] nhân với chính nó. Câu lệnh const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
5 chỉ định giá trị được trả về bởi hàm________số 8
Về cơ bản, các tham số được truyền cho các hàm theo giá trị — vì vậy nếu mã trong phần thân của hàm gán một giá trị hoàn toàn mới cho một tham số được truyền cho hàm, thì thay đổi đó không được phản ánh trên toàn cục hoặc trong mã gọi hàm đó
Khi bạn chuyển một đối tượng làm tham số, nếu hàm thay đổi thuộc tính của đối tượng, thì thay đổi đó sẽ hiển thị bên ngoài hàm, như minh họa trong ví dụ sau
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
Khi bạn chuyển một mảng dưới dạng tham số, nếu hàm thay đổi bất kỳ giá trị nào của mảng, thì thay đổi đó sẽ hiển thị bên ngoài hàm, như minh họa trong ví dụ sau
function myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
Mặc dù khai báo hàm ở trên là một câu lệnh về mặt cú pháp, các hàm cũng có thể được tạo bởi một biểu thức hàm
Một chức năng như vậy có thể ẩn danh; . Ví dụ, hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
1 có thể được định nghĩa làconst square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
Tuy nhiên, một tên có thể được cung cấp với một biểu thức chức năng. Việc cung cấp tên cho phép hàm tham chiếu đến chính nó và cũng giúp xác định hàm dễ dàng hơn trong dấu vết ngăn xếp của trình gỡ lỗi
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
3Các biểu thức hàm thuận tiện khi chuyển một hàm làm đối số cho một hàm khác. Ví dụ sau đây cho thấy một hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
7 sẽ nhận một hàm làm đối số thứ nhất và một mảng làm đối số thứ haiconst square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
5Trong đoạn mã sau, hàm nhận một hàm được xác định bởi một biểu thức hàm và thực thi nó cho mọi phần tử của mảng nhận được dưới dạng đối số thứ hai
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
6Hàm trả về.
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
8Trong JavaScript, một chức năng có thể được xác định dựa trên một điều kiện. Ví dụ: định nghĩa hàm sau chỉ xác định
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
9 nếu const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
30 bằng const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
31const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
1Ngoài việc xác định các hàm như được mô tả ở đây, bạn cũng có thể sử dụng hàm tạo
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
32 để tạo các hàm từ một chuỗi trong thời gian chạy, giống như const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
33Một phương thức là một chức năng là một thuộc tính của một đối tượng. Đọc thêm về đối tượng và phương pháp trong Làm việc với đối tượng
Xác định một chức năng không thực thi nó. Xác định nó đặt tên cho hàm và chỉ định những việc cần làm khi hàm được gọi
Gọi hàm thực sự thực hiện các hành động được chỉ định với các tham số được chỉ định. Ví dụ, nếu bạn định nghĩa hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
1, bạn có thể gọi nó như sauconst square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
5Câu lệnh trước gọi hàm với đối số là
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
35. Hàm thực thi các câu lệnh của nó và trả về giá trị const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
36Hàm phải nằm trong phạm vi khi chúng được gọi, nhưng phần khai báo hàm có thể nằm trong phạm vi [xuất hiện bên dưới lệnh gọi trong mã]. Phạm vi của một khai báo hàm là hàm mà nó được khai báo [hoặc toàn bộ chương trình, nếu nó được khai báo ở mức cao nhất]
Các đối số của hàm không giới hạn ở chuỗi và số. Bạn có thể chuyển toàn bộ đối tượng vào một hàm. Hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
37 [được định nghĩa trong ] là một ví dụ về hàm lấy một đối tượng làm đối sốMột chức năng có thể gọi chính nó. Ví dụ, đây là một hàm tính giai thừa theo cách đệ quy
return number * number;
0Sau đó, bạn có thể tính giai thừa của
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
38 đến const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
35 như saureturn number * number;
1Có nhiều cách khác để gọi hàm. Thường có những trường hợp một hàm cần được gọi động hoặc số lượng đối số cho một hàm khác nhau hoặc trong đó ngữ cảnh của lệnh gọi hàm cần được đặt thành một đối tượng cụ thể được xác định trong thời gian chạy
Hóa ra bản thân các hàm là các đối tượng - và ngược lại, các đối tượng này có các phương thức. [Xem đối tượng
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
32. ] Các phương pháp const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
51 và const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
52 có thể được sử dụng để đạt được mục tiêu nàyHãy xem xét ví dụ dưới đây
return number * number;
2Mã này chạy không có lỗi, mặc dù hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
53 được gọi trước khi nó được khai báo. Điều này là do trình thông dịch JavaScript nâng toàn bộ khai báo hàm lên đầu phạm vi hiện tại, vì vậy đoạn mã trên tương đương vớireturn number * number;
3Tính năng nâng hàm chỉ hoạt động với các khai báo hàm — không hoạt động với các biểu thức hàm. Mã bên dưới sẽ không hoạt động
return number * number;
4Các biến được xác định bên trong một hàm không thể được truy cập từ bất kỳ đâu bên ngoài hàm, bởi vì biến chỉ được xác định trong phạm vi của hàm. Tuy nhiên, một hàm có thể truy cập tất cả các biến và hàm được xác định bên trong phạm vi mà nó được xác định
Nói cách khác, một hàm được xác định trong phạm vi toàn cầu có thể truy cập tất cả các biến được xác định trong phạm vi toàn cầu. Một hàm được xác định bên trong một hàm khác cũng có thể truy cập tất cả các biến được xác định trong hàm cha của nó và bất kỳ biến nào khác mà hàm cha có quyền truy cập
return number * number;
5Một chức năng có thể tham khảo và gọi chính nó. Có ba cách để một hàm tham chiếu đến chính nó
- Tên chức năng
54const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
- Một biến trong phạm vi đề cập đến chức năng
Ví dụ, xét định nghĩa hàm sau
return number * number;
6Trong thân hàm, tất cả những điều sau đây đều tương đương
55const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
56const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
57const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
Hàm gọi chính nó được gọi là hàm đệ quy. Trong một số cách, đệ quy tương tự như một vòng lặp. Cả hai đều thực thi cùng một mã nhiều lần và cả hai đều yêu cầu một điều kiện [để tránh vòng lặp vô hạn, hay đúng hơn là đệ quy vô hạn trong trường hợp này]
Ví dụ, xét vòng lặp sau
return number * number;
7Nó có thể được chuyển đổi thành một khai báo hàm đệ quy, theo sau là lời gọi hàm đó
return number * number;
8Tuy nhiên, một số thuật toán không thể là các vòng lặp đơn giản. Ví dụ: lấy tất cả các nút của cấu trúc cây [chẳng hạn như DOM] dễ dàng hơn thông qua đệ quy
return number * number;
9So với hàm
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
58, mỗi lời gọi đệ quy tự nó thực hiện nhiều lời gọi đệ quy ở đâyCó thể chuyển đổi bất kỳ thuật toán đệ quy nào thành thuật toán không đệ quy, nhưng logic thường phức tạp hơn nhiều và làm như vậy yêu cầu sử dụng ngăn xếp
Trên thực tế, bản thân đệ quy sử dụng ngăn xếp. ngăn xếp chức năng. Hành vi giống như ngăn xếp có thể được nhìn thấy trong ví dụ sau
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
0Bạn có thể lồng một chức năng trong một chức năng khác. Hàm lồng nhau [bên trong] là riêng tư đối với hàm chứa [bên ngoài] của nó
Nó cũng tạo thành một đóng cửa. Bao đóng là một biểu thức [phổ biến nhất là một hàm] có thể có các biến tự do cùng với một môi trường liên kết các biến đó ["đóng" biểu thức]
Vì một hàm lồng nhau là một hàm bao đóng, điều này có nghĩa là một hàm lồng nhau có thể "kế thừa" các đối số và biến của hàm chứa nó. Nói cách khác, hàm bên trong chứa phạm vi của hàm bên ngoài
Để tóm tắt
- Hàm bên trong chỉ có thể được truy cập từ các câu lệnh trong hàm bên ngoài
- Hàm bên trong tạo thành một bao đóng. hàm bên trong có thể sử dụng các đối số và biến của hàm bên ngoài, trong khi hàm bên ngoài không thể sử dụng các đối số và biến của hàm bên trong
Ví dụ sau đây cho thấy các hàm lồng nhau
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
1Vì hàm bên trong tạo thành một bao đóng, nên bạn có thể gọi hàm bên ngoài và chỉ định các đối số cho cả hàm bên ngoài và bên trong
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
2Lưu ý cách
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59 được bảo toàn khi trả về const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
60. Một bao đóng phải bảo toàn các đối số và biến trong tất cả các phạm vi mà nó tham chiếu. Vì mỗi lệnh gọi cung cấp các đối số có khả năng khác nhau nên một lần đóng mới được tạo cho mỗi lệnh gọi tới const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
61. Bộ nhớ chỉ có thể được giải phóng khi const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
60 được trả về không còn truy cập được nữaĐiều này không khác với việc lưu trữ các tham chiếu trong các đối tượng khác, nhưng thường ít rõ ràng hơn vì người ta không đặt trực tiếp các tham chiếu và không thể kiểm tra chúng
Các chức năng có thể được nhân lồng nhau. Ví dụ
- Hàm [
63] chứa hàm [const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64], chính hàm này chứa hàm [const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65]const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
- Cả hai chức năng đóng biểu mẫu
64 vàconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 ở đây. Vì vậy,const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 có thể truy cậpconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63 vàconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 có thể truy cậpconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
- Ngoài ra, vì
65 có thể truy cậpconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 có thể truy cậpconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63, nênconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 cũng có thể truy cậpconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
Do đó, các bao đóng có thể chứa nhiều phạm vi; . Điều này được gọi là chuỗi phạm vi. [Lý do nó được gọi là "chuỗi" sẽ được giải thích sau. ]
Xem xét ví dụ sau
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
3Trong ví dụ này,
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
65 truy cập const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
19 của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
64 và const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59 của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
63Điều này có thể được thực hiện bởi vì
64 tạo thành một bao đóng bao gồmconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63 [i. e. ,const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 có thể truy cập các đối số và biến củaconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63]const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 tạo thành một bao đóng bao gồm cảconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
- Bởi vì bao đóng của
65 bao gồm cảconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 và bao đóng củaconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 bao gồm cảconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63, nên bao đóng củaconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 cũng bao gồm cảconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63. Điều này có nghĩa làconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 có thể truy cập cả đối số và biến củaconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 vàconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63. Nói cách khác,const square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
65 xâu chuỗi phạm vi củaconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
64 vàconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
63, theo thứ tự đóconst square = function [number] { return number * number; } const x = square[4]; // x gets the value 16
Tuy nhiên, điều ngược lại là không đúng.
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
63 không thể truy cập const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
65, vì const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
63 không thể truy cập bất kỳ đối số hoặc biến nào của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
64, mà const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
65 là một biến của. Do đó, const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
65 vẫn là riêng tư đối với chỉ const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
64Khi hai đối số hoặc biến trong phạm vi đóng có cùng tên, sẽ xảy ra xung đột tên. Nhiều phạm vi lồng nhau hơn được ưu tiên. Vì vậy, phạm vi trong cùng có mức độ ưu tiên cao nhất, trong khi phạm vi ngoài cùng có mức độ ưu tiên thấp nhất. Đây là chuỗi phạm vi. Đầu tiên trên chuỗi là phạm vi trong cùng và cuối cùng là phạm vi ngoài cùng. Hãy xem xét những điều sau đây
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
4Xung đột tên xảy ra tại câu lệnh
return number * number;
17 và nằm giữa tham số của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
60 là const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59 và biến của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
61 là const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59. Chuỗi phạm vi ở đây là {const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
60, const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
61, đối tượng toàn cầu}. Do đó, const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59 của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
60 được ưu tiên hơn const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
59 của const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
61 và return number * number;
28 [_______159 của ______160] được trả về thay vì ________ 831 [_______ 161 của _______ 159]Bao đóng là một trong những tính năng mạnh mẽ nhất của JavaScript. JavaScript cho phép lồng các hàm và cấp cho hàm bên trong toàn quyền truy cập vào tất cả các biến và hàm được xác định bên trong hàm bên ngoài [và tất cả các biến và hàm khác mà hàm bên ngoài có quyền truy cập]
Tuy nhiên, hàm bên ngoài không có quyền truy cập vào các biến và hàm được xác định bên trong hàm bên trong. Điều này cung cấp một loại đóng gói cho các biến của hàm bên trong
Ngoài ra, vì chức năng bên trong có quyền truy cập vào phạm vi của chức năng bên ngoài, các biến và hàm được xác định trong chức năng bên ngoài sẽ tồn tại lâu hơn thời lượng thực thi chức năng bên ngoài, nếu chức năng bên trong quản lý để tồn tại ngoài vòng đời của chức năng bên ngoài. . Một bao đóng được tạo khi chức năng bên trong bằng cách nào đó được cung cấp cho bất kỳ phạm vi nào bên ngoài chức năng bên ngoài
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
5Nó có thể phức tạp hơn nhiều so với đoạn mã trên. Một đối tượng chứa các phương thức để thao tác các biến bên trong của hàm bên ngoài có thể được trả về
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
6Trong đoạn mã trên, biến
return number * number;
34 của hàm bên ngoài có thể truy cập được đối với các hàm bên trong và không có cách nào khác để truy cập các biến bên trong ngoại trừ thông qua các hàm bên trong. Các biến bên trong của các hàm bên trong hoạt động như các kho lưu trữ an toàn cho các đối số và biến bên ngoài. Chúng giữ dữ liệu "liên tục" và "đóng gói" để các chức năng bên trong hoạt động với. Các chức năng thậm chí không phải được gán cho một biến hoặc có tênfunction myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
7Ghi chú. Có một số cạm bẫy cần chú ý khi sử dụng bao đóng
Nếu một hàm kèm theo định nghĩa một biến có cùng tên với một biến trong phạm vi bên ngoài, thì không có cách nào để tham chiếu lại biến đó trong phạm vi bên ngoài. [Biến phạm vi bên trong "đè" biến bên ngoài, cho đến khi chương trình thoát khỏi phạm vi bên trong. Nó có thể được coi là một. ]
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
8Các đối số của một hàm được duy trì trong một đối tượng giống như mảng. Trong một hàm, bạn có thể giải quyết các đối số được truyền cho nó như sau
function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
9trong đó
return number * number;
35 là số thứ tự của đối số, bắt đầu từ const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
31. Vì vậy, đối số đầu tiên được truyền cho một hàm sẽ là return number * number;
37. Tổng số đối số được biểu thị bằng return number * number;
38Sử dụng đối tượng
return number * number;
39, bạn có thể gọi một hàm có nhiều đối số hơn nó được khai báo chính thức để chấp nhận. Điều này thường hữu ích nếu bạn không biết trước có bao nhiêu đối số sẽ được truyền cho hàm. Bạn có thể sử dụng return number * number;
38 để xác định số lượng đối số thực sự được truyền cho hàm, sau đó truy cập từng đối số bằng cách sử dụng đối tượng return number * number;
39Ví dụ, xét một hàm nối nhiều chuỗi. Đối số chính thức duy nhất cho hàm là một chuỗi chỉ định các ký tự phân tách các mục để nối. Hàm được định nghĩa như sau
function myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
0Bạn có thể chuyển bất kỳ số lượng đối số nào cho hàm này và nó nối từng đối số thành một chuỗi "danh sách"
function myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
1Ghi chú. Biến
return number * number;
39 là "giống như mảng", nhưng không phải là một mảng. Nó giống mảng ở chỗ nó có chỉ mục được đánh số và thuộc tính return number * number;
43. Tuy nhiên, nó không sở hữu tất cả các phương thức thao tác mảngXem đối tượng
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
32 trong tài liệu tham khảo JavaScript để biết thêm thông tinCó hai loại cú pháp tham số đặc biệt. tham số mặc định và tham số còn lại
Trong JavaScript, tham số của hàm mặc định là
return number * number;
45. Tuy nhiên, trong một số trường hợp, có thể hữu ích khi đặt một giá trị mặc định khác. Đây chính xác là những gì các thông số mặc định làmTrước đây, chiến lược chung để đặt giá trị mặc định là kiểm tra các giá trị tham số trong phần thân của hàm và gán giá trị nếu chúng là
return number * number;
45Trong ví dụ sau, nếu không có giá trị nào được cung cấp cho
return number * number;
47, thì giá trị của nó sẽ là return number * number;
45 khi đánh giá return number * number;
49 và lệnh gọi tới return number * number;
50 thường sẽ trả về return number * number;
51. Tuy nhiên, điều này bị ngăn chặn bởi dòng thứ hai trong ví dụ nàyfunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
2Với các tham số mặc định, việc kiểm tra thủ công trong thân hàm không còn cần thiết nữa. Bạn có thể đặt
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
38 làm giá trị mặc định cho return number * number;
47 trong phần đầu của hàmfunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
3Để biết thêm chi tiết, hãy xem các tham số mặc định trong tài liệu tham khảo
Cú pháp tham số còn lại cho phép chúng ta biểu diễn một số lượng đối số không xác định dưới dạng một mảng
Trong ví dụ sau, hàm
return number * number;
50 sử dụng các tham số còn lại để thu thập các đối số từ phần thứ hai đến phần cuối. Sau đó, hàm sẽ nhân chúng với đối số đầu tiênfunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
4Một biểu thức hàm mũi tên [còn được gọi là mũi tên béo để phân biệt với cú pháp
return number * number;
55 giả định trong JavaScript tương lai] có cú pháp ngắn hơn so với các biểu thức hàm và không có return number * number;
56, return number * number;
39, return number * number;
58 hoặc return number * number;
59 của riêng nó. Các chức năng mũi tên luôn ẩn danhHai yếu tố ảnh hưởng đến việc giới thiệu các chức năng mũi tên. chức năng ngắn hơn và không ràng buộc của
return number * number;
56Trong một số mẫu chức năng, các chức năng ngắn hơn được hoan nghênh. So sánh
function myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
5Cho đến các hàm mũi tên, mọi hàm mới đã xác định giá trị
return number * number;
56 của riêng nó [một đối tượng mới trong trường hợp hàm tạo, không xác định trong các lệnh gọi hàm chế độ nghiêm ngặt, đối tượng cơ sở nếu hàm được gọi là "phương thức đối tượng", v.v. ]. Điều này được chứng minh là không lý tưởng với phong cách lập trình hướng đối tượngfunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
6Trong ECMAScript 3/5, sự cố này đã được khắc phục bằng cách gán giá trị trong
return number * number;
56 cho một biến có thể được đóng lạifunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
7Ngoài ra, một hàm ràng buộc có thể được tạo để giá trị
return number * number;
56 phù hợp sẽ được chuyển đến hàm return number * number;
64Hàm mũi tên không có
return number * number;
56 của riêng nó; . Do đó, trong đoạn mã sau, return number * number;
56 trong hàm được truyền cho return number * number;
68 có cùng giá trị với return number * number;
56 trong hàm kèm theofunction myFunc[theArr] {
theArr[0] = 30;
}
const arr = [45];
console.log[arr[0]]; // 45
myFunc[arr];
console.log[arr[0]]; // 30
8JavaScript có một số chức năng tích hợp, cấp cao nhất
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
33Phương thức
const square = function [number] {
return number * number;
}
const x = square[4]; // x gets the value 16
33 đánh giá mã JavaScript được biểu diễn dưới dạng chuỗireturn number * number;
72Hàm toàn cầu
return number * number;
72 xác định xem giá trị được truyền có phải là một số hữu hạn hay không. Nếu cần, tham số đầu tiên được chuyển đổi thành một sốreturn number * number;
74Hàm
return number * number;
74 xác định xem một giá trị có phải là return number * number;
51 hay không. Ghi chú. cưỡng chế bên trong hàm return number * number;
77 có quy tắc; return number * number;
79Hàm
return number * number;
79 phân tích một đối số chuỗi và trả về một số dấu phẩy độngreturn number * number;
81Hàm
return number * number;
81 phân tích một đối số chuỗi và trả về một số nguyên của cơ số đã chỉ định [cơ số trong các hệ thống số toán học]return number * number;
83Hàm
return number * number;
83 giải mã Mã định danh tài nguyên đồng nhất [URI] được tạo trước đó bởi return number * number;
85 hoặc bởi một quy trình tương tựreturn number * number;
86Phương thức
return number * number;
86 giải mã thành phần Mã định danh tài nguyên đồng nhất [URI] được tạo trước đó bởi return number * number;
88 hoặc bởi một quy trình tương tựreturn number * number;
89Phương thức
return number * number;
89 mã hóa Mã định danh tài nguyên đồng nhất [URI] bằng cách thay thế từng phiên bản của các ký tự nhất định bằng một, hai, ba hoặc bốn chuỗi thoát đại diện cho mã hóa UTF-8 của ký tự [sẽ chỉ có bốn chuỗi thoát cho các ký tự bao gồm hai return number * number;
91Phương thức
return number * number;
91 mã hóa thành phần Mã định danh tài nguyên đồng nhất [URI] bằng cách thay thế từng phiên bản của các ký tự nhất định bằng một, hai, ba hoặc bốn chuỗi thoát đại diện cho mã hóa UTF-8 của ký tự [sẽ chỉ có bốn chuỗi thoát cho các ký tự bao gồm return number * number;
93Phương thức
return number * number;
93 không dùng nữa tính toán một chuỗi mới trong đó một số ký tự nhất định đã được thay thế bằng một chuỗi thoát thập lục phân. Sử dụng return number * number;
85 hoặc return number * number;
88 để thay thếreturn number * number;
97Phương thức
return number * number;
97 không dùng nữa tính toán một chuỗi mới trong đó các chuỗi thoát thập lục phân được thay thế bằng ký tự mà nó đại diện. Các chuỗi thoát có thể được giới thiệu bởi một chức năng như return number * number;
99. Bởi vì return number * number;
97 không được dùng nữa, hãy sử dụng return number * number;
83 hoặc function myFunc[theObject] {
theObject.make = 'Toyota';
}
const mycar = {
make: 'Honda',
model: 'Accord',
year: 1998,
};
// x gets the value "Honda"
const x = mycar.make;
// the make property is changed by the function
myFunc[mycar];
// y gets the value "Toyota"
const y = mycar.make;
02 để thay thế