golang renvoie différents champs

Golang est un langage de programmation qui prend en charge plusieurs valeurs de retour, ce qui signifie que vous pouvez renvoyer plusieurs valeurs à partir d'une fonction. Cependant, il nous suffit parfois de renvoyer un ou quelques champs au lieu de toutes les valeurs. Alors, comment renvoyer différents champs dans Golang ?

Dans Golang, nous pouvons utiliser des structures pour définir les champs qui doivent être renvoyés. Une structure est un type de données personnalisé constitué d’un ensemble de champs de types identiques ou différents. Nous pouvons encapsuler les champs qui doivent être renvoyés dans une structure dans la fonction, puis renvoyer l'instance de structure.

Par exemple, supposons que nous ayons une fonction GetUserInfo qui interroge les informations de l'utilisateur dans la base de données. Les informations utilisateur comprennent plusieurs champs tels que le nom, l'âge, le sexe, l'adresse, etc., et nous n'avons besoin de renvoyer que deux champs : le nom et l'âge. On peut définir une structure comme celle-ci :

type UserBasicInfo struct{
    Name string
    Age int
}

Ensuite dans la fonction GetUserInfo, on peut utiliser cette structure pour définir le type de retour :

func GetUserInfo(userId int) UserBasicInfo {
    //从数据库中查询用户信息
    userInfo := queryUserInfo(userId)

    //封装需要返回的字段
    return UserBasicInfo{
        Name: userInfo.Name,
        Age: userInfo.Age,
    }
}

Quand on appelle la fonction GetUserInfo, elle retournera une instance du type UserBasicInfo, qui uniquement contient les champs Nom et Âge. Nous pouvons obtenir les différents champs renvoyés comme ceci :

userInfo := GetUserInfo(123)
name := userInfo.Name
age := userInfo.Age

En plus d'utiliser des structures pour renvoyer différents champs, nous pouvons également utiliser des structures anonymes et des littéraux de fonction pour simplifier le code. Cela évite de définir le type de structure et renvoie à la place une instance de structure anonyme directement dans la fonction.

Par exemple, on peut définir une fonction comme celle-ci :

func GetUserName(id int) string{
    userInfo := struct{
        Id int
        Name string
    }{Id:id, Name:"unknown"}

    //从数据库中查询用户信息
    result := queryUserInfo(id)
    if result.Name != ""{
        userInfo.Name = result.Name
    }

    return userInfo.Name
}

Dans cette fonction, on définit une structure anonyme contenant deux champs : id et name. Nous interrogeons la base de données pour obtenir des informations sur les utilisateurs et les ajoutons à une structure anonyme. Enfin, il suffit de renvoyer le champ nom.

En même temps, nous pouvons renvoyer une structure contenant différents champs en utilisant des littéraux de fonction. Un littéral de fonction est une fonction anonyme qui n’a pas de nom et qui peut être déclarée et exécutée en cas de besoin. Par exemple :

getUserInfo := func(id int) (name string, age int){
    //从数据库中查询用户信息
    userInfo := queryUserInfo(id)

    //封装需要返回的字段
    name = userInfo.Name
    age = userInfo.Age

    return
}

Dans cet exemple, nous déclarons une fonction littérale getUserInfo pour interroger les informations utilisateur. Cette fonction renvoie deux champs : nom et âge. Nous pouvons obtenir différentes valeurs de retour comme celle-ci :

name, age := getUserInfo(123)

Dans Golang, il existe de nombreuses façons de renvoyer différents champs. Nous pouvons choisir la méthode la plus appropriée en fonction de notre situation et de nos besoins réels. Plus précisément, nous pouvons utiliser des structures, des structures anonymes, des littéraux de fonction ou d'autres méthodes pour renvoyer les champs requis. Ces méthodes peuvent nous aider à améliorer la réutilisabilité et la lisibilité du code, ainsi que la maintenabilité et la facilité d'utilisation du code.

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!