Comment utiliser append() en langage Go

Dans le langage Go, la fonction append() est utilisée pour ajouter dynamiquement des éléments à une tranche. Vous pouvez ajouter des éléments à la fin de la tranche et renvoyer le résultat lors de l'appel de la fonction append, vous devez utiliser la variable slice d'origine. pour recevoir la valeur de retour. Pour ajouter un élément, vous pouvez utiliser l'instruction "slice = append(slice,elem1,elem2)". Pour ajouter une tranche, utilisez l'instruction "slice = append(slice,anotherSlice...)".

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

La fonction intégrée append() du langage Go peut ajouter dynamiquement des éléments à une tranche.

Points clés :

• append() est utilisé pour ajouter des éléments à la fin de la tranche et renvoyer le résultat.
• Lors de l'appel de la fonction append, vous devez utiliser la variable de tranche d'originepour recevoir la valeur de retour
• append pour ajouter des éléments Si la tranche a encore capacité, les nouveaux éléments seront placés dans l'espace restant derrière la tranche. tranche d'origine.Lorsque les données sous-jacentes ne peuvent pas être assemblées, Go créera un nouveau tableau sous-jacent pour enregistrer la tranche, et l'adresse de la tranche changera également en conséquence.
• Après avoir attribué une nouvelle adresse, copiez les éléments dans la tranche d'origine un par un dans la nouvelle tranche et revenez.

(1) append() ajoute un élément

slice = append(slice,elem1,elem2)

append Entre parenthèses, plusieurs paramètres peuvent être ajoutés après la première tranche de paramètres.

package  main
import "fmt"
//切片进阶操作
 
func main(){
	//append()为切片追加元素
	s1 := []string {"火鸡面","辛拉面","汤达人"}
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))
	
	//调用append函数必须用原来的切片变量接收返回值
	s1 = append(s1,"小当家") //append追加元素，原来的底层数组装不下的时候，Go就会创建新的底层数组来保存这个切片
  fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))//cap增加两倍
}

Résultat de sortie :

s1=[火鸡面 辛拉面 汤达人] len(s1)=3 cap(s1)=3
s1=[火鸡面 辛拉面 汤达人 小当家] len(s1)=4 cap(s1)=6

(2)append() ajoute une tranche

slice = append(slice,anotherSlice...)

append Il ne peut y avoir que deux paramètres entre parenthèses, une tranche et l'autre tranche ajoutée.

package  main
import "fmt"
//切片进阶操作
 
func main(){
	//append()为切片追加元素
	s1 := []string {"火鸡面","辛拉面","汤达人"}
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))
	
	//调用append函数必须用原来的切片变量接收返回值
	s1 = append(s1,"小当家") //append动态追加元素，原来的底层数组容纳不下足够多的元素时，切片就会开始扩容，Go底层数组就会把底层数组换一个
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1),cap(s1))

	//调用append添加一个切片
	s2 := []string{"脆司令","圣斗士"}
	s1 = append(s1,s2...)//...表示拆开切片，再添加
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d",s1,len(s1),cap(s1))
}

Résultat de sortie :

s1=[火鸡面 辛拉面 汤达人] len(s1)=3 cap(s1)=3
s1=[火鸡面 辛拉面 汤达人 小当家] len(s1)=4 cap(s1)=6
s1=[火鸡面 辛拉面 汤达人 小当家 脆司令 圣斗士] len(s1)=6 cap(s1)=6

(3) Lorsque vous utilisez make pour créer une tranche, c'est une erreur courante d'ajouter des éléments avec append()

package main

import "fmt"

func main(){
	var a = make([]int, 5, 10)
	fmt.Println(a)
	fmt.Printf("%p\n",a)
	for i := 0; i <10; i++ {
		a = append(a,i)
    //%p 打印切片地址
		fmt.Printf("%v,%p,cap(a):%d\n",a,a,cap(a))
	} 
}

Résultat de sortie :

[0 0 0 0 0]
0xc0000180a0
[0 0 0 0 0 0],0xc0000180a0,cap(a):10
[0 0 0 0 0 0 1],0xc0000180a0,cap(a):10
[0 0 0 0 0 0 1 2],0xc0000180a0,cap(a):10
[0 0 0 0 0 0 1 2 3],0xc0000180a0,cap(a):10
[0 0 0 0 0 0 1 2 3 4],0xc0000180a0,cap(a):10
[0 0 0 0 0 0 1 2 3 4 5],0xc00007c000,cap(a):20
[0 0 0 0 0 0 1 2 3 4 5 6],0xc00007c000,cap(a):20
[0 0 0 0 0 0 1 2 3 4 5 6 7],0xc00007c000,cap(a):20
[0 0 0 0 0 0 1 2 3 4 5 6 7 8],0xc00007c000,cap(a):20
[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9],0xc00007c000,cap(a):20

Remarque :

(1) make crée une tranche, avec La longueur par défaut a une valeur par défaut.

append() ajoute des éléments après la valeur par défaut, plutôt que d'écraser la valeur par défaut.

(2) Lorsque l'élément dépasse la capacité 10 définie lors de la création de make et que le numéro inférieur d'origine ne peut pas être assemblé, une nouvelle adresse continue sera utilisée pour stocker l'élément.

(4) Utilisez ajouter pour supprimer des éléments

Go ne fournit pas de fonction pour supprimer spécifiquement des éléments. Au lieu de cela, les éléments sont supprimés via les caractéristiques de la tranche elle-même.

C'est-à-dire prendre l'élément supprimé comme point de division, puis utiliser append pour reconnecter la mémoire des deux parties avant et après.

Par exemple :

Si vous souhaitez supprimer un élément dans la tranche s, l'index de l'élément supprimé est index

Ensuite, le processus de suppression est

s = append ( s[ :index ], s[ index+1: ] )

Reconnectez les deux parties avant et après, ce qui est essentiellement le point de suppression Les éléments sont avancés, la mémoire est reconnectée.

package main

import "fmt"

func main(){
	a1 := [...]int{1,2,5,3,78,9,4,9,23,32}
	s1 := a1[:] //得到切片
	fmt.Println(s1)

	//删除索引为4的78
	s1 = append(s1[:4],s1[5:]...)
	fmt.Println(s1)
	fmt.Println(a1)
}

Le principe de l'utilisation de append pour supprimer des éléments dans Go est :

(Le dessin est moche...)

Résultat de sortie :

[1 2 5 3 78 9 4 9 23 32]
[1 2 5 3 9 4 9 23 32]
[1 2 5 3 9 4 9 23 32 32]

Après avoir compris, vous pouvez essayer de deviner la sortie du programme suivante Quoi est :

package main

import "fmt"

func main(){
	a1 := [...]int{1,2,5,3,78,9,4,9,23,32}
	s1 := a1[:] //得到切片
	fmt.Println(s1)

	//删掉索引为2和3的5，3
	s1 = append(s1[:2],s1[4:]...)
	fmt.Println(s1)
	fmt.Println(a1)
}

Résultat correct :

[1 2 5 3 78 9 4 9 23 32]
[1 2 78 9 4 9 23 32]
[1 2 78 9 4 9 23 32 23 32]

[Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation]

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!