Qu'est-ce qu'une tranche en golang

En golang, une tranche est une référence à un fragment contigu d'un tableau. Ce fragment peut être l'intégralité du tableau ou un sous-ensemble de certains éléments identifiés par les indices de début et de fin. La structure interne des tranches dans le langage Go comprend l'adresse, la taille et la capacité. Les tranches sont généralement utilisées pour exploiter rapidement un ensemble de données. Si un ensemble de données est comparé à la découpe d'un gâteau, une tranche est le « morceau » que vous souhaitez. Le processus comprend le point de départ (la position de départ de la tranche) et la taille à couper (la taille de la tranche), la capacité peut être comprise comme la taille de la poche contenant la tranche.

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

Une tranche est une référence à un fragment continu d'un tableau, donc une tranche est un type référence (donc plus similaire au type tableau en C/C++, ou au type liste en Python. Ce fragment peut être le tableau entier). , Il peut également s'agir d'un sous-ensemble de certains éléments identifiés par les index de début et de fin. Il convient de noter que les éléments identifiés par l'index de fin ne sont pas inclus dans la tranche.

La structure interne des tranches dans le langage Go comprend l'adresse, la taille et la capacité. Les tranches sont généralement utilisées pour exploiter rapidement un ensemble de données. Si un ensemble de données est comparé à la découpe d'un gâteau, une tranche est le "morceau" que vous souhaitez. Le processus de coupe Comprenant par où commencer (la position de départ de la tranche) et quelle taille couper (la taille de la tranche), la capacité peut être comprise comme la taille de la poche contenant la tranche, comme le montre la figure ci-dessous.

Figure : structure des tranches et allocation de mémoire

Générer une nouvelle tranche à partir d'un tableau ou d'une tranche

Une tranche pointe par défaut vers une zone mémoire continue, qui peut être un tableau ou la tranche elle-même.

Générer des tranches à partir d'une zone mémoire continue est une opération courante. Le format est le suivant :

slice [开始位置 : 结束位置]

La syntaxe est la suivante :

• slice : représente l'objet slice cible ; l'index de l'objet slice cible ;

• End position : correspondant à l'index de fin de la slice cible.

• Générez une tranche à partir d'un tableau, le code est le suivant :

  var a  = [3]int{1, 2, 3}
  fmt.Println(a, a[1:2])

où a est un tableau de 3 éléments entiers, initialisé aux valeurs 1 à 3, utilisez a[1:2] pour générer un nouveau slice, Le résultat de l'exécution du code est le suivant :

[1 2 3]  [2]

où [2] est le résultat d'une opération de découpage [1:2].

La génération d'une nouvelle slice à partir d'un tableau ou d'une slice présente les caractéristiques suivantes :

Le nombre d'éléments retirés est : position finale - position de départ

• Les éléments retirés n'incluent pas l'index correspondant à la end position, et le dernier élément de la tranche utilise slice [len(slice)] Get;

• Lorsque la position de départ par défaut est utilisée, cela signifie du début de la zone continue à la position finale

• ; Lorsque la position de fin par défaut est utilisée, cela signifie de la position de départ à la fin de toute la zone continue 

• Lorsque les deux sont par défaut en même temps, cela équivaut à la tranche elle-même ; sont 0 en même temps, cela équivaut à une tranche vide et est généralement utilisé pour la réinitialisation des tranches.

• Lors de la prise de la valeur de l'élément de tranche en fonction de la position de l'index, la plage de valeurs est (0~len(slice)-1). Si elle dépasse la limite, une erreur d'exécution sera signalée lors de la génération de la tranche. la position finale peut être remplie dans len(slice) mais aucune erreur ne sera signalée. [Recommandations associées :

  Tutoriel vidéo Go
]

• Familiarisons-nous avec les caractéristiques du découpage à travers des exemples.

1) Générer des tranches à partir de la plage spécifiée

Les tranches et les tableaux sont indissociables. Si le tableau est compris comme un immeuble de bureaux, alors le découpage consiste à louer différents étages consécutifs aux utilisateurs. Le processus de location nécessite la sélection de l'étage de départ. et l'étage final, ce processus générera des tranches. L'exemple de code est le suivant :

var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
        highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])

Le résultat du code est le suivant :

Un immeuble de grande hauteur de 30 étages est construit dans le code. ​du tableau va de 1 à 30, représentant différents étages indépendants, les résultats de sortie sont différents plans de location et de vente.

La description du code est la suivante :

Ligne 8, essayez de louer un étage d'intervalle.

Ligne 11, à louer au dessus de 20 étages.

• Ligne 14, location d'étages inférieurs à 2 étages, généralement des commerces.

• Les tranches sont un peu comme les pointeurs en langage C. Les pointeurs peuvent effectuer des opérations, mais au prix d'opérations de mémoire hors limites, les tranches augmentent la taille en fonction des pointeurs, limitant la zone mémoire correspondant à la tranche. en utilisant une tranche, vous ne pouvez pas accéder à l'intérieur de la tranche. L'adresse et la taille sont ajustées manuellement, les tranches sont donc plus sûres et plus puissantes que les pointeurs.

• 2) Représente la tranche d'origine

Dans le format de génération de tranches, lorsque les positions de début et de fin sont ignorées, la tranche générée représentera une tranche cohérente avec la tranche d'origine, et la tranche générée sera cohérente avec la tranche originale dans les données Le contenu est également cohérent, le code est le suivant :

a := []int{1, 2, 3}
fmt.Println(a[:])

a 是一个拥有 3 个元素的切片，将 a 切片使用 a[:] 进行操作后，得到的切片与 a 切片一致，代码输出如下：

3) 重置切片，清空拥有的元素

把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：

a := []int{1, 2, 3}
fmt.Println(a[0:0])

代码输出如下：

直接声明新的切片

除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：

var name []Type

其中 name 表示切片的变量名，Type 表示切片对应的元素类型。

下面代码展示了切片声明的使用过程：

// 声明字符串切片
var strList []string
// 声明整型切片
var numList []int
// 声明一个空切片
var numListEmpty = []int{}
// 输出3个切片
fmt.Println(strList, numList, numListEmpty)
// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))
// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)

代码输出结果：

代码说明如下：

• 第 2 行，声明一个字符串切片，切片中拥有多个字符串。

• 第 5 行，声明一个整型切片，切片中拥有多个整型数值。

• 第 8 行，将 numListEmpty 声明为一个整型切片，本来会在{}中填充切片的初始化元素，这里没有填充，所以切片是空的，但是此时的 numListEmpty 已经被分配了内存，只是还没有元素。

• 第 11 行，切片均没有任何元素，3 个切片输出元素内容均为空。

• 第 14 行，没有对切片进行任何操作，strList 和 numList 没有指向任何数组或者其他切片。

• 第 17 行和第 18 行，声明但未使用的切片的默认值是 nil，strList 和 numList 也是 nil，所以和 nil 比较的结果是 true。

• 第 19 行，numListEmpty 已经被分配到了内存，但没有元素，因此和 nil 比较时是 false。

切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。

使用 make() 函数构造切片

如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：

make( []Type, size, cap )

其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

示例如下：

a := make([]int, 2)
b := make([]int, 2, 10)

fmt.Println(a, b)
fmt.Println(len(a), len(b))

代码输出如下：

其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。

容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。

温馨提示

使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

更多编程相关知识，请访问：编程视频！！

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!