Maison développement back-end Golang Comment utiliser le passage des paramètres de fonction dans Go ?

Comment utiliser le passage des paramètres de fonction dans Go ?

May 11, 2023 pm 05:00 PM
go 函数参数 传递

Go est un langage de programmation fortement typé, et ses paramètres de fonction sont passés par valeur. Cela signifie que lorsque vous transmettez un paramètre à une fonction, vous faites en fait une copie de la valeur du paramètre et transmettez cette valeur à la fonction pour traitement. Par conséquent, lorsque vous utilisez le passage de paramètres de fonction dans Go, vous devez faire attention aux points suivants :

  1. La différence entre les types valeur et les types référence
#🎜 🎜#In Go En plus des types de données de base, qui sont des types valeur, tous les types de données sont des types référence. Lorsque des données de type valeur sont transmises en tant que paramètre de fonction, une copie de la valeur sera transmise à la fonction ; tandis que lorsque des données de type référence sont transmises en tant que paramètre de fonction, l'adresse des données en mémoire sera transmise.

Par exemple, regardons le processus de passage des paramètres de type valeur et de type référence respectivement :

package main

import "fmt"

func main() {
    // 值类型参数传递
    var a = 10
    fmt.Println("Before call func: ", a) // 输出 10

    changeByVal(a)

    fmt.Println("After call func: ", a) // 输出 10

    // 引用类型参数传递
    var b = []int{1, 2, 3}
    fmt.Println("Before call func: ", b) // 输出 [1 2 3]

    changeByRef(b)

    fmt.Println("After call func: ", b) // 输出 [4 5]
}

// 值类型参数传递
func changeByVal(num int) {
    num = 100
}

// 引用类型参数传递
func changeByRef(arr []int) {
    arr[0] = 4
    arr[1] = 5
}
Copier après la connexion

Nous pouvons voir cela dans le cas du passage de paramètres de type valeur, même si La valeur du paramètre est modifiée à 100 à l'intérieur de la fonction, mais la variable externe a n'est toujours pas affectée. Dans le cas du passage de paramètres de type référence, le paramètre est modifié à l'intérieur de la fonction et les données réelles en dehors de la fonction sont également affectées.

    Passage de paramètres de type pointeur
Lorsque nous voulons modifier les données de type référence, nous pouvons utiliser le passage de paramètres de type pointeur. Le pointeur est un type de données qui stocke l'adresse d'une variable, qui est également transmise par valeur dans Go.

Nous pouvons utiliser l'opérateur & pour obtenir l'adresse d'une variable, et l'opérateur * pour obtenir les données stockées dans l'adresse.

Par exemple :

package main

import "fmt"

func main() {
    var a = 10
    var b *int

    b = &a

    fmt.Println("Before call func: ", a) // 输出 10

    changeByPtr(b)

    fmt.Println("After call func: ", a) // 输出 100
}

func changeByPtr(num *int) {
    *num = 100
}
Copier après la connexion

Nous pouvons constater que les données pointées par le pointeur (variable d'origine a) sont modifiées à l'intérieur de la fonction, et les données externes réelles sont également affectées .

    Utiliser... pour représenter des paramètres de longueur variable
Si notre fonction doit recevoir des paramètres de longueur variable, nous pouvons également utiliser. .. pour représenter . Cette syntaxe est similaire aux arguments et kwargs en Python.

Par exemple :

package main

import "fmt"

func main() {
    printNames("John", "Alice", "Bob")
}

func printNames(names ...string) {
    for _, name := range names {
        fmt.Println(name)
    }
}
Copier après la connexion

Dans cet exemple, nous définissons une fonction printNames avec des paramètres de longueur variable, et le type de paramètre qu'elle reçoit est une chaîne. À l'intérieur de la fonction, nous utilisons range pour parcourir tous les paramètres et afficher leurs valeurs une par une.

Résumé

Dans Go, les paramètres de fonction sont transmis par valeur, vous devez donc faire attention à la différence entre les types valeur et les types référence. Lorsque vous devez modifier des données de type référence, vous pouvez utiliser le passage de paramètres de type pointeur. De plus, nous pouvons également utiliser... pour représenter des paramètres de longueur variable, ce qui permet à la fonction de recevoir plus facilement des paramètres de longueur variable.

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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

AI Hentai Generator

AI Hentai Generator

Générez AI Hentai gratuitement.

Article chaud

R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Meilleurs paramètres graphiques
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Comment réparer l'audio si vous n'entendez personne
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
WWE 2K25: Comment déverrouiller tout dans Myrise
4 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Outils chauds

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Comment faire correspondre les horodatages à l'aide d'expressions régulières dans Go ? Comment faire correspondre les horodatages à l'aide d'expressions régulières dans Go ? Jun 02, 2024 am 09:00 AM

Dans Go, vous pouvez utiliser des expressions régulières pour faire correspondre les horodatages : compilez une chaîne d'expression régulière, telle que celle utilisée pour faire correspondre les horodatages ISO8601 : ^\d{4}-\d{2}-\d{2}T \d{ 2}:\d{2}:\d{2}(\.\d+)?(Z|[+-][0-9]{2}:[0-9]{2})$ . Utilisez la fonction regexp.MatchString pour vérifier si une chaîne correspond à une expression régulière.

Comment envoyer des messages Go WebSocket ? Comment envoyer des messages Go WebSocket ? Jun 03, 2024 pm 04:53 PM

Dans Go, les messages WebSocket peuvent être envoyés à l'aide du package gorilla/websocket. Étapes spécifiques : Établissez une connexion WebSocket. Envoyer un message texte : appelez WriteMessage(websocket.TextMessage,[]byte("message")). Envoyez un message binaire : appelez WriteMessage(websocket.BinaryMessage,[]byte{1,2,3}).

Explication détaillée des paramètres de fonction C++ : méthodes d'implémentation, avantages et inconvénients du passage de paramètres indéfinis Explication détaillée des paramètres de fonction C++ : méthodes d'implémentation, avantages et inconvénients du passage de paramètres indéfinis Apr 28, 2024 am 09:48 AM

Passage de paramètres indéfinis C++ : implémenté via l'opérateur..., qui accepte un certain nombre de paramètres supplémentaires. Les avantages incluent la flexibilité, l'évolutivité et le code simplifié. Les inconvénients incluent la surcharge de performances, les difficultés de débogage et la sécurité des types. Des exemples pratiques courants incluent printf() et std::cout, qui utilisent va_list pour gérer un nombre variable de paramètres.

La différence entre la langue Golang et Go La différence entre la langue Golang et Go May 31, 2024 pm 08:10 PM

Go et le langage Go sont des entités différentes avec des caractéristiques différentes. Go (également connu sous le nom de Golang) est connu pour sa concurrence, sa vitesse de compilation rapide, sa gestion de la mémoire et ses avantages multiplateformes. Les inconvénients du langage Go incluent un écosystème moins riche que les autres langages, une syntaxe plus stricte et un manque de typage dynamique.

Comment éviter les fuites de mémoire dans l'optimisation des performances techniques de Golang ? Comment éviter les fuites de mémoire dans l'optimisation des performances techniques de Golang ? Jun 04, 2024 pm 12:27 PM

Les fuites de mémoire peuvent entraîner une augmentation continue de la mémoire du programme Go en : fermant les ressources qui ne sont plus utilisées, telles que les fichiers, les connexions réseau et les connexions à la base de données. Utilisez des références faibles pour éviter les fuites de mémoire et ciblez les objets pour le garbage collection lorsqu'ils ne sont plus fortement référencés. En utilisant go coroutine, la mémoire de la pile de coroutines sera automatiquement libérée à la sortie pour éviter les fuites de mémoire.

Explication détaillée des paramètres de la fonction C++ : essence et précautions du mécanisme sortant Explication détaillée des paramètres de la fonction C++ : essence et précautions du mécanisme sortant Apr 27, 2024 pm 12:00 PM

Il existe deux manières de transmettre des paramètres de fonction en C++ : l'appel par valeur (qui n'affecte pas les paramètres réels) et l'appel par référence (qui affecte les paramètres réels). Les paramètres sortants sont transmis par référence ou par pointeur, et la fonction peut transmettre la valeur à l'appelant en modifiant la variable pointée par la référence de paramètre ou le pointeur. Attention lors de l'utilisation : les paramètres sortants doivent être clairement déclarés, ne peuvent correspondre qu'à un seul paramètre réel et ne peuvent pas pointer vers des variables locales au sein de la fonction. Lors d'un appel en passant un pointeur, veillez à éviter les pointeurs sauvages.

Comment utiliser le wrapper d'erreur de Golang ? Comment utiliser le wrapper d'erreur de Golang ? Jun 03, 2024 pm 04:08 PM

Dans Golang, les wrappers d'erreurs vous permettent de créer de nouvelles erreurs en ajoutant des informations contextuelles à l'erreur d'origine. Cela peut être utilisé pour unifier les types d'erreurs générées par différentes bibliothèques ou composants, simplifiant ainsi le débogage et la gestion des erreurs. Les étapes sont les suivantes : Utilisez la fonction error.Wrap pour envelopper les erreurs d'origine dans de nouvelles erreurs. La nouvelle erreur contient des informations contextuelles de l'erreur d'origine. Utilisez fmt.Printf pour générer des erreurs encapsulées, offrant ainsi plus de contexte et de possibilités d'action. Lors de la gestion de différents types d’erreurs, utilisez la fonction erreurs.Wrap pour unifier les types d’erreurs.

Un guide pour les tests unitaires des fonctions simultanées Go Un guide pour les tests unitaires des fonctions simultanées Go May 03, 2024 am 10:54 AM

Les tests unitaires des fonctions simultanées sont essentiels car cela permet de garantir leur comportement correct dans un environnement simultané. Des principes fondamentaux tels que l'exclusion mutuelle, la synchronisation et l'isolement doivent être pris en compte lors du test de fonctions concurrentes. Les fonctions simultanées peuvent être testées unitairement en simulant, en testant les conditions de concurrence et en vérifiant les résultats.

See all articles