[Golang] Phần 11 – Go Operators | Wiki của Hà Đăng Hoàng

1. Tổng quan.

Trong ngôn ngữ lập trình Go, operators (toán tử) được sử dụng để thực hiện các phép toán trên các biến và giá trị.

Các loại toán tử khác nhau có ý nghĩa và chức năng khác nhau.

Dưới đây là một tóm tắt ý nghĩa của các loại toán tử chính trong Go:

Arithmetic Operators (Toán tử số học):
- +: Thực hiện phép cộng.
- -: Thực hiện phép trừ.
- *: Thực hiện phép nhân.
- /: Thực hiện phép chia.
- %: Trả về phần dư của phép chia.
Assignment Operators (Toán tử gán):
- =: Gán giá trị từ phía bên phải sang biến ở bên trái.
- +=, -=, *=, /=, %=: Thực hiện phép toán và gán giá trị.
Comparison Operators (Toán tử so sánh):
- ==: So sánh bằng.
- !=: So sánh không bằng.
- >, <: So sánh lớn hơn và nhỏ hơn.
- >=, <=: So sánh lớn hơn hoặc bằng và nhỏ hơn hoặc bằng.
Logical Operators (Toán tử logic):
- &&: Logical AND (Và logic).
- ||: Logical OR (Hoặc logic).
- !: Logical NOT (Phủ định logic).
Bitwise Operators (Toán tử bitwise):
- &: AND bitwise (Và bitwise).
- |: OR bitwise (Hoặc bitwise).
- ^: XOR bitwise (XOR bitwise).
- <<: Zero fill left shift (Dịch sang trái và điền số 0).
- >>: Signed right shift (Dịch sang phải với giữ nguyên dấu).

Các toán tử này cho phép lập trình viên thực hiện các phép toán và so sánh giữa các giá trị, điều này làm nền tảng cho việc xây dựng các logic và tính toán trong chương trình Go.

2. Toán tử thao tác các biến và giá trị.

Cộng các giá trị với nhau.

package main

import "fmt"

func main() {
  // Sử dụng toán tử + để cộng hai giá trị
  var a = 15 + 25

  // In ra kết quả
  fmt.Println(a)  // Kết quả: 40
}

Trong ví dụ trên, biến a được gán giá trị là tổng của hai giá trị 15 và 25 sử dụng toán tử +. Khi chúng ta in giá trị của a kết quả sẽ là 40.

Cộng các biến với nhau.

Toán tử + trong Go không chỉ được sử dụng để cộng hai giá trị cố định mà còn có thể được sử dụng để cộng các biến với nhau hoặc cộng biến với giá trị.

package main

import "fmt"

func main() {
  // Khai báo các biến và thực hiện các phép cộng
  var (
    sum1 = 100 + 50    // 150 (100 + 50)
    sum2 = sum1 + 250  // 400 (150 + 250)
    sum3 = sum2 + sum2 // 800 (400 + 400)
  )

  // In ra kết quả
  fmt.Println(sum3)  // Kết quả: 800
}

Trong ví dụ trên, chúng ta có ba biến sum1, sum2, và sum3. Biến sum1 được khởi tạo bằng tổng của hai giá trị 100 và 50. Biến sum2 được khởi tạo bằng tổng của sum1 và 250. Biến sum3 được khởi tạo bằng tổng của sum2 và sum2. Kết quả của sum3 là 800.

3. Toán tử số học.

Addition (+): Thực hiện phép cộng giữa hai giá trị.

x + y

Subtraction (-): Thực hiện phép trừ giữa hai giá trị.

x - y

Multiplication (*): Thực hiện phép nhân giữa hai giá trị.

x * y

Division (/): Thực hiện phép chia giữa hai giá trị.

x / y

Modulus (%): Trả về phần dư của phép chia giữa hai giá trị.

x % y

Increment (++): Tăng giá trị của biến lên 1.

x++

Decrement (--): Giảm giá trị của biến đi 1.

x--

Dưới đây là một ví dụ minh họa sử dụng các toán tử số học:

package main

import "fmt"

func main() {
  // Khai báo và sử dụng các biến
  x := 10
  y := 5

  // Các phép toán số học
  addition := x + y
  subtraction := x - y
  multiplication := x * y
  division := x / y
  modulus := x % y

  // In ra kết quả
  fmt.Println("Addition:", addition)
  fmt.Println("Subtraction:", subtraction)
  fmt.Println("Multiplication:", multiplication)
  fmt.Println("Division:", division)
  fmt.Println("Modulus:", modulus)

  // Sử dụng toán tử ++ và --
  x++
  y--
  fmt.Println("Increment x:", x)
  fmt.Println("Decrement y:", y)
}

Kết quả thực thi sẽ hiển thị các giá trị của các phép toán số học và giá trị tăng/giảm của biến:

Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2
Modulus: 0
Increment x: 11
Decrement y: 4

4. Toán tử gán.

Đưới đây là một danh sách các toán tử gán trong Go:

=: Toán tử gán, gán giá trị bên phải cho biến bên trái.

x = 5

+=: Toán tử cộng thêm và gán, thêm giá trị bên phải vào giá trị hiện tại của biến bên trái.

x += 3

-=: Toán tử trừ và gán, trừ giá trị bên phải khỏi giá trị hiện tại của biến bên trái.

x -= 3

*=: Toán tử nhân và gán, nhân giá trị hiện tại của biến bên trái với giá trị bên phải.

x *= 3

/=: Toán tử chia và gán, chia giá trị hiện tại của biến bên trái cho giá trị bên phải.

x /= 3

%=: Toán tử phần dư và gán, gán giá trị hiện tại của biến bên trái là phần dư khi chia cho giá trị bên phải.

x %= 3

&=: Toán tử AND bitwise và gán, thực hiện AND bitwise giữa giá trị hiện tại của biến bên trái và giá trị bên phải, sau đó gán kết quả cho biến bên trái.

x &= 3

|=: Toán tử OR bitwise và gán, thực hiện OR bitwise giữa giá trị hiện tại của biến bên trái và giá trị bên phải, sau đó gán kết quả cho biến bên trái.

x |= 3

^=: Toán tử XOR bitwise và gán, thực hiện XOR bitwise giữa giá trị hiện tại của biến bên trái và giá trị bên phải, sau đó gán kết quả cho biến bên trái.

x ^= 3

>>=: Toán tử dịch phải và gán, dịch phải giá trị hiện tại của biến bên trái cho số lượng bit được xác định bởi giá trị bên phải, sau đó gán kết quả cho biến bên trái.

x >>= 3

<<=: Toán tử dịch trái và gán, dịch trái giá trị hiện tại của biến bên trái cho số lượng bit được xác định bởi giá trị bên phải, sau đó gán kết quả cho biến bên trái.

x <<= 3

Mỗi toán tử này thực hiện một phép toán và gán giá trị kết quả cho biến bên trái.

Ví dụ 1 – Toán tử gán (=) được sử dụng để gán giá trị cho biến trong Go.

package main

import "fmt"

func main() {
  // Sử dụng toán tử gán để gán giá trị 10 cho biến x
  var x = 10

  // In ra giá trị của biến x
  fmt.Println(x)  // Kết quả: 10
}

Trong ví dụ trên, toán tử = được sử dụng để gán giá trị 10 cho biến x. Sau đó, chúng ta in ra giá trị của biến x, kết quả là 10.

Ví dụ 2 – Đây là một ví dụ tổng hợp sử dụng các toán tử gán.

package main

import "fmt"

func main() {
  // Khởi tạo biến x và y
  var x, y int

  // Toán tử gán (=)
  x = 5
  fmt.Println("x =", x)  // Kết quả: x = 5

  // Toán tử cộng thêm và gán (+=)
  x += 3
  fmt.Println("x += 3:", x)  // Kết quả: x += 3: 8

  // Toán tử trừ và gán (-=)
  x -= 2
  fmt.Println("x -= 2:", x)  // Kết quả: x -= 2: 6

  // Toán tử nhân và gán (*=)
  x *= 2
  fmt.Println("x *= 2:", x)  // Kết quả: x *= 2: 12

  // Toán tử chia và gán (/=)
  x /= 3
  fmt.Println("x /= 3:", x)  // Kết quả: x /= 3: 4

  // Toán tử phần dư và gán (%=)
  x %= 2
  fmt.Println("x %= 2:", x)  // Kết quả: x %= 2: 0

  // Toán tử AND bitwise và gán (&=)
  y = 7
  x &= y
  fmt.Println("x &= 7:", x)  // Kết quả: x &= 7: 0

  // Toán tử OR bitwise và gán (|=)
  x |= 3
  fmt.Println("x |= 3:", x)  // Kết quả: x |= 3: 3

  // Toán tử XOR bitwise và gán (^=)
  x ^= 5
  fmt.Println("x ^= 5:", x)  // Kết quả: x ^= 5: 6

  // Toán tử dịch phải và gán (>>=)
  x >>= 1
  fmt.Println("x >>= 1:", x)  // Kết quả: x >>= 1: 3

  // Toán tử dịch trái và gán (<<=)
  x <<= 2
  fmt.Println("x <<= 2:", x)  // Kết quả: x <<= 2: 12
}

5. Toán tử gán cộng thêm.

Toán tử gán cộng thêm (+=) được sử dụng để thêm giá trị vào biến trong Go.

package main

import "fmt"

func main() {
  // Khởi tạo biến x và thực hiện phép cộng thêm
  var x = 10
  x += 5

  // In ra giá trị của biến x
  fmt.Println(x)  // Kết quả: 15
}

Trong ví dụ trên, biến x được khởi tạo với giá trị là 10, sau đó chúng ta sử dụng toán tử += để thêm 5 vào giá trị của x. Kết quả là giá trị của x sau phép toán là 15. Mỗi toán tử này thực hiện một phép toán và gán giá trị kết quả cho biến bên trái.

Dưới đây là một ví dụ tổng hợp sử dụng các toán tử gán trong Go:

package main

import "fmt"

func main() {
  // Khởi tạo biến x và y
  var x, y int

  // Toán tử gán (=)
  x = 5
  fmt.Println("x =", x)  // Kết quả: x = 5

  // Toán tử cộng thêm và gán (+=)
  x += 3
  fmt.Println("x += 3:", x)  // Kết quả: x += 3: 8

  // Toán tử trừ và gán (-=)
  x -= 2
  fmt.Println("x -= 2:", x)  // Kết quả: x -= 2: 6

  // Toán tử nhân và gán (*=)
  x *= 2
  fmt.Println("x *= 2:", x)  // Kết quả: x *= 2: 12

  // Toán tử chia và gán (/=)
  x /= 3
  fmt.Println("x /= 3:", x)  // Kết quả: x /= 3: 4

  // Toán tử phần dư và gán (%=)
  x %= 2
  fmt.Println("x %= 2:", x)  // Kết quả: x %= 2: 0

  // Toán tử AND bitwise và gán (&=)
  y = 7
  x &= y
  fmt.Println("x &= 7:", x)  // Kết quả: x &= 7: 0

  // Toán tử OR bitwise và gán (|=)
  x |= 3
  fmt.Println("x |= 3:", x)  // Kết quả: x |= 3: 3

  // Toán tử XOR bitwise và gán (^=)
  x ^= 5
  fmt.Println("x ^= 5:", x)  // Kết quả: x ^= 5: 6

  // Toán tử dịch phải và gán (>>=)
  x >>= 1
  fmt.Println("x >>= 1:", x)  // Kết quả: x >>= 1: 3

  // Toán tử dịch trái và gán (<<=)
  x <<= 2
  fmt.Println("x <<= 2:", x)  // Kết quả: x <<= 2: 12
}

Trong ví dụ trên, chúng ta sử dụng các toán tử gán để thực hiện các phép toán và gán giá trị kết quả cho biến x. Các giá trị và phép toán được in ra để minh họa kết quả của từng phép toán gán.

6. Toán tử so sánh.

Toán tử so sánh được sử dụng để so sánh hai giá trị trong Go. Kết quả của một phép so sánh là true (đúng) hoặc false (sai).

Dưới đây là một ví dụ sử dụng toán tử so sánh lớn hơn (>):

package main

import "fmt"

func main() {
  // Khởi tạo hai biến x và y
  var x = 5
  var y = 3

  // Sử dụng toán tử so sánh lớn hơn (>)
  result := x > y

  // In ra kết quả
  fmt.Println(result)  // Kết quả: true
}

Trong ví dụ trên, chúng ta sử dụng toán tử so sánh lớn hơn (>) để so sánh giá trị của biến x và y. Kết quả của phép so sánh là true, vì 5 lớn hơn 3.

Đây là một danh sách các toán tử so sánh trong Go:

==: So sánh bằng, kiểm tra xem hai giá trị có bằng nhau không.

x == y

!=: So sánh không bằng, kiểm tra xem hai giá trị có khác nhau không.

x != y

>: Lớn hơn, kiểm tra xem giá trị bên trái có lớn hơn giá trị bên phải không.

x > y

<: Nhỏ hơn, kiểm tra xem giá trị bên trái có nhỏ hơn giá trị bên phải không.

x < y

>=: Lớn hơn hoặc bằng, kiểm tra xem giá trị bên trái có lớn hơn hoặc bằng giá trị bên phải không.

x >= y

<=: Nhỏ hơn hoặc bằng, kiểm tra xem giá trị bên trái có nhỏ hơn hoặc bằng giá trị bên phải không.

x <= y

Dưới đây là một ví dụ sử dụng các toán tử so sánh:

package main

import "fmt"

func main() {
  // Khởi tạo hai biến x và y
  var x = 5
  var y = 3

  // Sử dụng các toán tử so sánh và in ra kết quả
  fmt.Println("x == y:", x == y)    // Kết quả: false
  fmt.Println("x != y:", x != y)    // Kết quả: true
  fmt.Println("x > y:", x > y)      // Kết quả: true
  fmt.Println("x < y:", x < y)      // Kết quả: false
  fmt.Println("x >= y:", x >= y)    // Kết quả: true
  fmt.Println("x <= y:", x <= y)    // Kết quả: false
}

Kết quả sẽ hiển thị các giá trị true hoặc false tương ứng với kết quả của từng phép so sánh.

7. Xác định logic giữa các biến hoặc giá trị.

Toán tử logic được sử dụng để xác định logic giữa các biến hoặc giá trị.

Dưới đây là một ví dụ sử dụng các toán tử logic trong Go:

package main

import "fmt"

func main() {
  // Khởi tạo biến x
  var x = 7

  // Sử dụng toán tử logic && (Logical AND)
  resultAnd := x < 5 && x < 10
  fmt.Println("x < 5 && x < 10:", resultAnd)  // Kết quả: false

  // Sử dụng toán tử logic || (Logical OR)
  resultOr := x < 5 || x < 4
  fmt.Println("x < 5 || x < 4:", resultOr)    // Kết quả: true

  // Sử dụng toán tử logic ! (Logical NOT)
  resultNot := !(x < 5 && x < 10)
  fmt.Println("!(x < 5 && x < 10):", resultNot)  // Kết quả: true
}

Trong ví dụ trên:

Toán tử && (Logical AND) trả về true nếu cả hai câu lệnh là đúng (x < 5 && x < 10 là false vì x không thỏa cả hai điều kiện).
Toán tử || (Logical OR) trả về true nếu ít nhất một trong hai câu lệnh là đúng (x < 5 || x < 4 là true vì x thỏa điều kiện đầu tiên).
Toán tử ! (Logical NOT) đảo ngược kết quả, trả về false nếu kết quả ban đầu là true và ngược lại (!(x < 5 && x < 10) là true vì kết quả của câu lệnh trong dấu ngoặc là false).

8. Thực hiện các phép toán trên các số nhị phân.

Toán tử bitwise (bitwise operators) được sử dụng để thực hiện các phép toán trên các số nhị phân (binary numbers).

Dưới đây là một ví dụ sử dụng các toán tử bitwise trong Go:

package main

import "fmt"

func main() {
  // Khởi tạo biến x và y
  var x uint8 = 5       // Biểu diễn nhị phân: 00000101
  var y uint8 = 3       // Biểu diễn nhị phân: 00000011

  // Toán tử AND bitwise (&)
  resultAnd := x & y
  fmt.Printf("x & y: %08b\n", resultAnd)  // Kết quả: 00000001 (Biểu diễn nhị phân của 1)

  // Toán tử OR bitwise (|)
  resultOr := x | y
  fmt.Printf("x | y: %08b\n", resultOr)    // Kết quả: 00000111 (Biểu diễn nhị phân của 7)

  // Toán tử XOR bitwise (^)
  resultXor := x ^ y
  fmt.Printf("x ^ y: %08b\n", resultXor)   // Kết quả: 00000110 (Biểu diễn nhị phân của 6)

  // Toán tử Zero fill left shift (<<)
  resultLeftShift := x << 2
  fmt.Printf("x << 2: %08b\n", resultLeftShift)  // Kết quả: 00010100 (Biểu diễn nhị phân của 20)

  // Toán tử Signed right shift (>>)
  resultRightShift := x >> 2
  fmt.Printf("x >> 2: %08b\n", resultRightShift)  // Kết quả: 00000001 (Biểu diễn nhị phân của 1)
}

Trong ví dụ trên, chúng ta sử dụng các toán tử bitwise để thực hiện các phép toán trên giá trị nhị phân của biến x và y.

Kết quả được in ra dưới dạng biểu diễn nhị phân (%08b) để dễ hiểu.

[Golang] Phần 11 – Go Operators

LEAVE A REPLY Cancel reply

LATEST POSTS

Tổng quan về netstat trong Linux

Tạo người dùng và sshkey trên Proxmox

Bài viết hướng dẫn nhanh cách tắt SIP ALG trên thiết bị tường lửa Fortigate

Quy trình thay lõi lọc cho bình lọc nước Karofi

Nên dùng MTU bao nhiêu cho Ceph Storage

Related Stories

Tổng quan về netstat trong Linux

Tạo người dùng và sshkey trên Proxmox

Bài viết hướng dẫn nhanh cách tắt SIP ALG trên thiết bị tường lửa Fortigate

Quy trình thay lõi lọc cho bình lọc nước Karofi

Nên dùng MTU bao nhiêu cho Ceph Storage

EDITOR PICKS

Tạo Instance AWS với Terraform

[AWS] Cost Explorer, Batch, AppFlow

[AWS] Simple Email, Pinpoint & Systems Manager

POPULAR POSTS

Tổng quan về netstat trong Linux

Tạo người dùng và sshkey trên Proxmox

Bài viết hướng dẫn nhanh cách tắt SIP ALG trên thiết bị tường lửa Fortigate

POPULAR CATEGORY

LIÊN KẾT