[Golang] Phần 8 – Go Data Types

1. Kiểu dữ liệu cơ bản trong Go.

Kiểu dữ liệu là một khái niệm quan trọng trong lập trình. Kiểu dữ liệu xác định kích thước và loại giá trị của biến. Go là một ngôn ngữ tĩnh kiểu, điều này có nghĩa là khi một biến có kiểu được định nghĩa, nó chỉ có thể lưu trữ dữ liệu của kiểu đó.

• Go có ba kiểu dữ liệu cơ bản:
  • bool: Đại diện cho một giá trị boolean và có thể là true hoặc false.
  • Numeric: Đại diện cho các kiểu số nguyên, số thực và số phức.
  • string: Đại diện cho một giá trị chuỗi

Dưới đây là một ví dụ minh họa về cách sử dụng các kiểu dữ liệu khác nhau trong Go:

package main
import "fmt"

func main() {
  var a bool = true     // Boolean
  var b int = 5         // Integer
  var c float32 = 3.14  // Số thực
  var d string = "Hi!"  // Chuỗi
  fmt.Println("Boolean: ", a)
  fmt.Println("Integer: ", b)
  fmt.Println("Float:   ", c)
  fmt.Println("String:  ", d)
}

Kết quả sẽ là:

Boolean:  true
Integer:  5
Float:    3.14
String:   Hi!

Với những kiểu dữ liệu này, bạn có thể biểu diễn một loạt các giá trị khác nhau trong chương trình của mình.

2. Kiểu dữ liệu Boolean.

Kiểu dữ liệu boolean được khai báo bằng bool và chỉ có thể nhận giá trị true hoặc false. Giá trị mặc định của kiểu dữ liệu boolean là false.

package main
import "fmt"

func main() {
  var b1 bool = true        // Khai báo có kiểu và có giá trị khởi tạo
  var b2 = true             // Khai báo không có kiểu, có giá trị khởi tạo
  var b3 bool               // Khai báo có kiểu nhưng không có giá trị khởi tạo
  b4 := true                // Khai báo không có kiểu, có giá trị khởi tạo

  fmt.Println(b1) // In ra true
  fmt.Println(b2) // In ra true
  fmt.Println(b3) // In ra false (giá trị mặc định)
  fmt.Println(b4) // In ra true
}

Kết quả sẽ là:

true
true
false
true

Bạn có thể sử dụng các cách khác nhau để khai báo và sử dụng biến boolean trong Go tùy thuộc vào tình huống cụ thể của bạn.

3. Kiểu dữ liệu Integer.

Kiểu dữ liệu là số nguyên (integer) được sử dụng để lưu trữ số nguyên không có phần thập phân, chẳng hạn như 35, -50, hoặc 1345000.

Kiểu dữ liệu số nguyên có hai loại chính:

• Số nguyên có dấu (Signed integers): Có thể lưu trữ cả giá trị dương và giá trị âm.
• Số nguyên không dấu (Unsigned integers): Chỉ có thể lưu trữ giá trị không âm.

Lưu ý, nếu bạn không chỉ định một kiểu mặc định cho số thì kiểu mặc định sẽ là int.

Số nguyên có dấu (Signed Integers):

package main
import "fmt"

func main() {
  var x int = 500
  var y int = -4500
  fmt.Printf("Type: %T, value: %v\n", x, x)
  fmt.Printf("Type: %T, value: %v\n", y, y)
}

• Go có năm kiểu dữ liệu số nguyên có dấu:
  • int: Tùy thuộc vào nền tảng (32 bit trong hệ thống 32 bit và 64 bit trong hệ thống 64 bit), khoảng giá trị từ -2147483648 đến 2147483647 trong hệ thống 32 bit và từ -9223372036854775808 đến 9223372036854775807 trong hệ thống 64 bit.
  • int8: 8 bit/1 byte, khoảng giá trị từ -128 đến 127.
  • int16: 16 bit/2 byte, khoảng giá trị từ -32768 đến 32767.
  • int32: 32 bit/4 byte, khoảng giá trị từ -2147483648 đến 2147483647.
  • int64: 64 bit/8 byte, khoảng giá trị từ -9223372036854775808 đến 9223372036854775807.

Số nguyên không dấu (Unsigned Integers):

package main
import "fmt"

func main() {
  var x uint = 500
  var y uint = 4500
  fmt.Printf("Type: %T, value: %v\n", x, x)
  fmt.Printf("Type: %T, value: %v\n", y, y)
}

• Số nguyên không dấu chỉ có thể lưu trữ giá trị không âm.
  • uint: Tùy thuộc vào nền tảng (32 bit trong hệ thống 32 bit và 64 bit trong hệ thống 64 bit), khoảng giá trị từ 0 đến 4294967295 trong hệ thống 32 bit và từ 0 đến 18446744073709551615 trong hệ thống 64 bit.
  • uint8: 8 bit/1 byte, khoảng giá trị từ 0 đến 255.
  • uint16: 16 bit/2 byte, khoảng giá trị từ 0 đến 65535.
  • uint32: 32 bit/4 byte, khoảng giá trị từ 0 đến 4294967295.
  • uint64: 64 bit/8 byte, khoảng giá trị từ 0 đến 18446744073709551615.

Nên sử dụng loại số nguyên nào?

• Khi lựa chọn kiểu số nguyên, bạn cần xác định kích thước giá trị mà biến sẽ lưu trữ. Dưới đây là một số hướng dẫn tổng quan:
  • int: Nếu không có yêu cầu đặc biệt, int thường là lựa chọn an toàn vì nó có kích thước tùy thuộc vào nền tảng, giảm thiểu rủi ro tràn số.
  • int8, int16, int32, int64: Chọn kiểu số nguyên dựa trên kích thước cần thiết cho giá trị bạn đang lưu trữ. Hãy lưu ý rằng sự chọn lựa giữa các kiểu này là một sự đánh đổi giữa khoảng giá trị có thể lưu trữ và sử dụng bộ nhớ.
  • uint: Sử dụng khi bạn chỉ cần lưu trữ giá trị không âm và không cần biểu diễn giá trị âm.
  • uint8, uint16, uint32, uint64: Chọn kiểu số nguyên không dấu dựa trên kích thước cần thiết cho giá trị không âm bạn đang lưu trữ.

Khi giá trị nằm ngoài phạm vi của kiểu số nguyên, Go sẽ sinh lỗi như bạn đã thấy trong ví dụ dưới đây.

package main
import ("fmt")

func main() {
  var x int8 = 1000
  fmt.Printf("Type: %T, value: %v", x, x)
}

Kết quả

./prog.go:5:7: constant 1000 overflows int8

Điều này nhấn mạnh sự quan trọng của việc chọn kiểu dữ liệu phù hợp với giá trị bạn đang làm việc.

4. Kiểu dữ liệu Float.

Các kiểu dữ liệu float trong Go được sử dụng để lưu trữ số thực có dấu, như 35.3, -2.34 hoặc 3597.34987.

• Dưới đây là một số điểm quan trọng về float trong Go:
  • float32 và float64: Bạn có thể sử dụng float32 hoặc float64 tùy thuộc vào độ chính xác và phạm vi giá trị mà bạn cần. Tuy nhiên, mặc định là float64 nếu không có kiểu dữ liệu nào được xác định.
  • Phạm vi giá trị: Sự quan trọng của việc chọn float32 hoặc float64 đặc biệt nếu bạn đang làm việc với các số có giá trị lớn hoặc độ chính xác cao.
  • Sử dụng mặc định: Trong hầu hết các trường hợp, sử dụng mặc định là float64 là lựa chọn an toàn vì nó cung cấp độ chính xác cao và phạm vi giá trị lớn hơn.
  • Chú ý đến tràn số: Hãy luôn kiểm tra xem giá trị bạn đang gán vào biến có nằm trong phạm vi cho phép hay không để tránh lỗi tràn số.

package main

import "fmt"

func main() {
  // Sử dụng float64 mặc định
  var defaultFloat = 123.45
  fmt.Printf("Type: %T, value: %v\n", defaultFloat, defaultFloat)

  // Sử dụng float32
  var float32Value float32 = 3.4e+38
  fmt.Printf("Type: %T, value: %v\n", float32Value, float32Value)

  // Sử dụng float64 với giá trị vượt qua phạm vi của float32
  var float64Value float64 = 3.4e+39
  fmt.Printf("Type: %T, value: %v\n", float64Value, float64Value)
}

5. Lựa chọn kiểu dữ liệu Float nào để sử dụng?

Trong ví dụ này, bạn đang cố gán giá trị 3.4e+39 cho một biến kiểu float32. Tuy nhiên, giá trị này vượt quá phạm vi của kiểu dữ liệu float32, nên bạn sẽ nhận được một lỗi “overflow” (tràn số).

package main

import "fmt"

func main() {
  var x float32 = 3.4e+39
  fmt.Println(x)
}

Kết quả:

./prog.go:5:7: constant 3.4e+39 overflows float32

Điều này xảy ra vì float32 có phạm vi giới hạn và không thể lưu trữ giá trị lớn như 3.4e+39. Nếu bạn cần lưu trữ giá trị lớn như vậy, bạn có thể sử dụng kiểu float64, như sau:

package main

import "fmt"

func main() {
  var x float64 = 3.4e+39
  fmt.Println(x)
}

Kết quả sẽ là:

3.4e+39

Ở đây, float64 có phạm vi lớn hơn nên có thể chứa giá trị 3.4e+39 mà không gây ra lỗi tràn số.

6. Go String Data Type.

Kiểu dữ liệu string trong Go được sử dụng để lưu trữ chuỗi ký tự (văn bản). Giá trị của kiểu string phải được bao quanh bởi dấu ngoặc kép.

package main

import "fmt"

func main() {
  var txt1 string = "Hello!"
  var txt2 string
  txt3 := "World 1"

  fmt.Printf("Type: %T, value: %v\n", txt1, txt1)
  fmt.Printf("Type: %T, value: %v\n", txt2, txt2)
  fmt.Printf("Type: %T, value: %v\n", txt3, txt3)
}

Kết quả:

Type: string, value: Hello!
Type: string, value:
Type: string, value: World 1

• txt1 được khai báo với giá trị “Hello!” và kiểu dữ liệu string.
• txt2 được khai báo nhưng không có giá trị, do đó giá trị mặc định của string là chuỗi rỗng ("").
• txt3 được khai báo và khởi tạo bằng cách sử dụng := với giá trị “World 1”. Kiểu dữ liệu của txt3 cũng là string.