Types de données du langage Go

Le type de données spécifie ce qui estVariables GoTypes de données qui peuvent être stockés. En langage Go, les types sont divisés en quatre catégories suivantes :

1. Types de base :Nombres, chaînes et valeurs booléennes appartiennent à cette catégorie.

2. Types agrégés :Tableaux et structures appartiennent à cette catégorie.

3. Types de référence :Pointeurs, tranches, ensembles map, fonctions et Channels appartiennent à cette catégorie.

4. Types d'interface

Ici, nous allons discuter des types d'interfaces du langage GoTypes de données de base。Types de données de baseSont divisés en trois sous-catégories respectivement :

• Numbers

• Booleans

• Strings

Types de nombres

En langage Go, les nombres sont divisés enTroisSous-catégorie :

• Entiers :En langage Go, les entiers signés et non signés peuvent utiliser quatre tailles différentes, comme indiqué dans le tableau suivant. int signé est représenté par int, et les entiers non signés par uint.
  

  Type de données	Description
  int8	8Entiers signés
  int16	16Entiers signés
  int32	32Entiers signés
  int64	64Entiers signés
  uint8	8Entiers non signés
  uint16	16Entiers non signés
  uint32	32Entiers non signés
  uint64	64Entiers non signés
  int	in et uint contiennent la même taille, que ce soit32Bits ou64Bits.
  uint	in et uint contiennent la même taille, que ce soit32Bits ou64Bits.
  rune	Il s'agit de int32Synonyme, également représentant les points de code Unicode.
  byte	Il s'agit de int8Synonyme de
  uintptr	Il s'agit d'un type d'entier non signé. Sa largeur n'est pas définie, mais il peut容纳所有位值的指针。

  Exemple

  //　Utilisation des entiers　
  package　main　　
  import　"fmt"
  　　　　　　　　　
  func　main()　{　
  　　　　　　
  　　　　//　Utilisation8Bits de type entier non signé
  　　　　var X uint8　=　225　
  　　　　fmt.Println(X+1, X)　
  　　　　　　
  　　　　//　Utilisation16Bits de type entier signé
  　　　　var Y int16　=　32767　
  　　　　fmt.Println(Y+2, Y-2)　　
  }

  Sortie :

  226　225
  -32767　32765

• Nombres flottants :En langage Go, les nombres flottants sont divisés en2Comme indiqué dans le tableau suivant :
  

  Type de données	Description
  float32	32Bits IEEE 754Nombres flottants
  float64	64Bits IEEE 754Nombres flottants

  Exemple

  //　Utilisation des nombres flottants　
  package　main　　
  import　"fmt"
  　　　　　　　　　
  func　main()　{　
  　　　　a :=　20.45　
  　　　　b :=　34.89　
  　　　　　　
  　　　　//Soustraction de deux nombres flottants
  　　　　c := b-a　
  　　　　　　
  　　　　//Afficher le résultat　
  　　　　fmt.Printf("Résultat: %f", c)　
  　　　　　　
  　　　　//Afficher le type de la variable c
  　　　　fmt.Printf("\nc est de type:　%T",　c)　　　
  }

  Sortie :

  Résultat :　14.440000
  Le type de c est:　float64

• Nombre complexe :Divisent le nombre complexe en deux parties, comme le tableau suivant le montre. float32et float64Fait également partie de ces nombres complexes. Les fonctions intégrées créent un nombre complexe à partir de ses parties réelles et imaginaires, et les fonctions intégrées réelles et imaginaires extraient ces parties.
  

  Type de données	Description
  complex64	Contient float32En tant que nombres complexes composés de composantes réelles et imaginaires.
  complex128	Contient float64En tant que nombres complexes composés de composantes réelles et imaginaires.

  Exemple

  //Utilisation des nombres complexes　
  package　main　
  import　"fmt"
  　　
  func　main()　{　
  　　　　　　
  　　　var　a　complex128　=　complex(6,　2)　
  　　　var　b　complex64　=　complex(9,　2)　
  　　　fmt.Println(a)　
  　　　fmt.Println(b)　
  　　　　　
  　　　//Afficher le type　
  　　fmt.Printf("Le type de a est　%T　et"+　"Le type de b est　%T",　a,　b)　
  }

  Sortie :

  (6+2i)
  (9+2i)
  Le type de a est　complex128　et le type de b est　complex64

Type de données booléen

Le type de données booléen ne représente que true ou false. Les valeurs du type booléen ne sont pas converties implicitement ou explicitement en tout autre type.

//Utilisation des valeurs booléennes
package　main
import　"fmt"
func　main()　{
　　　　//Variable
　　　　str1　:=　"w3codebox"
　　　　str2　:=　"w3codebox"
　　　　str3　:=　"w3codebox"
　　　　result1　:=　str1　==　str2
　　　　result2　:=　str1　==　str3
　　　　//Afficher le résultat
　　　　fmt.Println(result1)
　　　　fmt.Println(result2)
　　　　//Afficher result1et result2Le type
　　　　fmt.Printf("result1　Le type est　%T　，　"+"result2Le type est　%T",　result1,　result2)
}

Sortie :

true
true
result1　Le type est　bool　，　result2Le type est　bool

Type de données 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 d'octets immuables, ce qui signifie que dès que vous avez créé une chaîne, vous ne pouvez pas la modifier. Une chaîne peut contenir des données arbitraires, y compris des octets de zéro dans un format lisible par l'homme.

//Utilisation des chaînes
package　main　
import　"fmt"
　　
func　main()　{　
　　　　　　
　　　　//Variable utilisée pour stocker la chaîne str
　　　str　:=　"w3codebox"
　　　　　
　　　//Afficher la longueur de la chaîne
　　　fmt.Printf("La longueur de la chaîne:%d",　len(str))　
　　　　　
　　　//Afficher la chaîne　
　　　fmt.Printf("\nLa chaîne est:　%s",　str)　
　　　　　
　　　//　Afficher le type de la variable str
　　　fmt.Printf("\nLe type de str est:　%T",　str)　
}

Sortie :

La longueur de la chaîne:5
La chaîne est:　w3codebox
Le type de str est: string