There are several scopes for go language variables

Go language variables have two scopes: 1. Local variables, which are variables declared at the function level and block level; local variables can only be accessed in their blocks or functions, and declared local variables Cannot be redeclared within the same block or function. 2. Global variables are variables declared at the package level; global variables are available throughout the entire life cycle of the program, and global variables cannot be declared using the ":=" operator.

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

The location of variable declarations

The locations of variable declarations in Go language have three levels:

• Package level: Variables are declared outside the function
• Function level: The variables are inside the function, including the parameter variables of the function, but declared outside the code block
• Block level: There are two types of this, one is Explicitly, code enclosed in braces {} is used; the other is implicitly, such as the initialization expression after for or if.

Variable location example

package main

import "fmt"

var test = "test"  //在函数外，包级别变量

func main() {
    a, b := 1, 2  //a和b，c在main函数内定义，函数级别变量
    c := sum(a, b)
    fmt.Println(c)
    fmt.Println(test)

    for i := 0; i < 10; i++ {   //i为for循环内定义，为隐式块级别变量
        var d = i + 1    //d在for的循环体内，以大括号{}括起来，为显式块级别变量
        fmt.Println(d)
    }

}

func sum(a, b int) int {   //函数参数a和b，在函数内定义，为函数级别变量
    fmt.Println(a)
    fmt.Println(b)
    nu := a + b
    return nu
}

Variable scope

The location of the variable declaration determines what the variable is allowed to be in The place to be accessed and the declaration period of the variable. The accessible range of a variable is called the scope of the variable. In the Go language, the scope of variables is divided into two categories:

• Local variables, also called local variables
• Global variables

Local variables

Variables declared at function level and block level are local variables. Local variables have the following characteristics:

• Local variables can only be accessed within their block or function.
• Local variables only live until the end of the block or function in which they are declared. Afterwards, they are collected by the garbage collector.
• Local variables that have been declared cannot be redeclared in the same block or function.

Example:

package main

import "fmt"

func main() {
    var a= "astrng"
    fmt.Println(a)
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
    fmt.Println(i)
}

func testLocal() {
    fmt.Println(a)
}

This code will report an error when compiling:

undefined: i
undefined: a

Reason:

i: It is a block level in the for loop body Local variables will report undefined when accessed outside the for loop in which they are defined.

a: It is a local variable at the main function level and cannot be accessed within the testLocal function, and an undefined error will be reported.

Global variables

Variables declared at the package level are global variables. Global variables have the following characteristics:

• When a global variable starts with lowercase, the global variable can only be used within the package in which it is defined. That is, the variables are visible within the package.
• When a global variable starts with a capital letter, this global variable can be used across different packages. That is, the variable is visible everywhere.
• Global variables are available throughout the life cycle of the program.
• Global variables cannot be declared using the := operator.

package main

import "fmt"

var a = "astring"

func main() {
    testGlobal()
}

func testGlobal() {
    fmt.Println(a)  //运行结果是，正确打印出a的值“astring”
}

Local variables and global variables have the same name

Global variables and local variables in Go language programs can have the same name, but local variables in the function body will be given priority consider.

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\n", a)
}

The running results are as follows:

a = 3

Go language runs local variables and global variables with the same name. The variable with the same name is in the local scope, and it will cover the variables in the external scope.

package main

import "fmt"

var a = "globala"

func main() {
    var a = "locala"
    fmt.Println(a)  //此处的a会遮蔽外面定义的a全局变量，输出locala
}
func testGlobal() {
  fmt.Println(a)  //此处是全局变量a，输出globala
}

【Related recommendations: Go video tutorial, Programming teaching】

The above is the detailed content of There are several scopes for go language variables. For more information, please follow other related articles on the PHP Chinese website!