Combien de types de données Go possède-t-il ?

Go propose quatre types de données : 1. Les types de base, notamment les entiers, les nombres à virgule flottante, les nombres complexes, les valeurs booléennes, les chaînes et les constantes ; 2. Les types d'agrégation, notamment les tableaux et les structures (un type de données agrégé, composé d'une entité composé de zéro ou plusieurs valeurs de n'importe quel type. Chaque valeur est appelée un membre de la structure); 3. Les types de référence, y compris les pointeurs, les tranches, les cartes, les fonctions et les canaux 4. Les types d'interface, qui sont destinés à d'autres types ; . L'abstraction et la généralisation du comportement sont un type d'abstraction.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Les types de données de Go sont divisés en quatre catégories principales : Types de base, types d'agrégats, types de référence et types d'interface.

• Les types de base sont divisés en : entiers, nombres à virgule flottante, nombres complexes, valeurs booléennes, chaînes, constantes
• Les types d'agrégation incluent : tableaux, structures
• Les types de référence incluent : pointeurs, tranches, cartes, fonctions, canaux
Type d'interface rreee

pluriel

// int8 is the set of all signed 8-bit integers.
// Range: -128 through 127.
type int8 int8

// int16 is the set of all signed 16-bit integers.
// Range: -32768 through 32767.
type int16 int16

// int32 is the set of all signed 32-bit integers.
// Range: -2147483648 through 2147483647.
type int32 int32

// int64 is the set of all signed 64-bit integers.
// Range: -9223372036854775808 through 9223372036854775807.
type int64 int64

// uint8 is the set of all unsigned 8-bit integers.
// Range: 0 through 255.
type uint8 uint8

// uint16 is the set of all unsigned 16-bit integers.
// Range: 0 through 65535.
type uint16 uint16

// uint32 is the set of all unsigned 32-bit integers.
// Range: 0 through 4294967295.
type uint32 uint32

// uint64 is the set of all unsigned 64-bit integers.
// Range: 0 through 18446744073709551615.
type uint64 uint64

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

// int is a signed integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, int32.
type int int

// uint is an unsigned integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, uint32.
type uint uint

Valeur booléenne

// float32 is the set of all IEEE-754 32-bit floating-point numbers.
type float32 float32

// float64 is the set of all IEEE-754 64-bit floating-point numbers.
type float64 float64

string

// complex64 is the set of all complex numbers with float32 real and
// imaginary parts.
type complex64 complex64

// complex128 is the set of all complex numbers with float64 real and
// imaginary parts.
type complex128 complex128

// The complex built-in function constructs a complex value from two
// The complex built-in function constructs a complex value from two
// floating-point values. The real and imaginary parts must be of the same
// size, either float32 or float64 (or assignable to them), and the return
// value will be the corresponding complex type (complex64 for float32,
// complex128 for float64).
func complex(r, i FloatType) ComplexType

// The real built-in function returns the real part of the complex number c.
// The return value will be floating point type corresponding to the type of c.
func real(c ComplexType) FloatType

// The imag built-in function returns the imaginary part of the complex
// number c. The return value will be floating point type corresponding to
// the type of c.
func imag(c ComplexType) FloatType

constant

// bool is the set of boolean values, true and false.
type bool bool

// true and false are the two untyped boolean values.
const (
	true  = 0 == 0 // Untyped bool.
	false = 0 != 0 // Untyped bool.
)

type d'agrégation Les tableaux et les structures sont des types d'agrégats ;

Leurs valeurs sont ; donné par Composé de valeurs provenant de nombreux éléments ou champs membres. Les tableaux sont composés d'éléments isomorphes - chaque élément du tableau est exactement du même type - tandis que les structures sont composées d'éléments hétérogènes. Les tableaux et les structures sont des structures de données avec une taille de mémoire fixe. En revanche, slice et map sont des structures de données dynamiques qui grandiront dynamiquement selon les besoins.

array

// string is the set of all strings of 8-bit bytes, conventionally but not
// necessarily representing UTF-8-encoded text. A string may be empty, but
// not nil. Values of string type are immutable.
type string string

Si les types d'éléments d'un tableau peuvent être comparés les uns aux autres, alors les types de tableaux peuvent également être comparés les uns aux autres. À ce stade, nous pouvons comparer directement les deux. grâce à l'opérateur de comparaison == Tableaux, Les tableaux ne sont égaux que si tous les éléments de deux tableaux sont égaux. L'opérateur de comparaison d'inégalité != suit les mêmes règles.

Lorsqu'une fonction est appelée, chaque paramètre d'appel de la fonction sera attribué à la variable paramètre à l'intérieur de la fonction, de sorte que la variable paramètre de fonction reçoit une copie copiée, pas la variable de l'appel d'origine. Parce que le mécanisme de transmission des paramètres de fonction rend inefficace la transmission de grands types de tableaux,
• et toute modification des paramètres du tableau se produit sur le tableau copié et ne peut pas modifier directement la variable du tableau d'origine lorsqu'elle est appelée
. Appel par passage de valeur
• Nous pouvons
• passer explicitement un pointeur de tableau
, dans ce cas, toute modification du tableau par la fonction via le pointeur peut être directement renvoyée à l'appelant

structure La structure est un type de données agrégé, qui est une entité agrégée à partir de zéro ou plusieurs valeurs de tout type. Chaque valeur est appelée membre de la structure.

Si le nom du membre de la structure commence par une lettre majuscule, alors le membre est exporté

• // iota is a predeclared identifier representing the untyped integer ordinal
  // number of the current const specification in a (usually parenthesized)
  // const declaration. It is zero-indexed.
  const iota = 0 // Untyped int.

Si tous les membres de la structure sont comparables, alors la structure est également comparable, dans ce cas les deux structures seront comparées en utilisant les opérateurs
• ou !=. L'opérateur de comparaison d'égalité comparera chaque membre des deux structures, donc les deux expressions comparées suivantes sont équivalentes :

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int

Type de référence

Pointeur

• Une variable pointeur pointe vers le adresse mémoire d'une valeur.

1,
结构体值也可以用结构体面值表示，结构体面值可以指定每个成员的值。

type Point struct{ X, Y int }
p := Point{1, 2}

2,
以成员名字和相应的值来初始化，可以包含部分或全部的成员，

anim := gif.GIF{LoopCount: nframes}

在这种形式的结构体面值写法中，如果成员被忽略的话将默认用零值。

3,
因为结构体通常通过指针处理，可以用下面的写法来创建并初始化一个结构体变量，并返回结构体的地址：

pp := &Point{1, 2}

它是下面的语句是等价的

pp := new(Point)
*pp = Point{1, 2}

不过&Point{1, 2}写法可以直接在表达式中使用，比如一个函数调用。

• Processus d'utilisation du pointeur :

Définissez les variables du pointeur.
• Attribuez une valeur à une variable de pointeur.
Accédez à la valeur pointant vers l'adresse dans la variable pointeur.

Ajoutez le signe * (préfixe) devant le type de pointeur pour que le contenu pointe par le pointeur.

type Point struct{ X, Y int }

p := Point{1, 2}
q := Point{2, 1}
fmt.Println(p.X == q.X && p.Y == q.Y) // "false"
fmt.Println(p == q)                   // "false"

sliceSlice (slice) représente une séquence de longueur variable et chaque élément de la séquence a le même type.

Un type de tranche s'écrit généralement comme []T, où T représente le type d'élément dans la tranche

La syntaxe de slice est très similaire à celle d'un tableau, sauf qu'elle n'a pas de longueur fixe

var ip *int        /* 指向整型*/  ip是一个指向int类型对象的 指针
var fp *float32    /* 指向浮点型 */  fp是一个指向float32类型对象的 指针

• Plusieurs tranches peuvent réutiliser le même tableau de couches sous-jacent
• 
  

   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )

map

• 在Go语言中，一个map就是一个哈希表的引用，map类型可以写为map[K]V，其中K和V分别对应key和value。map中所有的key都有相同的类型，所有的value也有着相同的类型。
• 其中K对应的key必须是支持==比较运算符的数据类型，所以map可以通过测试key是否相等来判断是否已经存在。虽然浮点数类型也是支持相等运算符比较的，但是将浮点数用做key类型则是一个坏的想法。
• 对于V对应的value数据类型则没有任何的限制。

创建map：
1，
内置的make函数可以创建一个map：

ages := make(map[string]int) // mapping from strings to ints

2，
我们也可以用map字面值的语法创建map，同时还可以指定一些最初的key/value：

ages := map[string]int{
    "alice":   31,
    "charlie": 34,
}
这相当于

ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34
因此，另一种创建空的map的表达式是map[string]int{}。

Map中的元素通过key对应的下标语法访问：
ages["alice"] = 32

delete(ages, "alice") // remove element ages["alice"]

所有这些操作是安全的，即使这些元素不在map中也没有关系；
如果一个查找失败将返回value类型对应的零值，例如，
即使map中不存在“bob”下面的代码也可以正常工作，因为ages["bob"]失败时将返回0。
ages["bob"] = ages["bob"] + 1 // happy birthday!

遍历map

for name, age := range ages {
    fmt.Printf("%s\t%d\n", name, age)
}

函数

函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。

func name(parameter-list) (result-list) {
    body
}

channel 通道

• 如果说goroutine是Go语音程序的并发体的话，那么channels它们之间的通信机制。
• 一个channels是一个通信机制，它可以让一个goroutine通过它给另一个goroutine发送值信息。
• 每个channel都有一个特殊的类型，也就是channels可发送数据的类型。一个可以发送int类型数据的channel一般写为chan int。

使用内置的make函数，我们可以创建一个channel：

使用内置的make函数，我们可以创建一个channel：

ch := make(chan int) // ch has type 'chan int'

• 和map类似，channel也一个对应make创建的底层数据结构的引用。

• 当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者何被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

• 两个相同类型的channel可以使用==运算符比较。如果两个channel引用的是相通的对象，那么比较的结果为真。一个channel也可以和nil进行比较。

接口类型

接口

• 接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起，通过这种抽象的方式我们可以让我们的函数更加灵活和更具有适应能力。

• 很多面向对象的语言都有相似的接口概念，但Go语言中接口类型的独特之处在于它是满足隐式实现的。

• 也就是说，我们没有必要对于给定的具体类型定义所有满足的接口类型；简单地拥有一些必需的方法就足够了。

• 这种设计可以让你创建一个新的接口类型满足已经存在的具体类型却不会去改变这些类型的定义；当我们使用的类型来自于不受我们控制的包时这种设计尤其有用。

• 接口类型是一种抽象的类型。它不会暴露出它所代表的对象的内部值的结构和这个对象支持的基础操作的集合；它们只会展示出它们自己的方法。也就是说当你有看到一个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的方法来做什么。

【相关推荐：Go视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!