My Go language project development journey

In recent years, with the popularity of Go language in China, more and more programmers have begun to use this language for development. As a programmer, I am no exception. In this article, I will share my Go language project development journey.

Go language for beginners

Before learning Go language, I already had some programming experience and was proficient in Java, Python and other languages. However, when I first came into contact with the Go language, I felt a little unfamiliar. Compared with other languages, the Go language has many unique features, such as:

1. Concurrency processing capabilities: The Go language focuses on concurrency principles when designing and provides efficient, lightweight Goroutine and Channel Mechanism makes concurrent processing very simple.
2. Memory management: Go language uses a garbage collection mechanism, so developers do not need to manage memory themselves, which can greatly improve development efficiency.
3. Static typed language: Unlike dynamically typed languages ​​such as Python, Go language is a statically typed language that can reduce bugs caused by type errors.

After I started learning the Go language, I mainly learned by reading official documents and books such as "Go Language Programming". Following the advice, I started with simple exercises and gradually learned more deeply.

Development Project

After becoming familiar with the basic knowledge of the Go language, I started to develop a small project. The function of this project is to obtain weather information from an API interface and output it to the command line. We named this project GoWeather.

First, we need to understand the return data format of the weather API. By viewing the API interface document, we can obtain the following data:

{
    "weatherinfo": {
        "city": "北京",
        "temp": "32℃",
        "WD": "东南风",
        "WS": "1级",
        "SD": "54%",
        "AP": "980hPa",
        "njd": "暂无实况",
        "time": "17:55",
        "sm": "3.3",
        "isRadar": "1",
        "Radar": "JC_RADAR_AZ9010_JB"
    }
}

Then, we can start coding. First, we need to create a Weather structure and define the properties corresponding to the data in the API:

type Weather struct {
    City    string `json:"city"`
    Temp    string `json:"temp"`
    WD      string `json:"WD"`
    WS      string `json:"WS"`
    SD      string `json:"SD"`
    AP      string `json:"AP"`
    NJD     string `json:"njd"`
    Time    string `json:"time"`
    SM      string `json:"sm"`
    IsRadar string `json:"isRadar"`
    Radar   string `json:"Radar"`
}

Next, we need to write a function to get the weather data and parse it into the Weather type, which The function code is as follows:

func getWeather(city string) (*Weather, error) {
    resp, err := http.Get("http://www.weather.com.cn/data/cityinfo/" + city + ".html")
    if err != nil {
        return nil, err
    }

    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)

    if err != nil {
        return nil, err
    }

    var weatherData struct {
        WeatherInfo Weather `json:"weatherinfo"`
    }

    if err := json.Unmarshal(body, &weatherData); err != nil {
        return nil, err
    }

    return &weatherData.WeatherInfo, nil
}

In the function, we first obtain the data returned by the API interface through the http.Get() method and read it into a variable. Then, we "parse" the string into a Weather type structure through the json.Unmarshal() method and return the structure.

Finally, we need to output the weather information obtained. In order to facilitate testing, we will only output it to the command line at first, and we can later expand it to output weather information to a log file or database. The output function code is as follows:

func printWeather(w *Weather) {
    fmt.Printf("城市: %s
", w.City)
    fmt.Printf("温度: %s
", w.Temp)
    fmt.Printf("风向: %s
", w.WD)
    fmt.Printf("风力: %s
", w.WS)
    fmt.Printf("湿度: %s
", w.SD)
    fmt.Printf("气压: %s
", w.AP)
    fmt.Printf("时间: %s
", w.Time)
}

Test

Similar to other languages, the Go language also provides a rich testing framework, allowing us to easily conduct unit testing.

After completing the above code writing, we need to conduct a simple test and run the following test program to verify whether our code is correct:

func TestWeather(t *testing.T) {
    city := "101010100"
    w, err := getWeather(city)

    if err != nil {
        t.Error(err)
    } else {
        printWeather(w)
    }
}

When running the test program, we can see The following output:

城市: 北京
温度: 32℃
风向: 东南风
风力: 1级
湿度: 54%
气压: 980hPa
时间: 17:55

It can be seen from the output that the weather information we obtained is correct.

Summary

Through this simple project, I have a deeper understanding of the Go language. In actual development, the concurrent processing and memory management of the Go language have improved our efficiency and given us a better user experience. I believe that in the days to come, I will continue to use and study the Go language.

The above is the detailed content of My Go language project development journey. For more information, please follow other related articles on the PHP Chinese website!