典型的程序使用各种值，这些值在执行过程中可能会发生变化。
例如，对用户输入的值执行某些操作的程序。一个用户输入的值可能与另一个用户输入的值不同。因此，这就需要使用变量，因为其他用户可能不会使用相同的值。当一个用户输入一个新值将用于在操作的过程中,可以将暂时存储在计算机的随机存取存储器,这些值在执行这部分内存不同,因此这来的另一个术语称为变量。变量是可以在运行时更改的信息的占位符。并且变量允许检索和处理存储的信息。
变量命名规则：
变量名称必须以字母或下划线（_）开头。并且名称中可能包含字母“ a-z”或“ A-Z”或数字0-9，以及字符“ _”。
Geeks, geeks, _geeks23 //合法变量 123Geeks, 23geeks // 非法变量
变量名称不应以数字开头。
234geeks //非法变量
变量名称区分大小写。
geeks 和Geeks 是两个不同的变量
关键字不允许用作变量名。
变量名称的长度没有限制，但是建议仅使用4到15个字母的最佳长度。
在Go语言中，变量是通过两种不同的方式创建的：
（一）使用var关键字：在Go语言中，变量是使用特定类型的var关键字创建的，该关键字与变量名关联并赋予其初始值。
语法：
var variable_name type = expression
重要事项：
在上述语法中，类型（type） 或=表达式可以删除，但不能同时删除变量声明中的两个。
如果删除了类型，则变量的类型由表达式中的值初始化确定。
//变量的概念
package main
import "fmt"
func main() {
//变量声明和初始化
//显式类型
var myvariable1 = 20
var myvariable2 = "cainiaojc"
var myvariable3 = 34.80
// Display the value and the
// type of the variables
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable1的类型是 : %T\n", myvariable1)
fmt.Printf("myvariable2的值是 : %s\n", myvariable2)
fmt.Printf("myvariable2的类型是 : %T\n", myvariable2)
fmt.Printf("myvariable3的值是 : %f\n", myvariable3)
fmt.Printf("myvariable3的类型是 : %T\n", myvariable3)
}输出：
myvariable1的值是 : 20 myvariable1的类型是 : int myvariable2的值是 : cainiaojc myvariable2的类型是 : string myvariable3的值是 : 34.800000 myvariable3的类型是 : float64
如果删除了表达式，则该变量的类型为零，数字为零，布尔值为false，字符串为“”，接口和引用类型为nil。因此，在Go语言中没有这样的未初始化变量的概念。
package main
import "fmt"
func main() {
//变量声明和初始化不使用表达式
var myvariable1 int
var myvariable2 string
var myvariable3 float64
//显示0值变量
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable2的值是 : %d\n", myvariable2)
fmt.Printf("myvariable3的值是 : %d\n", myvariable3)
}输出：
myvariable1的值是 : 0 myvariable2的值是 : %!d(string=) myvariable3的值是 : %!d(float64=0)
如果使用类型，则可以在单个声明中声明相同类型的多个变量。
package main
import "fmt"
func main() {
// 在一行上同时声明和初始化多个类型相同的变量
var myvariable1, myvariable2, myvariable3 int = 2, 454, 67
// 输出变量的值
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable2的值是 : %d\n", myvariable2)
fmt.Printf("myvariable3的值是 : %d\n", myvariable3)
}输出：
myvariable1的值是 : 2 myvariable2的值是 : 454 myvariable3的值是 : 67
如果删除类型，则可以在单个声明中声明不同类型的多个变量。变量的类型由初始化值确定。
package main
import "fmt"
func main() {
//多个不同类型的变量
//在单行中声明和初始化
var myvariable1, myvariable2, myvariable3 = 2, "GFG", 67.56
// 打印变量值和类型
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable1的类型是 : %T\n", myvariable1)
fmt.Printf("\nmyvariable2的值是 : %s\n", myvariable2)
fmt.Printf("myvariable2的类型是 : %T\n", myvariable2)
fmt.Printf("\nmyvariable3的值是 : %f\n", myvariable3)
fmt.Printf("myvariable3的类型是 : %T\n", myvariable3)
}输出：
myvariable1的值是 : 2 myvariable1的类型是 : int myvariable2的值是 : GFG myvariable2的类型是 : string myvariable3的值是 : 67.560000 myvariable3的类型是 : float64
返回多个值的调用函数允许您初始化一组变量。
例如：
//这里，os.Open函数返回一个 //文件中的i变量和一个错误 //在j变量中 var i, j = os.Open(name)
（二）使用短变量声明：使用短变量声明来声明在函数中声明和初始化的局部变量。
语法：
variable_name:= expression
注意：请不要在：=和=之间混淆，因为：= 是声明，而 = 是赋值。
重要事项：
在上面的表达式中，变量的类型由表达式的类型确定。
package main
import "fmt"
func main() {
// 使用短变量声明
myvariable1 := 39
myvariable2 := "(cainiaojc.com)"
myvariable3 := 34.67
// 打印变量值和类型
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable1的类型是 : %T\n", myvariable1)
fmt.Printf("\nmyvariable2的值是 : %s\n", myvariable2)
fmt.Printf("myvariable2的类型是 : %T\n", myvariable2)
fmt.Printf("\nmyvariable3的值是 : %f\n", myvariable3)
fmt.Printf("myvariable3的类型是 : %T\n", myvariable3)
}输出：
myvariable1的值是 : 39 myvariable1的类型是 : int myvariable2的值是 : (cainiaojc.com) myvariable2的类型是 : string myvariable3的值是 : 34.670000 myvariable3的类型是 : float64
由于它们的简洁性和灵活性，大多数局部变量都是使用短变量声明来声明和初始化的。
变量的var声明用于那些需要与初始值设定项表达式不同的显式类型的局部变量，或用于其值稍后分配且初始值不重要的那些变量。
使用短变量声明，可以在单个声明中声明多个变量。
package main
import "fmt"
func main() {
//在单行中声明和初始化变量
//使用简短的变量声明
//多个相同类型的变量
myvariable1, myvariable2, myvariable3 := 800, 34.7, 56.9
// 打印变量值和类型
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable1的类型是 : %T\n", myvariable1)
fmt.Printf("\nmyvariable2的值是 : %f\n", myvariable2)
fmt.Printf("myvariable2的类型是 : %T\n", myvariable2)
fmt.Printf("\nmyvariable3的值是 : %f\n", myvariable3)
fmt.Printf("myvariable3的类型是 : %T\n", myvariable3)
}输出：
myvariable1的值是 : 800 myvariable1的类型是 : int myvariable2的值是 : 34.700000 myvariable2的类型是 : float64 myvariable3的值是 : 56.900000 myvariable3的类型是 : float64
在简短的变量声明中，允许返回多个值的调用函数初始化一组变量。
//这里，os.Open函数返回一个 //文件中的i变量和一个错误 //在j变量中 i, j := os.Open(name)
简短的变量声明仅当对于已在同一语法块中声明的那些变量起作用时，才像赋值一样。在外部块中声明的变量将被忽略。如下面的示例所示，这两个变量中至少有一个是新变量。
package main
import "fmt"
func main() {
//使用简短的变量声明
//这里，短变量声明动作
//作为myvar2变量的赋值
//因为相同的变量存在于同一块中
//因此myvar2的值从45更改为100
myvar1, myvar2 := 39, 45
myvar3, myvar2 := 45, 100
//如果您尝试运行注释行，
//然后编译器将给出错误，因为
//这些变量已经定义，例如
// myvar1，myvar2：= 43，47
// myvar2：= 200
// 打印变量值
fmt.Printf("myvar1 和 myvar2 的值 : %d %d\n", myvar1, myvar2)
fmt.Printf("myvar3 和 myvar2 的值 : %d %d\n", myvar3, myvar2)
}输出：
myvar1 和 myvar2 的值 : 39 100 myvar3 和 myvar2 的值 : 45 100
使用短变量声明，可以在单个声明中声明不同类型的多个变量。这些变量的类型由表达式确定。
package main
import "fmt"
func main() {
//在单行中声明和初始化
//使用简短的变量声明
//多个不同类型的变量
myvariable1, myvariable2, myvariable3 := 800, "NHOOO", 47.56
// 打印变量值和类型
fmt.Printf("myvariable1的值是 : %d\n", myvariable1)
fmt.Printf("myvariable1的类型是 : %T\n", myvariable1)
fmt.Printf("\nmyvariable2的值是 : %s\n", myvariable2)
fmt.Printf("myvariable2的类型是 : %T\n", myvariable2)
fmt.Printf("\nmyvariable3的值是 : %f\n", myvariable3)
fmt.Printf("myvariable3的类型是 : %T\n", myvariable3)
}输出：
myvariable1的值是 : 800 myvariable1的类型是 : int myvariable2的值是 : NHOOO myvariable2的类型是 : string myvariable3的值是 : 47.560000 myvariable3的类型是 : float64