Gegevenstypen in Golang

Het gegevenstype specificeert welk type gegevens een geldige Golang- variabele kan bevatten . In de Go-taal worden typen als volgt in vier categorieën verdeeld:

• Basistypen: getallen, strings en Booleaanse waarden
• Aggregatietypen: Arrays en structuren
• Referentietypen: pointer, slice, map, functie en kanaal
• Interfacetype

Hier bespreken we de basisgegevenstypen in de Go-taal. Ze worden ingedeeld in drie subcategorieën:

• Nummer
• Booleaanse
• Ketting

Veelvoorkomende gegevenstypen in Golang

• Getallen in Golang
• Booleaanse
• Ketting

Getallen in Golang

In het Go-systeem worden getallen onderverdeeld in drie subcategorieën:

Gehele getallen: In de Go-taal zijn er vier verschillende grootten voor zowel signed als unsigned integers, zoals weergegeven in de onderstaande tabel. Getekende gehele getallen worden weergegeven door inten ongetekende gehele getallen worden weergegeven door uint.

Mogelijke rekenkundige bewerkingen: optellen, aftrekken, vermenigvuldigen, delen, rest

Bijvoorbeeld:

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

Resultaat:

225 222
-32767 32765

Voorbeeld van rekenkundige bewerkingen:

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

Resultaat:

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

• Getallen met drijvende komma: In de Go-taal worden getallen met drijvende komma onderverdeeld in twee typen, zoals weergegeven in de onderstaande tabel.
  • Rekenkundige bewerkingen zijn onder andere: optellen, aftrekken, vermenigvuldigen en delen.
  • Er zijn drie lettertypen:
    • decimaal (3,15)
    • macht (12e18 of 3e10)
    • gemengd (13.16e12)

Bijvoorbeeld:

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

Resultaat:

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

Voorbeeld van rekenkundige bewerkingen voor drijvendekommagetallen:

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

}

Resultaat:

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

• Complexe getallen: Complexe getallen bestaan ​​uit twee delen, die u in de onderstaande tabel kunt zien. float32en float64maakt ook deel uit van deze complexe getallen. De integratiefunctie genereert een complex getal uit zijn imaginaire en reële delen en de integratiefunctie extraheert die delen.
  • Er zijn verschillende ingebouwde functies in complexe getallen:
    • complex – maak een complex getal van twee floats.
    • real() – haalt het reële deel van het complexe invoergetal op als een float.
    • imag() – het imaginaire deel van het complexe invoergetal ophalen als een float

Bijvoorbeeld:

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

Resultaat:

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

Voorbeelden van ingebouwde functies:

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

}

Resultaat:

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

Booleaanse

Het gegevenstype Booleaans vertegenwoordigt slechts één bit aan informatie die waar of onwaar kan zijn. Waarden van het type boolean worden niet impliciet of expliciet naar een ander type geconverteerd.

Bijvoorbeeld:

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

Resultaat:

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

Ketting

Het gegevenstype string vertegenwoordigt een reeks Unicode-codepunten. Met andere woorden, we kunnen zeggen dat een string een onveranderlijke reeks bytes is. Dat wil zeggen dat je een string niet meer kunt wijzigen nadat deze is gemaakt. Strings kunnen willekeurige gegevens bevatten, waaronder bytes met een waarde van nul in een voor mensen leesbare vorm. Strings kunnen worden samengevoegd met behulp van de opteloperator (+).

Bijvoorbeeld:

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

Resultaat:

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

Voorbeeld van string-samenvoeging:

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

}

Resultaat:

New string :  STRING_Concatenation