Hướng dẫn what is javascript structure? - cấu trúc javascript là gì?

JavaScript là một ngôn ngữ đa hình, động lực với các loại và toán tử, các đối tượng tích hợp tiêu chuẩn và phương pháp. Cú pháp của nó dựa trên các 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 truyền xung quanh như bất kỳ đối tượng nào khác.

Trang này đóng vai trò là 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ó nền bằng các ngôn ngữ khác, chẳng hạn như C hoặc Java.

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:

  • Số: Được sử dụng cho tất cả các giá trị số (số nguyên và điểm nổi) 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: Được sử dụng để lưu trữ văn bản.
  • Boolean:
    console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    6 và
    console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    7 - thường được sử dụng cho logic có điều kiện.
  • Biểu tượng: Được sử dụng để tạo các định danh độc đáo sẽ không va chạm.
  • Không xác định: Chỉ ra rằng một biến chưa được gán một giá trị.
  • NULL: Chỉ ra một giá trị có giá trị có chủ ý.

Mọi thứ khác được gọi là một đối tượng. Các loại đối tượng phổ biến bao gồm:

  • console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    8
  • console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    9
  • console.log("Hello"[1] === "e"); // true
    
    0
  • console.log("Hello"[1] === "e"); // true
    
    1
  • console.log("Hello"[1] === "e"); // true
    
    2

Các chức năng 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 loại số tích hợp: số và bigint.

Loại số là giá trị điểm nổi độ chính xác kép của IEEE 754 64 bit, có nghĩa là 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 bị mất độ chính xác và số điểm nổi có thể được lưu trữ trong suốt thời gian Lên đến 1,79 × 10308. Trong các số, JavaScript không phân biệt giữa số điểm nổi và số nguyên.

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

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

Đố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(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503

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

console.log(-3n / 2n); // -1n

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
4 cung cấp các hàm và hằng số toán học tiêu chuẩn.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;

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

  • console.log("Hello"[1] === "e"); // true
    
    5, phân tích chuỗi cho một số nguyên.
  • console.log("Hello"[1] === "e"); // true
    
    6, phân tích chuỗi cho một số điểm nổi.
  • Hàm
    console.log("Hello"[1] === "e"); // true
    
    7, 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
8 làm tốc ký cho
console.log("Hello"[1] === "e"); // true
7.

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

const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
0 (viết tắt cho "không phải số") và
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
1. Nhiều hoạt động "Toán học không hợp lệ" sẽ trả về
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
0-ví dụ: nếu cố gắng phân tích chuỗi không phải là Numeric hoặc sử dụng
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
3 trên một giá trị âm. Phân chia theo 0 tạo ra
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
1 (tích cực hoặc tiêu cực).

const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
0 rất dễ lây lan: Nếu bạn cung cấp nó như một toán hạng cho bất kỳ hoạt động toán học nào, kết quả cũng sẽ là
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
0.
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
0 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).

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

const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
8 của nó.

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
8 bị quá tải cho các chuỗi: khi một trong các toán hạng là một chuỗi, nó thực hiện kết hợp chuỗi thay vì bổ sung số. Một cú pháp theo nghĩa đen của mẫu đặc biệt cho phép bạn viết các chuỗi với các biểu thức nhúng ngắn gọn hơn. Không giống như các chuỗi được nội suy của Python hoặc các chuỗi được nội suy của C#, các chữ cái mẫu sử dụng backticks (không phải là trích dẫn đơn hoặc kép).

const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal

Các loại khác

JavaScript phân biệt giữa

Boolean(""); // false
Boolean(234); // true
0, cho thấy một giá trị không có giá trị có chủ ý (và chỉ có thể truy cập được thông qua từ khóa
Boolean(""); // false
Boolean(234); // true
0) và
Boolean(""); // false
Boolean(234); // true
2, cho thấy sự vắng mặt của giá trị. Có nhiều cách để có được
Boolean(""); // false
Boolean(234); // true
2:

  • Một câu lệnh
    Boolean(""); // false
    Boolean(234); // true
    
    4 không có giá trị (
    Boolean(""); // false
    Boolean(234); // true
    
    5) ngầm trả về
    Boolean(""); // false
    Boolean(234); // true
    
    2.
  • Truy cập thuộc tính đối tượng không tồn tại (
    Boolean(""); // false
    Boolean(234); // true
    
    7) trả về
    Boolean(""); // false
    Boolean(234); // true
    
    2.
  • Một khai báo biến mà không cần khởi tạo (
    Boolean(""); // false
    Boolean(234); // true
    
    9) sẽ ngầm khởi tạo biến thành
    Boolean(""); // false
    Boolean(234); // true
    
    2.

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

  1. console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    7,
    let a;
    let name = "Simon";
    
    // myLetVariable is *not* visible out here
    
    for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
      // myLetVariable is only visible in here
    }
    
    // myLetVariable is *not* visible out here
    
    4, chuỗi trống (
    let a;
    let name = "Simon";
    
    // myLetVariable is *not* visible out here
    
    for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
      // myLetVariable is only visible in here
    }
    
    // myLetVariable is *not* visible out here
    
    5),
    const age = 25;
    console.log("I am " + age + " years old."); // String concatenation
    console.log(`I am ${age} years old.`); // Template literal
    
    0,
    Boolean(""); // false
    Boolean(234); // true
    
    0 và
    Boolean(""); // false
    Boolean(234); // true
    
    2 đều trở thành
    console.log("Hello, world");
    console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
    
    7.
  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
    
    6.

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

Boolean(""); // false
Boolean(234); // 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 câu lệnh

console.log(0.1 + 0.2); // 0.30000000000000004
02 (xem các cấu trúc điều khiển). Vì lý do này, đôi khi chúng ta nói về "sự thật" và "giả", có nghĩa là các giá trị trở thành
console.log("Hello, world");
console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
6 và
console.log("Hello, world");
console.log("你好,世界!"); // Nearly all Unicode characters can be written literally in string literals
7, khi được sử dụng trong bối cảnh Boolean.

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

console.log(0.1 + 0.2); // 0.30000000000000004
05 (logic và),
console.log(0.1 + 0.2); // 0.30000000000000004
06 (logic hoặc) và
console.log(0.1 + 0.2); // 0.30000000000000004
07 (logic không) được hỗ trợ; Xem các nhà khai thác.

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(0.1 + 0.2); // 0.30000000000000004
08 được đảm bảo là duy nhất. Ngoài ra, có các ký hiệu đã đăng ký, là các hằng số được chia sẻ và các biểu tượng nổi tiếng, được ngôn ngữ sử dụng làm "giao thức" cho các hoạt động nhất định. Bạn có thể đọc thêm về chúng trong tham chiếu biểu tượng.

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
09,
console.log(0.1 + 0.2); // 0.30000000000000004
10 hoặc
console.log(0.1 + 0.2); // 0.30000000000000004
11.

console.log(0.1 + 0.2); // 0.30000000000000004
09 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 đính kèm.

let a;
let name = "Simon";

// myLetVariable is *not* visible out here

for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
  // myLetVariable is only visible in here
}

// myLetVariable is *not* visible out here

console.log(0.1 + 0.2); // 0.30000000000000004
10 cho phép bạn khai báo các biến có giá trị không bao giờ có ý định thay đổi. Biến có sẵn từ khối mà nó được khai báo.

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

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

console.log(0.1 + 0.2); // 0.30000000000000004
10 không thể được chỉ định lại.

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

console.log(0.1 + 0.2); // 0.30000000000000004
10 Các khai báo chỉ ngăn chặn việc chỉ định lại - chúng không ngăn chặn các đột biến của giá trị của biến, nếu đó là một đối tượng.

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

console.log(0.1 + 0.2); // 0.30000000000000004
11 Tuyên bố có thể có những hành vi đáng ngạc nhiên (ví dụ, chúng không bị ảnh hưởng bởi 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ó, giá trị của nó là

Boolean(""); // false
Boolean(234); // true
2. Bạn không thể khai báo biến
console.log(0.1 + 0.2); // 0.30000000000000004
10 mà không có trình khởi tạo, vì dù sao bạn cũng không thể thay đổi nó sau này.

console.log(0.1 + 0.2); // 0.30000000000000004
09 và
console.log(0.1 + 0.2); // 0.30000000000000004
10 Các biến được tuyên bố vẫn chiếm toàn bộ phạm vi mà chúng được xác định và ở trong một khu vực được gọi là vùng chết tạm thời 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 thay đổi, không xảy ra trong các ngôn ngữ khác.

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

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(0.1 + 0.2); // 0.30000000000000004
21,
console.log(0.1 + 0.2); // 0.30000000000000004
22 vẫn nên đề cập đến tham số
console.log(0.1 + 0.2); // 0.30000000000000004
22 trong phạm vi trên. Trong JavaScript, vì mỗi tuyên bố chiếm toàn bộ phạm vi, điều này sẽ gây ra lỗi vào
console.log(0.1 + 0.2); // 0.30000000000000004
24 đầu tiên: "Không thể truy cập 'X' trước khi khởi tạo". Để biết thêm thông tin, xem trang tham chiếu của
console.log(0.1 + 0.2); // 0.30000000000000004
09.

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 ____ 109 đượ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
8,
console.log(0.1 + 0.2); // 0.30000000000000004
28,
console.log(0.1 + 0.2); // 0.30000000000000004
29,
console.log(0.1 + 0.2); // 0.30000000000000004
30,
console.log(0.1 + 0.2); // 0.30000000000000004
31 (phần còn lại) và
console.log(0.1 + 0.2); // 0.30000000000000004
32 (số liệu). Các giá trị được gán bằng cách sử dụng
console.log(0.1 + 0.2); // 0.30000000000000004
33. Mỗi toán tử nhị phân cũng có một đối tác gán hợp chất như
console.log(0.1 + 0.2); // 0.30000000000000004
34 và
console.log(0.1 + 0.2); // 0.30000000000000004
35, mở rộng đến
console.log(0.1 + 0.2); // 0.30000000000000004
36.

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

console.log(0.1 + 0.2); // 0.30000000000000004
37 và
console.log(0.1 + 0.2); // 0.30000000000000004
38 để tăng và giảm tương ứng. Chúng có thể được sử dụng như một toán tử tiền tố hoặc postfix.

Toán tử

console.log("Hello"[1] === "e"); // true
8 cũng thực hiện nối chuỗi:

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

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

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
40,
console.log(0.1 + 0.2); // 0.30000000000000004
41,
console.log(0.1 + 0.2); // 0.30000000000000004
42 và
console.log(0.1 + 0.2); // 0.30000000000000004
43, hoạt động cho cả hai chuỗi và số. Đối với sự bình đẳng, toán tử công bằng kép thực hiện ép buộc loại nếu bạn cho nó các loại khác nhau, với kết quả đôi khi thú vị. Mặt khác, toán tử ba công bằng không cố gắng ép buộc loại và thường được ưa thích.

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

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(0.1 + 0.2); // 0.30000000000000004
44 và
console.log(0.1 + 0.2); // 0.30000000000000004
45.

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

Các nhà khai thác

console.log(0.1 + 0.2); // 0.30000000000000004
05 và
console.log(0.1 + 0.2); // 0.30000000000000004
06 sử dụng logic ngắn mạch, điều đó có nghĩa là liệu họ sẽ thực thi toán hạng thứ hai của họ có phụ thuộc vào phần đầu tiên hay không. Điều này rất 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:

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

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

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

Để 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(0.1 + 0.2); // 0.30000000000000004
    
    48 hoặc
    console.log(0.1 + 0.2); // 0.30000000000000004
    
    49, trong khi nhiều ngôn ngữ kịch bản khác như Perl, Python và Bash sử dụng
    console.log(0.1 + 0.2); // 0.30000000000000004
    
    50.
  • 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(0.1 + 0.2); // 0.30000000000000004
02 và
console.log(0.1 + 0.2); // 0.30000000000000004
52; Bạn có thể xâu chuỗi chúng lại với nhau:

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

JavaScript không có

console.log(0.1 + 0.2); // 0.30000000000000004
53 và
console.log(0.1 + 0.2); // 0.30000000000000004
54 thực sự chỉ là một nhánh
console.log(0.1 + 0.2); // 0.30000000000000004
52 bao gồm một câu lệnh
console.log(0.1 + 0.2); // 0.30000000000000004
02 duy nhất.

JavaScript có vòng lặp

console.log(0.1 + 0.2); // 0.30000000000000004
57 và vòng lặp
console.log(0.1 + 0.2); // 0.30000000000000004
58. Đầu tiên là tốt cho vòng lặp cơ bản; Thứ hai là cho các vòng lặp mà bạn muốn đảm bảo rằng phần thân của vòng lặp được thực thi ít nhất một lần:

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

Vòng lặp

console.log(0.1 + 0.2); // 0.30000000000000004
59 của JavaScript giống như 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 bạn trên một dòng.

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

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

console.log(0.1 + 0.2); // 0.30000000000000004
60, lặp đi lặp lại trên các vòng lặp, đáng chú ý nhất là các mảng và
console.log(0.1 + 0.2); // 0.30000000000000004
61, truy cập tất cả các thuộc tính có thể tìm thấy của một đối tượng.

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

Câu lệnh

console.log(0.1 + 0.2); // 0.30000000000000004
62 có thể được sử dụng cho nhiều nhánh dựa trên kiểm tra bình đẳng.

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

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(0.1 + 0.2); // 0.30000000000000004
63, việc thực thi sẽ "rơi vào" lên 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 đề
console.log(0.1 + 0.2); // 0.30000000000000004
64, không chỉ là chuỗi hoặc chữ số, và chúng sẽ được đánh giá từng người một cho đến khi một giá trị phù hợp. So sánh diễn ra giữa hai người sử dụng toán tử
console.log(0.1 + 0.2); // 0.30000000000000004
65.

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

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

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

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

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

console.log(0.1 + 0.2); // 0.30000000000000004
68. Nhiều hoạt động tích hợp cũng có thể ném là tốt.

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

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(0.1 + 0.2); // 0.30000000000000004
68. Tuy nhiên, bạn thường có thể giả sử đó là một ví dụ
console.log("Hello"[1] === "e"); // true
2, như ví dụ trên. Có một số lớp con của
console.log("Hello"[1] === "e"); // true
2 tích hợp, như
console.log(0.1 + 0.2); // 0.30000000000000004
72 và
console.log(0.1 + 0.2); // 0.30000000000000004
73, mà bạn có thể sử dụng để cung cấp thêm ngữ nghĩa về lỗi. Không có 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 bắt mọi thứ, xác định loại lỗi bằng cách sử dụng
console.log(0.1 + 0.2); // 0.30000000000000004
74, sau đó tái hiện các trường hợp khác.

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

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

console.log(0.1 + 0.2); // 0.30000000000000004
67 trong ngăn xếp cuộc gọi, chương trình sẽ thoát.

Để 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(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
8

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

console.log(0.1 + 0.2); // 0.30000000000000004
76) hoặc dấu ngoặc (
console.log(0.1 + 0.2); // 0.30000000000000004
77). Khi sử dụng ký hiệu dấu chấm, khóa phải là định danh hợp lệ. Mặt khác, dấu ngoặc cho phép lập chỉ mục đối tượng với giá trị khóa động.

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

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

console.log(-3n / 2n); // -1n
0

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(-3n / 2n); // -1n
1

Đ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(0.1 + 0.2); // 0.30000000000000004
45), bởi vì chúng là các tài liệu tham khảo khác nhau. Nếu bạn giữ hai tài liệu tham khảo của cùng một đối tượng, việc biến đổi người này sẽ có thể quan sát được thông qua người kia.

console.log(-3n / 2n); // -1n
2

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

console.log(0.1 + 0.2); // 0.30000000000000004
79. Để biết thêm thông tin về cú pháp khởi tạo đối tượng, hãy xem trang tham chiếu của nó.

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 (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(0.1 + 0.2); // 0.30000000000000004
77) nhưng chúng có một thuộc tính ma thuật được gọi là
const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
8. Đây luôn là một chỉ số cao hơn chỉ số cao nhất trong mảng.

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

console.log(-3n / 2n); // -1n
3

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à

const age = 25;
console.log("I am " + age + " years old."); // String concatenation
console.log(`I am ${age} years old.`); // Template literal
8 sẽ được tự động cập nhật khi bạn đặt một chỉ mục cụ thể.

console.log(-3n / 2n); // -1n
4

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à

Boolean(""); // false
Boolean(234); // true
2 trở lại:

console.log(-3n / 2n); // -1n
5

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(-3n / 2n); // -1n
6

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

console.log(0.1 + 0.2); // 0.30000000000000004
59, như bạn có thể trong các ngôn ngữ giống như C khác:

console.log(-3n / 2n); // -1n
7

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(0.1 + 0.2); // 0.30000000000000004
60, đồng nghĩa với cú pháp
console.log(0.1 + 0.2); // 0.30000000000000004
86 của C ++/Java:

console.log(-3n / 2n); // -1n
8

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
87 sẽ áp dụng một cuộc gọi lại cho mọi phần tử mảng và trả về một mảng mới:

console.log(-3n / 2n); // -1n
9

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:

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
0

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

Boolean(""); // false
Boolean(234); // true
4 có thể được sử dụng để trả về một giá trị bất cứ lúc nào, chấm dứt hàm. Nếu không sử dụng câu lệnh trả về (hoặc trả về trống không có giá trị), JavaScript trả về
Boolean(""); // false
Boolean(234); // true
2.

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

Boolean(""); // false
Boolean(234); // true
2. Nếu bạn vượt qua nhiều tham số hơn mong đợi, hàm sẽ bỏ qua các tham số bổ sung.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
1

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 người gọi truyền vào một mảng, tương tự như

console.log(0.1 + 0.2); // 0.30000000000000004
91 của Python. (Vì JS không đặt tên tham số ở cấp ngôn ngữ, nên không có
console.log(0.1 + 0.2); // 0.30000000000000004
92.)

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
2

Trong mã trên, biến

console.log(0.1 + 0.2); // 0.30000000000000004
93 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 khi được khai báo, nhưng không phải trước đó. tức là

console.log(0.1 + 0.2); // 0.30000000000000004
94 sẽ lưu trữ giá trị đầu tiên được truyền vào hàm trong biến
console.log(0.1 + 0.2); // 0.30000000000000004
95 và các đối số còn lại trong
console.log(0.1 + 0.2); // 0.30000000000000004
93.

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

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.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
3

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à

Boolean(""); // false
Boolean(234); // true
2) có giá trị mặc định.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
4

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.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
5

Đ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(0.1 + 0.2); // 0.30000000000000004
99 với một số đối số - nghĩa là, nó tương đương về mặt ngữ nghĩa khi khai báo chức năng bằng cách sử dụng cú pháp khai báo
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
00.

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.

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
6

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

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
7

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

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
8

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

Math.sin(3.5);
const circumference = 2 * Math.PI * r;
9

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
0

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
1

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

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
01. 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 được 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 chức năng trả về các lớp hoặc bạn có thể có nhiều lớp cho mỗi tệp. Dưới đây là một ví dụ về cách tạo ra sự tạo ra của một lớp: đó chỉ là một biểu thức được trả về từ một hàm mũi tên. Mô hình này được gọi là một mixin.

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

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

console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
02. Các thuộc tính riêng được tạo ra bằng cách chi tiêu một hàm băm
console.log(0.1 + 0.2); // 0.30000000000000004
50 (không phải
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
04). Hash là một phần không thể thiếu của tên tài sản. .

Để 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(0b111110111); // 503
    console.log(0o767); // 503
    console.log(0x1f7); // 503
    console.log(5.03e2); // 503
    
    07)
  • console.log(0b111110111); // 503
    console.log(0o767); // 503
    console.log(0x1f7); // 503
    console.log(5.03e2); // 503
    
    08-based
  • ________ 209/________ 210, đó 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
4

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(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
11. Tương tự,
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
10 chỉ có thể được sử dụng trong bối cảnh không đồng bộ, thường là hàm async hoặc một mô -đun. Những lời hứa không bao giờ chặn - chỉ có logic tùy thuộc vào kết quả của lời hứa sẽ được hoãn lại; Mọi thứ khác tiếp tục thực hiện trong lúc này. Nếu bạn là một lập trình viên chức năng, bạn có thể nhận ra những lời hứa là các đơn vị có thể được ánh xạ bằng
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
11 (tuy nhiên, chúng không phải là đơn vị thích hợp vì chúng tự động được phát hành; tức là bạn không thể có
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
14).

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(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
15 và
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
16 để 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
5

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
4 và
console.log(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
18 thay thế. Điều này là do lịch sử lâu dài của JavaScript thiếu một hệ thống mô -đun và thực tế là chọn vào 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.

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(0b111110111); // 503
console.log(0o767); // 503
console.log(0x1f7); // 503
console.log(5.03e2); // 503
19), hành vi của chương trình JavaScript là hoàn toàn không thể quan sát được.

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