How to use goto in go language

In the go language, the goto statement is used for unconditional jumps, which can be unconditionally transferred to the specified line in the program; it performs unconditional jumps between codes through labels. goto is followed by a label. The meaning of this label is to tell the Go program which line of code to execute next. The syntax is "goto label;... ...label: expression;". goto breaks the original code execution order and jumps directly to the specified line to execute the code; the goto statement is usually used in conjunction with conditional statements and can be used to implement functions such as conditional transfer, forming a loop, and jumping out of the loop body.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

The goto statement in go language

goto Gu Yansiyi means jump.

The goto statement of Go language can unconditionally transfer to the specified line in the program, and make unconditional jumps between codes through labels. At the same time, the goto statement is also helpful in quickly jumping out of loops and avoiding repeated exits. Use The goto statement can simplify the implementation process of some codes.

The syntax of the goto statement

goto is followed by a label. The meaning of this label is to tell the Go program which line of code to execute next.

So how and where to place this label is the most important thing to pay attention to in goto.

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

The goto statement flow chart is as follows:

Usage of goto statement

• goto can break the original code execution order and jump directly to a certain line of code execution.

import "fmt"

func main() {

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

}

The execution result will not output B, but only A

A

• goto statements are usually used in conjunction with conditional statements. It can be used to implement conditional transfer, form a loop, jump out of the loop body and other functions.

Here is an example of using goto to implement a loop that prints 1 to 5.

import "fmt"

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

The output is as follows

As another example, use goto to achieve the effect of type break.

import "fmt"

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

The output is as follows

Finally, as an example, use goto to achieve the effect of type continue, printing all even numbers from 1 to 10.

import "fmt"

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

The output is as follows

Use goto to exit the multi-layer loop

The following is When the conditions are met, the code needs to continuously exit two levels of loops. The traditional coding method is as follows:

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

The code description is as follows:

• Line 10, construct the outer cycle.

• Line 13, build the inner loop.

• Line 16, when y==2, all for loops need to be exited.

• Line 19, by default the loop can only exit one level at a time. To do this, you need to set a state variable breakAgain. When you need to exit, set this variable to true.

• In line 22, use break to exit the current loop. After execution, the code is transferred to line 28.

• Line 28, after exiting one layer of the loop, determine whether it is necessary to exit the outer layer of the loop again based on the breakAgain variable.

• Line 34, after exiting all loops, print done.

Use the goto statement of Go language to optimize the above code:

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

The code description is as follows:

• 13 line, use the goto statement to jump to the specified label, which is defined on line 23.

• Line 20, the label can only be used by goto, but it does not affect the code execution process. If you do not return manually here, the 24th line of code will also be executed when the conditions are not met. .

• Line 23 defines the breakHere tag.

After using the goto statement, all loops can be quickly exited without additional variables.

Use goto to centrally handle errors

It is very tricky when there is code duplication in multiple error handling, for example:

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

The code description is as follows:

• Line 1 executes a certain logic and returns an error.

• Lines 2 to 6, if an error occurs, print the error and exit the process.

• Line 8 executes certain logic and returns an error.

• Lines 10 to 14, exit the process after an error occurs.

• Line 16, no errors, printing is completed.

In the above code, some of them are repeated error handling codes. If more judgments are added to these codes later, these similar codes need to be modified in sequence. It is extremely easy to cause oversights and errors.

使用 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视频教程】

The above is the detailed content of How to use goto in go language. For more information, please follow other related articles on the PHP Chinese website!