Types de données dans Golang

Le type de données spécifie quel type de données une variable Golang valide peut contenir . Dans le langage Go, les types sont divisés en quatre catégories comme suit :

• Types de base : nombres, chaînes et booléens
• Types d'agrégats : tableaux et structures
• Types de référence : pointeur, tranche, carte, fonction et canal
• Type d'interface

Ici, nous discuterons des types de données de base dans le langage Go. Ils sont classés en trois sous-catégories :

• Nombre
• Booléen
• Chaîne

Types de données courants dans Golang

• Les nombres en Golang
• Booléen
• Chaîne

Les nombres en Golang

En langage Go, les nombres sont divisés en trois sous-catégories :

Entiers : dans le langage Go, les entiers signés et non signés sont disponibles en quatre tailles différentes, comme indiqué dans le tableau ci-dessous. Les entiers signés sont représentés par intet les entiers non signés sont représentés par uint.

Opérations arithmétiques possibles : Addition, soustraction, multiplication, division, reste

Par exemple:

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

Résultat:

225 222
-32767 32765

Exemple d'opérations arithmétiques :

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

Résultat:

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

• Nombres à virgule flottante : dans le langage Go, les nombres à virgule flottante sont divisés en deux types comme indiqué dans le tableau ci-dessous.
  • Les opérations arithmétiques peuvent être : l'addition, la soustraction, la multiplication, la division.
  • Il existe trois polices :
    • décimal (3,15)
    • puissance (12e18 ou 3e10)
    • mixte (13.16e12)

Par exemple:

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

Résultat:

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

Exemple d'opérations arithmétiques pour les nombres à virgule flottante :

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

}

Résultat:

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

• Nombres complexes : Les nombres complexes sont divisés en deux parties, présentées dans le tableau ci-dessous. float32et float64fait également partie de ces nombres complexes. La fonction d'intégration génère un nombre complexe à partir de ses parties imaginaires et réelles et la fonction d'intégration extrait ces parties.
  • Il existe plusieurs fonctions intégrées dans les nombres complexes :
    • complexe – créer un nombre complexe à partir de deux flottants.
    • real() – obtient la partie réelle du nombre complexe d'entrée sous forme de flottant.
    • imag() – récupère la partie imaginaire du nombre complexe d'entrée sous forme de nombre flottant

Par exemple:

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

Résultat:

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

Exemples de fonctions intégrées :

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

}

Résultat:

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

Booléen

Le type de données booléen représente un seul bit d'information qui est soit vrai, soit faux. Les valeurs de type booléen ne sont pas implicitement ou explicitement converties en un autre type.

Par exemple:

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

Résultat:

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

Chaîne

Le type de données chaîne représente une séquence de points de code Unicode. En d'autres termes, nous pouvons dire qu'une chaîne est une séquence immuable d'octets, ce qui signifie qu'une fois qu'une chaîne est créée, vous ne pouvez pas la modifier. Les chaînes peuvent contenir des données arbitraires, y compris des octets de valeur zéro sous une forme lisible par l'homme. Les chaînes peuvent être concaténées à l'aide de l'opérateur d'addition (+).

Par exemple:

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

Résultat:

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

Exemple de concaténation de chaînes :

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

}

Résultat:

New string :  STRING_Concatenation