开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第3天，点击查看活动详情

关键字分析

Go语言中的基础类型关键字大致有25个：

BREAK	DEFAULT	FUNC	INTERFACE	SELECT
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

关键字： 作为go语言中重要的组成部分，在各种数据声明，数据执行中都有很多使用的地方。

关键字释义：

• var和const：变量和常量的声明
• package and import：导入
• func：用于定义函数和方法
• return：用于从函数返回
• defer someCode：在函数退出之前执行
• go:用于并行
• select：用于选择不同类型的通讯
• interface：用于定义接口
• struct：用于定义抽象数据类型
• break、case、continue、for、fallthrough、else、if、switch、goto、default流程控制
• chan用于channel通讯
• type用于声明自定义类型
• map用于声明自定义类型
• range用于读取slice，map， channel数据

实例（1） ：在go语言编辑器中分别声明一个变量和一个常量。

 var Name string                                                  //变量的声明
 const name = 3.13                                                //常量的声明

解析： 无论是变量还是常量的声明，在声明过程中都需要关键字来定义，在关键字的定义下go语言编辑器才能识别相应的方法操作，从而实现对应的功能，对于变量声明，不论定义什么类型的变量，都可以使用var来定义。对于常量声明，go语言使用关键字const来声明。

实例（2） ：在go语言编辑器中实现包的声明。

 package main                                                    //包的声明

解析： package main 代表当前的 .go文件属于哪个包，其中 package 是 Go 语言声明包的关键字，main 是要声明的包名。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

实例（3） ：在go语言编辑器中实现包名为package的包的声明。

 package package                                                    //包的声明

解析： package main 代表当前的 .go文件属于哪个包，其中 package 是 Go 语言声明包的关键字，main 是要声明的包名。但如果在声明时使用关键字做包名，则go语言编译器就无法正确编译，报错显示出现关键字符号。

终端输出：

总结：Go语言中的关键字, 是指被Go语言赋予特殊含义的单词，在定义程序中的类型，方法，函数，接口等各方面都有特殊用处，它与C语言中的关键字存在形式是类似的。需要注意的是他本身的特殊含义不能作为变量或方法命名。

变量分析

标准格式声明

标准格式声明分析

1. 结构：

 var <name> <type>

结构分解：

解析： 其中 var 是关键字（固定不变），name 是变量名，type 是类型。在 Go 程序中，变量的声明通过关键字var来引导变量的声明从而在编辑器编译中获取存储位置，而Go语言和许多编程语言不同的是，它在声明变量时将变量的类型放在变量的名称之后。在声明变量后再获取对应的变量类型实现标准格式化的变量声明。

2. 举例： 分别声明一个字符串类型变量和一个整型类型的变量并分别输出。

 var PrevBlockHash string                                             //变量的声明  
 var blockHeight int
 fmt.Println(PrevBlockHash)                                    //语句&表达式输出
 fmt.Println(blockHeight)

终端输出：

结构解析：

 var PrevBlockHash string                                             //变量的声明  
 var blockHeight int

变量声明： Go语言是静态类型语言，因此变量（variable）是有明确类型的。变量通过关键字Var来命名标识符再通过明确变量类型来完成变量的完整声明的过程。编译器也会检查函数调用中，来验证变量类型的正确性。

 fmt.Println(PrevBlockHash)                                    //语句&表达式输出
 fmt.Println(blockHeight)

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

标准格式赋值分析

标准格式赋值分析

1. 结构：

var =

结构分解：

解析： 其中 var 是关键字（固定不变），name 是变量名，type 是类型，value是所赋值。使用 var ，虽然只指定了类型，但是 Go 会对其进行隐式初始化。

2. 举例： 分别对一个字符串类型变量和一个整型类型的变量进行初始化赋值并分别输出。

 var PrevBlockHash string = "前置hash"                      //变量的赋值  
 var blockHeight int = 3
 fmt.Println(PrevBlockHash)                                  //语句&表达式输出
 fmt.Println(blockHeight)

终端输出：

结构解析：

var PrevBlockHash string = "前置hash"                      //变量的赋值 
var blockHeight int = 3

变量赋值： 在Go语言中给变量的赋值可以分为三个阶段，先创建变量，在内存中开辟空间后再初始化变量，将变量初始化为underfined,最后再进行真正赋值。

fmt.Println(PrevBlockHash)                                    //语句&表达式输出
fmt.Println(blockHeight)

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

局部变量分析

局部变量分析

1. 释义：

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。局部变量一定是在函数内部。在哪个{}内部声明,只能在哪个{}内部访问。

2. 举例： 在一个基本的go语言程序中，声明一个局部变量。

func main() {                                                         //函数
   var age1 int = 10                                                  //变量的声明  
   fmt.Printf("age1 = %d ", age1)                             //语句&表达式输出
}

终端输出：

结构解析：

func main() { }                                                  //函数          

函数：func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

var age1 int = 10                                                  //局部变量声明 

局部变量声明* *：**局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。局部变量一定是在函数内部。在哪个{}内部声明,只能在哪个{}内部访问。局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

fmt.Printf("age1 = %d ", age1)                             //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

全局变量分析

全局变量分析

1. 解析：

在函数体外声明的变量称之为全局变量。全局变量只需要在一个源文件中定义，就可以在所有源文件中使用。当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。

2. 举例： 在一个基本的go语言程序中，声明一个全局变量。

var age4 int = 2022                                                  //变量的声明
func main() {                                                         //函数
   fmt.Printf("age4 = %d", age4)                              //语句&表达式输出
}

终端输出：

结构解析：

var age4 int = 2022                                                  //全局变量声明

全局变量声明： 在函数体外声明的变量称之为全局变量。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。全局变量声明到函数外部,整个包都可以访问。如果全局变量首字母大写,跨包也可以访问.。

func main() { }                                                  //函数          

函数：func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

fmt.Printf("age4 = %d ", age4)                             //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

常量分析

常量初始化分析

1.显示定义

结构： const name [type] = value

关键字 名称 类型 = 值

结构分解：

解析：常量使用一个名称来绑定一块内存地址，该内存地址中存放的数据类型有定义常量时指定的类型来决定，并且存放在该内存地址里面的存放的值是不可以被改变的。

举例： 请用go语言的结构去输出一个值为字符串类型的常量name。

const name string = "知链-区块链人才培养摇篮"             //常量的显式赋值
fmt.Println(name)                                         //语句&表达式输出

终端输出：

结构解析：

const name string = "知链-区块链人才培养摇篮"             //常量的显式赋值

常量的显式赋值： 常量的声明以关键字const开头，后接常量类型并进行赋值，行尾没有其他标点符号。需要注意的是常量在定义的时候必须赋值，但不能使用短变量声明关键字 := 来定义常量。

fmt.Println(name)                                         //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

2. 隐式定义

结构： const 常量名 = value

解析： 由于Go是编译型语言，定义常量时可以省略常量类型，因为编译器可以根据变量的值来推断其类型。常量声明可以同时指定类型和值，如果没有显式指定类型，则类型根据右边的表达式推断。若同时声明一组变量，除了第一项之外，其他项在等号右侧的表达式都可以省略，这意味着会复用前面一项的表达式及其类型。

举例： 请用go语言的结构去输出一个值为字符串类型的常量pi。

const pi = 3.1415926                                  //常量的隐式赋值
fmt.Println(pi)                                         //语句&表达式输出

终端输出：

结构解析：

const pi = 3.1415926                                  //常量的隐式赋值

常量的隐式赋值： 由于Go是编译型语言，定义常量时可以省略常量类型，因为编译器可以根据变量的值来推断其类型。常量声明可以同时指定类型和值，如果没有显式指定类型，则类型根据右边的表达式推断。若同时声明一组变量，除了第一项之外，其他项在等号右侧的表达式都可以省略，这意味着会复用前面一项的表达式及其类型。

fmt.Println(pi)                                         //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

常量的作用域分析

1. 局部常量作用域

解析： 在函数体内声明的常量称之为局部常量，它们的作用域只在函数体内，局部常量一定是在函数内部。在哪个{}内部声明,只能在哪个{}内部访问。但需要注意与变量不同的是，常量在初始化后不需要必须使用，可以只声明赋值不做其他操作。

举例： 在一个基本的go语言程序中，声明一个局部常量。

func main() {                                                         //函数
   const name string = “知链-区块链人才培养摇篮”                   //常量的初始化
   fmt.Printf(name)                                           //语句&表达式输出
}

结构解析：

func main() { }                                                  //函数           

函数：func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

const name string = “知链-区块链人才培养摇篮”                   //常量的初始化

局部常量声明： 局部常量，它们的作用域只在函数体内，局部常量一定是在函数内部。在哪个{}内部声明,只能在哪个{}内部访问。常量在初始化后不需要必须使用，可以只声明赋值不做其他操作。

fmt.Printf( name)                             //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。

2. 全局常量作用域

解析：在函数体外声明的变量称之为全局常量。全局常量只需要在一个源文件中定义，就可以在所有源文件中使用。当然，不包含这个全局常量的源文件需要使用“import”关键字引入全局常量所在的源文件之后才能使用这个全局常量。

举例： 在一个基本的go语言程序中，声明一个全局常量。

 const PI = 3.1415926                                          //常量的初始化
 func main() {                                                       //函数
     fmt.Println(PI)                                            //语句&表达式输出
 }

终端输出：

结构解析：

 const PI = 3.1415926                                          //常量的初始化

全局常量声明： 在函数体外声明的常量称之为全局常量。全局常量声明必须以 const 关键字开头，如果想要在外部包中使用全局常量的首字母必须大写。全局常量声明到函数外部,整个包都可以访问。如果全局常量首字母大写,跨包也可以访问。

func main() {}                                                 //函数    

函数：func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

fmt.Println(PI)                                            //语句&表达式输出

语句&表达式输出：fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。函数内语句依照main函数内依次执行。