Tạo python vòng lặp vô hạn

Loại dữ liệu

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

• Con số. đượ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
• BigInt. được sử dụng cho các số nguyên lớn tùy ý
• Chuỗi. dùng để chứa văn bản
• Boolean.

  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
• Biểu tượng. được sử dụng để tạo số nhận dạng duy nhất sẽ không xung đột
• Không xác định. chỉ ra rằng một biến chưa được gán giá trị
• Vô giá trị. chỉ ra một phi giá trị có chủ ý

Mọi thứ khác được gọi là Đối tượng. 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

số

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

console.log(3 / 2); // 1.5, not 1

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

________số 8

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

Chữ số cũng có thể 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ũ

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

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

Các toán tử số học 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

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

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

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

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

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

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

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

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

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

Dây

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 được mã hóa UTF-16

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

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 thức này trả về các chuỗi mới

Toán tử

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

• Câu lệnh

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

  96 không có giá trị (

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

  97) hoàn toàn trả về

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

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

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

  99) trả về

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

  94
• Một khai báo biến không có khởi tạo (

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

  11) sẽ mặc nhiên khởi tạo biến thành

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

  94

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

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
   

   9,

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

   16, chuỗi rỗng (

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

   17),

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

   72,

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

   92 và

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

   94 đều trở thành

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

   9
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
   

   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

console.log(0.1 + 0.2); // 0.30000000000000004

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 giá trị boolean, chẳng hạn như trong câu lệnh

console.log(0.1 + 0.2); // 0.30000000000000004

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(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

console.log(0.1 + 0.2); // 0.30000000000000004

Biến

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

Không thể gán lại một biến được khai báo bằng

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

Khai báo

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

Khai báo

console.log(0.1 + 0.2); // 0.30000000000000004

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à

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

console.log(0.1 + 0.2); // 0.30000000000000004

Các biến được khai báo

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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ị chứ không phải với các biến. Đối với các biến được khai báo

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

nhà điều hành

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

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

Toán tử

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

console.log(0.1 + 0.2); // 0.30000000000000004

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ã

console.log(0.1 + 0.2); // 0.30000000000000004

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(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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.

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

JavaScript cũng có toán tử bitwise và toán tử logic. Đá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ị

console.log(0.1 + 0.2); // 0.30000000000000004

Toán tử

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

Để 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ử

Văn phạm

Ngữ pháp JavaScript rất giống với họ 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(0.1 + 0.2); // 0.30000000000000004
  

  50 hoặc

  console.log(0.1 + 0.2); // 0.30000000000000004
  

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

  console.log(0.1 + 0.2); // 0.30000000000000004
  

  52
• Dấu chấm phẩy là tùy chọn trong JavaScript — ngôn ngữ sẽ tự động chèn chú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

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

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

JavaScript không có

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

JavaScript có các vòng lặp

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

Vòng lặp

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

Câu lệnh

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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ư

console.log(0.1 + 0.2); // 0.30000000000000004

Lỗi JavaScript được xử lý bằng cách sử dụng câu lệnh

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0.1 + 0.2); // 0.30000000000000004

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

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

Nếu một lỗi không được phát hiện bởi bất kỳ

console.log(0.1 + 0.2); // 0.30000000000000004

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

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ữ

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

Thuộc tính đối tượng có thể được truy cập bằng cách sử dụng dấu chấm (

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

Quyền truy cập tài sản có thể được kết nối với nhau

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

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

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

Đ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 (______847), 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

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

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

console.log(0.1 + 0.2); // 0.30000000000000004

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 bởi vì bạn thường có thể đạt được tính 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 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

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 bằng cách sử dụng cú pháp

console.log(0.1 + 0.2); // 0.30000000000000004

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

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

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

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à

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

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

Mảng chúng ta có ở trên được gọi là mảng thưa thớt 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à

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

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

Mảng có thể có bất kỳ phần tử nào và có thể tăng hoặc giảm tùy ý

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

Mảng có thể được lặp với vòng lặp

console.log(0.1 + 0.2); // 0.30000000000000004

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

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

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

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(0.1 + 0.2); // 0.30000000000000004

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

Chức năng

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

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

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

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 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, world");
console.log("你好，世界！"); // Nearly all Unicode characters can be written literally in string literals

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ư

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

Trong đoạn mã trên, biến

console.log(0.1 + 0.2); // 0.30000000000000004

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,

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2); // 0.30000000000000004

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

console.log(0.1 + 0.2); // 0.30000000000000004

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

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

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

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

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

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

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

Đ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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

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

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)

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

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

hàm đệ quy

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

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

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

Hàm là đố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 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

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

chức năng bên trong

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

Đ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

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 bằng toán tử

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

Thuộc tính tĩnh được tạo bằng cách thêm trước

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

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

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ư

  console.log(0b111110111); // 503
  console.log(0o767); // 503
  console.log(0x1f7); // 503
  console.log(5.03e2); // 503
  

  09)
• dựa trên

  console.log(0b111110111); // 503
  console.log(0o767); // 503
  console.log(0x1f7); // 503
  console.log(5.03e2); // 503
  

  10

• console.log(0b111110111); // 503
  console.log(0o767); // 503
  console.log(0x1f7); // 503
  console.log(5.03e2); // 503
  

  11/

  console.log(0b111110111); // 503
  console.log(0o767); // 503
  console.log(0x1f7); // 503
  console.log(5.03e2); // 503
  

  12, là 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

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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ộ

mô-đun

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

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 ở 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. Đặc 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 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à

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

thăm dò 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 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á