Partagez des notes sur l'utilisation de Slice in go

Cet article est rédigé par la rubrique go languagetutorial pour partager avec vous les précautions d'utilisation de Slice in go. J'espère qu'il sera utile aux amis dans le besoin !

                                                                                                           

Cet article traite de l'utilisation de slice dans Go. Jetons un coup d'œil au programme suivant

package mainimport (
    "fmt"
    )func main() {
    var array [10]int
    var slice = array[5:6]
    fmt.Println("lenth of slice: ", len(slice))
    fmt.Println("capacity of slice: ", cap(slice))
    fmt.Println(&slice[0] == &array[5])}

• Ce que je veux dire à propos de ce programme est : la fonction principale définit un tableau d'entiers de 10 longueurs, puis définit une tranche. slice, coupez le 6ème élément du tableau, et enfin imprimez la longueur et la capacité de la tranche pour déterminer si les adresses du premier élément de la tranche et du 6ème élément du tableau sont égales.
• Tout le monde se demande si le premier élément de la tranche est égal au 6ème élément du tableau. Peut-être pouvez-vous exécuter ce programme pour le prouver et regarder les résultats ci-dessous. D'accord, je ne serai pas trop pointilleux. dans le programme ci-dessus, le tableau est créé et partage l'espace de stockage avec le tableau. La position de départ de la tranche est array[5], la longueur est 1 et la capacité est 5. Les adresses de slice[0]. ] et array[5] sont identiques.

Ensuite, jetons un coup d'œil à ce programme et essayons de l'exécuter vous-même. La pratique pratique est le meilleur professeur

package mainimport (
    "fmt")func AddElement(slice []int, e int) []int {
    return append(slice, e)
    }func main() {
    var slice []int
    slice = append(slice, 1, 2, 3)
    newSlice := AddElement(slice, 4)
    fmt.Println(&slice[0] == &newSlice[0])}

• Ce que je veux exprimer dans le paragraphe ci-dessus, c'est que la fonction AddElement() accepte une tranche. et un élément, et ajoute des éléments à la tranche et renvoie la tranche. Définissez une tranche dans la fonction main(), ajoutez 3 éléments à la tranche, puis appelez AddElement() pour continuer à ajouter le quatrième élément à la tranche et définir une nouvelle tranche newSlice. Enfin, il est jugé si la nouvelle tranche newSlice et l'ancienne tranche partagent un espace de stockage
• Je crois que de nombreux amis pensent que l'ajout peut déclencher l'expansion de l'ancienne Slice, mais ils n'en sont pas sûrs, alors continuez à lire "Il est possible" Remplacé par "oui":
  1. Lorsque la fonction d'ajout est exécutée, elle déterminera si la capacité de la tranche peut stocker les nouveaux éléments. Sinon, elle demandera à nouveau de l'espace de stockage. Le nouvel espace de stockage sera 2 fois ou 1,25 fois l'original (en fonction de l'extension de la taille de l'espace d'origine). Dans cet exemple, deux opérations d'ajout sont en fait effectuées la première fois que l'espace passe à 4, donc le deuxième ajout ne s'agrandira pas, donc l'ancien et le nouveau. les tranches partageront un espace de stockage. Le programme affichera « vrai ».

Ensuite, continuez à voir comment ce programme va sortir. Vous pouvez y réfléchir ou exécuter le programme :

 package mainimport (
    "fmt")func main() {
    orderLen := 5
    order := make([]uint16, 2 * orderLen)
    pollorder := order[:orderLen:orderLen]
    lockorder := order[orderLen:][:orderLen:orderLen]
    fmt.Println("len(pollorder) = ", len(pollorder))
    fmt.Println("cap(pollorder) = ", cap(pollorder))
    fmt.Println("len(lockorder) = ", len(lockorder))
    fmt.Println("cap(lockorder) = ", cap(lockorder))}

Après avoir exécuté le programme ci-dessus avec des questions, il sera préférable de continuer à lire ci-dessous. Toute la personne se sentira soudainement éclairée. . Au sentiment, si vous n'y croyez pas, vous pouvez essayer :

1. Définir un ordre de tranche d'une longueur de 10 dans le programme. Pollorder et lockorder sont des tranches générées en effectuant des opérations order[start, stop, max] sur le. order slice respectivement. Enfin, le programme imprime respectivement pollorder et lockorder.
2. order[start,stop,max] signifie l'ordre de découpage, la nouvelle plage de découpage est [start, stop) et la nouvelle capacité de découpage est max. La longueur de la commande est 2 fois celle de orderLen. La tranche pollorder fait référence à la première moitié de la commande et la lockorder fait référence à la seconde moitié de la commande, c'est-à-dire que la commande originale est divisée en deux segments. Par conséquent, la longueur et la capacité du pollorder et du lockerorder sont toutes deux orderLen, soit 5.

Cet article contient quelques explications sur l'utilisation de Slice. J'espère qu'il pourra aider les partenaires dans le besoin. Pour plus d'informations sur l'utilisation de Slice, veuillez laisser un message pour en discuter

.

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!