Hướng dẫn how many types of operators are there in javascript - có bao nhiêu loại toán tử trong javascript

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;         // => -Infinity

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;         // => -Infinity

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

Chất nền

2 - a

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

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

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

> =

Lớn hơn hoặc bằng

a> = b

<

10 / 0;         // =>  Infinity
-10 / 0;        // => -Infinity
2 / +0;         // => +Infinity
2 / -0;         // => -Infinity

Ít hơn

a

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

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 NaN

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 NaN

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

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

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

Bấ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);

Nế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;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

Đó 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;
}

var str1 = "Hello";
var str2 = " Vivek";

str1 += str2;              // => "Hello Vivek"
console.log(str1);

Ở đâ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);

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

Trong 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;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var str1 = "Hello";
var str2 = " Vivek";

str1 += str2;              // => "Hello Vivek"
console.log(str1);

Nế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);

Ở đây

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

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

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

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var str1 = "Hello";
var str2 = " Vivek";

str1 += str2;              // => "Hello Vivek"
console.log(str1);

Ở đâ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

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

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

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

Toán tử

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

var profit = NaN;
if (isNaN(profit)) {
    profit = 0;
}

Các nhà khai thác bitwise

Bảng dưới đây tóm tắt các toán tử bitwise trong JavaScript:

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

Bạ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;         // => -Infinity

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

0.119 / 100;    // => evaluates to 0.0011899999999999999
0.14 / 100;     // => evaluates to 0.0014000000000000002

0.119 / 100;    // => evaluates to 0.0011899999999999999
0.14 / 100;     // => evaluates to 0.0014000000000000002

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;         // => -Infinity

Đ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.0014000000000000002

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

Có bao nhiêu loại toán tử JavaScript?

4 loại toán tử JavaScript là gì?

7 toán tử JavaScript phổ biến nhất là gì?

Có bao nhiêu loại vận hành?