So verwenden Sie goto in der Go-Sprache

In der Go-Sprache wird die goto-Anweisung für bedingungslose Sprünge verwendet, die bedingungslos auf die angegebene Zeile im Programm übertragen werden können. Sie führt bedingungslose Sprünge zwischen Codes durch Beschriftungen durch. Auf goto folgt eine Bezeichnung. Die Bedeutung dieser Bezeichnung besteht darin, dem Go-Programm mitzuteilen, welche Codezeile als nächstes ausgeführt werden soll. Die Syntax lautet „goto label;... ...label: expression;“. goto unterbricht die ursprüngliche Codeausführungsreihenfolge und springt direkt zur angegebenen Zeile, um den Code auszuführen. Die goto-Anweisung wird normalerweise in Verbindung mit bedingten Anweisungen verwendet und kann zum Implementieren bedingter Übertragungen, zum Bilden von Schleifen und zum Herausspringen aus Schleifenkörpern verwendet werden.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Die goto-Anweisung in der Go-Sprache

goto Gu Yansi bedeutet „Sprung“.

Die goto-Anweisung der Go-Sprache kann bedingungslos zur angegebenen Zeile im Programm wechseln und über Beschriftungen bedingungslos zwischen Codes springen. Gleichzeitig ist die goto-Anweisung auch hilfreich, um schnell aus Schleifen zu springen und wiederholte Ausgänge zu vermeiden Anweisungen können den Implementierungsprozess einiger Codes vereinfachen.

Auf die Syntax der goto-Anweisung

goto folgt eine Beschriftung. Diese Beschriftung soll dem Go-Programm mitteilen, welche Codezeile als nächstes ausgeführt werden soll.

Also ist es bei goto das Wichtigste, darauf zu achten, wie und wo dieses Etikett platziert wird. Das Flussdiagramm der

goto 标签;
...
...
标签: 表达式;

goto-Anweisung sieht wie folgt aus:

Verwendung der goto-Anweisung

• goto kann die ursprüngliche Codeausführungsreihenfolge unterbrechen und direkt zu einer bestimmten Codeausführungszeile springen.

import "fmt"

func main() {

    goto flag
    fmt.Println("B")
flag:
    fmt.Println("A")

}

Das Ausführungsergebnis gibt nicht B aus, sondern nur A.

A

• goto-Anweisungen werden normalerweise in Verbindung mit bedingten Anweisungen verwendet. Es kann verwendet werden, um eine bedingte Übertragung zu implementieren, eine Schleife zu bilden, aus dem Schleifenkörper zu springen und andere Funktionen.

Hier ist ein Beispiel für die Verwendung von goto zur Implementierung einer Schleife, die 1 bis 5 ausgibt.

import "fmt"

func main() {
    i := 1
flag:
    if i <= 5 {
        fmt.Println(i)
        i++
        goto flag
    }
}

Die Ausgabe ist wie folgt

Ein weiteres Beispiel: Verwenden Sie goto, um den Effekt eines Typumbruchs zu erzielen.

import "fmt"

func main() {
    i := 1
    for {
        if i > 5 {
            goto flag
        }
        fmt.Println(i)
        i++
    }
flag:
}

Die Ausgabe sieht wie folgt aus

Verwenden Sie abschließend als Beispiel goto, um den Effekt des Typs continue zu erzielen und alle geraden Zahlen von 1 bis 10 zu drucken.

import "fmt"

func main() {
    i := 1
flag:
    for i <= 10 {
        if i%2 == 1 {
            i++
            goto flag
        }
        fmt.Println(i)
        i++
    }
}

Die Ausgabe ist wie folgt:

Verwenden Sie goto, um mehrstufige Schleifen zu verlassen. Der folgende Code muss zweistufige Schleifen kontinuierlich verlassen, wenn die Bedingungen erfüllt sind. Die herkömmliche Codierungsmethode lautet wie folgt folgt:

package main
import "fmt"
func main() {
    var breakAgain bool
    // 外循环
    for x := 0; x < 10; x++ {
        // 内循环
        for y := 0; y < 10; y++ {
            // 满足某个条件时, 退出循环
            if y == 2 {
                // 设置退出标记
                breakAgain = true
                // 退出本次循环
                break
            }
        }
        // 根据标记, 还需要退出一次循环
        if breakAgain {
                break
        }
    }
    fmt.Println("done")
}

Codebeschreibung Wie folgt:

Zeile 10, baue die äußere Schleife.

• Zeile 13, konstruieren Sie die innere Schleife.

• Zeile 16: Wenn y==2, müssen alle for-Schleifen beendet werden.

• Zeile 19. Standardmäßig kann die Schleife nur Schicht für Schicht beendet werden. Dazu müssen Sie eine Zustandsvariable breakAgain festlegen. Wenn Sie sie beenden müssen, setzen Sie diese Variable auf true.

• In Zeile 22 verwenden Sie break, um die aktuelle Schleife zu verlassen. Nach der Ausführung wird der Code in Zeile 28 übertragen.

• Zeile 28: Verwenden Sie nach dem Verlassen einer Schicht der Schleife die Variable breakAgain, um zu bestimmen, ob die äußere Schicht der Schleife erneut verlassen werden muss.

• Zeile 34, nach Verlassen aller Schleifen, Ausdruck fertig.

• Optimieren Sie den obigen Code mithilfe der goto-Anweisung der Go-Sprache:

  package main
  import "fmt"
  func main() {
      for x := 0; x < 10; x++ {
          for y := 0; y < 10; y++ {
              if y == 2 {
                  // 跳转到标签
                  goto breakHere
              }
          }
      }
      // 手动返回, 避免执行进入标签
      return
      // 标签
  breakHere:
      fmt.Println("done")
  }

Die Codebeschreibung lautet wie folgt:

Verwenden Sie in Zeile 13 die goto-Anweisung, um zur angegebenen Beschriftung zu springen, die online definiert ist 23.

• Zeile 20, die Beschriftung kann nur von goto verwendet werden, hat jedoch keinen Einfluss auf den Codeausführungsprozess. Wenn Sie hier nicht manuell zurückkehren, wird auch die 24. Codezeile ausgeführt, wenn die Bedingungen nicht erfüllt sind.

• Zeile 23, definiere das BreakHere-Tag.

• Nach der Verwendung der goto-Anweisung können Sie alle Schleifen ohne zusätzliche Variablen schnell verlassen.

Verwenden Sie goto, um Fehler zentral zu behandeln

Es ist sehr schwierig, wenn bei der Behandlung mehrerer Fehler Codeduplizierungen auftreten, zum Beispiel:

err := firstCheckError()
if err != nil {
    fmt.Println(err)
    exitProcess()
    return
}
err = secondCheckError()
if err != nil {
    fmt.Println(err)
    exitProcess()
    return
}
fmt.Println("done")

Die Codebeschreibung lautet wie folgt:

Zeile 1, führen Sie a aus bestimmte Logik und geben einen Fehler zurück.

• Zeile 2 bis 6: Wenn ein Fehler auftritt, drucken Sie den Fehler aus und beenden Sie den Vorgang.

• Zeile 8, bestimmte Logik ausführen und einen Fehler zurückgeben.

• Zeilen 10 bis 14, Beenden des Prozesses nach Auftreten eines Fehlers.

• Zeile 16, keine Fehler, Druck abgeschlossen.

• Im obigen Code handelt es sich teilweise um wiederholten Fehlerbehandlungscode. Wenn diesen Codes später weitere Beurteilungen hinzugefügt werden, müssen diese ähnlichen Codes nacheinander geändert werden, was leicht zu Versehen und Fehlern führen kann.

  使用 goto 语句来实现同样的逻辑：

      err := firstCheckError()
      if err != nil {
          goto onExit
      }
      err = secondCheckError()
      if err != nil {
          goto onExit
      }
      fmt.Println("done")
      return
  onExit:
      fmt.Println(err)
      exitProcess()

  代码说明如下：

  • 第 3 行和第 9 行，发生错误时，跳转错误标签 onExit。

  • 第 17 行和第 18 行，汇总所有流程进行错误打印并退出进程。

  注意事项

  goto语句与标签之间不能有变量声明，否则编译错误。

  import "fmt"
  
  func main() {
      fmt.Println("start")
      goto flag
      var say = "hello oldboy"
      fmt.Println(say)
  flag:
      fmt.Println("end")
  }

  编译错误

  .\main.go:7:7: goto flag jumps over declaration of say at .\main.go:8:6

  【相关推荐：Go视频教程】

  Das obige ist der detaillierte Inhalt vonSo verwenden Sie goto in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!