Các nhà khai thác JavaScript phong phú như những gì bạn mong đợi từ bất kỳ ngôn ngữ hiện đại nào. Có bốn loại: số học, so sánh, gán và logic.arithmetic, comparison, assignment, and logical.
Toán tử số học
Các toán tử số học thực hiện các tính toán cơ bản trên toán hạng của chúng [các biến chúng hoạt động]. Trong bảng dưới đây, biến
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity2 có giá trị 2 trước khi hoạt động được áp dụng.
+ | cộng | 2 + a | 4 |
- | Chất nền | 2 - a | 0 |
* | nhân | 3 * a | 6 |
/ | Chia | 3 / a | 1.5 |
Phần trăm | Mô đun - Phần còn lại của phân chia | 7 % a | 1 |
++ | Tăng - Tăng thêm 1 | A ++ | 3 |
- | Giảm - giảm 1 | một-- | 1 |
Toán tử chuỗi
#
Toán tử + được sử dụng để thêm các giá trị số, nhưng nó cũng có thể được sử dụng để kết hợp [tham gia] hai hoặc nhiều chuỗi và trả về một chuỗi. Đây là một ví dụ:
var str1 = "Hello";
var str2 = " Vivek";
str1 = str1 + str2; // => "Hello Vivek"
console.log[str1];
Câu lệnh cuối cùng cũng có thể được viết lại bằng cách sử dụng toán tử gán += như sau:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
Toán tử so sánh
Các toán tử so sánh so sánh giá trị của hai toán hạng. Nếu so sánh là đúng, họ sẽ trả về đúng, nếu không thì sai. Trong bảng bên dưới các biến là:
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity3 và
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity4.
+ | cộng | 2 + a | - |
Chất nền | 2 - a | * | nhân |
3 * a | / | Chia | nhân |
3 * a | / | Chia | - |
Chất nền | 2 - a | * | nhân |
3 * a | / | Chia | - |
Chất nền
2 - a
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity3,
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity4, and
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity7.
* | nhân | 3 * a |
/ | Chia | 3 / a |
Phần trăm | Mô đun - Phần còn lại của phân chia | 7 % a |
++ | Tăng - Tăng thêm 1 | A ++ |
- | Giảm - giảm 1 | một-- |
Toán tử chuỗi | # | Toán tử + được sử dụng để thêm các giá trị số, nhưng nó cũng có thể được sử dụng để kết hợp [tham gia] hai hoặc nhiều chuỗi và trả về một chuỗi. Đây là một ví dụ: |
Câu lệnh cuối cùng cũng có thể được viết lại bằng cách sử dụng toán tử gán += như sau:
Toán tử so sánh
Các toán tử so sánh so sánh giá trị của hai toán hạng. Nếu so sánh là đúng, họ sẽ trả về đúng, nếu không thì sai. Trong bảng bên dưới các biến là: 10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity3 và 10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity4. | == | Tương đương với | a == b |
sai | ! = | Không bằng | A! = B |
thật | Logical not. Unary operator that simply inverts the boolean value of its operand. | Ít hơn bằng | một |
> =
Lớn hơn hoặc bằng
a> = b
Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity
Ít hơn
a Nan. 0 / 0; // => Nan. "Hello" / 1; // => Nan. "Hello" cannot be converted to number Math.sqrt[-1]; // => Nan. NaN / 0; // => Nan. Any operation with NaN results in NaN
>
Lớn hơn
a> b
var profit = NaN; if [isNaN[profit]] { profit = 0; }
Thay vì sử dụng
Infinity / Infinity; // => Nan. 0 / 0; // => Nan. "Hello" / 1; // => Nan. "Hello" cannot be converted to number Math.sqrt[-1]; // => Nan. NaN / 0; // => Nan. Any operation with NaN results in NaN6, cách tiếp cận tốt hơn sẽ là sử dụng hàm tích hợp
Infinity / Infinity; // => Nan. 0 / 0; // => Nan. "Hello" / 1; // => Nan. "Hello" cannot be converted to number Math.sqrt[-1]; // => Nan. NaN / 0; // => Nan. Any operation with NaN results in NaN8 để xác định xem có thể sử dụng giá trị làm số hay không. Hàm này kiểm tra cả vô cực và NAN. Trước khi gọi
Infinity / Infinity; // => Nan. 0 / 0; // => Nan. "Hello" / 1; // => Nan. "Hello" cannot be converted to number Math.sqrt[-1]; // => Nan. NaN / 0; // => Nan. Any operation with NaN results in NaN8 Đảm bảo rằng giá trị được truyền thực sự là một số, như vậy:
var isNumber = function [val] {
if [typeof val === "number"] {
return isFinite[val];
}
return false;
}
var n = 3.6;
console.log[isNumber[n]]; // => true
n = NaN;
console.log[isNumber[n]]; // => false
n = Infinity;
console.log[isNumber[n]]; // => false
JavaScript làm tròn
Về độ chính xác số, JavaScript có thể không cung cấp cho bạn các giá trị chính xác mà bạn mong đợi.
0.119 / 100; // => evaluates to 0.0011899999999999999 0.14 / 100; // => evaluates to 0.0014000000000000002
Lý do cho các quyết định làm tròn này là JavaScript sử dụng định dạng điểm nổi nhị phân cho số. Các biểu diễn điểm nổi nhị phân có thể biểu diễn chính xác các phân số như 1/16 và 1/32, 1/64, 1/128, nhưng không phải là các phân số như 1/100, 1/10 rất phổ biến trong các tính toán tiền tệ. Điều này có thể gây ra một số hạn chế làm tròn như các ví dụ dưới đây:
var diff1 = .5 - .4; // => 0.09999999999999998
var diff2 = .4 - .3; // => 0.10000000000000003
console.log[diff1 == diff2]; // => false, the values are not the same
Tuyên bố cuối cùng có thể khá là không thành công. Cả
var profit = NaN; if [isNaN[profit]] { profit = 0; }0 và
var profit = NaN; if [isNaN[profit]] { profit = 0; }1 đều rất gần với .1, nhưng không chính xác. Vì vậy, hãy nhận biết các biểu diễn số nội bộ của JavaScript.
Các nhà khai thác ++ và -
Trong ngôn ngữ C, việc sao chép một chuỗi thường được mã hóa dưới dạng một lớp sau:
while [*str1++ = *str2++];
Mã này có xu hướng khó khăn và gây nhầm lẫn cho các nhà phát triển không quá quen thuộc với bản chất 'trước' và 'sau' của các toán tử tăng và giảm. Mặc dù JavaScript không hỗ trợ con trỏ, nhưng sự khó khăn của ++ và - các nhà khai thác là thứ sẽ cần phải được xem xét cẩn thận. Ví dụ, ngay cả một lập trình viên JavaScript có kinh nghiệm cũng sẽ cần một chút thời gian để tìm ra câu lệnh sau đây:
var m = 7;
m = m++ + --m;
console.log[m] // what is the value of m?
Rõ ràng, điều này làm cho mã phức tạp không cần thiết và khó hiểu. Tốt nhất là sử dụng các toán tử ++ và - trên một dòng giúp tăng cường khả năng đọc chương trình. Ví dụ:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
0Bất cứ điều gì ngoài đó có thể gây nhầm lẫn; Cơ hội làm lỗi chính tả là cao.
Tuy nhiên, các vòng lặp JavaScript có thể sử dụng một cách an toàn các toán tử gia tăng trong vòng lặp vì đó là thông lệ tiêu chuẩn và thường không gây nhầm lẫn.
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
1Nếu bạn thu nhỏ mã JavaScript, hãy rất cẩn thận khi sử dụng các toán tử ++ và -. Tối thiểu hóa loại bỏ khoảng trắng không cần thiết và nhận xét từ mã JavaScript của bạn. Ví dụ, nó có thể dịch
var profit = NaN; if [isNaN[profit]] { profit = 0; }2 thành
var profit = NaN; if [isNaN[profit]] { profit = 0; }3. Trình biên dịch sau đó coi biểu thức kết quả là
var profit = NaN; if [isNaN[profit]] { profit = 0; }4 không chính xác. May mắn thay, điều này dễ dàng được sửa chữa bằng cách thêm dấu ngoặc đơn như vậy:
var profit = NaN; if [isNaN[profit]] { profit = 0; }5. Vì vậy, bài học ở đây là luôn luôn thêm dấu ngoặc đơn để làm cho ý định của bạn rõ ràng.
var profit = NaN; if [isNaN[profit]] { profit = 0; }4 which is incorrect. Fortunately, this is easily corrected by adding parentheses like
so:
var profit = NaN; if [isNaN[profit]] { profit = 0; }5. So the lesson here is to always add parenthesis to make your intentions clear.
Đó cũng là một thông lệ tốt để chạy JSLINT trước khi thu nhỏ mã của bạn, vì nó kiểm tra những vấn đề này và các vấn đề tiềm năng khác liên quan đến các nhà khai thác ++ và -.
Toán tử == và ===
Toán tử
var profit = NaN; if [isNaN[profit]] { profit = 0; }6 so sánh các giá trị của các toán hạng của nó. Nếu giá trị của chúng bằng nhau, nó trả về đúng. Nếu các toán hạng có các loại dữ liệu khác nhau, JavaScript sẽ cố gắng chuyển đổi chúng thành một loại thích hợp thì hãy so sánh các giá trị của chúng. Xem xét điều này:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
2Ở đây chuỗi "1" được so sánh với số 1. JavaScript chuyển đổi chữ số chuỗi thành một giá trị số. Vì chúng bằng nhau, nó trả về đúng. Còn cái này thì sao:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
3Điều này trả về đúng. Trong trường hợp này, cả hai toán hạng được chuyển đổi thành số. Các giá trị true boolean được chuyển đổi thành 1 và false thành 0. và chuỗi "0" được chuyển đổi thành số 0. sau các chuyển đổi JavaScript so sánh 0 == 0 và trả về true.
Dưới đây là một vài trường hợp nữa:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
4Trong biểu thức cuối cùng, các giá trị ASCII cho các số thấp hơn các giá trị cho các chữ cái, trả về đúng.
Các quy tắc chuyển đổi dữ liệu với toán tử
var profit = NaN; if [isNaN[profit]] { profit = 0; }6 rất phức tạp và khó nhớ. Điều này có thể dễ dàng dẫn đến lỗi. May mắn thay, JavaScript cung cấp một giải pháp thay thế, được gọi là toán tử bình đẳng nghiêm ngặt [
var profit = NaN; if [isNaN[profit]] { profit = 0; }8] không chuyển đổi dữ liệu khi kiểm tra bình đẳng. Nó chỉ trả về đúng khi 1] các toán hạng được so sánh có cùng loại và 2] giá trị của chúng giống nhau. Dưới đây là một số ví dụ:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
5Nếu cả hai toán hạng là đối tượng và nếu chúng đề cập đến cùng một đối tượng, thì JavaScript trả về đúng. Hãy xem cách này hoạt động với các mảng: mảng:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
6Ở đây
var profit = NaN; if [isNaN[profit]] { profit = 0; }9 trả về sai, vì họ tham khảo các mảng khác nhau. So sánh nghiêm ngặt
var isNumber = function [val] {
if [typeof val === "number"] {
return isFinite[val];
}
return false;
}
var n = 3.6;
console.log[isNumber[n]]; // => true
n = NaN;
console.log[isNumber[n]]; // => false
n = Infinity;
console.log[isNumber[n]]; // => false
0 cũng trả về sai vì, mặc dù chúng có cùng giá trị, đây là hai mảng khác nhau trong bộ nhớ.Như trong nhiều ngôn ngữ khác, các chuỗi JavaScript có nghĩa là nội dung của một đối tượng chuỗi không thể thay đổi sau khi đối tượng được tạo, mặc dù cú pháp làm cho nó xuất hiện như thể bạn có thể làm điều này. Hãy xem điều này ảnh hưởng đến hoạt động
var profit = NaN; if [isNaN[profit]] { profit = 0; }6 và
var profit = NaN; if [isNaN[profit]] { profit = 0; }8 như thế nào:
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
7Ở đây
var isNumber = function [val] {
if [typeof val === "number"] {
return isFinite[val];
}
return false;
}
var n = 3.6;
console.log[isNumber[n]]; // => true
n = NaN;
console.log[isNumber[n]]; // => false
n = Infinity;
console.log[isNumber[n]]; // => false
3 và var isNumber = function [val] {
if [typeof val === "number"] {
return isFinite[val];
}
return false;
}
var n = 3.6;
console.log[isNumber[n]]; // => true
n = NaN;
console.log[isNumber[n]]; // => false
n = Infinity;
console.log[isNumber[n]]; // => false
4 Tham chiếu chuỗi "Hello World" bất biến và do đó cả var profit = NaN; if [isNaN[profit]] { profit = 0; }6 và
var profit = NaN; if [isNaN[profit]] { profit = 0; }8 trả về đúng.
Làm thế nào về việc so sánh các đối tượng chuỗi được tạo với hàm tạo chuỗi và với một chuỗi theo nghĩa đen?
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
8Toán tử
var profit = NaN; if [isNaN[profit]] { profit = 0; }6 chuyển đổi các đối tượng này ở hai bên thành cùng loại và sau đó trả về đúng vì các giá trị của chúng giống nhau. Toán tử
var profit = NaN; if [isNaN[profit]] { profit = 0; }8 hiểu rằng các đối tượng không thuộc cùng loại và do đó ngay lập tức trả về sai mà không nhìn vào giá trị của chúng.
Các nhà khai thác bitwise
Bảng dưới đây tóm tắt các toán tử bitwise trong JavaScript:
Bitwise và | a & b | Trả về 1 cho mỗi vị trí bit trong đó cả hai toán hạng là 1 |
Bitwise hoặc | A | b | Trả về 1 cho mỗi vị trí bit trong đó một trong hai toán hạng là 1 |
BitWise XOR | a ^ b | Trả về 1 cho mỗi vị trí bit trong đó nhưng không phải cả hai là 1 |
Dịch trái | a > b | Sự thay đổi trong thời trang nhị phân Tất cả các bit một vị trí sang bên phải, loại bỏ đúng bit. Hoạt động này duy trì dấu hiệu ban đầu [+ hoặc -]. |
0 Chất thay đổi bên phải | a >>> b | Thay đổi theo kiểu nhị phân Tất cả các bit một vị trí sang phải, loại bỏ bit bên phải và lấp đầy bit bên trái bằng 0. |
JavaScript không hỗ trợ một loại số nguyên. Tất cả các số trong JavaScript được lưu trữ ở định dạng điểm nổi 64 bit, tức là điểm nổi chính xác gấp đôi. Các toán tử bitwise thao tác các số ở cấp độ bit không thực hiện các thao tác trực tiếp trên biểu diễn điểm nổi 64 bit này. Thay vào đó, họ ép buộc các giá trị số thành các số nguyên đã ký 32 bit, thực hiện thao tác cần thiết và một lần nữa chuyển đổi kết quả trở lại định dạng điểm nổi. Chuyển đổi này có tác động hiệu suất.
Bạn nhận được kết quả chính xác chỉ với tối đa 32 bit. Trong quá trình chuyển đổi thành 32 bit, phần phân số và bất kỳ bit nào ngoài phần thứ 32 đều bị loại bỏ. Nếu bạn có nhiều bit hơn thế, giá trị sẽ được làm tròn đến số điểm nổi có thể đại diện gần nhất.
var str1 = "Hello";
var str2 = " Vivek";
str1 += str2; // => "Hello Vivek"
console.log[str1];
9Bạn có thể mong đợi rằng giá trị của C có tất cả 36 bit được đặt thành 1 sau BitWise & Hoạt động, nhưng vì việc chuyển đổi thành 32 bit không phải là trường hợp. JavaScript chuyển đổi thành 32 bit, thực hiện bitwise và hoạt động và kết quả 32 bit đều được đặt thành 1 tương đương với -1.
Chúng ta hãy xem một ví dụ với số điểm nổi:
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity0
Thật kỳ lạ, nếu bạn sử dụng
var isNumber = function [val] {
if [typeof val === "number"] {
return isFinite[val];
}
return false;
}
var n = 3.6;
console.log[isNumber[n]]; // => true
n = NaN;
console.log[isNumber[n]]; // => false
n = Infinity;
console.log[isNumber[n]]; // => false
9nan, 0.119 / 100; // => evaluates to 0.0011899999999999999 0.14 / 100; // => evaluates to 0.00140000000000000020 hoặc
0.119 / 100; // => evaluates to 0.0011899999999999999 0.14 / 100; // => evaluates to 0.00140000000000000021 làm toán tử trong các hoạt động bitwise, chúng được chuyển đổi thành 0.
Trong tất cả các ngôn ngữ giống như C, các toán tử bitwise cực kỳ nhanh. Cho đến gần đây, chúng chậm trong JavaScript nhưng các phiên bản mới nhất của trình duyệt web có thể mã JavaScript JIT. Các hoạt động này đã tăng tốc đủ để trở nên hữu ích.
Các thao tác bitwise thường gần với phần cứng và do đó chúng không xuất hiện rất thường xuyên trong chương trình JavaScript.
Một sai lầm phổ biến để sử dụng bitwise & và | toán tử thay vì logic && và || người vận hành. Điều này có thể dẫn đến các lỗi khó phát hiện. Đây là những gì có thể xảy ra. Giả sử chúng ta có một biến x với giá trị 5 và bạn đã gõ nhầm và thay vì &&.
10 / 0; // => Infinity -10 / 0; // => -Infinity 2 / +0; // => +Infinity 2 / -0; // => -Infinity1
Điều này là sai, giống nhau nếu bạn đã nhập toán tử && toán tử:
0.119 / 100; // => evaluates to 0.0011899999999999999 0.14 / 100; // => evaluates to 0.00140000000000000022. Mặc dù chúng tôi đang nhận được kết quả mong đợi, chúng tôi đã sử dụng không đúng cách một nhà điều hành logic & chỉ dành cho các hoạt động cấp độ bit. Một lần nữa, hãy lưu ý về sai lầm này vì nó có thể dẫn đến khó tìm lỗi.
Kiếm thu nhập với kỹ năng JavaScript của bạn with your JavaScript skills
Đăng ký và chúng tôi sẽ gửi cho bạn các cơ hội tự do tốt nhất đến hộp thư đến của bạn. Chúng tôi đang xây dựng thị trường tự do tự phục vụ lớn nhất cho những người như bạn.
We're building the largest self-service freelancing marketplace for people like
you.
- Hướng dẫn CSS
- Bộ chọn CSS
- Biên giới CSS
- CSS Flex
- Lưới CSS
- Bảng CSS
- Đơn vị CSS
- Phông chữ CSS
- Hoạt hình CSS
- CSS di chuột
- Hình ảnh CSS
- CSS bình luận