Kiểu dữ liệu trong Golang

Kiểu dữ liệu chỉ định kiểu dữ liệu mà một biến Golang hợp lệ có thể chứa. Trong ngôn ngữ Go, kiểu được chia thành bốn loại như sau:

• Kiểu cơ bản: Số, chuỗi và boolean
• Kiểu tổng hợp: Mảng và cấu trúc
• Kiểu tham chiếu: Con trỏ, lát cắt, bản đồ, hàm và kênh
• Kiểu giao diện

Ở đây, chúng ta sẽ thảo luận về các Kiểu dữ liệu cơ bản trong ngôn ngữ Go. Chúng được phân loại thành ba loại phụ là:

• Số
• Boolean
• Chuỗi

Số trong Golang

Trong ngôn ngữ Go, số được chia thành ba tiểu loại là:

Số nguyên: Trong ngôn ngữ Go, cả số nguyên có dấu và không dấu đều có bốn kích cỡ khác nhau như được hiển thị trong bảng bên dưới. Số nguyên có dấu được biểu diễn bằng int và số nguyên không dấu được biểu diễn bằng uint.

Các phép toán số học có thể có: Cộng, trừ, nhân, chia, phần dư

Ví dụ:

// Chương trình Go sử dụng số nguyên
package main 
import "fmt"
		
func main() {
	
	// Dùng 8-bit unsigned int 
	var X uint8 = 225
	fmt.Println(X, X-3)
	
	// Dùng 16-bit signed int 
	var Y int16 = 32767
	fmt.Println(Y+2, Y-2) 
}

Kết quả:

225 222
-32767 32765

Ví dụ về phép toán số học:

// Các phép tính số học có thể có đối với số nguyên
// Tác giả : Chhanda Saha

package main

import "fmt"

func main() {

	var x int16 = 170
	var y int16 = 83
	//Cộng
	fmt.Printf(" addition : %d + %d = %d\n ", x, y, x+y)
	//Trừ
	fmt.Printf("subtraction : %d - %d = %d\n", x, y, x-y)
	//Nhân
	fmt.Printf(" multiplication : %d * %d = %d\n", x, y, x*y)
	//Chia
	fmt.Printf(" division : %d / %d = %d\n", x, y, x/y)
	//Mô đun
	fmt.Printf(" remainder : %d %% %d = %d\n", x, y, x%y)
}

Kết quả:

Cộng :  170 + 83 = 253
Trừ : 170 - 83 = 87
Nhân : 170 * 83 = 14110
Chia : 170 / 83 = 2
Số dư : 170 % 83 = 4 

• Số dấu chấm động: Trong ngôn ngữ Go, số dấu chấm động được chia thành hai loại như thể hiện trong bảng bên dưới.
  • Các phép toán số học có thể: Cộng, trừ, nhân, chia.
  • Có ba kiểu chữ:
    • thập phân (3.15)
    • lũy thừa (12e18 hoặc 3E10)
    • hỗn hợp (13.16e12)

Ví dụ:

//Minh họa chương trình Go dùng số dấu chấm động
package main 
import "fmt"
		
func main() {
	a := 20.45
	b := 34.89
	
	// Phép trừ hai số dấu chấm động
	c := b-a
	
	// Hiện kết quả
	fmt.Printf("Result is: %f", c)
	
	// Hiện kiểu biến C
	fmt.Printf("\nThe type of c is : %T", c) 
}

Kết quả:

Kết quả: 14.440000
Kiểu của C là : float64

Ví dụ về phép toán số học cho số dấu chấm động:

// Các phép toán số học có thể có cho số thực
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	var x float32 = 5.00
	var y float32 = 2.25
	//Phép cộng
	fmt.Printf("addition : %g + %g = %g\n ", x, y, x+y)
	//Phép trừ
	fmt.Printf("subtraction : %g - %g = %g\n", x, y, x-y)
	//Phép nhân
	fmt.Printf("multiplication : %g * %g = %g\n", x, y, x*y)
	//Phép chia
	fmt.Printf("division : %g / %g = %g\n", x, y, x/y)

}

Kết quả:

Phép cộng :  5 + 2.25 = 7.25
Phép trừ : 5 - 2.25 = 2.75
Phép nhân : 5 * 2.25 = 11.25
Phép chia : 5 / 2.25 = 2.2222223

• Những con số phức tạp: Các số phức được chia thành hai phần, hiển thị trong bảng bên dưới. float32 và float64 cũng là một phần của các số phức này. Hàm tích hợp tạo ra một số phức từ phần ảo và phần thực của nó và hàm ảo và phần thực tích hợp trích xuất các phần đó.
  • Có một số hàm tích hợp trong số phức:
    • complex – tạo số phức từ hai số float.
    • real() – lấy phần thực của số phức đầu vào dưới dạng số float.
    • imag() – lấy phần ảo của phần số phức đầu vào dưới dạng số float

Ví dụ:

// Chương trình Go dùng số phức
package main
import "fmt"

func main() {
	
var a complex128 = complex(6, 2)
var b complex64 = complex(9, 2)
fmt.Println(a)
fmt.Println(b)
	
// Hiện kiểu
fmt.Printf("The type of a is %T and "+
			"the type of b is %T", a, b)
}

Kết quả:

(6+2i)
(9+2i)
Kiểu của a là complex128, kiểu của b là complex64

Ví dụ các hàm tích hợp:

// Các hàm tích hợp là số phức
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	comp1 := complex(10, 11)
	// cú pháp init số phức
	comp2 := 13 + 33i
	fmt.Println("Complex number 1 is :", comp1)
	fmt.Println("Complex number 1 is :", comp2)
	// lấy phần real
	realNum := real(comp1)
	fmt.Println("Real part of complex number 1:", realNum)
	// lấy phần hình ảnh
	imaginary := imag(comp2)
	fmt.Println("Imaginary part of complex number 2:", imaginary)

}

Kết quả:

Số phức 1 là: (10+11i)
Số phức 1 là: (13+33i)
Phần thực của số phức 1: 10
Phần ảo của số phức 2: 33

Boolean

Kiểu dữ liệu boolean chỉ biểu diễn một bit thông tin là đúng hoặc sai. Các giá trị của kiểu boolean không được chuyển đổi ngầm định hoặc rõ ràng sang bất kỳ kiểu nào khác.

Ví dụ:

//Minh họa chương trình dùng boolean
package main
import "fmt"

func main() {
	
	// Các biến
str1 := "Quantrimang"
str2:= "quantrimang"
str3:= "Quantrimang"
result1:= str1 == str2
result2:= str1 == str3
	
// Hiện kết quả
fmt.Println( result1)
fmt.Println( result2)
	
// Hiện kiểu của result1 và result2
fmt.Printf("Kiểu của result1 là %T và "+
				"kiểu của result2 là %T",
							result1, result2)
	
}

Kết quả:

false
true
Kiểu của result1 là bool và kiểu của result2 là bool

Chuỗi

Kiểu dữ liệu chuỗi biểu diễn một chuỗi các điểm mã Unicode. Hay nói cách khác, chúng ta có thể nói chuỗi là một chuỗi các byte bất biến, nghĩa là khi một chuỗi được tạo ra, bạn không thể thay đổi chuỗi đó. Chuỗi có thể chứa dữ liệu tùy ý, bao gồm các byte có giá trị bằng không ở dạng con người có thể đọc được. Chuỗi có thể được nối bằng toán tử cộng (+).

Ví dụ:

// Chương trình Go dùng chuỗi
package main
import "fmt"

func main() {
	
	// Biến str chứa chuỗi
str := "Quantrimang"
	
// Hiện độ dài của chuỗi
fmt.Printf("Length of the string is:%d",
								len(str))
	
// Hiện chuỗi
fmt.Printf("\nString is: %s", str)
	
// Hiện kiểu biến str 
fmt.Printf("\nType of str is: %T", str)
}

Kết quả:

Chiều dài của chuỗi là: 13
Chuỗi là: Quantrimang
Kiểu của chuỗi là: chuỗi

Ví dụ về nối chuỗi:

// Nối chuỗi
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	var str1 string = "STRING_"
	var str2 string = "Concatenation"

	// Nối chuỗi bằng toán tử + 
	fmt.Println("New string : ", str1+str2)

}

Kết quả:

New string :  STRING_Concatenation