Variables come from mathematics and can store calculation results or represent abstract concepts of values in computer language.
Variables can be accessed through variable names.
The Go language variable name consists of letters, numbers, and underscores, where the first character cannot be a number.
The general form of declaring variables is to use the var keywords:
var identifier type
You can declare multiple variables at a time:
var identifier1, identifier2 type
2.7.1. Example #
package main
import "fmt"
func main() {
var a string = "Runoob"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}
The output result of the above example is:
Runoob
1 2
Variable declaration #
First, specify the variable type, which defaults to zero if it is not initialized.
var v_name v_type
v_name = value
Zero is the default value set by the system when the variable is not initialized.
2.7.2. Example #
package main
import "fmt"
func main() {
// Declare a variable and initialize it
var a = "RUNOOB"
fmt.Println(a)
// Zero value without initialization
var b int
fmt.Println(b)
// Bool has a zero value of false
var c bool
fmt.Println(c)
}
The execution result of the above example is:
RUNOOB
0
false
Numeric type (including complex64/128) is 0
Boolean type is
falseThe string is
""(empty string)The following types are
nil:
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error is an interface
2.7.3. Example #
package main
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\\n", i, f, b, s)
}
The output is as follows:
0 0 false ""
The second is to determine the type of variable according to the value.
var v_name = value
2.7.4. Example #
package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}
The output is as follows:
true
Third, if the variable is already used var after the declaration, use the := declare a variable, resulting in a compilation error, format:
v_name := value
For example:
var intVal int
intVal :=1 // At this point, a compilation error will occur because intVal
has already been declared and does not need to be redeclared
You can simply use the following statement:
intVal := 1 // At this point, no compilation error will occur because a new
variable is declared because:=is a declaration statement
intVal := 1 equal to:
var intVal int
intVal =1
You can set the var f string = "Runoob" abbreviated as f := "Runoob"：
2.7.5. Example #
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}
The output is as follows:
Runoob
Multivariable declaration #
//Multiple variables of the same type, non global variables
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // Similar to Python, it does not need
to display declaration types and automatically infers
vname1, vname2, vname3 := v1, v2, v3 // The variable appearing on the left side of:=should not have
been declared, otherwise it will cause compilation errors
// This factorization keyword writing method
is generally used to declare global variables
var (
vname1 v_type1
vname2 v_type2
)
2.7.6. Example #
package main
var x, y int
var ( // This factorization keyword writing
method is generally used to declare global variables
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//This type of non declarative format can only appear in the function body
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
}
The execution result of the above example is:
0 0 0 false 1 2 123 hello 123 hello
Value type and reference type #
All the images int 、 float 、 bool and string , these basic types are value types, and variables that use these types point directly to values that exist in memory:
When using the equal sign = assigning the value of one variable to another, such as: j = i , which is actually in memory i has beencopied:
You can pass &i to get variables i the memory address of, for example: 0xf840000040 , the address may be different each time.
The value of a value type variable is stored in the heap.
Memory addresses vary from machine to machine, and even the same program will have different memory addresses after it is executed on different machines. Because each machine may have a different memory layout, and the location allocation may also be different.
More complex data usually requires the use of multiple words, which are generally saved using reference types.
A variable of a reference type r1 what is stored is r1 , the memory address (number) where the value of the or the first word in the memory address is located.
This memory address is called a pointer, and the pointer is actually stored in another value.
Pointers of the same reference type can point to multiple words in contiguous memory addresses (the memory layout is contiguous), which is the most computationally efficient form of storage, or they can be scattered in memory. each word indicates the memory address of the next word.
When using an assignment statement r2 = r1 only references (addresses) are copied.
If r1 is changed, then all references to the value point to the modified content, in this case r2 will also be affected.
Short form, using the: = assignment operator #
We know that the type of the variable can be omitted during the initialization of the variable and automatically inferred by the system, andthe declaration statement is written on var keywords are actually a little superfluous, so we can abbreviate them as a := 50 or b := false .
a and b type of int and bool will be automatically inferred by the compiler
This is the preferred form of using variables, but it can only be used in the body of a function, not for the declaration and assignment of global variables. Use operator := you can efficiently create a new variable called an initialization declaration.
Matters needing attention #
If we are in the same code block, we cannot use initialization declarations for variables with the same name again, for example: a:= 20 is not allowed, the compiler will prompt an error no new variables on left side of := , but a = 20 is possible, because it is assigning a new value to the same variable.
If you’re defining variables, if you use a before, you will get a undefined: a compilation error.
If you declare a local variable but do not use it in the same block of code,you will also get a compilation error, such as the variable in the following example a :
2.7.7. Example #
package main
import "fmt"
func main() {
var a string = "abc"
fmt.Println("hello, world")
}
Trying to compile this code will get an error a declared but not used .
In addition, simply give a assignment is also not enough, this value must be used
fmt.Println("hello, world", a)
The error is removed.
But global variables are allowed to be declared but not used. Multiple variables of the same type can be declared on the same line, such as:
var a, b, c int
Multiple variables can be assigned on the same line, such as:
var a, b int
var c string
a, b, c = 5, 7, "abc"
The above line assumes that the variables a , b , and c have already been declared, otherwise they should be used as follows:
a, b, c := 5, 7, "abc"
The values on the right are assigned to the variables on the left in the same order, so the value of a is 5 , the value of b is 7 , andthe value of c is "abc" .
This is called parallel or simultaneous assignment.
If you want to exchange the values of two variables, you can simply use a , b = b , a , and the types of the two variables must be the same.
Blank identifier \_ is also used to discard values, such as the value 5 in ：_ abandoned in b = 5 , 7 .
\_ actually a write-only variable, and you can’t get its value. I did it because Go you have to use all the declared variables in the language, but sometimes you don’t need to use all the return values you get from a function.
Parallel assignment is also used when a function returns multiple return values, such as the val and mistakes. err is by calling the Func1 function also gets val, err = Func1 (var1) .