Hướng dẫn intermediate javascript - javascript trung gian

Giới thiệu

Tổng quan: Giới thiệu

• Về sự hướng dẫn này
• Về JavaScript
• JavaScript và Java
• Ecmascript
• Công cụ
• Chào thế giới

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

Tổng quan: Ngữ pháp và các loại

• Cú pháp và bình luận cơ bản
• Tuyên bố
• Phạm vi biến đổi
• Tăng cường biến
• Cấu trúc và loại dữ liệu
• Nghĩa đen

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

Tổng quan: Xử lý luồng và xử lý lỗi

• 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
• ________ 58/________ 59/________ 60
• Đối tượng lỗi

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

Tổng quan: Vòng lặp và Lặp lại

• 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

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

  7

Chức năng

Tổng quan: Chức năng

• Xác định chức năng
• Gọi chức năng
• Phạm vi chức năng
• Đóng cửa
• Đối số & tham số
• Hàm mũi tên

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

Tổng quan: Biểu thức và toán tử

• Phân công & so sánh
• Toán tử số học
• Các nhà khai thác bitwise & logic
• Nhà điều hành có điều kiện (ternary)

Số và ngày

Tổng quan: Số và ngày

• Số chữ
• Đối tượng

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

  8
• Đối tượng

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

  9
• Đối tượng

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

  0

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

Tổng quan: Định dạng văn bản

• Chuỗi chữ
• Đối tượng

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

  1
• Mẫu chữ
• Quốc tế hóa
• Biểu cảm thường xuyên

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

Tổng quan: Bộ sưu tập được lập chỉ mục

• Mảng
• Gõ mảng

Bộ sưu tập khóa

Tổng quan: Bộ sưu tập khóa

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

  2

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

  3

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

  4

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

  5

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

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

• Đối tượng và thuộc tính
• Tạo đối tượng
• Xác định phương pháp
• Getter và setter

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

Tổng quan: Sử dụng các lớp

• Tuyên bố một lớp học
• Các tính năng lớp khác nhau
• Mở rộng và thừa kế
• Tại sao các lớp học?

Hứa hẹn

Tổng quan: Lời hứa

• Đảm bảo
• Chuỗi
• Sự truyền lỗi
• Thành phần
• Thời gian

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

Tổng quan: Trình lặp và máy phát điện

• Trình lặp
• Vòng lặp
• Máy phát điện

Lập trình meta

Tổng quan: Lập trình meta

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

  6
• Người xử lý và bẫy
• Proxy có thể hủy bỏ

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

  7

Mô -đun JavaScript

Tổng quan: Mô -đun JavaScript

• Xuất khẩu
• Nhập khẩu
• Xuất khẩu mặc định
• Đổi tên các tính năng
• Các mô -đun tổng hợp
• Tải mô -đun động

• Tiếp theo "

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:

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

  8 và

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

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

• Boolean(""); // false
  Boolean(234); // true
  

  0

• Boolean(""); // false
  Boolean(234); // true
  

  1

• 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
  

  3

• Boolean(""); // false
  Boolean(234); // true
  

  4

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ố

Boolean(""); // false
Boolean(234); // true

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

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

• Boolean(""); // false
  Boolean(234); // true
  

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

• Boolean(""); // false
  Boolean(234); // true
  

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

  Boolean(""); // false
  Boolean(234); // true
  

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

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

Boolean(""); // false
Boolean(234); // true

Giá trị số cũng bao gồ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

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

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

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

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

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

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

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

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

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ử

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

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

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

• Một câu lệnh

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

  06 không có giá trị (

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

  07) ngầm trả về

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

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

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

  09) trả về

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

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

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

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

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

  04.

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

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

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

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

   9,

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

   16, chuỗi trống (

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

   17),

   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
   

   2,

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

   02 và

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

   04 đều trở thành

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

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

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

   8.

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

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 tuyên bố

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

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

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

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

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

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

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

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

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

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

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

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

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

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ử

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

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

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

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

Các nhà khai thá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

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

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

  70 hoặc

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

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

  72.
• 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

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ó vòng lặp

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

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

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

Vòng lặp

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

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("Hello"[1] === "e"); // true

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

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

Câu lệnh

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

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

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

Lỗi JavaScript được xử lý bằ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 ném bằng cách sử dụng câu lệnh

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

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

Boolean(""); // false
Boolean(234); // true

Boolean(""); // false
Boolean(234); // 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 bị ảnh hưởng bởi bất kỳ

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

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

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

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

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

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

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

Đ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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

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

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

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

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

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

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

Trong mã trên, biến

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

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

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

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;

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

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

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;

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

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;

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

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;

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

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

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

  29)

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

  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(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 đã 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

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

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

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