Typy danych w Golang

Typ danych określa, jaki typ danych może zawierać prawidłowa zmienna języka Golang . W języku Go typy dzielą się na cztery kategorie:

• Typy podstawowe: liczby, ciągi znaków i wartości logiczne
• Typy agregatów: tablice i struktury
• Typy odniesień: wskaźnik, wycinek, mapa, funkcja i kanał
• Typ interfejsu

Tutaj omówimy podstawowe typy danych w języku Go. Dzielą się na trzy podkategorie:

• Numer
• Wartość logiczna
• Łańcuch

Typowe typy danych w Golang

• Liczby w Golang
• Wartość logiczna
• Łańcuch

Liczby w Golang

W języku Go liczby dzielą się na trzy podkategorie:

Liczby całkowite: W języku Go liczby całkowite, zarówno ze znakiem, jak i bez znaku, występują w czterech różnych rozmiarach, jak pokazano w poniższej tabeli. Liczby całkowite ze znakiem są reprezentowane przez , inta liczby całkowite bez znaku są reprezentowane przez uint.

Możliwe działania arytmetyczne: dodawanie, odejmowanie, mnożenie, dzielenie, reszta

Na przykład:

// 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) 
}

Wynik:

225 222
-32767 32765

Przykład operacji arytmetycznych:

// 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)
}

Wynik:

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

• Liczby zmiennoprzecinkowe: W języku Go liczby zmiennoprzecinkowe dzielą się na dwa typy, jak pokazano w poniższej tabeli.
  • Operacjami arytmetycznymi mogą być: dodawanie, odejmowanie, mnożenie i dzielenie.
  • Istnieją trzy czcionki:
    • dziesiętny (3,15)
    • moc (12e18 lub 3e10)
    • mieszany (13.16e12)

Na przykład:

//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) 
}

Wynik:

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

Przykład operacji arytmetycznych na liczbach zmiennoprzecinkowych:

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

}

Wynik:

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

• Liczby zespolone: ​​Liczby zespolone dzielą się na dwie części, jak pokazano w poniższej tabeli. float32i float64również jest częścią tych liczb zespolonych. Funkcja całkowania generuje liczbę zespoloną z jej części urojonej i rzeczywistej, a następnie funkcja całkowania wyodrębnia te części.
  • W liczbach zespolonych występuje kilka wbudowanych funkcji:
    • complex – utwórz liczbę zespoloną z dwóch liczb zmiennoprzecinkowych.
    • real() – pobiera część rzeczywistą wejściowej liczby zespolonej jako wartość zmiennoprzecinkową.
    • imag() – pobierz część urojoną wejściowej liczby zespolonej jako liczbę zmiennoprzecinkową

Na przykład:

// 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)
}

Wynik:

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

Przykłady wbudowanych funkcji:

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

}

Wynik:

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

Wartość logiczna

Typ danych boolowskich reprezentuje tylko jeden bit informacji, który może być prawdziwy lub fałszywy. Wartości typu logicznego nie są ani jawnie, ani domyślnie konwertowane na żaden inny typ.

Na przykład:

//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)
	
}

Wynik:

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

Łańcuch

Typ danych string reprezentuje sekwencję punktów kodowych Unicode. Innymi słowy, możemy powiedzieć, że ciąg znaków jest niezmienną sekwencją bajtów, co oznacza, że ​​po utworzeniu ciągu znaków nie można go już zmienić. Ciągi znaków mogą zawierać dowolne dane, w tym bajty o wartości zerowej w formie czytelnej dla człowieka. Ciągi znaków można łączyć za pomocą operatora dodawania (+).

Na przykład:

// 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)
}

Wynik:

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

Przykład łączenia ciągów znaków:

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

}

Wynik:

New string :  STRING_Concatenation