golang returns different fields

Golang is a programming language that supports multiple return values, which means you can return multiple values ​​from a function. However, sometimes we only need to return one or a few fields instead of all values. So, how to return different fields in Golang?

In Golang, we can use structures to define the fields that need to be returned. A structure is a custom data type that consists of a set of fields of the same or different types. We can encapsulate the fields that need to be returned into a structure in the function, and then return the structure instance.

For example, suppose we have a function GetUserInfo that queries the user's information from the database. User information includes multiple fields such as name, age, gender, address, etc., and we only need to return two fields: name and age. We can define a structure like this:

type UserBasicInfo struct{
    Name string
    Age int
}

Then in the GetUserInfo function, we can use this structure to define the return type:

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

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

When we call the GetUserInfo function, it will return a UserBasicInfo An instance of the type, which contains only two fields: name and age. We can get the different fields returned like this:

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

In addition to using structures to return different fields, we can also use anonymous structures and function literals to simplify the code. This avoids defining the structure type and instead returns an anonymous structure instance directly in the function.

For example, we can define a function like this:

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
}

In this function, we define an anonymous structure containing two fields: id and name. We query the database for user information and add it to an anonymous structure. Finally, we just need to return the name field.

At the same time, we can return a structure containing different fields by using function literals. A function literal is an anonymous function that has no name and can be declared and run when needed. For example:

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

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

    return
}

In this example, we declare a function literal getUserInfo to query user information. This function returns two fields: name and age. We can get different return values ​​like this:

name, age := getUserInfo(123)

In Golang, there are many ways to return different fields. We can choose the most suitable method according to our actual situation and needs. Specifically, we can use structures, anonymous structures, function literals, or other methods to return the required fields. These methods can help us improve the reusability and readability of the code, as well as the maintainability and ease of use of the code.

The above is the detailed content of golang returns different fields. For more information, please follow other related articles on the PHP Chinese website!