Tổng hợp javascript

Question

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

Nội dung chính Show

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ề forEach

forEach 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 function

Ngoà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 <= với độ dài ban đầu

Các ví dụ sau

let companyObject = dataCompany.filter((company) => {
              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

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 — thường được sử dụng cho logic có điều kiện

đượ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

console.log("Hello"[1] === "e"); // true

0

console.log("Hello"[1] === "e"); // true

1

console.log("Hello"[1] === "e"); // true

2

console.log("Hello"[1] === "e"); // true

3

console.log("Hello"[1] === "e"); // true

4

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]);

4

Vì 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]);

6

Loạ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

5

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

8

Tiê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ẩn

function sumOfArray(numbers){
  numbers.forEach(function sumElement(element){
    console.log(element);
  });
}

0

Có ba cách để chuyển đổi một chuỗi thành một số

```
console.log("Hello"[1] === "e"); // true
```
7, phân tích cú pháp chuỗi cho một số nguyên
```
console.log("Hello"[1] === "e"); // true
```
8, phân tích cú pháp chuỗi cho số dấu phẩy động
Hàm
```
console.log("Hello"[1] === "e"); // true
```
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 nhau

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

9

Cá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);
  });
}

4

JavaScript 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

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 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

64

Truy cập thuộc tính đối tượng không tồn tại (

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

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

64

Khai báo biến không có khởi tạo (

let arrayName = dataResponse.map( item => {
    return item.Name
}

81) sẽ mặc nhiên khởi tạo biến 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

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

console.log("Hello, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

9,

let arrayName = dataResponse.map( item => {
    return item.Name
}

86, chuỗi rỗng (

let arrayName = dataResponse.map( item => {
    return item.Name
}

87),

function sumOfArray(numbers){
  numbers.forEach(function sumElement(element){
    console.log(element);
  });
}

42,

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 đều trở thành

console.log("Hello, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

9

Tất cả các giá trị khác trở thành

console.log("Hello, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

8

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]);

503

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

6

Tuy 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 boolean

Cá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ượng

Cá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]);

513

arr.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 trong

let arrayName = dataResponse.map( item => {
    return item.Name
}

8

arr.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 trong

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

50

Khô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]);

512

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

51

Cá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ượng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

52

Khai 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 đại

Nế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ày

Cá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ác

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

53

Trong 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]);

511

JavaScript đượ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ại

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

54

Cá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]);

538

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

55

Bạ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ỗi

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

56

Nế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]);

57

Thê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ên

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

58

Cá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]);

547

JavaScript 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]);

59

Toá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úng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

60

Hoặ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à

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

550 hoặc

arr.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ụng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

552

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]);

62

JavaScript 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ất

JavaScript 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]);

63

Vò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òng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

64

JavaScript 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ượng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

65

Câ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ức

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

66

Tươ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]);

567

Khô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]);

568

Lỗ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]);

569

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

67

Lỗ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ém

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

68

Nó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ác

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

69

Nế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]);

80

Cá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 động

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

81

Quyề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]);

82

Cá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ảng

Mảng thường được tạo bằng ký tự mảng

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

85

Cá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]);

86

Mả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

64

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

87

Mả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]);

88

Mả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ác

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

89

Hoặ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++/Java

function sumOfArray(numbers){
  numbers.forEach(function sumElement(element){
    console.log(element);
  });
}

00

Mả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ới

function sumOfArray(numbers){
  numbers.forEach(function sumElement(element){
    console.log(element);
  });
}

01

Cù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);
  });
}

02

Hà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

64

Cá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);
  });
}

03

Có 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);
  });
}

04

Trong đ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àm

Tham 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]);

595

Nế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]);

599

Chú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);
  });
}

05

Ngoà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 định

function sumOfArray(numbers){
  numbers.forEach(function sumElement(element){
    console.log(element);
  });
}

06

JavaScript 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]);

602

Có 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);
  });
}

08

Cá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

0

Cá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

1

Tê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

2

Lư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

4

Cá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ột

console.log("Hello, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

5

Thuộ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ư

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

609)

dựa trên

arr.forEach(function callback(currentValue, index, array) {
    // your iterator
}[, thisArg]);

610

arr.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 Promises

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

6

Ngô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ô-đun

console.log("Hello, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

7

Khô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ạy

Thờ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 được

Thờ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á

programming javascript

Tổng hợp javascript

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội