Meine Entwicklungsreise zum Go-Sprachprojekt

Mit der Popularität der Go-Sprache in China haben in den letzten Jahren immer mehr Programmierer begonnen, diese Sprache für die Entwicklung zu verwenden. Als Programmierer bin ich keine Ausnahme. In diesem Artikel werde ich meine Reise zur Entwicklung des Go-Sprachprojekts teilen.

Anfänger beim Erlernen der Go-Sprache

Bevor ich die Go-Sprache lernte, hatte ich bereits einige Programmiererfahrung und beherrschte Java, Python und andere Sprachen. Als ich jedoch zum ersten Mal mit der Go-Sprache in Berührung kam, kam ich mir etwas fremd vor. Im Vergleich zu anderen Sprachen verfügt die Go-Sprache über viele einzigartige Funktionen, wie zum Beispiel:

1. Funktionen zur Parallelitätsverarbeitung: Die Go-Sprache konzentriert sich beim Entwerfen auf Parallelitätsprinzipien und bietet effiziente, leichte Goroutine- und Kanalmechanismen, die die Parallelitätsverarbeitung vereinfachen ganz einfach.
2. Speicherverwaltung: Die Go-Sprache verwendet einen Garbage-Collection-Mechanismus, sodass Entwickler den Speicher nicht selbst verwalten müssen, was die Entwicklungseffizienz erheblich verbessern kann.
3. Statisch typisierte Sprache: Im Gegensatz zu dynamisch typisierten Sprachen wie Python ist die Go-Sprache eine statisch typisierte Sprache, die durch Typfehler verursachte Fehler reduzieren kann.

Nachdem ich angefangen habe, die Go-Sprache zu lernen, habe ich sie hauptsächlich durch das Lesen offizieller Dokumente und Bücher wie „Go Language Programming“ gelernt. Den Ratschlägen folgend, begann ich mit einfachen Übungen und lernte nach und nach tiefer.

Entwicklungsprojekt

Nachdem ich mich mit den Grundlagen der Go-Sprache vertraut gemacht hatte, begann ich mit der Entwicklung eines kleinen Projekts. Die Funktion dieses Projekts besteht darin, Wetterinformationen von einer API-Schnittstelle abzurufen und an die Befehlszeile auszugeben. Wir haben dieses Projekt GoWeather genannt.

Zuerst müssen wir das Rückgabedatenformat der Wetter-API verstehen. Wenn wir uns das API-Schnittstellendokument ansehen, können wir die folgenden Daten erhalten:

{
    "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"
    }
}

Dann können wir mit dem Codieren beginnen. Zuerst müssen wir eine Wetterstruktur erstellen und die Eigenschaften definieren, die den Daten in der API entsprechen:

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"`
}

Als nächstes müssen wir eine Funktion schreiben, um die Wetterdaten abzurufen und sie in den Wettertyp zu analysieren. Der Funktionscode lautet wie folgt folgt: In der Funktion

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
}

erhalten wir zunächst die von der API-Schnittstelle zurückgegebenen Daten über die Methode http.Get() und lesen sie in eine Variable ein. Anschließend „analysieren“ wir die Zeichenfolge mithilfe der Methode json.Unmarshal() in eine Struktur vom Typ Weather und geben die Struktur zurück.

Abschließend müssen wir die erhaltenen Wetterinformationen ausgeben. Um das Testen zu erleichtern, geben wir es zunächst nur in der Befehlszeile aus und können es später erweitern, um Wetterinformationen in einer Protokolldatei oder Datenbank auszugeben. Der Ausgabefunktionscode lautet wie folgt:

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

Ähnlich wie andere Sprachen bietet auch die Go-Sprache ein umfangreiches Test-Framework, das uns die einfache Durchführung von Unit-Tests ermöglicht.

Nach Abschluss des obigen Codeschreibens müssen wir einen einfachen Test durchführen und das folgende Testprogramm ausführen, um zu überprüfen, ob unser Code korrekt ist:

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

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

Beim Ausführen des Testprogramms können wir die folgende Ausgabe sehen:

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

From Die Ausgabe Die Ergebnisse zeigen, dass die von uns erhaltenen Wetterinformationen korrekt sind.

Zusammenfassung

Durch dieses einfache Projekt habe ich ein tieferes Verständnis der Go-Sprache erlangt. In der tatsächlichen Entwicklung haben die gleichzeitige Verarbeitung und Speicherverwaltung der Go-Sprache unsere Effizienz verbessert und uns ein besseres Benutzererlebnis beschert. Ich glaube, dass ich in den kommenden Tagen weiterhin die Go-Sprache verwenden und studieren werde.

Das obige ist der detaillierte Inhalt vonMeine Entwicklungsreise zum Go-Sprachprojekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!