Praktische Erfahrung in der testgetriebenen Entwicklung in Golang

Praktische Erfahrung in testgetriebener Entwicklung in Golang

Übersicht:
Testgetriebene Entwicklung (TDD) ist eine gängige Softwareentwicklungsmethode. Der Schwerpunkt liegt auf dem Schreiben von Testcode, der die Funktionalität überprüft, bevor der eigentliche Code geschrieben wird. Durch das Schreiben von Testcode können Entwickler Anforderungen besser verstehen, Schnittstellen genau definieren und die Qualität und Wartbarkeit des Codes verbessern. In diesem Artikel wird die Golang-Sprache als Beispiel verwendet, um die Verwendung der TDD-Entwicklung in tatsächlichen Projekten vorzustellen.

1. Umgebungseinstellungen und Abhängigkeitsmanagement
   Bevor Sie TDD starten, müssen Sie zunächst die Golang-Entwicklungsumgebung vorbereiten. Stellen Sie sicher, dass Golang installiert ist und die Umgebungsvariablen GOROOT und GOPATH festgelegt sind.

In Golang stehen viele Tools für das Abhängigkeitsmanagement zur Auswahl. Zu den gebräuchlichsten gehören go mod, dep usw. Am Beispiel von Go Mod verwenden Sie den folgenden Befehl, um das Projekt zu initialisieren:

go mod init <项目名>

2. Testdateien erstellen
   Um TDD auszuführen, sollte jede Funktion über entsprechenden Testcode verfügen. In Golang wird der Testdatei das Suffix _test.go hinzugefügt und Test wird vor dem Funktionsnamen hinzugefügt. _test.go为后缀，并且在函数名前加上Test。

以一个简单的计算器为例，我们可以创建一个calculator_test.go的文件，并编写测试代码：

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    c := add(2, 3)
    if c != 5 {
        t.Error("Expected 5, got ", c)
    }
}

func TestSubtract(t *testing.T) {
    c := subtract(5, 2)
    if c != 3 {
        t.Error("Expected 3, got ", c)
    }
}

3. 编写功能代码
   测试代码编写完成后，我们需要编写功能代码来满足测试的需求。在本例中，我们可以在calculator.go文件中编写功能代码：

package main

func add(a, b int) int {
    return a + b
}

func subtract(a, b int) int {
    return a - b
}

4. 运行测试
   测试代码和功能代码编写完成后，我们可以运行测试代码来验证功能的正确性。在项目根目录下，运行以下命令：

go test

如果输出结果中没有出现错误，那么说明测试通过。

5. 迭代开发
   TDD的核心思想是迭代开发。在已经通过的测试代码基础上，我们可以添加更多的测试来覆盖更多的场景。然后，根据这些测试来修改和完善功能代码。

例如，我们可以添加一个测试来测试乘法运算：

func TestMultiply(t *testing.T) {
    c := multiply(4, 3)
    if c != 12 {
        t.Error("Expected 12, got ", c)
    }
}

然后，在功能代码中添加乘法函数：

func multiply(a, b int) int {
    return a * b
}

再次运行go test

Am Beispiel eines einfachen Taschenrechners können wir eine Datei calculator_test.go erstellen und den Testcode schreiben:

6. func TestDivideByZero(t *testing.T) {
       defer func() {
           if r := recover(); r != nil {
               if r != "divide by zero" {
                   t.Error("Expected 'divide by zero' error")
               }
           } else {
               t.Error("Expected 'divide by zero' error")
           }
       }()
       divide(5, 0)
   }

   
   Funktionscode schreiben
Test Nach dem Wenn der Code geschrieben ist, müssen wir Funktionscode schreiben, um die Testanforderungen zu erfüllen. In diesem Fall können wir den Funktionscode in die Datei calculator.go schreiben:

func divide(a, b int) int {
    if b == 0 {
        panic("divide by zero")
    }
    return a / b
}

Führen Sie den Test aus

Nachdem der Testcode und der Funktionscode geschrieben wurden, Wir können Testcode ausführen, um die Funktionalität zu überprüfen. Führen Sie im Stammverzeichnis des Projekts den folgenden Befehl aus:

rrreee

Wenn die Ausgabe keine Fehler enthält, ist der Test erfolgreich.

Iterative EntwicklungDie Kernidee von TDD ist die iterative Entwicklung. Basierend auf dem bereits bestandenen Testcode können wir weitere Tests hinzufügen, um mehr Szenarien abzudecken. Anschließend modifizieren und verbessern Sie den Funktionscode basierend auf diesen Tests.

Zum Beispiel können wir einen Test hinzufügen, um die Multiplikationsoperation zu testen:

rrreee🎜Dann fügen Sie die Multiplikationsfunktion im Funktionscode hinzu: 🎜rrreee🎜Führen Sie den Befehl go test erneut aus, falls dies der Fall ist Wenn wir den Test bestehen, bedeutet das, dass unsere iterative Entwicklung auf dem richtigen Weg ist. 🎜🎜🎜Umgang mit anormalen Situationen🎜In der tatsächlichen Entwicklung müssen wir verschiedene anormale Situationen berücksichtigen und entsprechende Testcodes schreiben. 🎜🎜🎜Zum Beispiel müssen wir im Rechner den Fall berücksichtigen, bei dem der Divisor 0 ist. Wir können einen Test wie folgt hinzufügen: 🎜rrreee🎜 Fügen Sie dann die Divisionsfunktion in den Funktionscode ein: 🎜rrreee🎜Führen Sie den Test aus und wir erhalten ein bestandenes Testergebnis. 🎜🎜Zusammenfassung: 🎜Durch die TDD-Entwicklung können wir die Codequalität und Wartbarkeit verbessern. In Golang können wir durch das Schreiben von Testcode die Anforderungen besser verstehen, die Schnittstelle genau definieren und die Korrektheit des Codes sicherstellen. 🎜🎜Obwohl TDD die Entwicklungszeit und den Arbeitsaufwand erhöht, kann es die spätere Debugging- und Wartungszeit verkürzen sowie die Entwicklungseffizienz und Codequalität verbessern. Daher ist TDD in tatsächlichen Projekten von großer Bedeutung, insbesondere bei Projekten mit komplexer Logik und häufigen Anforderungsänderungen. 🎜🎜Durch die Einleitung dieses Artikels hoffe ich, dass die Leser die praktischen Erfahrungen der testgetriebenen Entwicklung in Golang besser verstehen und anwenden können. Lassen Sie uns gemeinsam hochwertigen Code erstellen! 🎜

Das obige ist der detaillierte Inhalt vonPraktische Erfahrung in der testgetriebenen Entwicklung in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!