Go 语言中的变量

在这个 Go 语言教程中，也称为 Go 或 Golang，您将了解所有关于
所有编程语言的核心——变量，它是编程语言的基本单元。我们将详细讨论什么是变量，如何在 Golang 中声明和定义变量，然后理解变量的作用域和生命周期，它们的命名约定，以及变量如何在 Golang 中被遮蔽。

Golang 变量的概念 

让我们从理解编程语言中变量的需求开始，
考虑下面的简单可执行 Go 语言程序

package main            //Declaration of main package 

import "fmt" //Importing input-output libraries

func main() {          //Main function

 fmt.Println("Hello Users")    //Display print statement
}

输出

Hello Users

这个可执行的 Golang 程序包含 4 个不同的部分。为了更好地理解变量概念，让我们简要讨论这些代码行。

• 包 main
• 导入 “fmt”
• 函数 main()
• fmt.Println()

•  包 main： package main 是每个程序开始执行的包声明。package main 通过告诉 Go 编译器程序必须作为可执行代码执行而不是使用共享库来初始化程序执行。

  注意：共享库包用于构建可重用代码，而包 main 用于开发可执行代码。

• 导入 “fmt”： 第二行代码 import “fmt”。导入负责实现 I/O 方法或函数的 fmt 包文件。
• 函数 main()： 主函数，带有 func 关键字，后跟大括号 {}。写入大括号内的程序代码从此处开始执行。简单来说，就是程序执行的入口点。
• fmt.Println()： Println() 是一个函数，它在屏幕上打印双引号内指定的文本，它从 Go 语言中的 fmt 包导入，用于在控制台中向用户显示输出。fmt.Println() 函数在控制台中显示“Hello Users”作为输出。

为了更好地理解，让我们看一下下面相同程序的屏幕截图（示例 1）。创建了一个名为 simple.go 的文件，并添加了上面给出的代码行。

使用命令运行 Go 程序

go run simple.go

在控制台中打印（显示）输出为

输出

Hello Users

多次执行同一个程序会打印出相同的结果作为输出。打印语句保持固定，在程序执行期间无法更改。用固定值解决实际场景是不可能的，因此需要某种机制来存储从用户读取的值。它还应该满足在程序执行期间更改存储值的要求。这就是为什么我们有变量的概念。

Golang 中的变量是什么？

变量是特殊的容器，能够存储一个值，并且该值在程序执行期间保持固定。

Golang 中为什么需要声明

声明指定 Go 程序中使用的变量名和变量类型。像其他语言 C、C++、Java Go 一样，它也是一种静态类型编程语言。Go 编程语言是一种静态类型编程语言，其中变量在使用之前在程序执行期间声明。

Golang 中的命名约定和样式

• 变量名只包含字母 'a-z' 或 'A-Z' 或数字 0-9 以及下划线字符 '_'。

  Golang     //valid variable name
  _golang     //valid variable name
  Golang236,golang_0   //valid variable name
  236golang   //invalid varaible name
  

• 变量名必须以字母或下划线 (_) 开头，不能以数字开头。

  236golang     //invalid variable name
  

• 变量名区分大小写。
• 不允许将关键字用作变量名
• 变量名的长度没有限制，但建议使用 4-15 个字母的最佳长度。
• 变量样式使用 mixedCaps 或 MixedCaps 

  考虑 emp_details，其中员工姓名可以表示为 emp_Name 或 Emp_Name

  示例  : var emp_Name = “john” Emp_Name := “Stephen”

  理解示例的程序

  
  package main
  import ("fmt")
  
  func main() {
    var emp_Name string = "John" //Variable in mixedCaps
   
    Emp_Name:= "Stephen" //Variable in MixedCaps
  
    fmt.Println("The variable name in mixedCaps : ",emp_Name)
   
    fmt.Println("The variable name in MixedCaps : ",Emp_Name)
  }
  
   
  

  输出

  
  The variable name  in mixedCaps :  John
  The variable  name in MixedCaps :  Stephen
  

为了更好地理解命名规则和样式，我们来看一个表格

Golang 中的变量声明方法

Go 中的变量主要使用以下方式声明： 

1.     使用 'var' 关键字 
2.     使用“ := ”进行短变量声明。

使用 Golang 中的 var 关键字声明变量

var 关键字用于两种不同的方法来声明变量

1. 使用 var 关键字，后跟变量名及其类型进行两步声明。然后将变量值初始化为已声明的变量。

   语法

   
   var <variable_name> <type>
   <variable_name> =  <value>
   
   

   示例

   
   var  price int
   price = 35 
   
   

   声明了关键字 var，后跟类型为整数的变量 price。在下一行，将值 35 分配给变量 price。因此，变量 price 在程序执行期间持有值 35。

2. 一种简单的声明方法，语法遵循 var 关键字，后跟变量名，并为其赋值。

   语法

   
   var <variable_name> = <value>
   
   

   示例

   
   var price = 35
   
   

使用冒号-等于赋值运算符 (:=) 声明变量

局部变量使用短变量声明在函数中声明和初始化。在“:=”变量声明中，变量的类型由编译器从赋值或存储到变量的值推断。

<variable_name> := <value>

Price := 35

Var 关键字和短变量声明的使用

var name1 string = “Golang”
   

var name1 string
name1=” Golang”

name1:= “Golang”

函数内部和外部的 var 关键字

这个 Go 程序是使用 var 关键字在函数内部和外部声明变量的示例

package main
import ("fmt")
/* variable declared outside function */
var name1 string
/* variables declared and assigned values outside function */
var num int = 2021   
var c = 3

func main() {
/* variable name1 declared outside function assigned value inside function */
  name1 = "Golang"   
  fmt.Println(name1)
  fmt.Println(num)
  fmt.Println(c)
}

输出

Golang
2021
3

函数外部的短变量声明

在函数外部声明短变量会导致编译错误。变量不能使用“:=”在函数外部声明和赋值。

package main
import ("fmt")
 
name1 := "Golang"    //short variable declaration
 
func main() {
  fmt.Println(name1)  //Type inferred as string
}

输出

-/home/5ZqYyz
prog.go:4:1 Syntax error non-declaration statement outside function body

Golang 中的初始化变量声明

在 Golang 中，如果每个变量要存储或包含的值已经已知或预定义，则 Go 程序中存在的每个变量的值可以在程序开头进行初始化。

package main

import "fmt"

func main() {
  var price_ph //var keyword
                    //variable  price_phone
                    //value 15000

 var mobile_name  = "SAMSUNG" //var keyword,variable phone
     //value string type SAMSUNG
 Ear_phone := 300             // := assigns 300 to variable Ear_phone

 fmt.Println("Prints phone prices by inferring its type", price_phone)
 fmt.Println("Displays name of phone ", phone)
 fmt.Println("Displays price of Ear_phone", Ear_phone)
}

在这些代码行中，所有变量都用某种类型的值初始化，以便稍后在 Go 程序中使用。这是关于变量如何用值初始化或在 Go 语言中使用的简要概念。

• var price_ph 行将整型值 15000 赋值给使用 var 关键字声明的变量 price_phone。
• var mobile_name = "SAMSUNG", 此行使用 var 关键字将字符串类型的大写字母 Samsung 赋值给变量 mobile_name。
• Ear_phone := 300，冒号等于赋值运算符将整数类型值 300 赋值给名为 Ear_phone 的变量。

输出

Prints phone prices by inferring its type : 15000
Displays name of phone : SAMSUNG
Displays price of ear_phone :300

未初始化的变量声明的默认值

在 Go 语言中，未初始化的变量，即如果一个变量没有用初始值声明，那么该变量将初始化为其声明类型的默认值。一旦变量被声明，它就会被分配一个与其内置类型匹配的零值。变量的零值或默认值通过一个例子解释如下。

package main
import ("fmt")

func main() {

  var words string    //default value set to string
  var number int  //default value set to integer
  var Logic_gates bool //default value set to boolean

  fmt.Println(words)
  fmt.Println(number)
  fmt.Println(Logic_gates)
}

输出

0
false

解释

• 下面代码行中的变量没有任何初始值
  • var words string
  • var number int
  • var Logic_gates bool
• 有三个变量，即 words、number、logic_gates，它们分别指定了字符串、整数、布尔类型。
• 这些变量没有用任何值初始化，但在编译代码时，会将相应类型的默认值（零值）分配给变量。
• 这就是当变量没有设置初始值时，默认值是如何设置的。
• 代码成功编译后，将分配相应类型的默认值
  • Words 为 “ ”
  • number 为 0
  • Logic_gates 为 false

如何在 Golang 中声明后为变量赋值？

如果变量的值未知，则可以在程序中声明变量后为其赋值。

考虑语法 

var <varaiable_name><type>
<variable_name> = <value>

使用此语法，可以在变量声明后为变量赋值。

package main
import ("fmt")

func main() {

  var mobile_name string           // variable phone of string type 
  mobile_name = "SAMSUNG"          // variable phone reads value samsung
  fmt.Println(mobile_name )         //Displays value as output
}

输出

SAMSUNG

在这个程序中，变量首先由程序员声明其类型。在下一行，只将值赋给变量。

• var mobile_name string   :  声明了一个字符串类型的变量 mobile_name。
• mobile_name = "SAMSUNG" :  变量 mobile_name 读取值 Samsung

包含不同声明类型的简单 Go 程序

到目前为止，我们讨论了 Go 程序中不同类型的声明。下面给出的简单程序是这三种不同类型声明的组合，其中包含 2 个 var 语句和 1 个简写 ":=" 声明。

package main
import "fmt"
func main() {
 
 //method 1
 var value1 int
 value1 = 380

 //method 2
 var value2 = "cat"

 //method 3
 value3 := 87

 fmt.Println(value1, value2, value3)
}

从上述程序中可以理解声明和定义变量的三种不同语法，分别命名为方法1、方法2、方法3。

输出

多个变量声明定义

Go 程序中的多个变量使用另一个简写来定义。关键字 var 后跟括号用于在 Go 程序的不同的代码行中定义变量。

var (
x=100
y=” hello”
z=0
)

package main
import ("fmt")
func main() {
/* Multiple variable declaration*/
  var(
   x=100
 y= "hello"
 z=0  )
  fmt.Println(x,y,z)         //Displays value as output
}

输出

100 hello 0

变量的多重赋值

Go 编程语言允许用户或程序员在同一行中为不同的变量分配多个值。单行中的变量可以具有不同数据类型的值。

package main
import ("fmt")

func main(){
 
num1, num2, num3 := "one", 2, "three"  //Multiple variable assignment

fmt.Println(num1)
fmt.Println(num2)
fmt.Println(num3)

}

输出

one
2
three

在这个 Go 示例中，Num1,num2,num3 是在同一行中声明的三个变量。每个变量都具有不同的数据类型。

• num1 是字符串类型
• num2 是整数类型
• num3 是字符串类型

变量的作用域和生命周期

变量根据其名称和存储位置分为三种类型。

•     局部变量：在函数内部声明的变量
•     全局变量：在函数外部声明的变量，变量名应以大写字母开头。
•     包级变量：在函数外部声明的变量，变量名应以小写字母开头。
   

让我们用一个例子来理解

package main
import "fmt"

/*Global variables can be  accessed by all
the  functions in the same or different packages
*/

var Global_var int  //Begins with uppercase letter

/*Package level variables only accessed
from the function of the same package
*/

var pack_var int   //begins with lowercase letter

func main() {
 /* Local variables cannot be accessed
 from outside of the function
 */

 //method 1
 var value1 int
 value1 = 380

 //method 2
 var value2 = "cat"

 //method 3
 value3 := 87

 fmt.Println(value1, value2, value3)
}

输出

380 cat 87

解释

• 在上述程序中，在 main 函数中声明了三个变量。因此，变量 value1、value2、value3 是局部变量，只能从 main 函数访问。程序中的其他函数被限制访问局部变量。
• 该程序声明了 var pack_var = int，pack_var 是另一个以小写字母开头的变量，并在 main 函数外部声明，形成一个包级变量。
• 类似地，变量 Global_var 以大写字母开头声明，使用的语法是 var Global_var = int，它可以在 Go 程序中被其他函数访问，称为全局变量。
   

Golang 中的变量遮蔽

假设在包级别声明的变量被重新声明为局部变量。当尝试访问局部变量时，包级别变量会被局部变量遮蔽。
考虑 Go 程序

Package main
import "fmt"

var value0 = 0   //package level variable

func main() {
 var value0 = 34  //local variable
 fmt.Println(value0)

}

输出

34

value0 是一个初始化为两个值的变量，一个作为包级别变量，使用 var 关键字后的语法，将 0 赋值给 value0。同一个变量 value0 在 main 函数内部被重新声明为局部变量，存储值 34。当程序执行时，只考虑局部变量执行，因此遮蔽概念起作用。变量不限于字符串、整数和布尔值等数据类型。变量可以用下面给出的一些其他数据类型表示，这将在下一个教程中讨论。

s := "Hello, World!"
f := 465.86
b := 15 > 9 // A Boolean value will return either true or false
array := [3]string{"item_1", "item_2", "item_3"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "h", "number": "nine", "symbol": "&"}