Hướng dẫn what syntax is followed by javascript? - cú pháp nào được theo sau bởi javascript?

Cú pháp JavaScript là tập hợp & NBSP; Quy tắc, cách các chương trình JavaScript được xây dựng:

// Cách tạo biến: Var X; Hãy để y;
var x;
let y;

// Cách sử dụng các biến: x = 5; y = 6; Đặt z = x + y;
x = 5;
y = 6;
let z = x + y;

Giá trị JavaScript

Cú pháp JavaScript xác định hai loại giá trị:

• Giá trị cố định
• Giá trị biến

Giá trị cố định được gọi là nghĩa đen.Literals.

Giá trị biến được gọi là biến.Variables.

JavaScript nghĩa đen

Hai quy tắc cú pháp quan trọng nhất cho các giá trị cố định là:

1. Số được viết có hoặc không có số thập phân:Numbers are written with or without decimals:

2. Chuỗi là văn bản, được viết trong các trích dẫn gấp đôi hoặc đơn:Strings are text, written within double or single quotes:

Biến JavaScript

Trong ngôn ngữ lập trình, các biến được sử dụng để lưu trữ các giá trị dữ liệu.variables are used to store data values.

JavaScript sử dụng các từ khóa

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Một dấu hiệu bằng nhau được sử dụng để gán các giá trị cho các biến.equal sign is used to assign values to variables.

Trong ví dụ này, x được định nghĩa là một biến. Sau đó, x được gán (đã cho) giá trị 6:

Toán tử JavaScript

JavaScript sử dụng các toán tử số học (

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

JavaScript sử dụng toán tử gán (

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Biểu thức JavaScript

Một biểu thức là sự kết hợp của các giá trị, biến và toán tử, tính toán theo giá trị.

Việc tính toán được gọi là đánh giá.

Ví dụ: 5 * 10 đánh giá là 50:

Biểu thức cũng có thể chứa các giá trị biến:

Các giá trị có thể thuộc nhiều loại khác nhau, chẳng hạn như số và chuỗi.

Ví dụ: "John" + "" + "DOE", đánh giá thành "John Doe":

Từ khóa JavaScript

Từ khóa JavaScript được sử dụng để xác định các hành động sẽ được thực hiện.keywords are used to identify actions to be performed.

Từ khóa

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Từ khóa

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Trong các ví dụ này, sử dụng

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Bạn sẽ tìm hiểu thêm về

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

JavaScript Nhận xét

Không phải tất cả các câu lệnh JavaScript đều được "thực hiện".

Mã sau khi chém đôi

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Nhận xét bị bỏ qua và sẽ không được thực thi:

Bạn sẽ tìm hiểu thêm về các bình luận trong một chương sau.

Định danh / tên JavaScript

Định danh là tên JavaScript.

Định danh được sử dụng để đặt tên cho các biến và từ khóa và các chức năng.

Các quy tắc cho tên hợp pháp là giống nhau trong hầu hết các ngôn ngữ lập trình.

Tên JavaScript phải bắt đầu bằng:

• Một chữ cái (A-Z hoặc A-Z)
• Một dấu hiệu đô la ($)
• Hoặc một dấu gạch dưới (_)

Các ký tự tiếp theo có thể là các chữ cái, chữ số, dấu gạch dưới hoặc dấu hiệu đô la.

Ghi chú

Các số không được phép là ký tự đầu tiên trong tên.

Bằng cách này, JavaScript có thể dễ dàng phân biệt các định danh với các số.

JavaScript nhạy cảm

Tất cả các định danh JavaScript đều nhạy cảm trường hợp. & NBSP;case sensitive. 

Các biến

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

JavaScript không giải thích cho hoặc cho là từ khóa cho phép.LET or Let as the keyword let.

JavaScript và vỏ Camel

Trong lịch sử, các lập trình viên đã sử dụng các cách khác nhau để tham gia nhiều từ vào một tên biến:

Hyphens:

tên đầu tiên, tên cuối cùng, thẻ chính, liên thành phố.

HNED không được phép trong JavaScript. Chúng được dành riêng cho phép trừ.

Underscore:

First_name, last_name, master_card, inter_city.

Vỏ lạc đà trên (trường hợp Pascal):

FirstName, LastName, MasterCard, Internal.

Vỏ lạc đà thấp hơn:

Các lập trình viên JavaScript có xu hướng sử dụng vỏ lạc đà bắt đầu bằng chữ thường:

FirstName, LastName, MasterCard, Internal.

Bộ ký tự JavaScript

JavaScript sử dụng bộ ký tự Unicode.Unicode character set.

Unicode bao gồm (gần như) tất cả các nhân vật, dấu chấm câu và biểu tượng trên thế giới.

Để xem xét kỹ hơn, xin vui lòng nghiên cứu tài liệu tham khảo Unicode hoàn chỉnh của chúng tôi.

Cú pháp của JavaScript là tập hợp các quy tắc xác định chương trình JavaScript có cấu trúc chính xác.syntax of JavaScript is the set of rules that define a correctly structured JavaScript program.

Các ví dụ dưới đây sử dụng chức năng nhật ký của đối tượng console có trong hầu hết các trình duyệt cho đầu ra văn bản tiêu chuẩn.

Thư viện tiêu chuẩn JavaScript thiếu chức năng đầu ra văn bản tiêu chuẩn chính thức (ngoại trừ

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Origins[edit][edit]

Brendan Eich đã tóm tắt tổ tiên của cú pháp trong đoạn đầu tiên của đặc tả JavaScript 1.1 [1] [2] như sau:

JavaScript mượn hầu hết cú pháp của nó từ Java, nhưng cũng được thừa hưởng từ AWK và Perl, với một số ảnh hưởng gián tiếp từ bản thân trong hệ thống nguyên mẫu đối tượng của nó.

Basics[edit][edit]

Độ nhạy của trường hợp [Chỉnh sửa][edit]

JavaScript là trường hợp nhạy cảm. Người ta thường bắt đầu tên của một hàm tạo với một chữ cái viết hoa và tên của một hàm hoặc biến với một chữ cái chữ thường.

Thí dụ:

var a = 5;
console.log(a); // 5
console.log(A); // throws a ReferenceError: A is not defined

Khoảng trắng và dấu chấm phẩy [chỉnh sửa][edit]

Không giống như trong C, khoảng trắng trong nguồn JavaScript có thể ảnh hưởng trực tiếp đến ngữ nghĩa. Semicolons kết thúc tuyên bố trong JavaScript. Do chèn dấu chấm phẩy tự động (ASI), một số tuyên bố được hình thành tốt khi một dòng mới được phân tích cú pháp sẽ được coi là hoàn thành, như thể một dấu chấm phẩy được chèn ngay trước khi dòng mới. Một số cơ quan tư vấn cung cấp các dấu chấm phẩy cuối cùng tuyên bố một cách rõ ràng, bởi vì nó có thể làm giảm các tác động ngoài ý muốn của việc chèn dấu chấm phẩy tự động. [3]

Có hai vấn đề: năm mã thông báo có thể bắt đầu một tuyên bố hoặc là phần mở rộng của một tuyên bố hoàn chỉnh; và năm sản phẩm bị hạn chế, trong đó không được phép phá vỡ dòng ở một số vị trí nhất định, có khả năng mang lại phân tích cú pháp không chính xác.

Năm mã thông báo có vấn đề là dấu ngoặc đơn "

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

với đề xuất rằng tuyên bố trước đó được chấm dứt bằng dấu chấm phẩy.

Một số người đề nghị thay vào đó việc sử dụng các dấu chấm phẩy hàng đầu trên các dòng bắt đầu bằng '

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Bán kết ban đầu đôi khi cũng được sử dụng khi bắt đầu các thư viện JavaScript, trong trường hợp chúng được thêm vào một thư viện khác bỏ qua dấu chấm phẩy kéo dài, vì điều này có thể dẫn đến sự mơ hồ của tuyên bố ban đầu.

Năm sản phẩm bị hạn chế là

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

[edit]edit]

Cú pháp nhận xét giống như trong C ++, Swift và nhiều ngôn ngữ khác.

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Variables[edit][edit]

Các biến trong JavaScript tiêu chuẩn không có loại đính kèm, do đó, bất kỳ giá trị nào (mỗi giá trị có một loại) có thể được lưu trữ trong bất kỳ biến nào. Bắt đầu với ES6, phiên bản thứ 6 của ngôn ngữ, các biến có thể được khai báo với

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Bắt đầu với JavaScript 1.5, ISO 8859-1 hoặc các chữ cái Unicode (hoặc

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Phạm vi và nâng [chỉnh sửa][edit]

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

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Với các tuyên bố

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Tuyên bố chức năng, khai báo một biến và gán một hàm cho nó, tương tự như các câu lệnh biến, nhưng ngoài việc nâng Tuyên bố, chúng cũng kéo được gán - như thể toàn bộ câu lệnh xuất hiện ở đầu hàm chứa - và do đó Tham khảo phía trước cũng có thể: vị trí của câu lệnh hàm trong hàm kèm theo là không liên quan. Điều này khác với biểu thức chức năng được gán cho một biến trong câu lệnh

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Ví dụ,

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Phạm vi khối có thể được tạo ra bằng cách gói toàn bộ khối trong một hàm và sau đó thực thi nó-điều này được gọi là mẫu biểu thức chức năng được phát sóng ngay lập tức-hoặc bằng cách khai báo biến bằng từ khóa

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Tuyên bố và Bài tập [Chỉnh sửa][edit]

Các biến được khai báo bên ngoài một phạm vi là toàn cầu. Nếu một biến được khai báo trong phạm vi cao hơn, nó có thể được truy cập bằng phạm vi trẻ em.

Khi JavaScript cố gắng giải quyết một định danh, nó sẽ nhìn vào phạm vi cục bộ. Nếu số nhận dạng này không được tìm thấy, nó trông ở phạm vi bên ngoài tiếp theo, và cứ như vậy dọc theo chuỗi phạm vi cho đến khi nó đạt đến phạm vi toàn cầu nơi các biến toàn cầu nằm. Nếu nó vẫn chưa được tìm thấy, JavaScript sẽ tăng ngoại lệ

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Khi gán một định danh, JavaScript sẽ trải qua chính xác quá trình để truy xuất định danh này, ngoại trừ nếu nó không được tìm thấy trong phạm vi toàn cầu, nó sẽ tạo ra "biến" trong phạm vi mà nó được tạo. [7] Do đó, một biến không bao giờ được tuyên bố sẽ là toàn cầu, nếu được gán. Khai thác một biến (với từ khóa

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Lưu ý rằng chế độ nghiêm ngặt của JavaScript cấm việc gán một biến không được khai báo, tránh ô nhiễm không gian tên toàn cầu.

Examples[edit][edit]

Dưới đây là một số ví dụ về khai báo và phạm vi biến:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Các loại dữ liệu nguyên thủy [Chỉnh sửa][edit]

Ngôn ngữ JavaScript cung cấp sáu loại dữ liệu nguyên thủy:

• Chưa xác định
• Con số
• Bigint
• Sợi dây
• Boolean
• Biểu tượng

Một số loại dữ liệu nguyên thủy cũng cung cấp một tập hợp các giá trị được đặt tên đại diện cho phạm vi của ranh giới loại. Các giá trị được đặt tên này được mô tả trong các phần thích hợp dưới đây.

Undefined[edit][edit]

Giá trị của "không xác định" được gán cho tất cả các biến không được chỉ định và cũng được trả về khi kiểm tra các thuộc tính đối tượng không tồn tại. Trong bối cảnh Boolean, giá trị không xác định được coi là một giá trị sai.

Lưu ý: Không xác định được coi là một loại nguyên thủy chính hãng. Trừ khi được chuyển đổi rõ ràng, giá trị không xác định có thể hoạt động bất ngờ so với các loại khác đánh giá sai trong bối cảnh logic.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Lưu ý: Không có ngôn ngữ tích hợp theo nghĩa đen cho không xác định. Do đó,

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các chức năng như thế này sẽ không hoạt động như mong đợi:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Ở đây, gọi

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Number[edit][edit]

Các số được thể hiện trong nhị phân khi IEEE-754 ILOATING POELD. Mặc dù định dạng này cung cấp độ chính xác của gần 16 chữ số quan trọng, nhưng nó không thể luôn luôn đại diện chính xác các số thực, bao gồm cả phân số.

Điều này trở thành một vấn đề khi so sánh hoặc định dạng số. Ví dụ:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Do đó, một thói quen như phương thức tofixed () nên được sử dụng cho các số tròn bất cứ khi nào chúng được định dạng cho đầu ra.toFixed() method should be used to round numbers whenever they are formatted for output.

Các số có thể được chỉ định trong bất kỳ ký hiệu nào trong số này:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Ngoài ra còn có một dấu phân cách số, _ (dấu gạch dưới), được giới thiệu trong ES2021:_ (the underscore), introduced in ES2021:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các phạm vi +, và NAN (không phải là số) của loại số có thể được lấy bằng hai biểu thức chương trình:+∞, −∞ and NaN (Not a Number) of the number type may be obtained by two program expressions:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Infinity và Nan là những con số:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Ba giá trị đặc biệt này tương ứng và hoạt động như IEEE-754 mô tả chúng.

Hàm tạo số (được sử dụng làm hàm) hoặc unary + hoặc -, có thể được sử dụng để thực hiện chuyển đổi số rõ ràng:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Khi được sử dụng làm hàm tạo, một đối tượng trình bao bọc số được tạo (mặc dù nó ít sử dụng):

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Tuy nhiên, NAN không bằng chính nó:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

BigInt[edit][edit]

Bigint có thể được sử dụng cho các số nguyên lớn tùy ý. Đặc biệt là các số toàn bộ lớn hơn 253 - 1, là số JavaScript lớn nhất có thể biểu thị một cách đáng tin cậy với số nguyên thủy và được biểu thị bằng hằng số.MAX_SAFE_Integer.

Khi chia lớn, kết quả bị cắt ngắn.

String[edit][edit]

Một chuỗi trong JavaScript là một chuỗi các ký tự. Trong JavaScript, các chuỗi có thể được tạo trực tiếp (theo nghĩa đen) bằng cách đặt một loạt các ký tự giữa các trích dẫn Double (") hoặc Single ('). n). Tiêu chuẩn JavaScript cho phép ký tự bảo phòng (`, a.k.a. Accent hoặc backtick) để trích dẫn các chuỗi nghĩa đen đa dòng, nhưng điều này chỉ được hỗ trợ trên một số trình duyệt nhất định kể từ năm 2016: Firefox và Chrome, nhưng không phải Internet Explorer 11. [8]

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các ký tự riêng lẻ trong một chuỗi có thể được truy cập bằng phương thức Charat (được cung cấp bởi String.Prototype). Đây là cách ưa thích khi truy cập các ký tự riêng lẻ trong một chuỗi, bởi vì nó cũng hoạt động trong các trình duyệt không hiện đại:charAt method (provided by String.prototype). This is the preferred way when accessing individual characters within a string, because it also works in non-modern browsers:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Trong các trình duyệt hiện đại, các ký tự riêng lẻ trong một chuỗi có thể được truy cập (như các chuỗi chỉ có một ký tự duy nhất) thông qua cùng một ký hiệu với các mảng:

Tuy nhiên, chuỗi JavaScript là bất biến:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Áp dụng toán tử bình đẳng ("==") cho hai chuỗi trả về đúng, nếu các chuỗi có cùng nội dung, có nghĩa là: có cùng độ dài và chứa cùng một chuỗi ký tự (trường hợp có ý nghĩa đối với bảng chữ cái). Do đó:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Trích dẫn cùng loại không thể được lồng trừ khi chúng được thoát ra.

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Trình xây dựng chuỗi tạo một đối tượng chuỗi (một đối tượng quấn một chuỗi):String constructor creates a string object (an object wrapping a string):

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Các đối tượng này có một phương thức giá trị trả về chuỗi nguyên thủy được bọc trong chúng:valueOf method returning the primitive string wrapped within them:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Bình đẳng giữa hai đối tượng chuỗi không hoạt động như với các nguyên thủy chuỗi:String objects does not behave as with string primitives:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Boolean[edit][edit]

JavaScript cung cấp một loại dữ liệu boolean với các chữ đúng và sai. Toán tử typeof trả về chuỗi "boolean" cho các loại nguyên thủy này. Khi được sử dụng trong bối cảnh logic, 0, -0, null, nan, không xác định và chuỗi trống ("") đánh giá là sai do chuyển đổi loại tự động. Tất cả các giá trị khác (phần bổ sung của danh sách trước đó) đánh giá là đúng, bao gồm các chuỗi "0", "sai" và bất kỳ đối tượng nào.true and false literals. The typeof operator returns the string "boolean" for these primitive types. When used in a logical context, 0, -0, null, NaN, undefined, and the empty string ("") evaluate as false due to automatic type conversion. All other values (the complement of the previous list) evaluate as true, including the strings "0", "false" and any object.

Loại chuyển đổi [Chỉnh sửa][edit]

Có thể tránh bị ép buộc loại tự động bởi các toán tử so sánh bình đẳng (

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Khi cần chuyển đổi loại, JavaScript chuyển đổi boolean, số, chuỗi hoặc toán hạng đối tượng như sau: [9]Boolean, Number, String, or Object operands as follows:[9]

Douglas Crockford ủng hộ các thuật ngữ "sự thật" và "giả" để mô tả cách các giá trị của nhiều loại hoạt động khi được đánh giá trong bối cảnh logic, đặc biệt là liên quan đến các trường hợp cạnh. [10] Các toán tử logic nhị phân đã trả lại giá trị boolean trong các phiên bản đầu của JavaScript, nhưng bây giờ họ trả lại một trong các toán hạng thay thế. Các operand và được trả lại, nếu nó có thể được đánh giá là & nbsp; Nếu không, đúng và được trả lại. Sự ép buộc loại tự động của các toán tử so sánh có thể khác nhau đối với các trường hợp các toán hạng boolean và tương thích số hỗn hợp (bao gồm cả các chuỗi có thể được đánh giá dưới dạng một số một giá trị số. Điều này có thể là bất ngờ. Một biểu thức có thể được chuyển đến một nguyên thủy boolean bằng cách nhân đôi toán tử phủ định logic: (!!), sử dụng hàm boolean () hoặc sử dụng toán tử có điều kiện: (

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Toán tử mới có thể được sử dụng để tạo một trình bao bọc đối tượng cho một nguyên thủy boolean. Tuy nhiên, toán tử typeof không trả về boolean cho trình bao bọc đối tượng, nó trả về đối tượng. Bởi vì tất cả các đối tượng đánh giá là đúng, một phương thức như. Để ép buộc rõ ràng với loại Boolean, Mozilla khuyến nghị rằng hàm boolean () (không có mới) được sử dụng theo sở thích đối với đối tượng boolean.typeof operator does not return boolean for the object wrapper, it returns object. Because all objects evaluate as true, a method such as .valueOf(), or .toString(), must be used to retrieve the wrapped value. For explicit coercion to the Boolean type, Mozilla recommends that the Boolean() function (without new) be used in preference to the Boolean object.

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Symbol[edit][edit]

Mới trong ecmascript6. Một biểu tượng là một định danh độc đáo và bất biến.

Thí dụ:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Cũng có những biểu tượng nổi tiếng.

Một trong số đó là

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Đối tượng gốc [Chỉnh sửa][edit]

Ngôn ngữ JavaScript cung cấp một số ít các đối tượng gốc. Các đối tượng gốc JavaScript được coi là một phần của đặc điểm kỹ thuật JavaScript. Môi trường JavaScript mặc dù, tập hợp các đối tượng này phải luôn luôn có sẵn.

Array[edit][edit]

Một mảng là một nguyên mẫu đối tượng JavaScript được tạo ra từ hàm tạo

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Như trong họ C, các mảng sử dụng sơ đồ lập chỉ mục dựa trên không: một giá trị được chèn vào một mảng trống bằng phương thức

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Các mảng có thuộc tính

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các yếu tố của

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Hai trên là tương đương. Không thể sử dụng các chuỗi hoặc chuỗi "dấu chấm" với các biểu diễn thay thế của số:

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Tuyên bố của một mảng có thể sử dụng một hàm tạo

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Các mảng được thực hiện để chỉ các phần tử được xác định sử dụng bộ nhớ; Họ là "mảng thưa thớt". Cài đặt

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Người ta có thể sử dụng khai báo đối tượng theo nghĩa đen để tạo các đối tượng hoạt động giống như các mảng kết hợp trong các ngôn ngữ khác:

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Người ta có thể sử dụng các chữ cái khai báo đối tượng và mảng để nhanh chóng tạo ra các mảng có liên kết, đa chiều hoặc cả hai. (Về mặt kỹ thuật, JavaScript không hỗ trợ các mảng đa chiều, nhưng người ta có thể bắt chước chúng bằng các mảng.)

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Date[edit][edit]

Một đối tượng

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Các phương pháp để trích xuất các trường được cung cấp, cũng như một

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Error[edit][edit]

Thông báo lỗi tùy chỉnh có thể được tạo bằng lớp

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Chúng có thể bị bắt bởi thử ... bắt ... cuối cùng các khối như được mô tả trong phần xử lý ngoại lệ.

Math[edit][edit]

Đối tượng toán học chứa các hằng số liên quan đến toán học khác nhau (ví dụ: π) và các hàm (ví dụ: cosin). .Math object contains various math-related constants (for example, π) and functions (for example, cosine). (Note that the Math object has no constructor, unlike Array or Date. All its methods are "static", that is "class" methods.) All the trigonometric functions use angles expressed in radians, not degrees or grads.

Thí dụ	Trả lại giá trị đến 5 chữ số rounded to 5 digits	Sự mô tả
Math.abs(-2.3)	2.3	E: Cơ sở logarit tự nhiên
Math.acos(Math.SQRT1_2)	Logarit tự nhiên của 2 = 45°	Logarit tự nhiên của 10
Math.asin(Math.SQRT1_2)	Logarit tự nhiên của 2 = 45°	Logarit tự nhiên của 10
Math.atan(1)	Logarit tự nhiên của 2 = 45°	Logarit tự nhiên của 10 to )
Logarit vào cơ sở 2 của E	Logarit vào cơ sở 10 của e = −135°	π: chu vi/đường kính của một vòng tròn to )
Math.ceil(1.1)	2	Căn bậc hai của ½
Math.cos(Math.PI/4)	0.70711	Căn bậc hai của 2
Phương pháp của đối tượng toán học(1)	2.7183	Thí dụe raised to this power
Math.floor(1.9)	1	Giá trị tuyệt đối
Math.log(Math.E)	1	0,78540 & nbsp; rad = 45 °e
Arccosine	1	Vòng cung(x > y) ? x : y
Half Circle Arctangent (đến)	Math.atan2 (-3.7, -3.7)	−2.3562 & nbsp; rad = −135 °(x < y) ? x : y
Toàn bộ vòng tròn Arctangent (đến)	9	Trần: làm tròn lên đến số nguyên nhỏ nhất ≥ đối sốMath.pow(x, y) gives xy
Math.random()	ví dụ. 0.17068	Số giả giữa 0 (bao gồm) và 1 (độc quyền)
Math.round(1.5)	2	Tròn đến số nguyên gần nhất; Một nửa phân số được làm tròn lên (ví dụ: 1,5 vòng đến 2)
Math.sin(Math.PI/4)	0.70711	Sin
Math.sqrt(49)	7	Căn bậc hai
Math.tan(Math.PI/4)	1	Đường tiếp tuyến

Biểu thức chính quy [Chỉnh sửa][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Các lớp ký tự [Chỉnh sửa][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Kết hợp nhân vật [Chỉnh sửa][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Repeaters[edit][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Anchors[edit][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Subexpression[edit][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Flags[edit][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Phương pháp nâng cao [Chỉnh sửa][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Bắt các nhóm [chỉnh sửa][edit]

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Function[edit][edit]

Mỗi chức năng trong JavaScript là một ví dụ của hàm tạo

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Hàm thêm ở trên cũng có thể được xác định bằng cách sử dụng biểu thức chức năng:

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Trong ES6, cú pháp hàm mũi tên đã được thêm vào, cho phép các hàm trả về giá trị ngắn gọn hơn. Họ cũng giữ lại

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Đối với các chức năng cần được nâng lên, có một biểu thức riêng biệt:

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Tăng cường cho phép bạn sử dụng chức năng trước khi nó được "tuyên bố":

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Một thể hiện chức năng có các thuộc tính và phương thức.

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Operators[edit][edit]

Toán tử '+' bị quá tải: nó được sử dụng để kết hợp chuỗi và bổ sung số học. Điều này có thể gây ra vấn đề khi vô tình trộn chuỗi và số. Là một toán tử đơn, nó có thể chuyển đổi một chuỗi số thành một số.

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Tương tự, toán tử '*' bị quá tải: nó có thể chuyển đổi một chuỗi thành một số.

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Arithmetic[edit][edit]

JavaScript hỗ trợ các toán tử số học nhị phân sau:binary arithmetic operators:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

JavaScript hỗ trợ các toán tử số học không sau đây:unary arithmetic operators:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

modulo (trả về phần còn lại)

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Assignment[edit][edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Thêm và gán

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Trừ và gán[edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Nhân và gán[edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

chia và gán provides another way to destructure arrays. It indicates that the elements in a specified array should be used as the parameters in a function call or the items in an array literal.

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

modulo và gánrest parameter. The rest parameter must be the final named parameter in the function's parameter list. It will be assigned an

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

số mũ và gán

Comparison[edit][edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các biến tham chiếu các đối tượng chỉ bằng hoặc giống hệt nhau nếu chúng tham chiếu cùng một đối tượng:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Xem thêm Chuỗi.

Logical[edit][edit]

JavaScript cung cấp bốn toán tử logic:

• không phủ định (

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  42)
• Phân tích nhị phân (

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  43) và kết hợp (

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  44)
• Điều kiện ternary (

  a = b + c
  (d + e).foo()
  
  // Treated as:
  //  a = b + c(d + e).foo();
  

  78)

Trong bối cảnh của một hoạt động logic, bất kỳ biểu thức nào cũng đánh giá là đúng ngoại trừ những điều sau::

• Chuỗi:

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  46,

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  47,
• Số:

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  48,

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  49,

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  50,
• Đặc biệt:

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  51,

  a = b + c
  (d + e).foo()
  
  // Treated as:
  //  a = b + c(d + e).foo();
  

  58,
• Boolean:

  a = b + c
  ;(d + e).foo()
  
  // Treated as:
  //  a = b + c;
  //  (d + e).foo();
  

  53.

Chức năng Boolean có thể được sử dụng để chuyển đổi rõ ràng thành nguyên thủy của loại

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Nhà điều hành không đánh giá toán hạng của nó là boolean và trả về phủ định. Sử dụng toán tử hai lần liên tiếp, làm âm tính kép, rõ ràng chuyển đổi một biểu thức thành nguyên thủy của boolean:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Toán tử ternary cũng có thể được sử dụng để chuyển đổi rõ ràng:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

Các biểu thức sử dụng các tính năng như quá trình kết nối sau (

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

Trong các phiên bản đầu của JavaScript và JScript, các toán tử logic nhị phân đã trả về một giá trị boolean (giống như hầu hết các ngôn ngữ lập trình có nguồn gốc C). Tuy nhiên, tất cả các triển khai đương đại đều trả về một trong các toán hạng của họ thay vào đó:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

Các lập trình viên quen thuộc hơn với hành vi trong C có thể thấy tính năng này đáng ngạc nhiên, nhưng nó cho phép biểu hiện ngắn gọn hơn của các mẫu như NULL kết hợp lại:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

Bài tập hợp lý [Chỉnh sửa][edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Bitwise[edit][edit]

Phần này cần mở rộng. Bạn có thể giúp đỡ bằng cách phát triển nó. (Tháng 4 năm 2011)needs expansion. You can help by adding to it. (April 2011)

JavaScript hỗ trợ các toán tử bitwise nhị phân sau:binary bitwise operators:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Ví dụ:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

JavaScript hỗ trợ toán tử bitwise sau đây:unary bitwise operator:

Bài tập bitwise [Chỉnh sửa][edit]

JavaScript hỗ trợ các toán tử gán nhị phân sau:binary assignment operators:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Ví dụ:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

String[edit][edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Ví dụ:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

??[edit][edit]

JavaScript hỗ trợ toán tử bitwise sau đây:

Bài tập bitwise [Chỉnh sửa]

JavaScript hỗ trợ các toán tử gán nhị phân sau:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

và[edit]

a = b + c ;(d + e).foo() // Treated as: // a = b + c; // (d + e).foo(); 68[edit]

hoặc

a = b + c ;(d + e).foo() // Treated as: // a = b + c; // (d + e).foo(); 69[edit]

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

XOR[edit]

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

giống như:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

Không giống như câu lệnh IF, toán tử có điều kiện không thể bỏ qua "nhánh khác" của nó.

Tuyên bố chuyển đổi [Chỉnh sửa][edit]

Cú pháp của câu lệnh JavaScript Switch như sau:

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

• return
  a + b;
  
  // Returns undefined. Treated as:
  //   return;
  //   a + b;
  // Should be written as:
  //   return a + b;
  

  01 là tùy chọn; Tuy nhiên, thường cần thiết, vì nếu không thì thực thi mã sẽ tiếp tục vào phần của khối trường hợp tiếp theo. Sự rơi vào hành vi này có thể được sử dụng khi cùng một tập hợp các câu lệnh được áp dụng trong một số trường hợp, tạo ra một sự phân biệt giữa các trường hợp đó.
• Thêm một tuyên bố phá vỡ vào cuối trường hợp cuối cùng dưới dạng biện pháp phòng ngừa, trong trường hợp các trường hợp bổ sung được thêm vào sau.
• Các giá trị theo nghĩa đen cũng có thể được sử dụng cho các giá trị trường hợp.
• Biểu thức có thể được sử dụng thay vì các giá trị.
• Trường hợp mặc định (tùy chọn) được thực thi khi biểu thức không khớp với bất kỳ trường hợp được chỉ định nào khác.
• Niềng răng là bắt buộc.

Cho Loop [Chỉnh sửa][edit]

Cú pháp của JavaScript cho vòng lặp như sau:

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

hoặc

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Cho ... trong vòng lặp [chỉnh sửa][edit]

Cú pháp của JavaScript

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

• Lặp lại thông qua tất cả các thuộc tính có thể suy nghĩ của một đối tượng.
• Lặp lại thông qua tất cả các chỉ số được sử dụng của mảng bao gồm tất cả các thuộc tính do người dùng xác định của đối tượng mảng, nếu có. Do đó, có thể tốt hơn để sử dụng một vòng lặp truyền thống cho một chỉ số số khi lặp qua các mảng.
• Có sự khác biệt giữa các trình duyệt web khác nhau liên quan đến các thuộc tính nào sẽ được phản ánh bằng ... trong câu lệnh LOOP. Về lý thuyết, điều này được kiểm soát bởi một thuộc tính trạng thái nội bộ được xác định bởi tiêu chuẩn ECMAScript gọi là "donenum", nhưng trong thực tế, mỗi trình duyệt trả về một tập hợp các thuộc tính hơi khác nhau trong quá trình hướng nội. Rất hữu ích khi kiểm tra một thuộc tính nhất định bằng cách sử dụng

  return
  a + b;
  
  // Returns undefined. Treated as:
  //   return;
  //   a + b;
  // Should be written as:
  //   return a + b;
  

  03}. Do đó, việc thêm một phương thức vào nguyên mẫu mảng với

  return
  a + b;
  
  // Returns undefined. Treated as:
  //   return;
  //   a + b;
  // Should be written as:
  //   return a + b;
  

  04} có thể khiến các vòng lặp

  return
  a + b;
  
  // Returns undefined. Treated as:
  //   return;
  //   a + b;
  // Should be written as:
  //   return a + b;
  

  05 để lặp qua tên của phương thức.

Trong khi vòng lặp [chỉnh sửa][edit]

Cú pháp của JavaScript trong khi vòng lặp như sau:

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Làm ... trong khi vòng lặp [chỉnh sửa][edit]

Cú pháp của JavaScript

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

With[edit][edit]

Tuyên bố với tất cả các thuộc tính và phương thức của đối tượng đã cho vào phạm vi của khối sau, cho phép chúng được tham chiếu như thể chúng là các biến cục bộ.

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

• Lưu ý sự vắng mặt của tài liệu. Trước mỗi lần gọi getElementByid ().document. before each getElementById() invocation.

Các ngữ nghĩa tương tự như với tuyên bố của Pascal.

Bởi vì tính khả dụng với các câu lệnh cản trở hiệu suất của chương trình và được cho là làm giảm độ rõ ràng của mã (vì bất kỳ biến nào thực sự có thể là một thuộc tính từ một sự cố), nên câu lệnh này không được phép ở chế độ nghiêm ngặt.with), this statement is not allowed in strict mode.

Labels[edit][edit]

JavaScript hỗ trợ nhãn lồng nhau trong hầu hết các triển khai. Các vòng hoặc khối có thể được dán nhãn cho câu lệnh Break và các vòng cho

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Functions[edit][edit]

Một hàm là một khối với danh sách tham số (có thể trống) thường được đặt tên. Một hàm có thể sử dụng các biến cục bộ. Nếu bạn thoát chức năng mà không có câu lệnh trả về, giá trị không xác định sẽ được trả về.undefined is returned.

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Các chức năng là các đối tượng lớp đầu tiên và có thể được gán cho các biến khác.

Số lượng đối số được đưa ra khi gọi một hàm có thể không nhất thiết tương ứng với số lượng đối số trong định nghĩa hàm; Một đối số được đặt tên trong định nghĩa không có đối số phù hợp trong cuộc gọi sẽ có giá trị không được xác định (có thể được sử dụng hoàn toàn sai). Trong hàm, các đối số cũng có thể được truy cập thông qua đối tượng đối số; Điều này cung cấp quyền truy cập vào tất cả các đối số bằng cách sử dụng các chỉ số (ví dụ:

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Các giá trị nguyên thủy (số, boolean, chuỗi) được truyền theo giá trị. Đối với các đối tượng, nó là tham chiếu đến đối tượng được truyền.

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Các chức năng có thể được khai báo bên trong các chức năng khác và truy cập các biến cục bộ của hàm bên ngoài. Hơn nữa, họ thực hiện đóng cửa đầy đủ bằng cách ghi nhớ các biến cục bộ của hàm bên ngoài ngay cả sau khi hàm bên ngoài đã thoát ra.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Async/await[edit][edit]

Toán tử đang chờ đợi trong JavaScript chỉ có thể được sử dụng từ bên trong hàm Async. Nếu tham số là một lời hứa, việc thực hiện hàm async sẽ tiếp tục khi lời hứa được giải quyết (trừ khi lời hứa bị từ chối, trong trường hợp đó sẽ bị loại bỏ lỗi có thể được xử lý bằng xử lý ngoại lệ JavaScript bình thường). Nếu tham số không phải là một lời hứa, chính tham số sẽ được trả về ngay lập tức. [16]

Nhiều thư viện cung cấp các đối tượng hứa hẹn cũng có thể được sử dụng với sự chờ đợi, miễn là chúng phù hợp với đặc điểm kỹ thuật cho lời hứa JavaScript bản địa. Tuy nhiên, những lời hứa từ Thư viện JQuery không được hứa hẹn/A+ tương thích cho đến khi JQuery 3.0. [17]

Đây là một ví dụ (được sửa đổi từ bài viết này [18]):

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Node.js Phiên bản 8 bao gồm một tiện ích cho phép sử dụng các phương thức dựa trên cuộc gọi lại thư viện tiêu chuẩn như lời hứa. [19]

Objects[edit][edit]

Để thuận tiện, các loại thường được chia thành các nguyên thủy và đối tượng. Các đối tượng là các thực thể có danh tính (chúng chỉ bằng với chính chúng) và ánh xạ tên thuộc tính thành các giá trị ("khe" trong thuật ngữ lập trình dựa trên nguyên mẫu). Các đối tượng có thể được coi là mảng kết hợp hoặc băm và thường được triển khai bằng các cấu trúc dữ liệu này. Tuy nhiên, các đối tượng có các tính năng bổ sung, chẳng hạn như chuỗi nguyên mẫu [cần làm rõ], mà các mảng liên kết thông thường không có.clarification needed], which ordinary associative arrays do not have.

JavaScript có một số loại đối tượng tích hợp, cụ thể là

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Tạo đối tượng [Chỉnh sửa][edit]

Các đối tượng có thể được tạo bằng cách sử dụng một hàm tạo hoặc một đối tượng theo nghĩa đen. Hàm tạo có thể sử dụng hàm đối tượng tích hợp hoặc hàm tùy chỉnh. Đó là một quy ước rằng các chức năng của hàm tạo được đặt tên bắt đầu bằng chữ cái viết hoa:

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Đối tượng Lingerals and Array Ltersors cho phép một người dễ dàng tạo các cấu trúc dữ liệu linh hoạt:

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Đây là cơ sở cho JSON, đây là một ký hiệu đơn giản sử dụng cú pháp giống như JavaScript để trao đổi dữ liệu.

Methods[edit][edit]

Một phương thức chỉ đơn giản là một hàm đã được gán cho một tên thuộc tính của một đối tượng. Không giống như nhiều ngôn ngữ hướng đối tượng, không có sự phân biệt giữa định nghĩa hàm và định nghĩa phương thức trong JavaScript liên quan đến đối tượng. Thay vào đó, sự khác biệt xảy ra trong quá trình gọi chức năng; Một hàm có thể được gọi là một phương thức.

Khi được gọi là phương thức, biến cục bộ tiêu chuẩn, điều này chỉ tự động được đặt thành thể hiện đối tượng ở bên trái của ".". .this is just automatically set to the object instance to the left of the ".". (There are also call and apply methods that can set this explicitly—some packages such as jQuery do unusual things with this.)

Trong ví dụ dưới đây, FOO đang được sử dụng như một nhà xây dựng. Không có gì đặc biệt về một hàm tạo - nó chỉ là một hàm đơn giản khởi tạo một đối tượng. Khi được sử dụng với từ khóa mới, như tiêu chuẩn, điều này được đặt thành một đối tượng trống mới được tạo.new keyword, as is the norm, this is set to a newly created blank object.

Lưu ý rằng trong ví dụ dưới đây, FOO chỉ đơn giản là gán các giá trị cho các vị trí, một số trong đó là các hàm. Do đó, nó có thể gán các chức năng khác nhau cho các trường hợp khác nhau. Không có nguyên mẫu trong ví dụ này.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Constructors[edit][edit]

Các hàm xây dựng chỉ cần gán các giá trị cho các vị trí của một đối tượng mới được tạo. Các giá trị có thể là dữ liệu hoặc các hàm khác.

Ví dụ: Thao tác với một đối tượng:

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Bản thân hàm tạo được tham chiếu trong khe tạo hàm tạo nguyên mẫu của đối tượng. Vì thế,

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Các hàm là chính các đối tượng, có thể được sử dụng để tạo ra một hiệu ứng tương tự như "thuộc tính tĩnh" (sử dụng thuật ngữ C ++/Java) như được hiển thị bên dưới. (Đối tượng chức năng cũng có thuộc tính

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Xóa đối tượng hiếm khi được sử dụng vì công cụ kịch bản sẽ thu thập rác thu thập các đối tượng không còn được tham chiếu.

Inheritance[edit][edit]

JavaScript hỗ trợ phân cấp kế thừa thông qua tạo mẫu theo cách của bản thân.

Trong ví dụ sau, lớp dẫn xuất kế thừa từ lớp cơ sở. Khi D được tạo dưới dạng xuất phát, tham chiếu đến thể hiện cơ sở của cơ sở được sao chép vào D.Base.Derived class inherits from the Base class. When d is created as Derived, the reference to the base instance of Base is copied to d.base.

DRIVE không chứa một giá trị cho abasefunction, do đó, nó được lấy từ abaseFunction khi truy cập abaseFunction. Điều này được làm rõ bằng cách thay đổi giá trị của cơ sở.abasefunction, được phản ánh trong giá trị của D.AbaseFunction.aBaseFunction, so it is retrieved from aBaseFunction when aBaseFunction is accessed. This is made clear by changing the value of base.aBaseFunction, which is reflected in the value of d.aBaseFunction.

Một số triển khai cho phép nguyên mẫu được truy cập hoặc đặt rõ ràng bằng cách sử dụng khe __proto__ như hình dưới đây.__proto__ slot as shown below.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Sau đây cho thấy rõ các tham chiếu đến các nguyên mẫu được sao chép khi tạo ví dụ như thế nào, nhưng điều đó thay đổi thành nguyên mẫu có thể ảnh hưởng đến tất cả các trường hợp đề cập đến nó.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Trong thực tế, nhiều biến thể của các chủ đề này được sử dụng, và nó có thể vừa mạnh mẽ vừa khó hiểu.

Xử lý ngoại lệ [Chỉnh sửa][edit]

JavaScript bao gồm một câu lệnh xử lý ngoại lệ

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Câu lệnh

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Ban đầu, các câu lệnh trong Thử thực thi. Nếu một ngoại lệ được ném, luồng điều khiển của tập lệnh ngay lập tức chuyển sang các câu lệnh trong khối bắt, ngoại lệ có sẵn dưới dạng đối số lỗi. Nếu không, khối bắt được bỏ qua. Khối Catch có thể ném (ErrorValue), nếu nó không muốn xử lý một lỗi cụ thể.throw(errorValue), if it does not want to handle a specific error.

Trong mọi trường hợp, các câu trong khối cuối cùng luôn được thực thi. Điều này có thể được sử dụng để tài nguyên miễn phí, mặc dù bộ nhớ được tự động thu thập rác.

Hoặc bắt hoặc mệnh đề cuối cùng có thể được bỏ qua. Đối số bắt được là bắt buộc.

Việc triển khai Mozilla cho phép nhiều câu lệnh bắt, như một phần mở rộng cho tiêu chuẩn ECMAScript. Chúng theo một cú pháp tương tự như được sử dụng trong Java:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Trong một trình duyệt, sự kiện OnError thường được sử dụng để bẫy các ngoại lệ.onerror event is more commonly used to trap exceptions.

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Các hàm và phương pháp gốc [Chỉnh sửa][edit]

(Không liên quan đến trình duyệt web.)

Eval (Biểu thức) [Chỉnh sửa][edit]

Đánh giá tham số đầu tiên là một biểu thức, có thể bao gồm các câu lệnh gán. Các biến cục bộ đến các hàm có thể được tham chiếu bởi biểu thức. Tuy nhiên,

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

Xem thêm [sửa][edit]

• So sánh các trình chỉnh sửa mã nguồn dựa trên JavaScript
• JavaScript

References[edit][edit]

1. ^Đặc tả JavaScript 1.1 JavaScript 1.1 specification
2. ^"Chương 1. JavaScript cơ bản". nóis.com. Truy cập ngày 22 tháng 9 năm 2020. "Chapter 1. Basic JavaScript". speakingjs.com. Retrieved 22 September 2020.
3. ^Flanagan, David (2006). JavaScript: Hướng dẫn dứt khoát. p. & nbsp; 16. ISBN & NBSP; 978-0-596-10199-2. Bỏ qua dấu chấm phẩy không phải là một thực hành lập trình tốt; Bạn nên có thói quen chèn chúng. Flanagan, David (2006). JavaScript: The definitive Guide. p. 16. ISBN 978-0-596-10199-2. Omitting semicolons is not a good programming practice; you should get into the habit of inserting them.
4. ^"Các giá trị, biến và chữ - MDC". Mạng lưới nhà phát triển Mozilla. Ngày 16 tháng 9 năm 2010, lưu trữ từ bản gốc vào ngày 29 tháng 6 năm 2011. Truy cập ngày 1 tháng 2 năm 2020. "Values, Variables, and Literals - MDC". Mozilla Developer Network. 16 September 2010. Archived from the original on 29 June 2011. Retrieved 1 February 2020.
5. ^"JavaScript nâng". W3Schools. Trong JavaScript, một biến có thể được khai báo sau khi nó đã được sử dụng. Nói cách khác; Một biến có thể được sử dụng trước khi nó được khai báo. "JavaScript Hoisting". W3Schools. In JavaScript, a variable can be declared after it has been used. In other words; a variable can be used before it has been declared.
6. ^"Phạm vi và nâng cao JavaScript", Ben Cherry, đầy đủ, 2010/02-08 "JavaScript Scoping and Hoisting", Ben Cherry, Adequately Good, 2010-02-08
7. ^ECMA-262 5E Phiên bản đã làm rõ hành vi này với hồ sơ môi trường khai báo và hồ sơ môi trường đối tượng. Với chủ nghĩa hình thức này, đối tượng toàn cầu là hồ sơ môi trường đối tượng của môi trường từ vựng toàn cầu (phạm vi toàn cầu). ECMA-262 5e edition clarified this behavior with the Declarative Environment Record and Object Environment Record. With this formalism, the global object is the Object Environment Record of the global Lexical Environment (the global scope).
8. ^"Mẫu nghĩa đen". MDN Web Docs. Truy cập ngày 2 tháng 5 năm 2018. "Template literals". MDN Web Docs. Retrieved 2 May 2018.
9. ^"Các nhà khai thác so sánh - Trung tâm tài liệu MDC". Mozilla. Ngày 5 tháng 8 năm 2010. Truy cập ngày 5 tháng 3 năm 2011. "Comparison Operators - MDC Doc Center". Mozilla. 5 August 2010. Retrieved 5 March 2011.
10. ^"Các yếu tố của phong cách JavaScript". Douglas Crockford. Truy cập ngày 5 tháng 3 năm 2011. "The Elements of JavaScript Style". Douglas Crockford. Retrieved 5 March 2011.
11. ^"Cú pháp lan truyền". "Spread syntax".
12. ^"Tham số nghỉ". "rest parameters".
13. ^"Ecmascript". Được lưu trữ từ bản gốc vào ngày 9 tháng 8 năm 2016. "Ecmascript". Archived from the original on 9 August 2016.
14. ^"Đặc điểm kỹ thuật ngôn ngữ ECMAScript 2020". Ecma International. Tháng 6 năm 2020. "ECMAScript 2020 Language Specification". Ecma International. June 2020.
15. ^ECMA-262, Phiên bản 3, 7.5.3 Các từ dành riêng trong tương lai ECMA-262, Edition 3, 7.5.3 Future Reserved Words
16. ^"Await - JavaScript (MDN)". Truy cập ngày 2 tháng 5 năm 2017. "await - JavaScript (MDN)". Retrieved 2 May 2017.
17. ^"Hướng dẫn nâng cấp Core 3.0". Truy cập ngày 2 tháng 5 năm 2017. "jQuery Core 3.0 Upgrade Guide". Retrieved 2 May 2017.
18. ^"Taming con thú không đồng bộ với es7". Truy cập ngày 12 tháng 11 năm 2015. "Taming the asynchronous beast with ES7". Retrieved 12 November 2015.
19. ^Foundation, Node.js. "Node v8.0.0 (hiện tại) - Node.js". Node.js. Foundation, Node.js. "Node v8.0.0 (Current) - Node.js". Node.js.
20. ^"Eval ()". MDN Web Docs. Truy cập ngày 29 tháng 1 năm 2020. "eval()". MDN Web Docs. Retrieved 29 January 2020.

Đọc thêm [Chỉnh sửa][edit]

• Danny Goodman: Kinh thánh JavaScript, Wiley, John & Sons, ISBN & NBSP; 0-7645-3342-8.
• David Flanagan, Paula Ferguson: JavaScript: Hướng dẫn dứt khoát, O'Reilly & Associates, ISBN & NBSP; 0-596-10199-6.
• Thomas A. Powell, Fritz Schneider: JavaScript: Tài liệu tham khảo đầy đủ, Công ty McGraw-Hill, ISBN & NBSP; 0-07-219127-9.
• Axel Rauschmayer: Nói JavaScript: Hướng dẫn chuyên sâu cho các lập trình viên, 460 trang, O'Reilly Media, ngày 25 tháng 2 năm 2014, ISBN & NBSP; 978-1449365035. (Phiên bản trực tuyến miễn phí)
• Emily Vander Veer: JavaScript cho người giả, Phiên bản thứ 4, Wiley, ISBN & NBSP; 0-7645-7659-3.

Liên kết bên ngoài [Chỉnh sửa][edit]

• Giới thiệu lại cho JavaScript - Trung tâm phát triển Mozilla
• Vòng lặp JavaScript
• Tài liệu tham khảo tiêu chuẩn Ecmascript: ECMA-262
• Bài học JavaScript tương tác - dựa trên ví dụ
• JavaScript trên abing.com: Bài học và giải thích
• Đào tạo JavaScript
• Tài liệu tham khảo cốt lõi của Trung tâm Phát triển Mozilla cho các phiên bản JavaScript 1.5, 1.4, 1.3 và 1.2
• Tài liệu ngôn ngữ Mozilla JavaScript

Cú pháp cho hoặc trong JavaScript là gì?

Cú pháp của giá trị JavaScript là gì?

Biểu thức cú pháp JavaScript là gì?

Các quy tắc cú pháp cơ bản của JavaScript là gì?