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[];03,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05 để khai báo các biến.declare variables.
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[];06
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];07
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];08
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];09] để tính toán các giá trị:arithmetic operators [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];06
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];07
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];08
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];09 ] to compute values:
JavaScript sử dụng toán tử gán [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];10] để gán các giá trị cho các biến:assignment operator [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];10 ] to assign values to variables:
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[];04 cho trình duyệt tạo các biến:
Từ khóa
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03 cũng cho trình duyệt tạo các biến:
Trong các ví dụ này, sử dụng
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03 hoặc
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 sẽ tạo ra kết quả tương tự.
Bạn sẽ tìm hiểu thêm về
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 sau này trong hướng dẫn này.
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[];17 hoặc giữa
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];18 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];19 được coi là một nhận xét.comment.
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[];20 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];21, là hai biến khác nhau:
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[];22]. Cho rằng JavaScript chủ yếu được sử dụng cho kịch bản phía máy khách trong các trình duyệt web hiện đại và hầu hết tất cả các trình duyệt web đều cung cấp chức năng cảnh báo,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];23 cũng có thể được sử dụng, nhưng không được sử dụng phổ biến.
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[];24", khung mở "
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];25", chém "
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];09", cộng với "
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];06" và trừ "
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];07". Trong số này, dấu ngoặc đơn mở là phổ biến trong mẫu biểu thức chức năng được phát hành ngay lập tức và đôi khi khung mở xảy ra, trong khi các dấu hiệu khác khá hiếm. Một ví dụ:
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[];24' hoặc '
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];25', do đó, dòng không vô tình tham gia với cái trước. Đây được gọi là một dấu chấm phẩy phòng thủ, và đặc biệt được khuyến nghị, bởi vì mã có thể trở nên mơ hồ khi nó được sắp xếp lại. Ví dụ:defensive semicolon, and is particularly recommended, because code may otherwise become ambiguous when it is rearranged. For example:
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[];31,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];32,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];33,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];34 và sau khi tăng/giảm. Trong mọi trường hợp, việc chèn các dấu chấm phẩy không khắc phục được vấn đề, nhưng làm cho cú pháp phân tích cú pháp rõ ràng, làm cho lỗi dễ dàng phát hiện hơn.
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];31 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];32 lấy giá trị tùy chọn, trong khi
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];33 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];34 lấy nhãn tùy chọn. Trong mọi trường hợp, lời khuyên là giữ giá trị hoặc nhãn trên cùng một dòng với câu lệnh. Điều này thường xuất hiện trong câu lệnh trả về, trong đó người ta có thể trả lại một đối tượng lớn theo nghĩa đen, có thể vô tình được đặt bắt đầu trên một dòng mới. Đối với sau khi tăng/giảm, có sự mơ hồ tiềm tàng với tiền tăng/giảm, và một lần nữa, bạn nên giữ những thứ này trên cùng một dòng.
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[];03 cho các biến phạm vi hàm và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 hoặc
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05 dành cho các biến cấp khối. Trước ES6, các biến chỉ có thể được khai báo với câu lệnh
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03. Các giá trị được gán cho các biến được khai báo với
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05 không thể được thay đổi, nhưng các thuộc tính của nó có thể. Định danh của một biến phải bắt đầu bằng một chữ cái, nhấn mạnh [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];44] hoặc dấu hiệu đô la [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];45], trong khi các ký tự tiếp theo cũng có thể là các chữ số [
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];46]. JavaScript nhạy cảm trường hợp, do đó các ký tự chữ hoa "" A "qua" Z "khác với các ký tự viết thường" A "đến" Z ".
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[];47 Trình tự thoát Unicode] có thể được sử dụng trong các định danh. [4] Trong một số triển khai JavaScript nhất định, dấu hiệu AT [@] có thể được sử dụng trong một định danh, nhưng điều này trái với các thông số kỹ thuật và không được hỗ trợ trong các triển khai mới hơn. [Cần trích dẫn]citation needed]
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[];03 được phạm vi từ vựng ở mức hàm, trong khi các biến có
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 hoặc
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05 có phạm vi cấp khối. Vì các khai báo được xử lý trước khi bất kỳ mã nào được thực thi, một biến có thể được gán và sử dụng trước khi được khai báo trong mã. [5] Điều này được gọi là nâng, và nó tương đương với các biến được chuyển tiếp ở đầu hàm hoặc khối. [6]hoisting, and it is equivalent to variables being forward declared at the top of the function or block.[6]
Với các tuyên bố
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 và
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05, chỉ có tuyên bố được nâng lên; Bài tập không được nâng lên. Do đó, một câu lệnh
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];54 ở giữa hàm tương đương với câu lệnh khai báo
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];55 ở đầu hàm và câu lệnh gán
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];56 tại điểm đó ở giữa hàm. Điều này có nghĩa là các giá trị không thể được truy cập trước khi chúng được khai báo; Tài liệu tham khảo chuyển tiếp là không thể. Với
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03, giá trị của biến là
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];58 cho đến khi nó được khởi tạo. Các biến được khai báo với
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 hoặc
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05 không thể được truy cập cho đến khi chúng được khởi tạo, do đó, việc tham chiếu các biến đó trước đó sẽ gây ra lỗi.
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[];03,
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];04 hoặc
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];05.
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[];04.
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[];65.resolve an identifier, it looks in the local scope. If this identifier is not found, it looks in the next outer scope, and so on along the scope chain until it reaches the global scope where global variables reside. If it is still not found, JavaScript will raise a
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];65 exception.
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[];03] trong phạm vi toàn cầu [nghĩa là bên ngoài bất kỳ cơ thể chức năng nào [hoặc khối trong trường hợp LET/const]], gán một định danh không bao giờ được khai báo hoặc thêm thuộc tính vào đối tượng toàn cầu [thường là cửa sổ] cũng sẽ tạo ra một biến toàn cầu mới.assigning an identifier, JavaScript goes through exactly the same process to retrieve this identifier, except that if it is not found in the global scope, it will create the "variable" in the scope where it was created.[7] As a consequence, a variable never declared will be global, if assigned. Declaring a variable [with the keyword
a = b + c [d + e].foo[] // Treated as: // a = b + c[d + e].foo[];03] in the global scope [i.e. outside of any function body [or block in the case of let/const]], assigning a never declared identifier or adding a property to the global object [usually window] will also create a new global variable.
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