Hướng dẫn javascript intermediate - javascript trung cấp

Giới thiệu

Lập trình meta

• Mô -đun JavaScript
• Loại dữ liệu
• Các loại khác
• Người vận hành
• Văn phạm
• Cấu trúc điều khiển

Ngữ pháp và các loại

Các đối tượng

• Chức năng ẩn danh
• Chức năng đệ quy
• Chức năng là các đối tượng hạng nhất
• Chức năng bên trong
• Các lớp học
• Lập trình không đồng bộ

Kiểm soát luồng và xử lý lỗi

Ngôn ngữ và thời gian chạy

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

  6

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

  7
• Khám phá thêm
• Hướng dẫn này được chia thành các chương sau.

Vòng lặp và lặp lại

Tổng quan: Giới thiệu

• 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

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

  5

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

  6
• Về sự hướng dẫn này

Chức năng

Biểu thức và toán tử

• Số và ngày
• Định dạng văn bản
• Bộ sưu tập được lập chỉ mục
• Bộ sưu tập khóa
• Làm việc với các đối tượng
• Sử dụng các lớp học

Biểu thức và toán tử

Số và ngày

• Định dạng văn bản
• Bộ sưu tập được lập chỉ mục
• Bộ sưu tập khóa
• Làm việc với các đối tượng

Số và ngày

Định dạng văn bản

• Bộ sưu tập được lập chỉ mục
• Bộ sưu tập khóa
• Làm việc với các đối tượng
• Sử dụng các lớp học

Định dạng văn bản

Bộ sưu tập được lập chỉ mục

• Bộ sưu tập khóa
• Làm việc với các đối tượng
• Sử dụng các lớp học
• Hứa hẹn
• Tererators và máy phát điện

Bộ sưu tập được lập chỉ mục

Bộ sưu tập khóa

• Làm việc với các đối tượng
• Sử dụng các lớp học

Bộ sưu tập khóa

Làm việc với các đối tượng

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

  12

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

  13

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

  14

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

  15

Làm việc với các đối tượng

Sử dụng các lớp học

• Hứa hẹn
• Tererators và máy phát điện
• Lập trình meta
• Mô -đun JavaScript

Sử dụng các lớp học

Hứa hẹn

• Tererators và máy phát điện
• Lập trình meta
• Mô -đun JavaScript
• Loại dữ liệu

Hứa hẹn

Tererators và máy phát điện

• Lập trình meta
• Mô -đun JavaScript
• Loại dữ liệu
• Các loại khác
• Người vận hành

Tererators và máy phát điện

Lập trình meta

• Mô -đun JavaScript
• Loại dữ liệu
• Các loại khác

Người vận hành

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

  16
• Văn phạm
• Cấu trúc điều khiển

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

  17

Mô -đun JavaScript

Loại dữ liệu

• Các loại khác
• Người vận hành
• Văn phạm
• Cấu trúc điều khiển
• Các đối tượng
• Chức năng ẩn danh

• Chức năng đệ quy

Loại dữ liệu

Các loại khác

• Người vận hành
• Văn phạm
• Cấu trúc điều khiển
• Các đối tượng
• Chức năng ẩn danh
• Chức năng đệ quy
• Chức năng là các đối tượng hạng nhất

Chức năng bên trong

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

  10

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

  11

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

  10

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

  13

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

  14

Các lớp học

Lập trình không đồng bộ

Ngôn ngữ và thời gian chạy

Khám phá thêm

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

Vì vậy, một số nguyên rõ ràng trong thực tế là một chiếc phao. Do mã hóa IEEE 754, đôi khi số học điểm nổi có thể không chính xác.

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

Đối với các hoạt động mong đợi các số nguyên, chẳng hạn như các hoạt động bitwise, số lượng sẽ được chuyển đổi thành số nguyên 32 bit.

Số chữ số cũng có thể có tiền tố để chỉ ra 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ũ.

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

Loại lớn là một số nguyên chiều dài tùy ý. Hành vi của nó tương tự như các loại số nguyên của C. Bigint được chỉ định với một số theo nghĩa đen và hậu tố

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

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

Các toán tử số học tiêu chuẩn được hỗ trợ, bao gồm bổ sung, trừ, số học còn lại, v.v ... Bigint 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

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

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

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

  17, phân tích chuỗi cho một số nguyên.

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

  18, phân tích chuỗi cho một số điểm nổi.
• Hàm

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

  19, phân tích một chuỗi như thể đó là một số theo nghĩa đen và hỗ trợ nhiều biểu diễn số khác nhau.

Bạn cũng có thể sử dụng Unary Plus

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

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

Giá trị số cũng bao gồm

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

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

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

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

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

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

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

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

Dây

Các chuỗi trong JavaScript là chuỗi các ký tự Unicode. Đây nên là tin tức đáng hoan nghênh cho bất cứ ai đã phải đối phó với quốc tế hóa. Chính xác hơn, chúng được mã hóa UTF-16.

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

Chuỗi có thể được viết bằng trích dẫn đơn hoặc đôi - JavaScript không có sự khác biệt giữa các 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 một ký tự duy nhất đó.

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

Để tìm độ dài của một chuỗi (trong các đơn vị mã), hãy truy cập thuộc tính

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

Chuỗi có các phương thức tiện ích để 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 pháp này trả về các chuỗi mới.

Toán tử

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

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

Các loại khác

JavaScript phân biệt giữa

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

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

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

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

• Một câu lệnh

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

  706 không có giá trị (

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

  707) ngầm trả về

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

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

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

  709) trả về

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

  704.
• Một khai báo biến mà không cần khởi tạo (

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

  711) sẽ ngầm khởi tạo biến thành

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

  704.

JavaScript có loại boolean, với các giá trị có thể

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

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

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

   19,

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

   716, chuỗi trống (

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

   717),

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

   62,

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

   702 và

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

   7 04 đều trở thành

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

   19.
2. 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
   

   18.

Bạn có thể thực hiện chuyển đổi này một cách rõ ràng bằng cách sử dụng hàm

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

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

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 boolean, chẳng hạn như trong một tuyên bố

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

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

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

Các hoạt động boolean như

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

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

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

Loại ký hiệu thường được sử dụng để tạo các định danh độc đáo. Mỗi biểu tượng được tạo ra với hàm

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

Biến

Các biến trong JavaScript được khai báo bằng một trong ba từ khóa:

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

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

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

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

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

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

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

Một biến được khai báo với

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

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

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

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

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

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ó, giá trị của nó là

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

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

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

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

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

Trong hầu hết các ngôn ngữ khác, điều này sẽ đăng nhập "1" và "2", bởi vì trước dòng

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

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

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

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

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

JavaScript được gõ động. Các loại (như được mô tả trong phần trước) chỉ được liên kết với các giá trị, nhưng không phải với các biến. Đối với các biến ____ 131 được khai báo, bạn luôn có thể thay đổi loại của nó thông qua việc phân công lại.

Người vận hành

Các toán tử số của JavaScript bao gồm

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

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

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

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

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

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

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

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

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

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

Bạn có thể sử dụng

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

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

Toán tử

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

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

Nếu bạn thêm một chuỗi vào một số (hoặc giá trị khác), mọi thứ sẽ được chuyển đổi thành một chuỗi trước tiên. Điều này có thể khiến bạn thất vọng:

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

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.

So sánh trong JavaScript có thể được thực hiện bằng cách sử dụng

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

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

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

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

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

Công bằng kép và ba bình đẳng cũng có các đối tác bất bình đẳng của họ:

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

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

JavaScript cũng có toán tử bitwise và toán tử logic. Đáng chú ý, các nhà khai thác logic không chỉ làm việc với các giá trị Boolean - chúng hoạt động theo "sự thật" của giá trị.

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

Các nhà khai thác

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

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

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

Hoặc cho các giá trị bộ nhớ đệm (khi các giá trị giả không hợp lệ):

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

Để biết danh sách toàn diện các nhà khai thác, hãy xem trang Hướng dẫn hoặc phần tham chiếu. Bạn có thể đặc biệt quan tâm đến sự ưu tiên của nhà điều hành.

Văn phạm

Ngữ pháp JavaScript rất giống với gia đình C. Có một vài điểm đáng nói:

• Định danh có thể có các ký tự Unicode, nhưng chúng không thể là một trong những từ dành riêng.
• Nhận xét thường là

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

  770 hoặc

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

  771, trong khi nhiều ngôn ngữ kịch bản khác như Perl, Python và Bash sử dụng

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

  772.
• Bán kết là tùy chọn trong JavaScript - ngôn ngữ tự động chèn chúng khi cần thiết. Tuy nhiên, có một số cảnh báo nhất định để coi chừng, 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 sắc về ngữ pháp JavaScript, hãy xem trang tham khảo cho ngữ pháp từ vựng.

Cấu trúc điều khiển

JavaScript có một bộ cấu trúc điều khiển tương tự với các ngôn ngữ khác trong họ C. Các tuyên bố có điều kiện được hỗ trợ bởi

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

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

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

JavaScript không có

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

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

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

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

JavaScript có vòng lặp

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

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

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

Vòng lặp

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

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

JavaScript cũng chứa hai vòng lặp nổi bật khác:

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

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

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

Câu lệnh

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

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

Tương tự như C, các điều khoản trường hợp về mặt khái niệm giống như các nhãn, vì vậy nếu bạn không thêm câu lệnh

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

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

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

Không giống như một số ngôn ngữ như rỉ sét, các cấu trúc dòng điều khiển là các câu trong JavaScript, có nghĩa là bạn không thể gán chúng cho một biến, như

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

Lỗi JavaScript được xử lý bằng câu lệnh

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

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

Lỗi có thể được ném bằng cách sử dụng câu lệnh

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

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

Nói chung, bạn không thể nói loại lỗi bạn vừa bắt, bởi vì bất cứ điều gì có thể được ném từ câu lệnh

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

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

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

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

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

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

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

Nếu một lỗi không bị ảnh hưởng bởi bất kỳ

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

Để biết danh sách toàn diện các câu lệnh luồng kiểm soát, xem phần tham chiếu.

Các đối tượng

Các đối tượng JavaScript có thể được coi là bộ sưu tập các cặp giá trị khóa. Như vậy, chúng tương tự như:

• Từ điển trong Python.
• Băm ở Perl và Ruby.
• Bảng băm trong C và C ++.
• Hashmaps ở Java.
• Mảng liên kết trong PHP.

Các đối tượng JavaScript là băm. Không giống như các đối tượng bằng các ngôn ngữ được đánh máy 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, đặt hàng lại, đột biến hoặc truy vấn động bất cứ lúc nào. Các phím đối tượng luôn là chuỗi hoặc ký hiệu - thậm chí các chỉ số mảng, là số nguyên theo kinh điển, 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 theo nghĩa đen:

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

Thuộc tính đối tượng có thể được truy cập bằng DOT (

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

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

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

Truy cập tài sản có thể được xích lại với nhau:

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

Các đối tượng luôn là tài liệu tham khảo, vì vậy trừ khi một cái gì đó đang sao chép rõ ràng đối tượng, các đột biến đến một đối tượng sẽ được nhìn thấy bên ngoài.

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

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

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

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

Để biết thêm về các đối tượng và nguyên mẫu, hãy xem trang tham chiếu

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

Trang này đã bỏ qua tất cả các chi tiết về các nguyên mẫu đối tượng và kế thừa vì bạn thường có thể đạt được sự kế thừa với các lớp mà không cần chạm vào cơ chế cơ bản (mà bạn có thể đã nghe là trừu tượng). Để tìm hiểu về họ, xem kế thừa và chuỗi nguyên mẫu.

Mảng

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ố tự nhiên chỉ có thể được truy cập bằng cách sử dụng cú pháp

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

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

Các mảng thường được tạo bằng chữ mảng:

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

Các mảng JavaScript vẫn là đố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 ý. "Phép thuật" duy nhất là

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

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

Mảng chúng tôi nhận được ở trên được gọi là một mảng thưa thớt vì có các khe không có người ở ở giữa và sẽ khiến động cơ giảm tối thiểu từ một mảng đến bảng băm. Hãy chắc chắn rằng mảng của bạn là đông dân 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à

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

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

Mảng có thể có bất kỳ yếu tố và có thể phát triển hoặc thu nhỏ tùy ý.

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

Các mảng có thể được lặp lại với vòng lặp

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

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

Hoặc, vì các mảng có thể sử dụng được, bạn có thể sử dụng vòng lặp

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

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

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

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 lại mảng - ví dụ,

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

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

Chức năng

Cùng với các đối tượng, các chức năng là thành phần cốt lõi trong việc hiểu JavaScript. Tuyên bố chức năng cơ bản nhất trông như thế này:

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

Hàm JavaScript có thể mất 0 hoặc nhiều tham số. Cơ thể chức năng có thể chứa bao nhiêu câu nói tùy thích và có thể khai báo các biến riêng của nó là cục bộ cho hàm đó. Câu lệnh

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

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

Các chức năng có thể được gọi với nhiều hoặc ít tham số hơn so với 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

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

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

Có một số cú pháp tham số khác có sẵn. Ví dụ, cú pháp tham số REST cho phép thu thập tất cả các tham số bổ sung được truyền bởi người gọi vào một mảng, tương tự như

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

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

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

Trong mã trên, biến

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

Tham số còn lại sẽ lưu trữ tất cả các đối số sau khi được khai báo, nhưng không phải trước đó. tức là

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

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

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

Nếu một hàm chấp nhận một danh sách các đối số và bạn đã giữ một mảng, bạn có thể sử dụng cú pháp lây lan trong lệnh gọi hàm để trải ra mảng dưới dạng danh sách các phần tử. Ví dụ:

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

Chúng tôi đã đề cập rằng JavaScript không đặt tên cho các tham số. Tuy nhiên, có thể thực hiện chúng bằng cách sử dụng phá 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.

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

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 các tham số được truyền là

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

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

Chức năng ẩn danh

JavaScript cho phép bạn tạo các hàm ẩn danh - nghĩa là các chức năng 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, ngay lập tức được gán 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.

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

Điều đó làm cho chức năng ẩn danh có thể được yêu cầu bằng cách gọi

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

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

Có một cách khác để xác định các hàm ẩn danh - sử dụng biểu thức chức năng mũi tên.

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

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 chức năng - để biết thêm thông tin, hãy xem trang tham chiếu 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 đồng thời và được gọi trong một biểu thức duy nhất, được gọi là biểu thức chức năng được gọi ngay lập tức (iife):

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

Đối với các trường hợp sử dụng của IIFES, bạn có thể đọc các phương thức riêng tư mô phỏng với các đóng cửa.

Chức năng đệ quy

JavaScript cho phép bạn gọi các chức năng đệ 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"[1] === "e"); // true

Biểu thức chức năng cũng có thể được đặt tên, cho phép chúng được đệ quy.

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

Tên được cung cấp cho một biểu thức chức năng như trên chỉ có sẵn cho phạm vi riêng của hàm. Điều này cho phép tối ưu hóa nhiều hơn được thực hiện bởi động cơ và dẫn đến mã dễ đọc hơn. Tên cũng xuất hiện trong trình gỡ lỗi và một số dấu vết ngăn xếp, 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, chỉ có JavaScriptCore (được Safari sử dụng) đã thực hiện nó, do khó khăn trong việc phục hồi 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 lần lặp để tránh tràn.

Chức năng là các đối tượng hạng nhất

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 chuyển làm đối số cho các chức năng khác và được trả lại từ các chức năng khác. Ngoài ra, JavaScript hỗ trợ đóng cửa ngoài hộp mà không bắt giữ rõ ràng, cho phép bạn áp dụng các kiểu lập trình chức năng thuận tiện.

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

Lưu ý rằng các hàm JavaScript là các đối tượng của chính chúng - như mọi thứ khác trong JavaScript - và bạn có thể thêm hoặc thay đổi thuộc tính trên chúng giống như chúng ta đã thấy trước đó trong phần đối tượng.

Chức năng bên trong

Khai báo chức năng JavaScript được cho phép bên trong các chức năng khác. Một chi tiết quan trọng của các chức năng lồng nhau trong JavaScript là chúng có thể truy cập các biến trong phạm vi chức năng cha mẹ của họ:

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

Điều này cung cấp rất nhiều tiện ích trong việc viết mã có thể duy trì hơn. Nếu một hàm được gọi là dựa trên một hoặc hai chức năng 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àm tổ các chức năng tiện ích đó bên trong nó. Điều này giữ cho số lượng các chức năng nằm trong phạm vi toàn cầu.

Đây cũng là một đối trọng tuyệt vời cho sự hấp dẫn của các biến toàn cầu. Khi viết mã phức tạp, thường rất hấp dẫn khi sử dụng các biến toàn cầu để chia sẻ các giá trị giữa nhiều hàm, dẫn đến mã khó duy trì. Các chức năng lồng nhau có thể chia sẻ các biến trong cha mẹ của chúng, vì vậy bạn có thể sử dụng cơ chế đó để kết hợp các hàm cùng nhau mà không làm ô nhiễm không gian tên toàn cầu của bạn.

Các lớp học

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

Các lớp JavaScript chỉ là các hàm phải được khởi tạo với toán tử

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

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

Các thuộc tính tĩnh được tạo bằng cách chi tiêu

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

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

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

Để có hướng dẫn chi tiết về các tính năng lớp khác nhau, bạn có thể đọc trang Hướng dẫn.

Lập trình không đồng bộ

JavaScript là một luồng đơn. Không có sự tương đồng; chỉ có sự đồng thời. 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 bộ nhiệm vụ được xếp hàng và bỏ phiếu để hoàn thành.

Có ba cách thành ngữ để viết mã không đồng bộ trong JavaScript:

• Dựa trên gọi lại (chẳng hạn như

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

  829)

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

  8 30-based
• ________ 231/________ 232, đó là một đường cú pháp cho những lời hứa

Ví dụ: đây là cách hoạt động đọc tệp có thể trông giống như trong JavaScript:

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

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 điều quan trọng là 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 các tệp. Việc giữ các hoạt động có khả năng chạy dài Async đảm bảo rằng các quy trình khác vẫn có thể chạy trong khi chương trình này chờ đợi-ví dụ, trình duyệt sẽ không đóng băng trong khi chờ người dùng nhấp vào nút để cấp quyền.

Nếu bạn có giá trị không đồng bộ, không thể có được 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

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

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

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

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

Trên thực tế, mô hình đơn luồng đã biến Node.js trở thành 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ó, khiến việc xử lý một số lượng lớn các yêu cầu cơ sở dữ liệu hoặc hệ thống tệp rất hiệu quả. Tuy nhiên, các nhiệm vụ liên kết CPU (chuyên sâu về mặt tính toán) đó là JavaScript thuần túy vẫn sẽ chặn luồng chính. Để đạt được sự tương đồng 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ề việc sử dụng lời hứa hoặc làm theo hướng dẫn JavaScript không đồng bộ.

Mô -đun

JavaScript cũng chỉ định một hệ thống mô -đun được hỗ trợ bởi hầu hết các 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 tệp của nó. Bạn có thể sử dụng các câu lệnh

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

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

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

Không giống như Haskell, Python, Java, v.v., độ phân giải mô-đun JavaScript hoàn toàn được xác định bởi máy chủ-nó thường dựa trên các URL hoặc đường dẫn tệp, do đó, các đườ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 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 - tất cả các chức năng cốt lõi được cung cấp bởi các biến toàn cầu như

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

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

Runtimes khác nhau có thể sử dụng các hệ thống mô -đun khác nhau. Ví dụ: Node.js sử dụng NPM Trình quản lý gói và chủ yếu dựa trên hệ thống tệp, trong khi DENO và trình duyệt dựa trên URL hoàn toàn và các mô-đun có thể được giải quyết từ URL HTTP.

Để biết thêm thông tin, xem trang Hướng dẫn mô -đun.

Ngôn ngữ và thời gian chạy

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 là cấp ngôn ngữ trong khi các tính năng khác là cấp độ thời gian chạy.

JavaScript là một ngôn ngữ kịch bản đa năng. Thông số kỹ thuật ngôn ngữ cốt lõi tập trung vào logic tính toán thuần túy. Nó không liên quan đến bất kỳ đầu vào/đầu ra nào-trên thực tế, không có API cấp độ thời gian chạy thêm (đáng chú ý nhất là

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

Thời gian chạy, hoặc máy chủ, là thứ cung cấp dữ liệu cho công cụ JavaScript (phiên dịch), cung cấp các thuộc tính toàn cầu bổ sung và cung cấp móc cho độ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, thông điệp in, gửi yêu cầu mạng, vv đều là 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 các 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ư truy cập hệ thống tệp), v.v. Mục đích), ứng dụng di động, ứng dụng máy tính để bàn, ứng dụng phía máy chủ, không có hệ thống nhúng, và nhiều hơn nữa. Mặc dù bạn tìm hiểu về các tính năng cốt lõi của JavaScript, nhưng điều quan trọng là phải hiểu các tính năng do máy chủ cung cấp để đưa kiến ​​thức sử dụng. 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 không phải là trình duyệt.

Khám phá thêm

Trang này cung cấp một cái nhìn sâu sắc rất cơ bản về cách các tính năng JavaScript khác nhau so sánh 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 với từng tính năng, bạn có thể đọc hướng dẫn JavaScript và tham chiếu 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à sự phức tạp, nhưng bạn có thể tự mình khám phá:

• Di truyền và chuỗi nguyên mẫu
• Đóng cửa
• Biểu cảm thường xuyên
• Lặp đi lặp lại