Các toán tử số học dễ hiểu trong JavaScript

Javascript căn bản | by Học Javascript

Trong lập trình, toán tử số học đóng vai trò quan trọng trong việc xử lý các phép toán liên quan đến số. JavaScript cung cấp một tập hợp các toán tử số học giúp thực hiện các phép tính cơ bản như cộng, trừ, nhân, chia, cũng như các phép toán nâng cao như lũy thừa, chia lấy dư.

Việc hiểu và sử dụng thành thạo các toán tử số học giúp lập trình viên viết các chương trình xử lý dữ liệu một cách hiệu quả. Chẳng hạn, chúng ta có thể sử dụng chúng để tính toán giá trị, thực hiện các phép đo, kiểm tra điều kiện số học, hoặc điều chỉnh giá trị của biến trong vòng lặp.

Trong bài viết này, mình sẽ cùng tìm hiểu chi tiết về các toán tử số học trong JavaScript, cách sử dụng chúng, cũng như những lỗi phổ biến mà lập trình viên có thể gặp phải.

Tại sao cần sử dụng toán tử số học trong lập trình?

Toán tử số học là một phần quan trọng trong lập trình vì chúng giúp thực hiện các phép toán trên dữ liệu số. Trong JavaScript, các toán tử này cho phép chúng ta tính toán, xử lý dữ liệu động, và điều chỉnh giá trị của biến một cách linh hoạt.

Dưới đây là một số lý do chính khiến toán tử số học trở nên quan trọng:

​Thực hiện các phép toán cơ bản

  • Giúp thực hiện các phép toán số học như cộng (+), trừ (-), nhân (*), chia (/), và lũy thừa (**).
  • Ví dụ:
let a = 10;
let b = 5;
console.log(a + b); // Kết quả: 15
console.log(a * b); // Kết quả: 50

Xử lý dữ liệu động

  • Khi làm việc với dữ liệu từ người dùng hoặc từ API, chúng ta thường cần tính toán giá trị trước khi hiển thị hoặc lưu trữ.
  • Ví dụ: Một ứng dụng thương mại điện tử cần tính tổng tiền hàng, áp dụng thuế, hoặc tính toán giảm giá.

Kiểm soát vòng lặp và điều kiện

  • Toán tử số học giúp đếm số lần lặp, điều chỉnh biến trong vòng lặp, và kiểm tra điều kiện số học.
  • Ví dụ:
for (let i = 1; i <= 5; i++) {
    console.log("Lần lặp thứ:", i);
}

Kết quả:

Lần lặp thứ: 1
Lần lặp thứ: 2
Lần lặp thứ: 3
Lần lặp thứ: 4
Lần lặp thứ: 5

Xử lý thời gian và ngày tháng

  • Tính toán thời gian chênh lệch giữa hai ngày.
  • Ví dụ: Tính số ngày còn lại đến một sự kiện.
let today = new Date();
let eventDate = new Date("2025-01-01");
let timeDiff = eventDate - today;
let daysLeft = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));
console.log("Số ngày còn lại:", daysLeft);

Các toán tử số học cơ bản trong JavaScript

Toán tử số học trong JavaScript được sử dụng để thực hiện các phép toán cơ bản trên số. Dưới đây là các toán tử số học quan trọng kèm theo ví dụ minh họa.

Toán tử cộng (+)

Chức năng: Dùng để cộng hai số lại với nhau.

Ví dụ minh họa:

let a = 10;
let b = 5;
let sum = a + b;
console.log("Kết quả của phép cộng:", sum); // Kết quả: 15

Lưu ý:

  • Nếu một trong hai toán hạng là chuỗi, toán tử + sẽ thực hiện nối chuỗi thay vì cộng số.
  • Ví dụ:
let x = "10";
let y = 5;
console.log(x + y); // Kết quả: "105" (chuỗi)

Toán tử trừ (-)

Chức năng: Dùng để trừ số này cho số khác.

Ví dụ minh họa:

let a = 15;
let b = 7;
let difference = a - b;
console.log("Kết quả của phép trừ:", difference); // Kết quả: 8

Lưu ý:

  • Nếu một trong hai toán hạng là chuỗi, JavaScript sẽ tự động chuyển đổi sang số nếu có thể.
  • Ví dụ:
console.log("10" - 2); // Kết quả: 8 (tự động chuyển "10" thành 10)
console.log("abc" - 2); // Kết quả: NaN (vì "abc" không thể chuyển thành số)

Toán tử nhân (*)

Chức năng: Dùng để nhân hai số với nhau.

Ví dụ minh họa:

let a = 6;
let b = 4;
let product = a * b;
console.log("Kết quả của phép nhân:", product); // Kết quả: 24

Lưu ý:

  • Nếu một trong hai toán hạng là chuỗi chứa số, JavaScript sẽ chuyển đổi thành số trước khi thực hiện phép toán.
  • Ví dụ:
console.log("5" * "2"); // Kết quả: 10
console.log("hello" * 2); // Kết quả: NaN (vì "hello" không phải số)

Toán tử chia (/)

Chức năng: Dùng để chia số này cho số khác.

Ví dụ minh họa:

4. Toán Tử Chia (/)
Chức năng: Dùng để chia số này cho số khác.

Ví dụ minh họa:

Lưu ý:

  • Nếu chia cho 0, JavaScript không báo lỗi mà sẽ trả về Infinity.
  • Ví dụ:
console.log(10 / 0); // Kết quả: Infinity
console.log(-10 / 0); // Kết quả: -Infinity

Toán tử chia lấy dư (%)

Chức năng: Trả về phần dư của phép chia.

Ví dụ minh họa:

let a = 10;
let b = 3;
let remainder = a % b;
console.log("Phần dư của phép chia:", remainder); // Kết quả: 1

Ứng dụng thực tế:

  • Kiểm tra xem một số có chia hết cho số khác không.
let number = 15;
if (number % 2 === 0) {
    console.log(number, "là số chẵn");
} else {
    console.log(number, "là số lẻ");
}

Kết quả:

Toán tử lũy thừa ()**

Chức năng: Dùng để tính lũy thừa của một số.

Ví dụ minh họa:

let base = 2;
let exponent = 3;
let result = base ** exponent;
console.log("Kết quả của lũy thừa:", result); // Kết quả: 8

Lưu ý:

  • Toán tử ** tương đương với Math.pow(base, exponent).
  • Ví dụ:
console.log(Math.pow(2, 3)); // Kết quả: 8

Toán tử tăng giảm trong JavaScript

Toán tử tăng (++) và toán tử giảm (--) được sử dụng để tăng hoặc giảm giá trị của một biến số nguyên hoặc số thực lên một đơn vị. Chúng có hai dạng: tiền tố (prefix)hậu tố (postfix), mỗi dạng có cách hoạt động khác nhau.

Toán tử tăng (++)

Chức năng:

Dùng để tăng giá trị của biến lên 1.

Có hai cách sử dụng:

  • Tiền tố (++x): Giá trị của biến được tăng trước khi sử dụng trong biểu thức.
  • Hậu tố (x++): Giá trị của biến được sử dụng trong biểu thức trước, sau đó mới tăng lên 1.

Ví dụ minh họa

Toán tử tăng ở dạng tiền tố (++x)

let a = 5;
let b = ++a; // Tăng a lên 6 trước, sau đó gán vào b
console.log("Giá trị của a:", a); // 6
console.log("Giá trị của b:", b); // 6

Giải thích:

  • ++a tăng a lên 6 trước khi gán giá trị cho b, nên b cũng nhận giá trị 6.

Toán tử tăng ở dạng hậu tố (x++)

let x = 5;
let y = x++; // Gán x vào y trước, sau đó x mới tăng lên 6
console.log("Giá trị của x:", x); // 6
console.log("Giá trị của y:", y); // 5

Giải thích:

x++ gán giá trị hiện tại của x vào y trước (y = 5), sau đó mới tăng x lên 6.

Toán tử giảm (--)

Chức năng:

  • Dùng để giảm giá trị của biến đi 1.
  • Có hai dạng tương tự như toán tử tăng:
    • Tiền tố (--x): Giảm giá trị của biến trước khi sử dụng trong biểu thức.
    • Hậu tố (x--): Sử dụng giá trị của biến trước, sau đó mới giảm đi 1.

Ví dụ minh họa

Toán giảm ở dạng tiền tốt (--x)

let p = 10;
let q = --p; // Giảm p xuống 9 trước, sau đó gán vào q
console.log("Giá trị của p:", p); // 9
console.log("Giá trị của q:", q); // 9

Giải thích:

--p giảm p xuống 9 trước khi gán giá trị cho q, nên q cũng nhận giá trị 9.

Toán tử giảm ở dạng hậu tố (x--)

let m = 10;
let n = m--; // Gán giá trị của m vào n trước, sau đó m giảm xuống 9
console.log("Giá trị của m:", m); // 9
console.log("Giá trị của n:", n); // 10

Giải thích:

m-- gán giá trị hiện tại của m vào n trước (n = 10), sau đó m mới giảm xuống 9.

Sự khác biệt giữ tiền tố và hậu tố

Toán tử Cách hoạt động Ví dụ Giá trị của biến sau phép toán Giá trị được sử dụng trong biểu thức
++x Tăng trước, sử dụng sau let b = ++a; a tăng lên trước, rồi gán vào b b = a + 1
x++ Sử dụng trước, tăng sau let y = x++; x giữ nguyên khi gán vào y, sau đó tăng y = x, x = x + 1
--x Giảm trước, sử dụng sau let q = --p; p giảm trước, rồi gán vào q q = p - 1
x-- Sử dụng trước, giảm sau let n = m--; m giữ nguyên khi gán vào n, sau đó giảm n = m, m = m - 1

Ứng dụng của toán tử tăng giảm

Dùng trong vòng lặp for

for (let i = 0; i < 5; i++) {
    console.log("Giá trị của i:", i);
}

Cách hoạt động:

  • i++ giúp tăng giá trị của i sau mỗi vòng lặp, kiểm soát số lần lặp.

Dùng trong vòng lặp while

let count = 5;
while (count > 0) {
    console.log("Giá trị của count:", count);
    count--; // Giảm count sau mỗi lần lặp
}

Cách hoạt động:

count-- giúp giảm dần count, đến khi đạt giá trị 0 thì vòng lặp dừng lại.

Toán tử gán kết hợp trong JavaScript

Toán tử gán kết hợp trong JavaScript giúp viết các phép toán ngắn gọn và dễ đọc hơn. Chúng kết hợp toán tử gán (=) với các toán tử số học như cộng, trừ, nhân, chia, v.v.

Cộng và gán (+=)

Toán tử += được dùng để cộng một giá trị vào biến hiện cógán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let x = 10;
x += 5; // Tương đương với: x = x + 5;
console.log(x); // Kết quả: 15

Giải thích: x ban đầu là 10, sau khi thực hiện x += 5, giá trị mới của x15.

Trừ và gán (-=)

Toán tử -= được dùng để trừ một giá trị khỏi biến hiện cógán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let y = 20;
y -= 7; // Tương đương với: y = y - 7;
console.log(y); // Kết quả: 13

Giải thích: y ban đầu là 20, sau khi thực hiện y -= 7, giá trị mới của y13.

Nhân và gán (*=)

Toán tử *= được dùng để nhân biến với một giá trị khácgán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let a = 4;
a *= 3; // Tương đương với: a = a * 3;
console.log(a); // Kết quả: 12

Giải thích: a ban đầu là 4, sau khi thực hiện a *= 3, giá trị mới của a12.

Chia và gán (/=)

Toán tử /= được dùng để chia biến cho một giá trị khácgán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let b = 20;
b /= 4; // Tương đương với: b = b / 4;
console.log(b); // Kết quả: 5

Giải thích: b ban đầu là 20, sau khi thực hiện b /= 4, giá trị mới của b5.

Chia lấy dư và gán (%=)

Toán tử %= được dùng để tính phần dư của phép chia biến cho một số khácgán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let c = 17;
c %= 5; // Tương đương với: c = c % 5;
console.log(c); // Kết quả: 2

Giải thích: 17 chia cho 5 được thương 32, nên c nhận giá trị mới là 2.

Lũy thừa và gán (**=)

Toán tử **= được dùng để tính lũy thừa của biến với một số khácgán lại giá trị mới cho biến đó.

Ví dụ minh họa:

let d = 3;
d **= 4; // Tương đương với: d = d ** 4;
console.log(d); // Kết quả: 81

Giải thích: 3 lũy thừa 4 bằng 81, nên d nhận giá trị mới là 81.

Tổng hợp tất cả toán tử gán kết hợp

Toán tử Mô tả Ví dụ Tương đương với Kết quả
+= Cộng và gán x += 5; x = x + 5; Nếu x = 10, thì x = 15
-= Trừ và gán y -= 7; y = y - 7; Nếu y = 20, thì y = 13
*= Nhân và gán a *= 3; a = a * 3; Nếu a = 4, thì a = 12
/= Chia và gán b /= 4; b = b / 4; Nếu b = 20, thì b = 5
%= Chia lấy dư và gán c %= 5; c = c % 5; Nếu c = 17, thì c = 2
**= Lũy thừa và gán d **= 4; d = d ** 4; Nếu d = 3, thì d = 81

Ứng dụng của toán tử gán kết hợp

Dùng trong vòng lặp

Toán tử gán kết hợp rất hữu ích khi sử dụng trong vòng lặp, giúp rút gọn cú pháp và cải thiện hiệu suất chương trình.

Ví dụ với vòng lặp for

for (let i = 1; i <= 5; i++) {
    let result = 1;
    result *= i; // Tương đương với: result = result * i;
    console.log("Lần lặp", i, "=>", result);
}

Giải thích:

  • Trong mỗi lần lặp, result được nhân với i và lưu lại giá trị mới.

Ví dụ với vòng lặp while

let n = 10;
while (n > 1) {
    n -= 2; // Tương đương với: n = n - 2;
    console.log("Giá trị n:", n);
}

Giải thích:

  • n giảm dần mỗi lần lặp cho đến khi nhỏ hơn 1, giúp kiểm soát số lần lặp hiệu quả.

Ứng dụng thực tế của toán tử số học trong JavaScript

Toán tử số học trong JavaScript được sử dụng rộng rãi trong nhiều bài toán thực tế. Dưới đây là một số ứng dụng phổ biến của các toán tử này trong lập trình.

Tính tổng, hiệu, tích, thương của hai số

Chúng ta có thể sử dụng các toán tử cộng (+), trừ (-), nhân (*), và chia (/) để thực hiện các phép tính cơ bản.

Ví dụ minh họa:

function calculate(a, b) {
    console.log("Tổng:", a + b);
    console.log("Hiệu:", a - b);
    console.log("Tích:", a * b);
    console.log("Thương:", a / b);
}

calculate(10, 5);
// Kết quả:
// Tổng: 15
// Hiệu: 5
// Tích: 50
// Thương: 2

Giải thích:

  • a + b: Cộng hai số.
  • a - b: Trừ số thứ hai khỏi số thứ nhất.
  • a * b: Nhân hai số.
  • a / b: Chia số thứ nhất cho số thứ hai.

Lưu ý:

  • Nếu b = 0, phép chia sẽ gây ra lỗi Infinity. Cần kiểm tra trước khi chia.

Ví dụ kiểm tra trước khi chia:

function safeDivide(a, b) {
    if (b === 0) {
        console.log("Lỗi: Không thể chia cho 0!");
        return;
    }
    console.log("Thương:", a / b);
}

safeDivide(10, 0); // Kết quả: Lỗi: Không thể chia cho 0!

Kiểm tra số chẵn/lẻ bằng toán tử %

Toán tử chia lấy dư (%) giúp kiểm tra xem một số có chia hết cho 2 hay không.

Ví dụ minh họa:

function isEvenOrOdd(number) {
    if (number % 2 === 0) {
        console.log(number + " là số chẵn.");
    } else {
        console.log(number + " là số lẻ.");
    }
}

isEvenOrOdd(10); // Kết quả: 10 là số chẵn.
isEvenOrOdd(7);  // Kết quả: 7 là số lẻ.

Giải thích:

  • Nếu number % 2 === 0, tức là số chia hết cho 2, đó là số chẵn.
  • Nếu number % 2 !== 0, tức là số không chia hết cho 2, đó là số lẻ.

Kết bài

Toán tử số học trong JavaScript là một phần quan trọng trong lập trình, giúp thực hiện các phép toán cơ bản như cộng, trừ, nhân, chia, lũy thừa, và chia lấy dư. Chúng không chỉ được sử dụng trong các phép tính đơn giản mà còn đóng vai trò quan trọng trong các cấu trúc điều kiện, vòng lặp và xử lý dữ liệu.

Việc hiểu rõ cách hoạt động của từng toán tử sẽ giúp lập trình viên tránh được những lỗi thường gặp và tối ưu hóa mã nguồn. Đồng thời, việc kết hợp toán tử số học với các tính năng khác của JavaScript sẽ giúp bạn viết các chương trình linh hoạt, hiệu quả hơn.

Hy vọng bài viết này đã giúp bạn có cái nhìn tổng quan và nắm vững cách sử dụng các toán tử số học trong JavaScript một cách dễ hiểu nhất!

Bài viết liên quan

  • 2