Giá trị của biến tổng từ đoạn mã javascript sau là gì
|
Tệp này là một phần của phiên bản đầu tiên của Eloquent JavaScript. Cân nhắc đọc ấn bản thứ ba để thay thế Show ¶ Bên trong thế giới máy tính, chỉ có dữ liệu. Cái không phải là dữ liệu thì không tồn tại. Mặc dù tất cả dữ liệu về bản chất chỉ là một chuỗi các bit và do đó về cơ bản là giống nhau, nhưng mỗi phần dữ liệu đều đóng vai trò riêng của nó. Trong hệ thống của JavaScript, hầu hết dữ liệu này được phân tách gọn gàng thành những thứ được gọi là giá trị. Mỗi giá trị có một loại, xác định loại vai trò mà nó có thể đóng. Có sáu loại giá trị cơ bản. Số, chuỗi, booleans, đối tượng, hàm và giá trị không xác định ¶ Để tạo một giá trị, người ta chỉ cần gọi tên của nó. Điều này rất thuận tiện. Bạn không cần phải thu thập vật liệu xây dựng cho các giá trị của mình hoặc trả tiền cho chúng, bạn chỉ cần gọi một cái và woosh, bạn có nó. Tất nhiên chúng không được tạo ra từ không khí loãng. Mọi giá trị phải được lưu trữ ở đâu đó và nếu bạn muốn sử dụng một số lượng lớn trong số chúng cùng một lúc, bạn có thể hết bộ nhớ máy tính. May mắn thay, đây chỉ là một vấn đề nếu bạn cần tất cả chúng cùng một lúc. Ngay sau khi bạn không còn sử dụng một giá trị, nó sẽ biến mất, chỉ để lại một vài bit. Các bit này được tái chế để tạo ra thế hệ giá trị tiếp theo ¶ Các giá trị của kiểu số, như bạn có thể đã suy luận, là các giá trị số. Chúng được viết theo cách mà các số thường được viết 144 ¶ Nhập nội dung đó vào bảng điều khiển và nội dung tương tự được in trong cửa sổ đầu ra. Văn bản bạn đã nhập tạo ra một giá trị số và bảng điều khiển lấy số này và viết lại ra màn hình. Trong trường hợp như thế này, đó là một bài tập khá vô nghĩa, nhưng chúng tôi sẽ sớm tạo ra các giá trị theo những cách ít đơn giản hơn và có thể hữu ích khi 'dùng thử' trên bảng điều khiển để xem những gì chúng tạo ra ¶ Đây là những gì 115 * 4 - 4 + 88 / 24 trông giống như trong các bit 0100000001100010000000000000000000000000000000000000000000000000 ¶ Số trên có 64 bit. Các số trong JavaScript luôn làm. Điều này có một tác động quan trọng. Có một số lượng hạn chế các số khác nhau có thể được thể hiện. Với ba chữ số thập phân chỉ viết được các số từ 0 đến 999 là 103 = 1000 số khác nhau. Với 64 chữ số nhị phân viết được 264 số khác nhau. Đây là rất nhiều, hơn 1019 (một với mười chín số không) ¶ Mặc dù vậy, không phải tất cả các số nguyên dưới 1019 đều phù hợp với một số JavaScript. Đối với một, cũng có các số âm, vì vậy một trong các bit phải được sử dụng để lưu dấu của số đó. Một vấn đề lớn hơn là các số không phải là số nguyên cũng phải được biểu diễn. Để làm điều này, 11 bit được sử dụng để lưu trữ vị trí của dấu chấm phân số trong số ¶ Điều đó để lại 52 bit. Bất kỳ số nguyên nào nhỏ hơn 252 (lớn hơn 1015) sẽ an toàn phù hợp với số JavaScript. Trong hầu hết các trường hợp, những con số chúng tôi đang sử dụng ở dưới mức đó, vì vậy chúng tôi không phải lo lắng về bit nào cả. Cái nào tốt. Tôi không có gì đặc biệt chống lại các bit, nhưng bạn cần rất nhiều trong số chúng để hoàn thành mọi việc. Khi có thể, sẽ dễ chịu hơn khi giải quyết những việc lớn hơn ¶ Các số phân số được viết bằng cách sử dụng dấu chấm 9.81 ¶ Đối với các số rất lớn hoặc rất nhỏ, người ta cũng có thể sử dụng ký hiệu 'khoa học' bằng cách thêm 115 * 4 - 4 + 88 / 25, theo sau là số mũ của số đó 2.998e8 ¶ Đó là 2. 998 * 108 = 299800000 ¶ Các phép tính với số nguyên (còn gọi là số nguyên) phù hợp với 52 bit được đảm bảo luôn chính xác. Thật không may, các phép tính với số phân số thường không. Giống như cách π (pi) không thể được biểu thị chính xác bằng một số lượng hữu hạn các chữ số thập phân, nhiều số mất đi một số độ chính xác khi chỉ có 64 bit để lưu trữ chúng. Điều này thật đáng tiếc, nhưng nó chỉ gây ra những vấn đề thực tế trong những tình huống rất cụ thể. Điều quan trọng là phải nhận thức được nó và coi các số kỹ thuật số phân số là xấp xỉ, không phải là giá trị chính xác ¶ Công việc chính cần làm với các con số là số học. Các phép toán số học như phép cộng hoặc phép nhân lấy hai giá trị số và tạo ra một số mới từ chúng. Đây là giao diện của chúng trong JavaScript 100 + 4 * 11 ¶ Các ký hiệu 115 * 4 - 4 + 88 / 26 và 115 * 4 - 4 + 88 / 27 được gọi là toán tử. Cái đầu tiên là viết tắt của phép cộng, và cái thứ hai là phép nhân. Đặt một toán tử giữa hai giá trị sẽ áp dụng nó cho các giá trị đó và tạo ra một giá trị mới ¶ Ví dụ có nghĩa là 'cộng 4 với 100, rồi nhân kết quả với 11' hay phép nhân được thực hiện trước khi cộng? . Nhưng, như trong toán học, điều này có thể được thay đổi bằng cách đặt phép cộng trong ngoặc đơn (100 + 4) * 11 ¶ Đối với phép trừ, có toán tử 115 * 4 - 4 + 88 / 28 và phép chia có thể được thực hiện với 115 * 4 - 4 + 88 / 29. Khi các toán tử xuất hiện cùng nhau mà không có dấu ngoặc đơn, thứ tự áp dụng chúng được xác định theo thứ tự ưu tiên của các toán tử. Ví dụ đầu tiên cho thấy phép nhân có quyền ưu tiên cao hơn phép cộng. Phép chia và phép nhân luôn đi trước phép trừ và phép cộng. Khi nhiều toán tử có cùng mức độ ưu tiên xuất hiện cạnh nhau ( 115 * 4 - 4 + 88 / 220), chúng được áp dụng từ trái sang phải ¶ Cố gắng tìm ra giá trị mà điều này tạo ra, sau đó chạy nó để xem bạn có đúng không 115 * 4 - 4 + 88 / 2 ¶ Những quy tắc ưu tiên này không phải là điều bạn nên lo lắng. Khi nghi ngờ, chỉ cần thêm dấu ngoặc đơn ¶ Còn một toán tử số học nữa mà có lẽ các bạn ít quen thuộc hơn. Ký hiệu 115 * 4 - 4 + 88 / 221 được dùng để biểu thị phép toán còn lại. 115 * 4 - 4 + 88 / 222 là phần còn lại của phép chia 115 * 4 - 4 + 88 / 223 cho 115 * 4 - 4 + 88 / 224. Ví dụ: 115 * 4 - 4 + 88 / 225 là 115 * 4 - 4 + 88 / 226, 115 * 4 - 4 + 88 / 227 là 115 * 4 - 4 + 88 / 228 và 115 * 4 - 4 + 88 / 229 là 010000000110001000000000000000000000000000000000000000000000000030. Phần dư có cùng ưu tiên như phép nhân và phép chia ¶ Kiểu dữ liệu tiếp theo là chuỗi. Việc sử dụng nó không rõ ràng từ tên của nó như với các con số, nhưng nó cũng hoàn thành một vai trò rất cơ bản. Các chuỗi được sử dụng để biểu diễn văn bản, cái tên này được cho là xuất phát từ thực tế là nó xâu chuỗi các ký tự lại với nhau. Các chuỗi được viết bằng cách đặt nội dung của chúng trong dấu ngoặc kép 115 * 4 - 4 + 88 / 22 ¶ Hầu hết mọi thứ đều có thể được đặt giữa hai dấu ngoặc kép và JavaScript sẽ tạo ra một giá trị chuỗi từ đó. Nhưng một vài nhân vật là khó khăn. Bạn có thể tưởng tượng việc đặt dấu ngoặc kép giữa các dấu ngoặc kép có thể khó như thế nào. Các dòng mới, những thứ bạn nhận được khi nhấn enter, cũng không thể đặt giữa các dấu ngoặc kép, chuỗi phải nằm trên một dòng ¶ Để có thể có các ký tự như vậy trong một chuỗi, thủ thuật sau đây được sử dụng. Bất cứ khi nào dấu gạch chéo ngược (' 010000000110001000000000000000000000000000000000000000000000000031') được tìm thấy bên trong văn bản được trích dẫn, điều đó cho biết ký tự sau nó có ý nghĩa đặc biệt. Một trích dẫn trước dấu gạch chéo ngược sẽ không kết thúc chuỗi, nhưng là một phần của nó. Khi một ký tự ' 010000000110001000000000000000000000000000000000000000000000000032' xuất hiện sau dấu gạch chéo ngược, nó được hiểu là một dòng mới. Tương tự, ' 010000000110001000000000000000000000000000000000000000000000000033' sau dấu gạch chéo ngược có nghĩa là ký tự tab 01000000011000100000000000000000000000000000000000000000000000003 ¶ Lưu ý rằng nếu bạn nhập nội dung này vào bảng điều khiển, nó sẽ hiển thị lại ở dạng 'nguồn', với dấu ngoặc kép và dấu gạch chéo ngược thoát. Để chỉ xem văn bản thực tế, bạn có thể nhập 010000000110001000000000000000000000000000000000000000000000000034. Điều đó thực hiện chính xác sẽ được làm rõ hơn một chút về ¶ Tất nhiên, có những tình huống mà bạn muốn dấu gạch chéo ngược trong một chuỗi chỉ là dấu gạch chéo ngược chứ không phải mã đặc biệt. Nếu hai dấu gạch chéo ngược nối tiếp nhau, chúng sẽ thu gọn vào nhau và chỉ còn lại một dấu gạch chéo ngược trong giá trị chuỗi kết quả 9.810 ¶ Các chuỗi không thể được chia, nhân hoặc trừ. Toán tử 115 * 4 - 4 + 88 / 26 có thể được sử dụng trên chúng. Nó không thêm, nhưng nó nối, nó dán hai chuỗi lại với nhau 01000000011000100000000000000000000000000000000000000000000000000 ¶ Có nhiều cách thao tác với chuỗi hơn, nhưng những cách này sẽ được thảo luận sau ¶ Không phải tất cả toán tử đều là ký hiệu, một số được viết dưới dạng từ. Ví dụ: toán tử 010000000110001000000000000000000000000000000000000000000000000036, tạo ra một giá trị chuỗi đặt tên cho loại giá trị mà bạn cung cấp cho nó 01000000011000100000000000000000000000000000000000000000000000001 ¶ Các toán tử khác mà chúng ta đã thấy đều hoạt động trên hai giá trị, 010000000110001000000000000000000000000000000000000000000000000036 chỉ nhận một. Toán tử sử dụng hai giá trị được gọi là toán tử nhị phân, trong khi những toán tử sử dụng một giá trị được gọi là toán tử đơn nguyên. Toán tử trừ có thể được sử dụng dưới dạng toán tử nhị phân và đơn nguyên 01000000011000100000000000000000000000000000000000000000000000002 ¶ Sau đó, có các giá trị của kiểu boolean. Chỉ có hai trong số này. 010000000110001000000000000000000000000000000000000000000000000038 và 010000000110001000000000000000000000000000000000000000000000000039. Đây là một cách để tạo ra giá trị 010000000110001000000000000000000000000000000000000000000000000038 01000000011000100000000000000000000000000000000000000000000000003 ¶ Và 010000000110001000000000000000000000000000000000000000000000000039 có thể được sản xuất như thế này 01000000011000100000000000000000000000000000000000000000000000004 ¶ Tôi hy vọng bạn đã nhìn thấy biển báo 9.8102 và 9.8103 trước đây. Chúng có nghĩa tương ứng là 'lớn hơn' và 'nhỏ hơn'. Chúng là các toán tử nhị phân và kết quả của việc áp dụng chúng là một giá trị boolean cho biết liệu chúng có giữ trong trường hợp này hay không ¶ Các chuỗi có thể được so sánh theo cùng một cách 01000000011000100000000000000000000000000000000000000000000000005 ¶ Cách sắp xếp các chuỗi ít nhiều theo thứ tự chữ cái. Nhiều hơn hoặc ít hơn. Chữ hoa luôn 'ít hơn' so với chữ thường, vì vậy, 9.8104 (chữ hoa Z, chữ thường a) là 010000000110001000000000000000000000000000000000000000000000000038 và các ký tự không thuộc bảng chữ cái (' 9.8106', ' 9.8107', v.v.) cũng được bao gồm trong thứ tự. Cách thức so sánh thực tế được thực hiện dựa trên tiêu chuẩn Unicode. Tiêu chuẩn này gán một số cho hầu hết mọi ký tự mà người ta cần, bao gồm các ký tự từ tiếng Hy Lạp, tiếng Ả Rập, tiếng Nhật, tiếng Tamil, v.v. Việc có các số như vậy là thiết thực để lưu trữ các chuỗi bên trong máy tính ― bạn có thể biểu diễn chúng dưới dạng danh sách các số. Khi so sánh chuỗi, JavaScript chỉ so sánh số ký tự bên trong chuỗi, từ trái sang phải ¶ Các toán tử tương tự khác là 9.8108 ('lớn hơn hoặc bằng'), 9.8109 (nhỏ hơn hoặc bằng), 010000000110001000000000000000000000000000000000000000000000000000 ('bằng') và 010000000110001000000000000000000000000000000000000000000000000001 ('không bằng') 01000000011000100000000000000000000000000000000000000000000000006 01000000011000100000000000000000000000000000000000000000000000007 ¶ Ngoài ra còn có một số thao tác hữu ích có thể được áp dụng cho chính các giá trị boolean. JavaScript hỗ trợ ba toán tử logic. và, hoặc, và không. Chúng có thể được sử dụng để 'lý luận' về booleans ¶ Toán tử 010000000110001000000000000000000000000000000000000000000000000002 đại diện cho logic và. Nó là một toán tử nhị phân, và kết quả của nó chỉ là 010000000110001000000000000000000000000000000000000000000000000038 nếu cả hai giá trị được gán cho nó là 010000000110001000000000000000000000000000000000000000000000000038 01000000011000100000000000000000000000000000000000000000000000008 ¶ 010000000110001000000000000000000000000000000000000000000000000005 là logic hoặc, nó là 010000000110001000000000000000000000000000000000000000000000000038 nếu một trong hai giá trị được cung cấp cho nó là 010000000110001000000000000000000000000000000000000000000000000038 01000000011000100000000000000000000000000000000000000000000000009 ¶ Not được viết dưới dạng dấu chấm than, 9.8106, đó là toán tử một ngôi lật ngược giá trị đã cho, 010000000110001000000000000000000000000000000000000000000000000009 là 010000000110001000000000000000000000000000000000000000000000000039 và 010000000110001000000000000000000000000000000000000000000000000011 là 010000000110001000000000000000000000000000000000000000000000000038 9.810 ¶ Điều này có đúng không? . Phiên bản đơn giản này có nghĩa là điều tương tự 9.811 ¶ Vâng, đó là 010000000110001000000000000000000000000000000000000000000000000038. Bạn có thể giảm từng bước như thế này 9.812______33 9.814 ¶ Tôi hy vọng bạn nhận thấy rằng 010000000110001000000000000000000000000000000000000000000000000014 là 010000000110001000000000000000000000000000000000000000000000000038. Cỏ có thể xanh nhưng không bằng xanh ¶ Không phải lúc nào cũng rõ ràng khi cần dấu ngoặc đơn. Trong thực tế, người ta thường có thể làm được khi biết rằng trong số các toán tử mà chúng ta đã thấy cho đến nay, 010000000110001000000000000000000000000000000000000000000000000005 có mức độ ưu tiên thấp nhất, sau đó đến 010000000110001000000000000000000000000000000000000000000000000002, sau đó là các toán tử so sánh ( 9.8102, 010000000110001000000000000000000000000000000000000000000000000000, v.v.), và phần còn lại. Điều này đã được chọn theo cách mà trong các trường hợp đơn giản, càng ít dấu ngoặc đơn càng tốt là cần thiết ¶ Tất cả các ví dụ cho đến nay đều sử dụng ngôn ngữ giống như bạn sử dụng máy tính bỏ túi. Tạo một số giá trị và áp dụng toán tử cho chúng để nhận giá trị mới. Tạo các giá trị như thế này là một phần thiết yếu của mọi chương trình JavaScript, nhưng nó chỉ là một phần. Một đoạn mã tạo ra một giá trị được gọi là một biểu thức. Mỗi giá trị được viết trực tiếp (chẳng hạn như 010000000110001000000000000000000000000000000000000000000000000020 hoặc 010000000110001000000000000000000000000000000000000000000000000021) là một biểu thức. Biểu thức nằm giữa dấu ngoặc đơn cũng là biểu thức. Và một toán tử nhị phân áp dụng cho hai biểu thức, hoặc toán tử một ngôi áp dụng cho một biểu thức, cũng là một biểu thức ¶ Còn một số cách xây dựng biểu thức nữa, sẽ tiết lộ khi thời điểm chín muồi ¶ Tồn tại một đơn vị lớn hơn một biểu thức. Nó được gọi là một tuyên bố. Một chương trình được xây dựng dưới dạng một danh sách các câu lệnh. Hầu hết các câu lệnh kết thúc bằng dấu chấm phẩy ( 010000000110001000000000000000000000000000000000000000000000000022). Loại câu lệnh đơn giản nhất là một biểu thức có dấu chấm phẩy sau nó. Đây là một chương trình 9.815 ¶ Đó là một chương trình vô dụng. Một biểu thức có thể hài lòng khi chỉ tạo ra một giá trị, nhưng một câu lệnh chỉ có giá trị nếu nó thay đổi thế giới bằng cách nào đó. Nó có thể in một cái gì đó lên màn hình - được coi là thay đổi thế giới - hoặc nó có thể thay đổi trạng thái bên trong của chương trình theo cách sẽ ảnh hưởng đến các câu lệnh xuất hiện sau nó. Những thay đổi này được gọi là 'tác dụng phụ'. Các câu lệnh trong ví dụ trên chỉ tạo ra các giá trị 115 * 4 - 4 + 88 / 228 và 010000000110001000000000000000000000000000000000000000000000000038, sau đó ngay lập tức ném chúng vào nhóm bit. Điều này không để lại ấn tượng gì với thế giới cả, và không phải là tác dụng phụ ¶ Làm thế nào để một chương trình giữ trạng thái bên trong? . Để bắt và giữ các giá trị, JavaScript cung cấp một thứ gọi là biến 9.816 ¶ Một biến luôn có một tên, và nó có thể chỉ vào một giá trị, giữ nó. Câu lệnh trên tạo một biến có tên là 010000000110001000000000000000000000000000000000000000000000000025 và sử dụng nó để lấy số được tạo ra bằng cách nhân 010000000110001000000000000000000000000000000000000000000000000026 với 010000000110001000000000000000000000000000000000000000000000000026 ¶ Sau khi chạy chương trình trên, bạn gõ từ 010000000110001000000000000000000000000000000000000000000000000025 vào console, nó sẽ lấy ra giá trị 010000000110001000000000000000000000000000000000000000000000000029 cho bạn. Tên của một biến được sử dụng để lấy giá trị của nó. 010000000110001000000000000000000000000000000000000000000000000030 cũng hoạt động. Một tên biến có thể được sử dụng như một biểu thức và do đó có thể là một phần của các biểu thức lớn hơn ¶ Từ 010000000110001000000000000000000000000000000000000000000000000031 được sử dụng để tạo một biến mới. Sau 010000000110001000000000000000000000000000000000000000000000000031, tên của biến theo sau. Tên biến có thể gần như mọi từ, nhưng chúng có thể không bao gồm khoảng trắng. Chữ số có thể là một phần của tên biến, 010000000110001000000000000000000000000000000000000000000000000033 là tên hợp lệ, nhưng tên không được bắt đầu bằng chữ số. Các ký tự ' 010000000110001000000000000000000000000000000000000000000000000034' và '_______235' có thể được sử dụng trong các tên như thể chúng là các chữ cái, vì vậy _____236 là một tên biến chính xác ¶ Nếu bạn muốn biến mới nắm bắt ngay một giá trị, điều này thường xảy ra, toán tử 010000000110001000000000000000000000000000000000000000000000000037 có thể được sử dụng để cung cấp cho nó giá trị của một số biểu thức ¶ Khi một biến chỉ vào một giá trị, điều đó không có nghĩa là nó mãi mãi gắn liền với giá trị đó. Bất cứ lúc nào, toán tử 010000000110001000000000000000000000000000000000000000000000000037 có thể được sử dụng trên các biến hiện có để kéo chúng ra khỏi giá trị hiện tại và khiến chúng trỏ đến một giá trị mới 9.817 ¶ Bạn nên tưởng tượng các biến là xúc tu, chứ không phải là hộp. Chúng không chứa các giá trị, chúng nắm bắt chúng ― hai biến có thể tham chiếu đến cùng một giá trị. Nó chỉ có thể truy cập các giá trị mà chương trình vẫn giữ. Khi bạn cần ghi nhớ điều gì đó, bạn phát triển một xúc tu để giữ lấy nó hoặc gắn lại một trong các xúc tu hiện có của bạn vào một giá trị mới. Để nhớ số đô la mà Luigi vẫn nợ bạn, bạn có thể làm 9.818 ¶ Sau đó, mỗi khi Luigi trả lại một thứ gì đó, số tiền này có thể giảm đi bằng cách đặt cho biến số một số mới 9.819 ¶ Tập hợp các biến và giá trị của chúng tồn tại tại một thời điểm nhất định được gọi là môi trường. Khi một chương trình khởi động, môi trường này không trống. Nó luôn chứa một số biến tiêu chuẩn. Khi trình duyệt của bạn tải một trang, nó sẽ tạo một môi trường mới và gắn các giá trị tiêu chuẩn này vào đó. Các biến được tạo và sửa đổi bởi các chương trình trên trang đó tồn tại cho đến khi trình duyệt chuyển sang trang mới ¶ Rất nhiều giá trị được cung cấp bởi môi trường tiêu chuẩn có kiểu 'hàm'. Một chức năng là một phần của chương trình được bọc trong một giá trị. Nói chung, đoạn chương trình này thực hiện điều gì đó hữu ích, có thể được gọi bằng cách sử dụng giá trị hàm chứa nó. Trong môi trường trình duyệt, biến 010000000110001000000000000000000000000000000000000000000000000039 giữ chức năng hiển thị một cửa sổ hộp thoại nhỏ có thông báo. Nó được sử dụng như thế này 2.998e80 ¶ Việc thực thi mã trong một hàm được gọi là gọi, gọi hoặc áp dụng nó. Ký hiệu để làm điều này sử dụng dấu ngoặc đơn. Mỗi biểu thức tạo ra một giá trị hàm có thể được gọi bằng cách đặt dấu ngoặc đơn sau nó. Trong ví dụ này, giá trị 010000000110001000000000000000000000000000000000000000000000000040 được gán cho hàm, sử dụng nó làm văn bản để hiển thị trong cửa sổ hộp thoại. Các giá trị được cung cấp cho các chức năng được gọi là tham số hoặc đối số. 010000000110001000000000000000000000000000000000000000000000000039 chỉ cần một trong số chúng, nhưng các chức năng khác có thể cần một số khác ¶ Hiển thị cửa sổ hộp thoại là một tác dụng phụ. Rất nhiều chức năng hữu ích vì tác dụng phụ mà chúng tạo ra. Cũng có thể một hàm tạo ra một giá trị, trong trường hợp đó, nó không cần phải có tác dụng phụ để hữu ích. Ví dụ: có một hàm 010000000110001000000000000000000000000000000000000000000000000042, nhận vào bất kỳ số lượng đối số số nào và trả về giá trị lớn nhất 2.998e81 ¶ Khi một hàm tạo ra một giá trị, nó được gọi là trả về giá trị đó. Vì những thứ tạo ra giá trị luôn là các biểu thức trong JavaScript, nên các lệnh gọi hàm có thể được sử dụng như một phần của các biểu thức lớn hơn 2.998e82 ¶ Chương 3 thảo luận về việc viết các chức năng của riêng bạn ¶ Như các ví dụ trước cho thấy, 010000000110001000000000000000000000000000000000000000000000000039 có thể hữu ích để hiển thị kết quả của một số biểu thức. Tuy nhiên, việc nhấp vào tất cả các cửa sổ nhỏ đó có thể khiến người ta lo lắng, vì vậy từ giờ trở đi, chúng tôi sẽ ưu tiên sử dụng một chức năng tương tự, được gọi là 010000000110001000000000000000000000000000000000000000000000000044, chức năng này không bật lên cửa sổ mà chỉ ghi một giá trị vào khu vực đầu ra của bảng điều khiển. 010000000110001000000000000000000000000000000000000000000000000044 không phải là một chức năng JavaScript tiêu chuẩn, các trình duyệt không cung cấp nó cho bạn, nhưng nó được cung cấp bởi cuốn sách này, vì vậy bạn có thể sử dụng nó trên các trang này 2.998e83 ¶ Một chức năng tương tự, cũng được cung cấp trên các trang này, là 010000000110001000000000000000000000000000000000000000000000000046. Trong khi 010000000110001000000000000000000000000000000000000000000000000044 sẽ hiển thị đối số của nó dưới dạng văn bản phẳng, thì 010000000110001000000000000000000000000000000000000000000000000046 sẽ cố gắng hiển thị nó theo cách nó trông giống như trong một chương trình, điều này có thể cung cấp thêm thông tin về loại giá trị. Ví dụ: các giá trị chuỗi giữ dấu ngoặc kép của chúng khi được cấp cho 010000000110001000000000000000000000000000000000000000000000000046 2.998e84 ¶ Môi trường tiêu chuẩn do các trình duyệt cung cấp có thêm một vài chức năng để bật lên các cửa sổ. Bạn có thể hỏi người dùng câu hỏi OK/Cancel bằng cách sử dụng 010000000110001000000000000000000000000000000000000000000000000050. Điều này trả về một giá trị boolean, 010000000110001000000000000000000000000000000000000000000000000038 nếu người dùng nhấn 'OK' và 010000000110001000000000000000000000000000000000000000000000000039 nếu anh ta nhấn 'Hủy' 2.998e85 ¶ 010000000110001000000000000000000000000000000000000000000000000053 có thể được sử dụng để đặt câu hỏi 'mở'. Đối số đầu tiên là câu hỏi, đối số thứ hai là văn bản mà người dùng bắt đầu bằng. Một dòng văn bản có thể được nhập vào cửa sổ và hàm sẽ trả về dòng này dưới dạng một chuỗi 2.998e86 ¶ Có thể cung cấp cho hầu hết mọi biến trong môi trường một giá trị mới. Điều này có thể hữu ích, nhưng cũng nguy hiểm. Nếu bạn cung cấp cho 010000000110001000000000000000000000000000000000000000000000000044 giá trị 010000000110001000000000000000000000000000000000000000000000000055, bạn sẽ không thể in mọi thứ nữa. May mắn thay, có một nút 'Đặt lại' lớn trên bảng điều khiển, nút này sẽ đặt lại môi trường về trạng thái ban đầu ¶ Các chương trình một dòng không thú vị lắm. Khi bạn đặt nhiều hơn một câu lệnh vào một chương trình, có thể đoán trước được, các câu lệnh đó sẽ được thực thi từng câu lệnh một, từ trên xuống dưới 2.998e87 ¶ Hàm 010000000110001000000000000000000000000000000000000000000000000056 chuyển đổi một giá trị thành một số, cần thiết trong trường hợp này vì kết quả của 010000000110001000000000000000000000000000000000000000000000000053 là một giá trị chuỗi. Có các hàm tương tự được gọi là 010000000110001000000000000000000000000000000000000000000000000058 và 010000000110001000000000000000000000000000000000000000000000000059 chuyển đổi giá trị thành các loại đó ¶ Xét một chương trình in ra tất cả các số chẵn từ 0 đến 12. Một cách để viết điều này là 2.998e88 ¶ Điều đó hiệu quả, nhưng ý tưởng viết chương trình là làm cho thứ gì đó ít hoạt động hơn, không phải nhiều hơn. Nếu chúng tôi cần tất cả các số chẵn dưới 1000, điều trên sẽ không khả thi. Những gì chúng ta cần là một cách để tự động lặp lại một số mã 2.998e89 ¶ Bạn có thể đã thấy 010000000110001000000000000000000000000000000000000000000000000060 trong chương giới thiệu. Một câu lệnh bắt đầu bằng từ 010000000110001000000000000000000000000000000000000000000000000060 sẽ tạo ra một vòng lặp. Vòng lặp là sự xáo trộn trong chuỗi các câu lệnh ― nó có thể khiến chương trình lặp lại một số câu lệnh nhiều lần. Trong trường hợp này, từ 010000000110001000000000000000000000000000000000000000000000000060 được theo sau bởi một biểu thức trong ngoặc đơn (dấu ngoặc đơn là bắt buộc ở đây), được sử dụng để xác định liệu vòng lặp sẽ lặp hay kết thúc. Miễn là giá trị boolean do biểu thức này tạo ra là 010000000110001000000000000000000000000000000000000000000000000038, mã trong vòng lặp được lặp lại. Ngay khi nó sai, chương trình sẽ đi đến cuối vòng lặp và tiếp tục như bình thường ¶ Biến 010000000110001000000000000000000000000000000000000000000000000064 thể hiện cách một biến có thể theo dõi tiến trình của một chương trình. Mỗi khi vòng lặp lặp lại, nó được tăng lên bởi 010000000110001000000000000000000000000000000000000000000000000065 và khi bắt đầu mỗi lần lặp lại, nó được so sánh với số 010000000110001000000000000000000000000000000000000000000000000066 để quyết định có tiếp tục vòng lặp hay không ¶ Phần thứ ba của câu lệnh 010000000110001000000000000000000000000000000000000000000000000060 là một câu lệnh khác. Đây là phần thân của vòng lặp, hành động hoặc hành động phải diễn ra nhiều lần. Nếu chúng tôi không phải in các số, chương trình có thể đã 100 + 4 * 110 ¶ Ở đây, 010000000110001000000000000000000000000000000000000000000000000068 là câu lệnh tạo thành phần thân của vòng lặp. Tuy nhiên, chúng ta cũng phải in số, vì vậy câu lệnh vòng lặp phải bao gồm nhiều hơn một câu lệnh. Dấu ngoặc nhọn ( 010000000110001000000000000000000000000000000000000000000000000069 và 010000000110001000000000000000000000000000000000000000000000000070) được sử dụng để nhóm các câu lệnh thành các khối. Đối với thế giới bên ngoài khối, một khối được tính là một câu lệnh. Trong ví dụ trước, điều này được sử dụng để bao gồm trong vòng lặp cả lời gọi đến 010000000110001000000000000000000000000000000000000000000000000044 và câu lệnh cập nhật 010000000110001000000000000000000000000000000000000000000000000064 ¶ Sử dụng các kỹ thuật đã trình bày cho đến nay để viết chương trình tính toán và hiển thị giá trị của 210 (2 mũ 10). Rõ ràng là bạn không được phép sử dụng thủ thuật rẻ tiền như chỉ viết 010000000110001000000000000000000000000000000000000000000000000073 ¶ Nếu bạn gặp rắc rối với điều này, hãy thử xem nó dưới dạng ví dụ về số chẵn. Chương trình phải thực hiện một hành động trong một số lần nhất định. Một biến đếm với vòng lặp 010000000110001000000000000000000000000000000000000000000000000060 có thể được sử dụng cho điều đó. Thay vì in bộ đếm, chương trình phải nhân một thứ gì đó với 2. Cái gì đó này phải là một biến khác, trong đó giá trị kết quả được xây dựng ¶ Đừng lo lắng nếu bạn vẫn chưa hiểu rõ cách thức hoạt động của nó. Ngay cả khi bạn hoàn toàn hiểu tất cả các kỹ thuật trong chương này, bạn vẫn khó có thể áp dụng chúng vào một vấn đề cụ thể. Đọc và viết mã sẽ giúp phát triển cảm giác về điều này, vì vậy hãy nghiên cứu lời giải và thử bài tập tiếp theo 100 + 4 * 111 ¶ Bộ đếm cũng có thể bắt đầu từ 115 * 4 - 4 + 88 / 228 và kiểm tra 010000000110001000000000000000000000000000000000000000000000000076, nhưng, vì những lý do mà sau này sẽ rõ, bạn nên làm quen với việc đếm từ 0 ¶ Rõ ràng, giải pháp của riêng bạn không bắt buộc phải hoàn toàn giống giải pháp của tôi. Họ nên làm việc. Và nếu chúng rất khác nhau, hãy chắc chắn rằng bạn cũng hiểu giải pháp của tôi ¶ Với một số sửa đổi nhỏ, có thể thực hiện lời giải cho bài tập trước để vẽ một hình tam giác. Và khi tôi nói 'vẽ hình tam giác', ý tôi là 'in ra một số văn bản gần giống hình tam giác khi bạn nheo mắt' ¶ In ra mười dòng. Trên dòng đầu tiên có một ký tự '#'. Trên cái thứ hai có hai. Và như thế ¶ Làm cách nào để lấy một chuỗi có ký tự X '#' trong đó? . Một cách đơn giản hơn là sử dụng lại chuỗi mà lần lặp trước của vòng lặp đã sử dụng và thêm một ký tự vào chuỗi đó 100 + 4 * 112 ¶ Bạn sẽ nhận thấy những khoảng trống tôi đặt trước một số câu lệnh. Những điều này không bắt buộc. Máy tính sẽ chấp nhận chương trình tốt mà không cần chúng. Trên thực tế, ngay cả ngắt dòng trong chương trình cũng là tùy chọn. Bạn có thể viết chúng thành một dòng dài nếu bạn cảm thấy thích. Vai trò của thụt đầu dòng bên trong các khối là làm cho cấu trúc của mã rõ ràng hơn đối với người đọc. Bởi vì các khối mới có thể được mở bên trong các khối khác, nên khó có thể biết được nơi một khối kết thúc và một khối khác bắt đầu trong một đoạn mã phức tạp. Khi các dòng được thụt vào, hình dạng trực quan của chương trình tương ứng với hình dạng của các khối bên trong nó. Tôi thích sử dụng hai khoảng trắng cho mỗi khối mở, nhưng thị hiếu khác nhau ¶ Trường trong bảng điều khiển nơi bạn có thể nhập chương trình sẽ giúp bạn bằng cách tự động thêm các khoảng trống này. Điều này thoạt nghe có vẻ khó chịu, nhưng khi bạn viết nhiều mã, nó sẽ tiết kiệm thời gian rất nhiều. Nhấn phím shift+tab sẽ thụt lề lại dòng mà con trỏ của bạn hiện đang bật ¶ Trong một số trường hợp, JavaScript cho phép bạn bỏ dấu chấm phẩy ở cuối câu lệnh. Trong các trường hợp khác, nó phải ở đó hoặc những điều kỳ lạ sẽ xảy ra. Các quy tắc khi nó có thể được bỏ qua một cách an toàn rất phức tạp và kỳ lạ. Trong cuốn sách này, tôi sẽ không bỏ bất kỳ dấu chấm phẩy nào, và tôi thực sự khuyên bạn nên làm như vậy trong các chương trình của riêng bạn ¶ Việc sử dụng 010000000110001000000000000000000000000000000000000000000000000060 mà chúng ta đã thấy cho đến nay đều cho thấy cùng một khuôn mẫu. Đầu tiên, một biến 'bộ đếm' được tạo. Biến này theo dõi tiến trình của vòng lặp. Bản thân 010000000110001000000000000000000000000000000000000000000000000060 chứa một kiểm tra, thường để xem liệu bộ đếm đã đạt đến một số ranh giới chưa. Sau đó, ở cuối thân vòng lặp, bộ đếm được cập nhật ¶ Rất nhiều vòng lặp rơi vào mô hình này. Vì lý do này, JavaScript và các ngôn ngữ tương tự cũng cung cấp một biểu mẫu ngắn hơn và toàn diện hơn một chút 100 + 4 * 113 ¶ Chương trình này hoàn toàn tương đương với ví dụ in số chẵn trước đó. Thay đổi duy nhất là tất cả các câu lệnh liên quan đến 'trạng thái' của vòng lặp hiện nằm trên một dòng. Dấu ngoặc đơn sau 010000000110001000000000000000000000000000000000000000000000000079 phải chứa hai dấu chấm phẩy. Phần trước dấu chấm phẩy đầu tiên khởi tạo vòng lặp, thường bằng cách xác định một biến. Phần thứ hai là biểu thức kiểm tra xem vòng lặp có còn phải tiếp tục hay không. Phần cuối cùng cập nhật trạng thái của vòng lặp. Trong hầu hết các trường hợp, điều này ngắn hơn và rõ ràng hơn cấu trúc 010000000110001000000000000000000000000000000000000000000000000060 ¶ Tôi đã sử dụng một số cách viết hoa khá kỳ quặc trong một số tên biến. Bởi vì bạn không thể có khoảng trắng trong các tên này ― máy tính sẽ đọc chúng dưới dạng hai biến riêng biệt ― các lựa chọn của bạn cho một tên được tạo thành từ nhiều từ ít nhiều bị giới hạn ở những điều sau. 010000000110001000000000000000000000000000000000000000000000000081, 010000000110001000000000000000000000000000000000000000000000000082, 010000000110001000000000000000000000000000000000000000000000000083 hoặc 010000000110001000000000000000000000000000000000000000000000000084. Cái đầu tiên khó đọc. Cá nhân mình thích cái có gạch dưới, dù gõ hơi đau tay. Tuy nhiên, các hàm JavaScript tiêu chuẩn và hầu hết các lập trình viên JavaScript đều tuân theo cái cuối cùng. Không khó để làm quen với những điều nhỏ nhặt như vậy, vì vậy tôi sẽ chỉ làm theo đám đông và viết hoa chữ cái đầu tiên của mỗi từ sau chữ cái đầu tiên ¶ Trong một số trường hợp, chẳng hạn như hàm 010000000110001000000000000000000000000000000000000000000000000056, chữ cái đầu tiên của biến cũng được viết hoa. Điều này đã được thực hiện để đánh dấu chức năng này là một hàm tạo. Hàm tạo là gì sẽ được làm rõ trong chương 8. Bây giờ, điều quan trọng là không bị làm phiền bởi sự thiếu nhất quán rõ ràng này. ¶ Lưu ý rằng các tên có ý nghĩa đặc biệt, chẳng hạn như 010000000110001000000000000000000000000000000000000000000000000031, 010000000110001000000000000000000000000000000000000000000000000060 và 010000000110001000000000000000000000000000000000000000000000000079 không được dùng làm tên biến. Chúng được gọi là từ khóa. Ngoài ra còn có một số từ được 'dành riêng để sử dụng' trong các phiên bản JavaScript sau này. Chúng cũng chính thức không được phép sử dụng làm tên biến, mặc dù một số trình duyệt cho phép chúng. Danh sách đầy đủ khá dài 100 + 4 * 114 ¶ Đừng lo lắng về việc ghi nhớ những điều này vào lúc này, nhưng hãy nhớ rằng đây có thể là vấn đề khi một thứ gì đó không hoạt động như mong đợi. Theo kinh nghiệm của tôi, 010000000110001000000000000000000000000000000000000000000000000089 (để lưu trữ chuỗi một ký tự) và 010000000110001000000000000000000000000000000000000000000000000090 là những tên phổ biến nhất vô tình sử dụng ¶ Viết lại lời giải của hai bài tập trước để sử dụng 010000000110001000000000000000000000000000000000000000000000000079 thay vì 010000000110001000000000000000000000000000000000000000000000000060 100 + 4 * 115 ¶ Lưu ý rằng ngay cả khi không có khối nào được mở bằng ' 010000000110001000000000000000000000000000000000000000000000000069', câu lệnh trong vòng lặp vẫn được thụt vào hai khoảng trắng để làm rõ rằng nó 'thuộc về' dòng phía trên nó 100 + 4 * 116 ¶ Một chương trình thường cần 'cập nhật' một biến có giá trị dựa trên giá trị trước đó của nó. Ví dụ 010000000110001000000000000000000000000000000000000000000000000094. JavaScript cung cấp lối tắt cho việc này. 010000000110001000000000000000000000000000000000000000000000000095. Điều này cũng có tác dụng đối với nhiều toán tử khác, ví dụ như 010000000110001000000000000000000000000000000000000000000000000096 để nhân đôi giá trị của 010000000110001000000000000000000000000000000000000000000000000097 hoặc 010000000110001000000000000000000000000000000000000000000000000098 để đếm ngược ¶ Đối với 010000000110001000000000000000000000000000000000000000000000000095 và 010000000110001000000000000000000000000000000000000000000000000098 thậm chí còn có các phiên bản ngắn hơn. 9.8101 và 9.8102 ¶ Vòng lặp được cho là ảnh hưởng đến luồng điều khiển của chương trình. Họ thay đổi thứ tự thực hiện các câu lệnh. Trong nhiều trường hợp, một loại luồng khác là hữu ích. câu lệnh bỏ qua ¶ Chúng tôi muốn hiển thị tất cả các số dưới 20 chia hết cho cả 3 và 4 100 + 4 * 117 ¶ Từ khóa 9.8103 không khác quá nhiều so với từ khóa 010000000110001000000000000000000000000000000000000000000000000060. Nó kiểm tra điều kiện được đưa ra (giữa các dấu ngoặc đơn) và thực thi câu lệnh sau nó dựa trên điều kiện này. Nhưng nó chỉ thực hiện điều này một lần, do đó câu lệnh được thực hiện không hoặc một lần ¶ Thủ thuật với toán tử dư (_______121) là một cách dễ dàng để kiểm tra xem một số có chia hết cho một số khác hay không. Nếu đúng như vậy, phần còn lại của phép chia của họ, là phần còn lại mang lại cho bạn, bằng không ¶ Nếu chúng ta muốn in tất cả các số dưới 20, nhưng đặt dấu ngoặc đơn xung quanh các số không chia hết cho 4, chúng ta có thể làm như thế này 100 + 4 * 118 ¶ Nhưng bây giờ chương trình phải xác định xem 9.8106 có chia hết cho 9.8107 hai lần hay không. Có thể đạt được hiệu ứng tương tự bằng cách nối thêm phần 9.8108 sau câu lệnh 9.8103. Câu lệnh 9.8108 chỉ được thực thi khi điều kiện của 9.8103 là sai 100 + 4 * 119 ¶ Để mở rộng ví dụ tầm thường này ra xa hơn một chút, bây giờ chúng ta muốn in các số giống như vậy, nhưng thêm hai ngôi sao sau chúng khi chúng lớn hơn 15, một ngôi sao khi chúng lớn hơn 10 (nhưng không lớn hơn 15) và không (100 + 4) * 110 ¶ Điều này chứng tỏ rằng bạn có thể xâu chuỗi các câu lệnh 9.8103 lại với nhau. Trong trường hợp này, trước tiên chương trình sẽ xem xét nếu 9.8106 lớn hơn 9.8114. Nếu đúng như vậy, hai ngôi sao sẽ được in và các bài kiểm tra khác sẽ bị bỏ qua. Nếu không ta tiếp tục kiểm tra xem 9.8106 có lớn hơn 9.8116 không. Chỉ khi 9.8106 cũng không lớn hơn 9.8116 thì nó mới đến câu lệnh 010000000110001000000000000000000000000000000000000000000000000044 cuối cùng ¶ Viết chương trình tự hỏi, sử dụng 010000000110001000000000000000000000000000000000000000000000000053, giá trị của 2 + 2 là bao nhiêu. Nếu câu trả lời là "4", hãy sử dụng 010000000110001000000000000000000000000000000000000000000000000039 để nói điều gì đó khen ngợi. Nếu là "3" hoặc "5", hãy nói "Hầu như. ". Trong các trường hợp khác, hãy nói điều gì đó có ý nghĩa (100 + 4) * 111 ¶ Khi một vòng lặp không phải lúc nào cũng phải đi từ đầu đến cuối, thì từ khóa 9.8122 có thể hữu ích. Nó ngay lập tức nhảy ra khỏi vòng lặp hiện tại, tiếp tục sau nó. Chương trình này tìm số đầu tiên lớn hơn hoặc bằng 20 và chia hết cho 7 (100 + 4) * 112 ¶ Cấu trúc 010000000110001000000000000000000000000000000000000000000000000079 hiển thị ở trên không có phần kiểm tra phần cuối của vòng lặp. Điều này có nghĩa là nó phụ thuộc vào câu lệnh 9.8122 bên trong nó để dừng lại. Chương trình tương tự cũng có thể được viết đơn giản là (100 + 4) * 113 ¶ Trong trường hợp này, phần thân của vòng lặp trống. Một dấu chấm phẩy đơn độc có thể được sử dụng để tạo ra một câu lệnh trống. Ở đây, tác dụng duy nhất của vòng lặp là tăng biến 9.8125 lên giá trị mong muốn của nó. Nhưng tôi cần một ví dụ sử dụng 9.8122, vì vậy hãy chú ý đến phiên bản đầu tiên ¶ Thêm một 010000000110001000000000000000000000000000000000000000000000000060 và một 9.8122 tùy chọn vào lời giải của bạn cho bài tập trước, để nó tiếp tục lặp lại câu hỏi cho đến khi có câu trả lời đúng ¶ Lưu ý rằng có thể sử dụng 9.8129 để tạo một vòng lặp không kết thúc trên tài khoản của chính nó. Cái này hơi ngớ ngẩn, bạn yêu cầu chương trình lặp chừng nào 010000000110001000000000000000000000000000000000000000000000000038 bằng 010000000110001000000000000000000000000000000000000000000000000038, nhưng nó là một thủ thuật hữu ích (100 + 4) * 114 ¶ Bởi vì phần thân của 9.8103 đầu tiên hiện có hai câu lệnh, tôi đã thêm các dấu ngoặc quanh tất cả các phần thân. Đây là một vấn đề của hương vị. Có một chuỗi 9.8103/ 9.8108 trong đó một số phần tử là các khối và một số phần tử khác là các câu lệnh đơn lẻ có vẻ hơi sai đối với tôi, nhưng bạn có thể tự quyết định về điều đó ¶ Một giải pháp khác, có thể nói là đẹp hơn, nhưng không có 9.8122 (100 + 4) * 115 ¶ Trong lời giải của bài tập trước có câu lệnh 9.8136. Điều này tạo ra một biến có tên là 9.8137, nhưng không cung cấp cho nó một giá trị. Điều gì xảy ra khi bạn lấy giá trị của biến này? (100 + 4) * 116 ¶ Về mặt xúc tu, biến này kết thúc trong không khí mỏng manh, nó không có gì để nắm bắt. Khi bạn yêu cầu giá trị của một chỗ trống, bạn sẽ nhận được một giá trị đặc biệt có tên là 9.8138. Các hàm không trả về giá trị thú vị, chẳng hạn như 010000000110001000000000000000000000000000000000000000000000000044 và 010000000110001000000000000000000000000000000000000000000000000039, cũng trả về giá trị 9.8138 (100 + 4) * 117 ¶ Ngoài ra còn có một giá trị tương tự, 9.8142, có nghĩa là 'biến này được xác định, nhưng nó không có giá trị'. Sự khác biệt về ý nghĩa giữa 9.8138 và 9.8142 chủ yếu là học thuật và thường không thú vị lắm. Trong các chương trình thực tế, thường cần kiểm tra xem thứ gì đó 'có giá trị' hay không. Trong những trường hợp này, biểu thức 9.8145 có thể được sử dụng, bởi vì, mặc dù chúng không hoàn toàn giống nhau về giá trị, nhưng 9.8146 sẽ tạo ra 010000000110001000000000000000000000000000000000000000000000000038 ¶ Điều này đưa chúng ta đến một chủ đề phức tạp khác (100 + 4) * 118 ¶ Tất cả những điều này mang lại giá trị 010000000110001000000000000000000000000000000000000000000000000038. Khi so sánh các giá trị có các loại khác nhau, JavaScript sử dụng một bộ quy tắc phức tạp và khó hiểu. Tôi sẽ không cố gắng giải thích chúng một cách chính xác, nhưng trong hầu hết các trường hợp, nó chỉ cố chuyển đổi một trong các giá trị thành loại của giá trị kia. Tuy nhiên, khi xảy ra 9.8142 hoặc 9.8138, nó chỉ tạo ra 010000000110001000000000000000000000000000000000000000000000000038 nếu cả hai bên đều là 9.8142 hoặc 9.8138 ¶ Điều gì sẽ xảy ra nếu bạn muốn kiểm tra xem một biến có tham chiếu đến giá trị 010000000110001000000000000000000000000000000000000000000000000039 hay không? . Do đó, biểu thức 9.8158 cũng là 010000000110001000000000000000000000000000000000000000000000000038 khi 9.8160 đề cập đến 010000000110001000000000000000000000000000000000000000000000000030 hoặc 9.8162. Đối với những trường hợp như thế này, khi bạn không muốn bất kỳ chuyển đổi loại tự động nào xảy ra, thì có hai toán tử bổ sung. 9.8163 và 9.8164. Lần đầu tiên kiểm tra xem một giá trị có chính xác bằng giá trị kia hay không và lần thứ hai kiểm tra xem giá trị đó có chính xác bằng nhau hay không (100 + 4) * 119 ¶ Tất cả đều là 010000000110001000000000000000000000000000000000000000000000000039 ¶ Các giá trị được đưa ra dưới dạng điều kiện trong câu lệnh 9.8103, 010000000110001000000000000000000000000000000000000000000000000060 hoặc 010000000110001000000000000000000000000000000000000000000000000079 không nhất thiết phải là boolean. Chúng sẽ được tự động chuyển đổi thành booleans trước khi chúng được kiểm tra. Điều này có nghĩa là số 010000000110001000000000000000000000000000000000000000000000000030, chuỗi trống 9.8162, 9.8142, 9.8138 và tất nhiên là 010000000110001000000000000000000000000000000000000000000000000039, tất cả sẽ được tính là sai ¶ Thực tế là tất cả các giá trị khác được chuyển đổi thành 010000000110001000000000000000000000000000000000000000000000000038 trong trường hợp này giúp có thể loại bỏ các phép so sánh rõ ràng trong nhiều tình huống. Nếu một biến được biết là chứa một chuỗi hoặc 9.8142, người ta có thể kiểm tra điều này rất đơn giản ¶. ngoại trừ trường hợp mã bí ẩn cung cấp cho 9.8176 giá trị 9.8162. Một chuỗi trống là sai, vì vậy không có gì được in. Tùy thuộc vào những gì bạn đang cố gắng làm, điều này có thể sai. Thường nên thêm một 9.8178 hoặc 9.8179 rõ ràng trong những trường hợp như thế này để tránh những sai lầm tinh vi. Điều tương tự cũng xảy ra với các giá trị số có thể là 010000000110001000000000000000000000000000000000000000000000000030 ¶ Dòng nói về 'mã bí ẩn' trong ví dụ trước có thể khiến bạn hơi nghi ngờ. Nó thường hữu ích để bao gồm văn bản bổ sung trong một chương trình. Cách sử dụng phổ biến nhất cho việc này là thêm một số giải thích bằng ngôn ngữ của con người vào chương trình ¶ Loại văn bản này được gọi là bình luận. Các quy tắc là như thế này. '______381' bắt đầu một nhận xét tiếp tục cho đến khi tìm thấy ' 9.8182'. '______383' bắt đầu một loại bình luận khác, tiếp tục cho đến cuối dòng ¶ Như bạn có thể thấy, ngay cả những chương trình đơn giản nhất cũng có thể trở nên to, xấu xí và phức tạp chỉ bằng cách thêm nhiều nhận xét vào chúng ¶ Có một số tình huống khác khiến chuyển đổi loại tự động xảy ra. Nếu bạn thêm một giá trị không phải chuỗi vào một chuỗi, thì giá trị đó sẽ tự động được chuyển đổi thành một chuỗi trước khi nó được nối. Nếu bạn nhân một số và một chuỗi, JavaScript sẽ cố gắng tạo một số trong chuỗi 115 * 4 - 4 + 88 / 20 ¶ Câu lệnh cuối in ra 9.8184, là một giá trị đặc biệt. Nó là viết tắt của 'not a number' và thuộc loại số (nghe có vẻ hơi mâu thuẫn). Trong trường hợp này, nó đề cập đến thực tế là một quả dâu tây không phải là một con số. Tất cả các phép tính số học trên giá trị 9.8184 đều cho kết quả là ________ 384, đó là lý do tại sao nhân nó với ________ 226, như trong ví dụ, vẫn cho giá trị 9.8184. Ngoài ra, và điều này đôi khi có thể khiến bạn mất phương hướng, 9.8189 bằng 010000000110001000000000000000000000000000000000000000000000000039, việc kiểm tra xem một giá trị có phải là 9.8184 hay không có thể được thực hiện bằng hàm 9.8192. 9.8184 là một giá trị (cuối cùng) khác được tính là 010000000110001000000000000000000000000000000000000000000000000039 khi được chuyển đổi thành boolean ¶ Những chuyển đổi tự động này có thể rất thuận tiện, nhưng chúng cũng khá kỳ lạ và dễ xảy ra lỗi. Mặc dù 115 * 4 - 4 + 88 / 26 và 115 * 4 - 4 + 88 / 27 đều là toán tử số học, nhưng chúng hoạt động hoàn toàn khác nhau trong ví dụ. Trong mã của riêng tôi, tôi sử dụng 115 * 4 - 4 + 88 / 26 để kết hợp nhiều chuỗi và không phải chuỗi, nhưng lưu ý không sử dụng 115 * 4 - 4 + 88 / 27 và các toán tử số khác trên các giá trị chuỗi. Chuyển đổi một số thành một chuỗi luôn có thể thực hiện được và đơn giản, nhưng chuyển đổi một chuỗi thành một số thậm chí có thể không hoạt động (như trong dòng cuối cùng của ví dụ). Chúng tôi có thể sử dụng 010000000110001000000000000000000000000000000000000000000000000056 để chuyển đổi rõ ràng chuỗi thành một số, làm rõ rằng chúng tôi có thể gặp rủi ro khi nhận giá trị 9.8184 115 * 4 - 4 + 88 / 21 ¶ Khi chúng ta thảo luận về các toán tử boolean 010000000110001000000000000000000000000000000000000000000000000002 và 010000000110001000000000000000000000000000000000000000000000000005 trước đó, tôi khẳng định rằng chúng tạo ra các giá trị boolean. Điều này hóa ra là một chút đơn giản hóa. Nếu bạn áp dụng chúng cho các giá trị boolean, chúng sẽ thực sự trả về các boolean. Nhưng chúng cũng có thể được áp dụng cho các loại giá trị khác, trong trường hợp đó, chúng sẽ trả về một trong các đối số của chúng ¶ Điều mà 010000000110001000000000000000000000000000000000000000000000000005 thực sự làm là đây. Nó nhìn vào giá trị bên trái của nó đầu tiên. Nếu chuyển đổi giá trị này thành boolean sẽ tạo ra 010000000110001000000000000000000000000000000000000000000000000038, nó sẽ trả về giá trị bên trái này, nếu không, nó sẽ trả về giá trị bên phải của nó. Hãy tự kiểm tra xem điều này có đúng không khi các đối số là booleans. Tại sao nó hoạt động như vậy? . Hãy xem xét ví dụ này 115 * 4 - 4 + 88 / 22 ¶ Nếu người dùng nhấn 'Hủy' hoặc đóng hộp thoại 010000000110001000000000000000000000000000000000000000000000000053 theo cách khác mà không đặt tên, biến 2.998e806 sẽ giữ giá trị 9.8142 hoặc 9.8162. Cả hai sẽ cung cấp cho 010000000110001000000000000000000000000000000000000000000000000039 khi được chuyển đổi thành boolean. Biểu thức 2.998e810 trong trường hợp này có thể được đọc là 'giá trị của biến 2.998e806, hoặc nếu không thì chuỗi 2.998e812'. Đây là một cách dễ dàng để cung cấp giá trị 'dự phòng' ¶ Toán tử 010000000110001000000000000000000000000000000000000000000000000002 hoạt động tương tự, nhưng ngược lại. Khi giá trị bên trái của nó là giá trị sẽ cho 010000000110001000000000000000000000000000000000000000000000000039 khi được chuyển đổi thành boolean, nó sẽ trả về giá trị đó, nếu không, nó sẽ trả về giá trị bên phải của nó ¶ Một thuộc tính khác của hai toán tử này là biểu thức bên phải của chúng chỉ được đánh giá khi cần thiết. Trong trường hợp của 2.998e815, bất kể 115 * 4 - 4 + 88 / 223 là gì, kết quả sẽ là 010000000110001000000000000000000000000000000000000000000000000038, vì vậy 115 * 4 - 4 + 88 / 223 không bao giờ được đánh giá và nếu nó có tác dụng phụ thì chúng cũng không bao giờ xảy ra. Điều tương tự cũng xảy ra với 2.998e819 Giá trị của một biến trong JavaScript là gì?var là từ khóa cho JavaScript biết bạn đang khai báo một biến. x là tên của biến đó. = là toán tử cho JavaScript biết giá trị sắp xuất hiện tiếp theo. 100 là giá trị biến cần lưu trữ .
Làm cách nào để in giá trị biến trong JavaScript?log() là một hàm trong JavaScript được sử dụng để in bất kỳ loại biến nào được xác định trước trong đó hoặc chỉ in bất kỳ thông báo nào cần hiển thị cho người dùng. cú pháp. bảng điều khiển. nhật ký("");
Biến này trong JavaScript là gì?Trong JavaScript, biến “this” là biến mà mọi ngữ cảnh thực thi đều nhận được, trong một lệnh gọi hàm thông thường . Mỗi hàm JavaScript có một tham chiếu đến bối cảnh thực thi hiện tại của nó trong khi thực thi, được gọi là. Bối cảnh thực thi có nghĩa ở đây có nghĩa là cách gọi các chức năng.
Ví dụ về biến JavaScript là gì?Trong JavaScript, chúng ta sử dụng từ khóa var hoặc let để khai báo biến. Ví dụ: var x; . Here, x and y are variables. |
