Cách trên khá dễ hiểu và thường đọc xong người ta sẽ nghĩ đến việc sử dụng cách này luôn. Tuy nhiên, trong trường hợp nào đó, vô tình chúng ta bị nhầm lẫn giữa các biến số đó với một số biến số nào trước đó thì thật là tai hại
Ngoài cách dùng vòng for, chúng ta có thể dùng forEach, một hàm khá hay và rút gọn
2. Use forEach thế nào ?Bài toán trên có thể được sử dụng với forEach như sau
const numbers = [1, 2, 3, 4, 5, 6];
let sum = 0;
forEach[numbers, function[element]{
sum += element;
}];
console.log[sum];
// => 21
Cũng khá dễ hiểu nhỉ vì nó khá giống với ngôn ngữ tự nhiên mà [hihi]
3. Giới thiệu về forEachforEach là một phương thức có sẵn của mảng được Javascript cung cấp
**Cú pháp của nó là. **
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
Giải thích
gọi lại. is a function to execute with each section of the array, bao gồm 3 tham số
giá trị hiện tại. the current section at being processing of array
mục lục. only number of the Element section at being processing of array
mảng. mảng hiện tại đang gọi hàm forEach
thisArg. value is used as this, is reference to the objects when thực hiện chức năng gọi lại hàm [If thisArg could not be said to the default, default is undefined]
Ví dụ trong tổng của mảng
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
Ví dụ sử dụng thisArg
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
Khá là dễ hiểu phải không ạ? . Tùy vào từng trường hợp, mình có thể sử dụng linh hoạt
4. A other functionNgoài forEach, thì Javascript còn cung cấp một số phương thức khác như. lọc, giảm, bản đồ, mọi. Trong dự án mình đang làm cũng liên quan khá nhiều đến xử lý các mảng, ơn giời là các phương thức này đã cứu cánh mình rất nhiều, nếu mình còn dùng for và for để xử lý thì. bao nhiêu dòng mã cho đủ, và mỗi lần duy trì lại thật là ác mộng. Sau đây là một số phương thức mình hay sử dụng
- Bản đồ
Cái đầu tiên phải kể đến đó chính là map, một hàm mình dùng khá là nhiều
Select a ví dụ
let arrayName = dataResponse.map[ item => {
return item.Name
}
Nói một cách dễ hiểu, map trả về 1 mảng mới có độ dài bằng mảng ban đầu
- Lọc
Nghe tới tên, là ta có thể hình dung luôn được nó sẽ làm gì rồi đúng không ạ? . Bộ lọc trả về 1 mảng có độ dài { return company["companyId"] === companyId; }]
- Giảm
Giảm thường được sử dụng nhiều cho công việc tính toán, nó trả về một giá trị
Selected ví dụ
let total_weight = animals.reduce[[weight, animal, index, animals] => {
return weight += animal.weight
}, 0]
Ngoài ra, thì còn rất nhiều hàm khác, mình có thể tham khảo thêm tại đây
Với các ví dụ đơn giản kể trên, ta hiểu rõ hơn về cách sử dụng các hàm map, filter và reduce. Các hàm này sẽ càng được ưu tiên tối đa hơn với các dữ liệu hay mã nhiều, phức tạp, mình khuyên các bạn nên tìm hiểu về nó, vì nó khá hay và đơn giản
Trên đây là chia sẻ của mình về công việc foreach và các hàm trong javascript. Cảm ơn các bạn đã đọc, mong bài viết của mình phần nào có thể giúp ích cho các bạn trong công việc xử lý mảng
JavaScript là một ngôn ngữ động, đa mô hình với các loại và toán tử, các đối tượng tích hợp sẵn và các phương thức. Cú pháp của nó dựa trên ngôn ngữ Java và C — nhiều cấu trúc từ các ngôn ngữ đó cũng áp dụng cho JavaScript. JavaScript hỗ trợ lập trình hướng đối tượng với các nguyên mẫu và lớp đối tượng. Nó cũng hỗ trợ lập trình chức năng vì các chức năng là hạng nhất có thể dễ dàng tạo thông qua các biểu thức và được chuyển qua lại như bất kỳ đối tượng nào khác
Trang này phục vụ như một tổng quan nhanh về các tính năng ngôn ngữ JavaScript khác nhau, được viết cho người đọc có kiến thức cơ bản về các ngôn ngữ khác, chẳng hạn như C hoặc Java
Hãy bắt đầu bằng cách nhìn vào các khối xây dựng của bất kỳ ngôn ngữ nào. Các loại. Các chương trình JavaScript thao tác các giá trị và tất cả các giá trị đó thuộc về một loại. JavaScript cung cấp bảy loại nguyên thủy
- được sử dụng cho tất cả các giá trị số [số nguyên và dấu phẩy động] ngoại trừ các số nguyên rất lớn
- được sử dụng cho các số nguyên lớn tùy ý
- dùng để chứa văn bản
8 vàconsole.log["Hello, world"]; console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
9 — thường được sử dụng cho logic có điều kiệnconsole.log["Hello, world"]; console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
- được sử dụng để tạo số nhận dạng duy nhất sẽ không xung đột
- chỉ ra rằng một biến chưa được gán giá trị
- chỉ ra một phi giá trị có chủ ý
Mọi thứ khác được gọi là. Các loại đối tượng phổ biến bao gồm
0console.log["Hello"[1] === "e"]; // true
1console.log["Hello"[1] === "e"]; // true
2console.log["Hello"[1] === "e"]; // true
3console.log["Hello"[1] === "e"]; // true
4console.log["Hello"[1] === "e"]; // true
Hàm không phải là cấu trúc dữ liệu đặc biệt trong JavaScript — chúng chỉ là một loại đối tượng đặc biệt có thể được gọi
JavaScript có hai kiểu số tích hợp. Số và BigInt
Loại Số là giá trị dấu phẩy động có độ chính xác kép 64 bit IEEE 754, có nghĩa là các số nguyên có thể được biểu diễn một cách an toàn giữa -[253 − 1] và 253 − 1 mà không làm mất độ chính xác và các số dấu phẩy động có thể được lưu trữ mọi lúc . 79 × 10308. Trong các số, JavaScript không phân biệt giữa số dấu phẩy động và số nguyên
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
4Vì vậy, một số nguyên rõ ràng trên thực tế hoàn toàn là một số float. Do mã hóa IEEE 754, đôi khi số học dấu phẩy động có thể không chính xác
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
5Đối với các hoạt động yêu cầu số nguyên, chẳng hạn như hoạt động theo bit, số sẽ được chuyển đổi thành số nguyên 32 bit
cũng có thể có các tiền tố để biểu thị cơ số [nhị phân, bát phân, thập phân hoặc thập lục phân] hoặc hậu tố số mũ
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
6Loại BigInt là một số nguyên có độ dài tùy ý. Hành vi của nó tương tự như các kiểu số nguyên của C [e. g. chia cắt ngắn thành 0], ngoại trừ nó có thể phát triển vô tận. BigInts được chỉ định bằng chữ số và hậu tố
console.log["Hello"[1] === "e"]; // true
5arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
8Tiêu chuẩn được hỗ trợ, bao gồm cộng, trừ, số học còn lại, v.v. BigInts và số không thể được trộn lẫn trong các hoạt động số học
Đối tượng
console.log["Hello"[1] === "e"]; // true
6 cung cấp các hàm và hằng số toán học tiêu chuẩnfunction sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
0Có ba cách để chuyển đổi một chuỗi thành một số
7, phân tích cú pháp chuỗi cho một số nguyênconsole.log["Hello"[1] === "e"]; // true
8, phân tích cú pháp chuỗi cho số dấu phẩy độngconsole.log["Hello"[1] === "e"]; // true
- Hàm
9, phân tích cú pháp một chuỗi như thể đó là một số bằng chữ và hỗ trợ nhiều cách biểu diễn số khác nhauconsole.log["Hello"[1] === "e"]; // true
Bạn cũng có thể sử dụng đơn nguyên cộng với
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
40 làm cách viết tắt của console.log["Hello"[1] === "e"]; // true
9Các giá trị số cũng bao gồm
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
42 [viết tắt của "Không phải là số"] và function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
43. Nhiều thao tác "toán học không hợp lệ" sẽ trả về function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
42 — ví dụ: nếu cố phân tích cú pháp một chuỗi không phải số hoặc sử dụng function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
45 trên một giá trị âm. Chia cho 0 tạo ra function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
43 [dương hoặc âm]function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
42 là truyền nhiễm. nếu bạn cung cấp nó như một toán hạng cho bất kỳ phép toán nào, kết quả cũng sẽ là function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
42. function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
42 là giá trị duy nhất trong JavaScript không bằng chính nó [theo thông số kỹ thuật của IEEE 754]Các chuỗi trong JavaScript là các chuỗi ký tự Unicode. Đây sẽ là tin vui cho bất kỳ ai đã phải đối mặt với quá trình quốc tế hóa. Chính xác hơn, chúng là
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
Các chuỗi có thể được viết bằng dấu nháy đơn hoặc kép — JavaScript không có sự phân biệt giữa ký tự và chuỗi. Nếu bạn muốn đại diện cho một ký tự duy nhất, bạn chỉ cần sử dụng một chuỗi bao gồm ký tự duy nhất đó
console.log["Hello"[1] === "e"]; // true
Để tìm độ dài của một chuỗi [theo đơn vị mã], hãy truy cập thuộc tính
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
60 của chuỗi đóChuỗi phải thao tác chuỗi và truy cập thông tin về chuỗi. Bởi vì tất cả các nguyên thủy là bất biến theo thiết kế, các phương thức này trả về các chuỗi mới
Toán tử
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
40 bị quá tải đối với chuỗi. khi một trong các toán hạng là một chuỗi, nó thực hiện nối chuỗi thay vì cộng số. Một cú pháp chữ mẫu đặc biệt cho phép bạn viết các chuỗi với các biểu thức được nhúng ngắn gọn hơn. Không giống như chuỗi f của Python hoặc chuỗi nội suy của C#, các mẫu chữ sử dụng dấu gạch ngược [không phải dấu ngoặc đơn hoặc dấu ngoặc kép]function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
4JavaScript phân biệt giữa
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
62, biểu thị sự không có giá trị có chủ ý [và chỉ có thể truy cập được thông qua từ khóa function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
62] và function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64, biểu thị sự vắng mặt của giá trị. Có nhiều cách để có được function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64- Câu lệnh
66 không có giá trị [function Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
67] hoàn toàn trả vềfunction Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
64function Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
- Truy cập thuộc tính đối tượng không tồn tại [
69] trả vềfunction Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
64function Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
- Khai báo biến không có khởi tạo [
81] sẽ mặc nhiên khởi tạo biến thànhlet arrayName = dataResponse.map[ item => { return item.Name }
64function Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
JavaScript có kiểu Boolean, với các giá trị có thể có là
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
8 và console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
9 — cả hai đều là từ khóa. Bất kỳ giá trị nào cũng có thể được chuyển đổi thành boolean theo các quy tắc sau
9,console.log["Hello, world"]; console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
86, chuỗi rỗng [let arrayName = dataResponse.map[ item => { return item.Name }
87],let arrayName = dataResponse.map[ item => { return item.Name }
42,function sumOfArray[numbers]{ numbers.forEach[function sumElement[element]{ console.log[element]; }]; }
62 vàfunction Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
64 đều trở thànhfunction Counter[] { this.sum = 0; this.count = 0; } Counter.prototype.add = function[array] { array.forEach[function[item] { this.sum += item; ++this.count; }, this]; }; const obj = new Counter[]; obj.add[[2, 5, 9]]; console.log[obj.count]; // => 3 console.log[obj.sum]; // => 16
9console.log["Hello, world"]; console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
- Tất cả các giá trị khác trở thành
8console.log["Hello, world"]; console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
Bạn có thể thực hiện chuyển đổi này một cách rõ ràng bằng hàm
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
503function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
6Tuy nhiên, điều này hiếm khi cần thiết, vì JavaScript sẽ âm thầm thực hiện chuyển đổi này khi nó mong đợi một giá trị boolean, chẳng hạn như trong câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
504 [xem phần ]. Vì lý do này, đôi khi chúng ta nói về "true" và "falsy", nghĩa là các giá trị lần lượt trở thành console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
8 và console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
9, khi được sử dụng trong ngữ cảnh booleanCác phép toán Boolean như
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
507 [logic và], arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
508 [logic hoặc] và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
509 [logic không] được hỗ trợ; Loại Ký hiệu thường được sử dụng để tạo các mã định danh duy nhất. Mỗi biểu tượng được tạo bằng hàm
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
510 được đảm bảo là duy nhất. Ngoài ra, còn có các ký hiệu đã đăng ký, là các hằng số được chia sẻ và các ký hiệu nổi tiếng, được ngôn ngữ sử dụng làm "giao thức" cho một số thao tác nhất định. Bạn có thể đọc thêm về chúng trong tài liệu tham khảo biểu tượngCác biến trong JavaScript được khai báo bằng một trong ba từ khóa.
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
511, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512 hoặc arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
513arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
511 cho phép bạn khai báo các biến cấp độ khối. Biến được khai báo có sẵn từ khối mà nó được đặt tronglet arrayName = dataResponse.map[ item => {
return item.Name
}
8arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512 cho phép bạn khai báo các biến có giá trị không bao giờ thay đổi. Biến có sẵn từ khối mà nó được khai báo trongarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
50Không thể gán lại một biến được khai báo bằng
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
51Các khai báo
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512 chỉ ngăn việc gán lại — chúng không ngăn các đột biến về giá trị của biến, nếu đó là một đối tượngarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
52Khai báo
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
513 có thể có các hành vi đáng ngạc nhiên [ví dụ: chúng không nằm trong phạm vi khối] và chúng không được khuyến khích trong mã JavaScript hiện đạiNếu bạn khai báo một biến mà không gán bất kỳ giá trị nào cho nó, thì giá trị của nó là
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64. Bạn không thể khai báo biến arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512 mà không có bộ khởi tạo, vì dù sao thì bạn cũng không thể thay đổi nó sau nàyCác biến được khai báo
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
511 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
512 vẫn chiếm toàn bộ phạm vi mà chúng được xác định và nằm trong vùng được gọi là trước dòng khai báo thực tế. Điều này có một số tương tác thú vị với bóng mờ thay đổi, không xảy ra ở các ngôn ngữ khácarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
53Trong hầu hết các ngôn ngữ khác, điều này sẽ ghi "1" và "2", bởi vì trước dòng
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
523, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
524 vẫn nên tham chiếu đến tham số arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
524 ở phạm vi phía trên. Trong JavaScript, vì mỗi khai báo chiếm toàn bộ phạm vi, điều này sẽ gây ra lỗi trên arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
526 đầu tiên. "Không thể truy cập 'x' trước khi khởi tạo". Để biết thêm thông tin, hãy xem trang tham khảo của arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
511JavaScript được gõ động. Các loại [như được mô tả trong ] chỉ được liên kết với các giá trị chứ không phải với các biến. Đối với các biến được khai báo
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
511, bạn luôn có thể thay đổi loại của nó thông qua việc gán lạiarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
54Các toán tử số của JavaScript bao gồm
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
40, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
530, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
531, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
532, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
533 [phần dư] và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
534 [lũy thừa]. Các giá trị được gán bằng cách sử dụng arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
535. Mỗi toán tử nhị phân cũng có một đối tác gán phức hợp, chẳng hạn như arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
536 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
537, mở rộng đến arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
538arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
55Bạn có thể sử dụng
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
539 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
540 để tăng và giảm tương ứng. Chúng có thể được sử dụng làm toán tử tiền tố hoặc hậu tốToán tử
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
40 cũng thực hiện nối chuỗiarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
56Nếu bạn thêm một chuỗi vào một số [hoặc giá trị khác], trước tiên mọi thứ sẽ được chuyển đổi thành một chuỗi. Điều này có thể khiến bạn vấp ngã
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
57Thêm một chuỗi trống vào một cái gì đó là một cách hữu ích để chuyển đổi nó thành một chuỗi
trong JavaScript có thể được tạo bằng cách sử dụng
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
542, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
543, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
544 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
545, hoạt động cho cả chuỗi và số. Đối với đẳng thức, toán tử bằng kép thực hiện ép buộc kiểu nếu bạn cung cấp cho nó các kiểu khác nhau, đôi khi có kết quả thú vị. Mặt khác, toán tử ba bằng không cố ép buộc kiểu và thường được ưu tiênarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
58Các dấu bằng nhân đôi và dấu bằng ba cũng có các dấu bằng bất đẳng thức của chúng.
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
546 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
547JavaScript cũng có và. Đáng chú ý, các toán tử logic không chỉ hoạt động với các giá trị boolean — chúng hoạt động dựa trên "độ trung thực" của giá trị
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
59Toán tử
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
507 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
508 sử dụng logic ngắn mạch, có nghĩa là chúng có thực thi toán hạng thứ hai hay không phụ thuộc vào toán hạng thứ nhất. Điều này hữu ích để kiểm tra các đối tượng null trước khi truy cập các thuộc tính của chúngarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
60Hoặc cho các giá trị bộ đệm [khi giá trị giả không hợp lệ]
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
61Để biết danh sách đầy đủ các nhà khai thác, hãy xem trang hướng dẫn hoặc phần tham khảo. Bạn có thể đặc biệt quan tâm đến quyền ưu tiên của toán tử
Ngữ pháp JavaScript rất giống với họ C. Có một vài điểm đáng nói
- có thể có các ký tự Unicode, nhưng chúng không thể là một trong
- thường là
550 hoặcarr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
551, trong khi nhiều ngôn ngữ kịch bản khác như Perl, Python và Bash sử dụngarr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
552arr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
- Dấu chấm phẩy là tùy chọn trong JavaScript — ngôn ngữ khi cần. Tuy nhiên, có một số lưu ý cần chú ý, vì không giống như Python, dấu chấm phẩy vẫn là một phần của cú pháp
Để có cái nhìn sâu hơn về ngữ pháp JavaScript, hãy xem trang tham khảo về ngữ pháp từ vựng
JavaScript có một bộ cấu trúc điều khiển tương tự như các ngôn ngữ khác trong họ C. Tuyên bố có điều kiện được hỗ trợ bởi
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
504 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
554; arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
62JavaScript không có
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
555 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
556 thực sự chỉ là một nhánh arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
554 bao gồm một câu lệnh arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
504 duy nhấtJavaScript có các vòng lặp
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
559 và vòng lặp arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
560. Đầu tiên là tốt cho vòng lặp cơ bản; arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
63Vòng lặp
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
561 của JavaScript giống như vòng lặp trong C và Java. nó cho phép bạn cung cấp thông tin điều khiển cho vòng lặp của mình trên một dòngarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
64JavaScript cũng chứa hai vòng lặp nổi bật khác.
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
562, lặp qua các lần lặp, đáng chú ý nhất là mảng và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
563, truy cập tất cả các thuộc tính có thể đếm được của một đối tượngarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
65Câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
564 có thể được sử dụng cho nhiều nhánh dựa trên việc kiểm tra đẳng thứcarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
66Tương tự như C, mệnh đề trường hợp về mặt khái niệm giống như nhãn, vì vậy nếu bạn không thêm câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
565, việc thực thi sẽ "rơi" sang cấp độ tiếp theo. Tuy nhiên, chúng không thực sự là các bảng nhảy — bất kỳ biểu thức nào cũng có thể là một phần của mệnh đề arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
566, không chỉ là các ký tự chuỗi hoặc số và chúng sẽ được đánh giá từng cái một cho đến khi một biểu thức bằng với giá trị được so khớp. So sánh diễn ra giữa hai bằng cách sử dụng toán tử arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
567Không giống như một số ngôn ngữ như Rust, cấu trúc luồng điều khiển là các câu lệnh trong JavaScript, nghĩa là bạn không thể gán chúng cho một biến, chẳng hạn như
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
568Lỗi JavaScript được xử lý bằng cách sử dụng câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
569arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
67Lỗi có thể được đưa ra bằng cách sử dụng câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
570. Nhiều hoạt động tích hợp cũng có thể némarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
68Nói chung, bạn không thể nói loại lỗi bạn vừa mắc phải, bởi vì bất cứ điều gì có thể được đưa ra từ một câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
570. Tuy nhiên, bạn thường có thể cho rằng đó là một phiên bản console.log["Hello"[1] === "e"]; // true
4, như ví dụ trên. Có một số lớp con của console.log["Hello"[1] === "e"]; // true
4 được tích hợp sẵn, chẳng hạn như arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
574 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
575, mà bạn có thể sử dụng để cung cấp thêm ngữ nghĩa về lỗi. Không có lệnh bắt có điều kiện trong JavaScript — nếu bạn chỉ muốn xử lý một loại lỗi, bạn cần phải nắm bắt mọi thứ, xác định loại lỗi bằng cách sử dụng arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
576, sau đó tính lại các trường hợp khácarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
69Nếu một lỗi không được phát hiện bởi bất kỳ
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
569 nào trong ngăn xếp cuộc gọi, chương trình sẽ thoátĐể biết danh sách đầy đủ các câu lệnh luồng điều khiển, hãy xem phần tham khảo
Các đối tượng JavaScript có thể được coi là tập hợp các cặp khóa-giá trị. Như vậy, chúng tương tự như
- Từ điển trong Python
- Băm trong Perl và Ruby
- Bảng băm trong C và C++
- HashMaps trong Java
- Mảng kết hợp trong PHP
Các đối tượng JavaScript là hàm băm. Không giống như các đối tượng trong ngôn ngữ gõ tĩnh, các đối tượng trong JavaScript không có hình dạng cố định — các thuộc tính có thể được thêm, xóa, sắp xếp lại, thay đổi hoặc truy vấn động bất kỳ lúc nào. Các khóa đối tượng luôn là các chuỗi hoặc ký hiệu — ngay cả các chỉ số mảng, là các số nguyên theo quy tắc, thực sự là các chuỗi dưới mui xe
Các đối tượng thường được tạo bằng cú pháp chữ
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
80Các thuộc tính của đối tượng có thể được truy cập bằng cách sử dụng dấu chấm [
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
578] hoặc dấu ngoặc vuông [arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
579]. Khi sử dụng ký hiệu dấu chấm, khóa phải hợp lệ. Mặt khác, dấu ngoặc cho phép lập chỉ mục đối tượng bằng giá trị khóa độngarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
81Quyền truy cập tài sản có thể được kết nối với nhau
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
82Các đối tượng luôn là các tham chiếu, vì vậy trừ khi có thứ gì đó sao chép đối tượng một cách rõ ràng, các đột biến đối với một đối tượng sẽ hiển thị ra bên ngoài
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
83Điều này cũng có nghĩa là hai đối tượng được tạo riêng biệt sẽ không bao giờ bằng nhau [______1547], bởi vì chúng là các tham chiếu khác nhau. Nếu bạn giữ hai tham chiếu của cùng một đối tượng, việc thay đổi một đối tượng sẽ có thể quan sát được thông qua đối tượng kia
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
84Để biết thêm về các đối tượng và nguyên mẫu, hãy xem trang tham khảo
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
581. Để biết thêm thông tin về cú pháp khởi tạo đối tượng, hãy xem trang tham khảo của nóTrang này đã bỏ qua tất cả các chi tiết về nguyên mẫu đối tượng và tính kế thừa vì bạn thường có thể đạt được tính kế thừa mà không cần chạm vào cơ chế cơ bản [mà bạn có thể nghe nói là khó hiểu]. Để tìm hiểu về chúng, hãy xem Kế thừa và chuỗi nguyên mẫu
Mảng trong JavaScript thực sự là một loại đối tượng đặc biệt. Chúng hoạt động rất giống các đối tượng thông thường [các thuộc tính số chỉ có thể được truy cập một cách tự nhiên bằng cách sử dụng cú pháp
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
579] nhưng chúng có một thuộc tính ma thuật được gọi là function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
60. Đây luôn là một chỉ số cao hơn chỉ số cao nhất trong mảngMảng thường được tạo bằng ký tự mảng
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
85Các mảng JavaScript vẫn là các đối tượng — bạn có thể gán bất kỳ thuộc tính nào cho chúng, bao gồm các chỉ số số tùy ý. "Điều kỳ diệu" duy nhất là
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
60 sẽ được cập nhật tự động khi bạn đặt một chỉ mục cụ thểarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
86Mảng mà chúng ta có ở trên được gọi là a vì có các vị trí không có người ở ở giữa và sẽ khiến công cụ hủy tối ưu hóa nó từ một mảng thành bảng băm. Đảm bảo rằng mảng của bạn có mật độ dân cư đông đúc
Lập chỉ mục ngoài giới hạn không ném. Nếu bạn truy vấn một chỉ mục mảng không tồn tại, bạn sẽ nhận được giá trị là
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
87Mảng có thể có bất kỳ phần tử nào và có thể tăng hoặc giảm tùy ý
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
88Mảng có thể được lặp với vòng lặp
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
561, như bạn có thể làm trong các ngôn ngữ giống như C khácarr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
89Hoặc, vì các mảng có thể lặp lại, bạn có thể sử dụng vòng lặp
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
562, đồng nghĩa với cú pháp arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
588 của C++/Javafunction sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
00Mảng đi kèm với rất nhiều phương thức mảng. Nhiều người trong số họ sẽ lặp mảng — ví dụ,
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
589 sẽ áp dụng gọi lại cho mọi phần tử mảng và trả về một mảng mớifunction sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
01Cùng với các đối tượng, hàm là thành phần cốt lõi để hiểu JavaScript. Khai báo chức năng cơ bản nhất trông như thế này
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
02Hàm JavaScript có thể nhận 0 hoặc nhiều tham số. Thân hàm có thể chứa bao nhiêu câu lệnh tùy thích và có thể khai báo các biến cục bộ của hàm đó. Câu lệnh
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
66 có thể được sử dụng để trả về một giá trị bất cứ lúc nào, kết thúc chức năng. Nếu không có câu lệnh trả về nào được sử dụng [hoặc trả về trống không có giá trị], JavaScript sẽ trả về function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64Các chức năng có thể được gọi với nhiều hoặc ít tham số hơn nó chỉ định. Nếu bạn gọi một hàm mà không chuyển các tham số mà nó mong đợi, chúng sẽ được đặt thành
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64. Nếu bạn truyền nhiều tham số hơn dự kiến, hàm sẽ bỏ qua các tham số phụfunction sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
03Có một số cú pháp tham số khác có sẵn. Ví dụ: cú pháp tham số còn lại cho phép thu thập tất cả các tham số bổ sung được người gọi truyền vào một mảng, tương tự như
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
593 của Python. [Vì JS không có các tham số được đặt tên ở cấp độ ngôn ngữ, nên không có arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
594. ]function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
04Trong đoạn mã trên, biến
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
595 chứa tất cả các giá trị được truyền vào hàmTham số còn lại sẽ lưu trữ tất cả các đối số sau vị trí được khai báo, chứ không phải trước đó. Nói cách khác,
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
596 sẽ lưu trữ giá trị đầu tiên được truyền vào hàm trong biến arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
597 và các đối số còn lại trong arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
595Nếu một hàm chấp nhận một danh sách các đối số và bạn đã có sẵn một mảng, bạn có thể sử dụng cú pháp trải rộng trong lời gọi hàm để trải rộng mảng dưới dạng một danh sách các phần tử. Ví dụ.
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
599Chúng tôi đã đề cập rằng JavaScript không có tham số được đặt tên. Tuy nhiên, có thể triển khai chúng bằng cách sử dụng tính năng hủy đối tượng, cho phép các đối tượng được đóng gói và giải nén một cách thuận tiện
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
05Ngoài ra còn có cú pháp tham số mặc định, cho phép các tham số bị bỏ qua [hoặc những tham số được truyền dưới dạng
function Counter[] {
this.sum = 0;
this.count = 0;
}
Counter.prototype.add = function[array] {
array.forEach[function[item] {
this.sum += item;
++this.count;
}, this];
};
const obj = new Counter[];
obj.add[[2, 5, 9]];
console.log[obj.count]; // => 3
console.log[obj.sum]; // => 16
64] có giá trị mặc địnhfunction sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
06JavaScript cho phép bạn tạo các hàm ẩn danh — nghĩa là các hàm không có tên. Trong thực tế, các hàm ẩn danh thường được sử dụng làm đối số cho các hàm khác, được gán ngay cho một biến có thể được sử dụng để gọi hàm hoặc được trả về từ một hàm khác
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
07Điều đó làm cho hàm ẩn danh trở nên bất khả xâm phạm bằng cách gọi
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
601 với một số đối số — nghĩa là về mặt ngữ nghĩa, nó tương đương với việc khai báo hàm bằng cách sử dụng cú pháp khai báo arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
602Có một cách khác để xác định hàm ẩn danh — sử dụng biểu thức hàm mũi tên
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
08Các hàm mũi tên không tương đương về mặt ngữ nghĩa với các biểu thức hàm — để biết thêm thông tin, hãy xem trang tham khảo của nó
Có một cách khác mà các chức năng ẩn danh có thể hữu ích. nó có thể được khai báo và gọi đồng thời trong một biểu thức duy nhất, được gọi là biểu thức hàm được gọi ngay lập tức [IIFE]
function sumOfArray[numbers]{
numbers.forEach[function sumElement[element]{
console.log[element];
}];
}
09Đối với các trường hợp sử dụng IIFE, bạn có thể đọc
JavaScript cho phép bạn gọi các hàm theo cách đệ quy. Điều này đặc biệt hữu ích để xử lý các cấu trúc cây, chẳng hạn như các cấu trúc được tìm thấy trong trình duyệt DOM
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
0Các biểu thức hàm cũng có thể được đặt tên, điều này cho phép chúng được đệ quy
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
1Tên được cung cấp cho biểu thức hàm như trên chỉ khả dụng cho phạm vi riêng của hàm. Điều này cho phép công cụ thực hiện nhiều tối ưu hóa hơn và dẫn đến mã dễ đọc hơn. Tên cũng hiển thị trong trình gỡ lỗi và một số dấu vết ngăn xếp, điều này có thể giúp bạn tiết kiệm thời gian khi gỡ lỗi
Nếu bạn đã quen với lập trình chức năng, hãy cẩn thận với ý nghĩa hiệu suất của đệ quy trong JavaScript. Mặc dù đặc tả ngôn ngữ chỉ định tối ưu hóa cuộc gọi đuôi, nhưng chỉ JavaScriptCore [được sử dụng bởi Safari] đã triển khai nó, do khó khôi phục dấu vết ngăn xếp và khả năng gỡ lỗi. Đối với đệ quy sâu, thay vào đó hãy xem xét sử dụng phép lặp để tránh tràn ngăn xếp
Các hàm JavaScript là các đối tượng hạng nhất. Điều này có nghĩa là chúng có thể được gán cho các biến, được truyền dưới dạng đối số cho các hàm khác và được trả về từ các hàm khác. Ngoài ra, JavaScript hỗ trợ các bao đóng sẵn dùng mà không cần nắm bắt rõ ràng, cho phép bạn áp dụng các kiểu lập trình chức năng một cách thuận tiện
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
2Lưu ý rằng bản thân các hàm JavaScript là các đối tượng — giống như mọi thứ khác trong JavaScript — và bạn có thể thêm hoặc thay đổi các thuộc tính trên chúng giống như chúng ta đã thấy trước đó trong phần Đối tượng
Khai báo hàm JavaScript được cho phép bên trong các hàm khác. Một chi tiết quan trọng của các hàm lồng nhau trong JavaScript là chúng có thể truy cập các biến trong phạm vi của hàm cha.
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
3Điều này cung cấp rất nhiều tiện ích trong việc viết mã dễ bảo trì hơn. Nếu một hàm được gọi phụ thuộc vào một hoặc hai hàm khác không hữu ích cho bất kỳ phần nào khác trong mã của bạn, bạn có thể lồng các hàm tiện ích đó vào bên trong nó. Điều này giữ cho số lượng chức năng trong phạm vi toàn cầu giảm xuống
Đây cũng là một biện pháp tuyệt vời để chống lại sự hấp dẫn của các biến toàn cục. Khi viết mã phức tạp, người ta thường muốn sử dụng các biến toàn cục để chia sẻ giá trị giữa nhiều hàm, điều này dẫn đến mã khó bảo trì. Các hàm lồng nhau có thể chia sẻ các biến trong cha của chúng, vì vậy bạn có thể sử dụng cơ chế đó để ghép các hàm với nhau mà không làm ô nhiễm không gian tên chung của bạn
JavaScript cung cấp cú pháp lớp rất giống với các ngôn ngữ như Java
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
4Các lớp JavaScript chỉ là các hàm phải được khởi tạo bằng toán tử
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
603. Mỗi khi một lớp được khởi tạo, nó sẽ trả về một đối tượng chứa các phương thức và thuộc tính mà lớp đã chỉ định. Các lớp không thực thi bất kỳ tổ chức mã nào — ví dụ: bạn có thể có các hàm trả về các lớp hoặc bạn có thể có nhiều lớp trên mỗi tệp. Đây là một ví dụ về cách tạo một lớp đặc biệt. nó chỉ là một biểu thức được trả về từ hàm mũi tên. Mô hình này được gọi là mộtconsole.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
5Thuộc tính tĩnh được tạo bằng cách thêm trước
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
604. Các thuộc tính riêng được tạo bằng cách thêm một hàm băm arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
552 [không phải arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
606]. Hàm băm là một phần không thể thiếu của tên thuộc tính. [Hãy nghĩ về arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
552 như arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
608 trong Python. ] Không giống như hầu hết các ngôn ngữ khác, hoàn toàn không có cách nào để đọc thuộc tính riêng bên ngoài thân lớp — thậm chí không có cách nào trong các lớp dẫn xuấtĐể có hướng dẫn chi tiết về các tính năng khác nhau của lớp học, bạn có thể đọc trang hướng dẫn
Bản chất JavaScript là đơn luồng. Không có song song; . Lập trình không đồng bộ được cung cấp bởi một vòng lặp sự kiện, cho phép một tập hợp các tác vụ được xếp hàng đợi và thăm dò để hoàn thành
Có ba cách thành ngữ để viết mã không đồng bộ trong JavaScript
- Dựa trên cuộc gọi lại [chẳng hạn như
609]arr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
- dựa trên
610arr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
611/arr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
612, là một cách viết cú pháp cho Promisesarr.forEach[function callback[currentValue, index, array] { // your iterator }[, thisArg]];
Ví dụ: đây là cách hoạt động đọc tệp có thể trông như thế nào trong JavaScript
console.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
6Ngôn ngữ cốt lõi không chỉ định bất kỳ tính năng lập trình không đồng bộ nào, nhưng nó rất quan trọng khi tương tác với môi trường bên ngoài — từ yêu cầu quyền của người dùng, tìm nạp dữ liệu, đọc tệp. Giữ cho các hoạt động có khả năng chạy lâu không đồng bộ đảm bảo rằng các quy trình khác vẫn có thể chạy trong khi quy trình này chờ — ví dụ: trình duyệt sẽ không bị treo trong khi chờ người dùng nhấp vào nút để cấp quyền
Nếu bạn có một giá trị không đồng bộ, thì không thể lấy giá trị của nó một cách đồng bộ. Ví dụ: nếu bạn có một lời hứa, bạn chỉ có thể truy cập kết quả cuối cùng thông qua phương thức
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
613. Tương tự, arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
612 chỉ có thể được sử dụng trong ngữ cảnh không đồng bộ, thường là chức năng không đồng bộ hoặc mô-đun. Các lời hứa không bao giờ bị chặn — chỉ logic tùy thuộc vào kết quả của lời hứa sẽ bị hoãn lại; . Nếu bạn là một lập trình viên chức năng, bạn có thể nhận ra các lời hứa là các đơn nguyên có thể được ánh xạ với arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
613 [tuy nhiên, chúng không phải là đơn nguyên thích hợp vì chúng tự động làm phẳng; i. e. bạn không thể có một arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
616]Trên thực tế, mô hình đơn luồng đã khiến Node. js là một lựa chọn phổ biến cho lập trình phía máy chủ do IO không chặn của nó, giúp xử lý một số lượng lớn cơ sở dữ liệu hoặc yêu cầu hệ thống tệp rất hiệu quả. Tuy nhiên, các tác vụ liên quan đến CPU [chuyên sâu về tính toán] là JavaScript thuần túy vẫn sẽ chặn luồng chính. Để đạt được song song thực sự, bạn có thể cần sử dụng công nhân
Để tìm hiểu thêm về lập trình không đồng bộ, bạn có thể đọc về cách sử dụng lời hứa hoặc làm theo hướng dẫn JavaScript không đồng bộ
JavaScript cũng chỉ định một hệ thống mô-đun được hỗ trợ bởi hầu hết thời gian chạy. Một mô-đun thường là một tệp, được xác định bởi đường dẫn hoặc URL của tệp đó. Bạn có thể sử dụng câu lệnh
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
617 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
618 để trao đổi dữ liệu giữa các mô-đunconsole.log["Hello, world"];
console.log["你好,世界!"]; // Nearly all Unicode characters can be written literally in string literals
7Không giống như Haskell, Python, Java, v.v. , độ phân giải mô-đun JavaScript hoàn toàn do máy chủ xác định — nó thường dựa trên URL hoặc đường dẫn tệp, do đó, đường dẫn tệp tương đối "chỉ hoạt động" và liên quan đến đường dẫn của mô-đun hiện tại thay vì một số đường dẫn gốc của dự án
Tuy nhiên, ngôn ngữ JavaScript không cung cấp các mô-đun thư viện tiêu chuẩn — thay vào đó, tất cả các chức năng cốt lõi đều được hỗ trợ bởi các biến toàn cục như
console.log["Hello"[1] === "e"]; // true
6 và arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
620. Điều này là do lịch sử lâu dài của JavaScript thiếu hệ thống mô-đun và thực tế là việc chọn tham gia hệ thống mô-đun liên quan đến một số thay đổi đối với thiết lập thời gian chạyThời gian chạy khác nhau có thể sử dụng các hệ thống mô-đun khác nhau. Ví dụ, nút. js sử dụng trình quản lý gói npm và chủ yếu dựa trên hệ thống tệp, trong khi Deno và các trình duyệt hoàn toàn dựa trên URL và các mô-đun có thể được giải quyết từ các URL HTTP
Để biết thêm thông tin, xem trang hướng dẫn mô-đun
Trong suốt trang này, chúng tôi đã liên tục đề cập rằng một số tính năng nhất định ở cấp độ ngôn ngữ trong khi các tính năng khác ở cấp độ thời gian chạy
JavaScript là ngôn ngữ kịch bản có mục đích chung. Tập trung vào logic tính toán thuần túy. Nó không xử lý bất kỳ đầu vào/đầu ra nào — trên thực tế, nếu không có API mức thời gian chạy bổ sung [đáng chú ý nhất là
arr.forEach[function callback[currentValue, index, array] {
// your iterator
}[, thisArg]];
621], hành vi của chương trình JavaScript hoàn toàn không thể quan sát đượcThời gian chạy hoặc máy chủ lưu trữ là thứ cung cấp dữ liệu cho công cụ JavaScript [trình thông dịch], cung cấp các thuộc tính toàn cầu bổ sung và cung cấp móc nối để công cụ tương tác với thế giới bên ngoài. Độ phân giải mô-đun, đọc dữ liệu, in tin nhắn, gửi yêu cầu mạng, v.v. là tất cả các hoạt động cấp thời gian chạy. Kể từ khi thành lập, JavaScript đã được áp dụng trong nhiều môi trường khác nhau, chẳng hạn như trình duyệt [cung cấp API như DOM], Node. js [cung cấp API như quyền truy cập hệ thống tệp], v.v. JavaScript đã được tích hợp thành công trong web [mục đích chính của nó], ứng dụng dành cho thiết bị di động, ứng dụng dành cho máy tính để bàn, ứng dụng phía máy chủ, serverless, hệ thống nhúng, v.v. Trong khi bạn tìm hiểu về các tính năng cốt lõi của JavaScript, điều quan trọng là phải hiểu các tính năng do máy chủ cung cấp để áp dụng kiến thức. Ví dụ: bạn có thể đọc về tất cả các API nền tảng web, được triển khai bởi các trình duyệt và đôi khi cả những người không sử dụng trình duyệt
Trang này cung cấp một cái nhìn sâu sắc rất cơ bản về cách so sánh các tính năng JavaScript khác nhau với các ngôn ngữ khác. Nếu bạn muốn tìm hiểu thêm về chính ngôn ngữ đó và các sắc thái của từng tính năng, bạn có thể đọc hướng dẫn về JavaScript và tài liệu tham khảo về JavaScript
Có một số phần thiết yếu của ngôn ngữ mà chúng tôi đã bỏ qua do không gian và độ phức tạp, nhưng bạn có thể tự mình khám phá