Go语言学习基础（二）编写注意，数据类型，关键字，标识符等

Go语言程序组成

• Go语言程序也是由众多函数组成的
• 程序运行时系统会自动调用名称叫做main的函数
• 如果一个程序没有主函数，则这个程序不具备运行能力
• 一个Go语言程序有且只能有一个主函数

---

Go语言程序主函数定义格式

• Go语言main函数格式
  • func 告诉系统这是一个函数
  • main主函数固定名称
  • 函数左括号必须和函数名在同一行
  • main函数必须在main包中

// 告诉系统当前编写的代码属于哪个包
package main
// 定义了一个名称叫做main的函数
func main() {
}

---

Go语言HelloWorld

package main // 告诉系统当前代码属于main这个包
import "fmt" // 导入打印函数对应的fmt包
func main() {
        // 通过包名.函数名称的方式, 利用fmt包中的打印函数输出语句
	fmt.Println("Hello World!!!")
}

---

Go语言注释

• 和C语言一样,Go语言也支持单行注释和多行注释, 并且所有注释的特性都和C语言一样
  • 单行注释 // 被注释内容
  • 多行注释 /* 被注释内容*/
• 在Go语言中,官方更加推荐使用单行注释,而非多行注释(详情可以直接查看Go官方源码)

---

Go语言编码风格

• 1.go程序编写在.go为后缀的文件中
• 2.包名一般使用文件所在文件夹的名称
• 2.包名应该简洁、清晰且全小写
• 3.main函数只能编写在main包中
• 4.每一条语句后面可以不用编写分号(推荐)
• 5.如果没有编写分号,一行只能编写一条语句
• 6.函数的左括号必须和函数名在同一行
• 7.导入包但没有使用包编译会报错
• 8.定义局部变量但没有使用变量编译也会报错
• 9.定义函数但没有使用函数不会报错
• 10.给方法、变量添加说明,尽量使用单行注释
• 11.使用GO编码，一句结束之后不需要使用分号，编译器在编译时会自动添加

关键字

• Go语言中的关键字和C语言中的关键字的含义样, 是指被Go语言赋予特殊含义的单词
• Go语言中关键字的特征和C语言也一样
  • 全部都是小写
  • 在开发工具中会显示特殊颜色
• Go语言中关键字的注意点和C语言也一样
  • 因为关键字在C语言中有特殊的含义, 所以不能用作变量名、函数名等

---

Go语言的关键字

• Go语言中一共有25个关键字

1	2	3	4	5	6	7	8
if	else	switch	case	default	break	return	goto
fallthrough	for	continue	type	struct	var	const	map
func	interface	range	import	package	defer	go	select
chan

---

• Go语言中除了关键字以外,还有30多个预定义标识符

内建常量
true	false	iota	nil

內建类型
int	int8	int16	int32
int64	uint	uint8	uint16
uint32	uint64	uintptr	float32
float64	complex64	complex128	bool
byte	rune	string	error

內建函数
make	len	cap	new
append	copy	delete	real
imag	panic	recover	complex

---

标识符

• Go语言中的标识符和C语言中的标识符的含义样, 是指程序员在程序中自己起的名字(变量名称、函数名称等)

---

• Go语言标识符和其他语言一样，有一套自己的命名规则, Go语言标识符的命名规则几乎和C语言一模一样

  • 只能由字母(a~z、 A~Z)、数字、下划线组成
  • 不能包含除下划线以外的其它特殊字符串
  • 不能以数字开头
  • 不能是Go语言中的关键字
  • 标识符严格区分大小写, test和Test是两个不同的标识符

• 和其他语言标识符命名规则不同的是

  • Go语言中_单独作为标识符出现时, 代表空标识符, 它对应的值会被忽略

  package main
  
  import "fmt"
  
  func main() {
  	// 将常量10保存到名称叫做num的变量中
  	var num int = 10
  	fmt.Println("num = ", num)
  
  	// 忽略常量20,不会分配存储空间,也不会保存常量20
  	//var _ int = 20
  	//fmt.Println("_ = ", _) // cannot use _ as value
  
  	// Go语言中如果定义了变量没有使用, 那么编译会报错(sub declared and not used)
  	// 所以如果我们只使用了sum,没有使用sub会报错
  	// 为了解决这个问题, 我们可以使用_忽略sub的值
  	//var sum, sub int = calculate(20, 10)
  	var sum, _ int = calculate(20, 10)
  	fmt.Println("sum = ", sum)
  
  }
  
  func calculate(a, b int)(int, int)  {
  	var sum int = a + b
  	var sub int = a - b
  	return sum, sub
  }
  
  ​```go
  + Go语言默认的编码方式就是UTF-8, 所以Go语言支持中文, 所以可以用中文作为标识符，只不过建议不要使用中文作为标识符
  ​```go
  package main
  
  import "fmt"
  
  func main() {
    // 不会报错, 可以正常运行
    var 年龄 int = 18
    fmt.Println("年龄 = ", 年龄) // 18
  
    // 不会报错, 可以正常运行
    var 结果 int = 计算器(10, 20)
    fmt.Println("结果 = ", 结果) // 30
  }
  func 计算器(第一个变量, 第二个变量 int)int  {
    return 第一个变量 + 第二个变量
  }
  

---

• 标识符除了有命名规则以外,还有标识符命名规范
  • 规则必须遵守, 规范不一定要遵守, 但是建议遵守
  • Go语言的命名规范是采用驼峰命名, 避免采用_命名
    • 驼峰命名: sendMessage / sayHello
    • _命名: send_message / say_hello

Go语言数据类型

• Go语言本质是用C语言编写的一套高级开发语言, 所以Go语言中的数据类型大部分都是由C语言演变而来的，如果有一定的C语言基础，那么在学习GO的数据类型时会更加的轻松
• Go语言数据类型占用内存空间

类型	32位编译器	64位编译器	本质
int8/uint8	1	1	signed char/unsigned char
int16/uint16	2	2	signed short/unsigned short
int32/uint32	4	4	signed int/unsigned int
int64/uint64	8	8	signed long long int/unsigned long long int
byte	1	1	uint8/unsigned char
rune	4	4	int32/signed int
int	4	8	根据机器位数决定长度
uintptr	4	8	根据机器位数决定长度 uint32/uint64
float32	4	4	float
float64	8	8	double
true	1	1	char类型的整型
false	1	1	char类型的整型

• Go语言也提供了Sizeof计算变量的内存空间
  • 1.导入import "unsafe"包
  • 2.通过unsafe.Sizeof()计算变量内存空间

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println("int size = ", unsafe.Sizeof(int(0)))
	fmt.Println("int8 size = ", unsafe.Sizeof(int8(0)))
	fmt.Println("int16 size = ", unsafe.Sizeof(int16(0)))
	fmt.Println("int32 size = ", unsafe.Sizeof(int32(0)))
	fmt.Println("int64 size = ", unsafe.Sizeof(int64(0)))
	fmt.Println("uint size = ", unsafe.Sizeof(uint(0)))
	fmt.Println("uint8 size = ", unsafe.Sizeof(uint8(0)))
	fmt.Println("uint16 size = ", unsafe.Sizeof(uint16(0)))
	fmt.Println("uint32 size = ", unsafe.Sizeof(uint32(0)))
	fmt.Println("uint64 size = ", unsafe.Sizeof(uint64(0)))
	fmt.Println("uintptr size = ", unsafe.Sizeof(uintptr(0)))
	fmt.Println("byte size = ", unsafe.Sizeof(byte(0)))
	fmt.Println("rune size = ", unsafe.Sizeof(rune(0)))
	fmt.Println("float32 size = ", unsafe.Sizeof(float32(0)))
	fmt.Println("float64 size = ", unsafe.Sizeof(float64(0)))
	fmt.Println("true size = ", unsafe.Sizeof(true))
	fmt.Println("false size = ", unsafe.Sizeof(false))

}

---

• Go语言基本数据类型内部实现
  可以进入自己的SDK进行查看，查看代码时可以选择老版本的，越老的版本里面的代码添加的东西越少，越存粹，更适合新手使用。

// 第8行到35行
typedef	signed char		int8;
typedef	unsigned char		uint8;
typedef	signed short		int16;
typedef	unsigned short		uint16;
typedef	signed int		int32;
typedef	unsigned int		uint32;
typedef	signed long long int	int64;
typedef	unsigned long long int	uint64;
typedef	float			float32;
typedef	double			float64;

#ifdef _64BIT
typedef	uint64		uintptr;
typedef	int64		intptr;
typedef	int64		intgo; // Go's int
typedef	uint64		uintgo; // Go's uint
#else
typedef	uint32		uintptr;
typedef	int32		intptr;
typedef	int32		intgo; // Go's int
typedef	uint32		uintgo; // Go's uint
#endif

#ifdef _64BITREG
typedef	uint64		uintreg;
#else
typedef	uint32		uintreg;
#endif

// 第153行到157行
enum
{
	true	= 1,
	false	= 0,
};

Go本质就是用C语言编写的一门高级编程语言
int会根据你当前的操作系统自动转换为int32和int64

---

Go语言中的变量

• Go语言中定义变量有三种格式

// 标准格式
var 变量名称 数据类型 = 值;
// 自动推到类型格式
var 变量名称 = 值;
// 简短格式(golang官方推荐格式)//这种定义格式并不是在任何地方都可以使用
变量名称 := 值;

package main
import "fmt"
func main() {
	var num1 int 
	num1 = 5 // 先定义后赋值
	fmt.Println("num1 = ", num1)

	var num2 int = 6 // 定义的同时赋值
	fmt.Println("num2 = ", num2)

	var num3  = 7 // 定义的同时赋值, 并省略数据类型
	fmt.Println("num3 = ", num3)
    
	num4  := 8 // 简短定义，定义的同时也赋值，但是这里没有说明数据类型

	fmt.Println("num4 = ", num4)
}

• 可以定义单个变量以外,还支持一次性定义多个变量

  • 方式一, 连续定义

  package main
  import "fmt"
  func main() {
   var num1, num2 int // 先定义
   num1 = 10	// 后赋值
   num2 = 20
   fmt.Println("num1 = ", num1)
   fmt.Println("num2 = ", num2)
  
   var num3, num4 int = 30, 40 // 定义的同时赋值
   fmt.Println("num3 = ", num3)
   fmt.Println("num4 = ", num4)
  
   var num5, num6 = 50, 60 // 定义的同时赋值, 并省略数据类型
   fmt.Println("num5 = ", num5)
   fmt.Println("num6 = ", num6)
  
   num7, num8 := 70, 80 // 定义的同时赋值, 并省略关键字和数据类型
   fmt.Println("num7 = ", num7)
   fmt.Println("num8 = ", num8)
  }
  

  • 方式二, 变量组

  package main
  import "fmt"
  func main() {
  	var( // 先定义
  		num1 int
  		num2 float32
  	)
  	num1 = 10 // 后赋值
  	num2 = 3.14
  	fmt.Println("num1 = ", num1)
  	fmt.Println("num2 = ", num2)
  
  	var( // 定义的同时赋值
  		num3 int = 30
  		num4 float32 = 6.66
  	)
  	fmt.Println("num3 = ", num3)
  	fmt.Println("num4 = ", num4)
  
  	var( // 定义的同时赋值, 并省略数据类型
  		num5 = 50
  		num6 = 7.77
  	)
  	fmt.Println("num5 = ", num5)
  	fmt.Println("num6 = ", num6)
  
  	var( // 一行定义多个
  		num7, num8 = 70, 80
  		num9, num10 = 9.99, 100
  	)
  	fmt.Println("num7 = ", num7)
  	fmt.Println("num8 = ", num8)
  	fmt.Println("num9 = ", num9)
  	fmt.Println("num10 = ", num10)
  }
  

---

Go语言变量定义注意点

• 简短模式的含义是定义的同时初始化

package main
import "fmt"
func main() {
	num := 5
	num := 6 // :=不能重复定义同一个变量
	fmt.Println("num = ", num)
}

• :=不是赋值运算符，这里请大家注意

package main
import "fmt"
var num = 5 // 定义一个全局变量
func main() {
	num := 6 // 定义一个局部变量
	fmt.Println("num = ", num)
        test()
}
func test() {
	fmt.Println("num = ", num) // 还是输出5
}

• :=只能用于定义局部变量,不能用于定义全局变量

package main
import "fmt"
num := 5 // 编译报错，全局变量使用var定义，后文会讲解
func main() {
	fmt.Println("num = ", num)
}

• 使用:=定义变量时,不能指定var关键字和数据类型

package main
import "fmt"
func main() {
	num int := 10 // 编译报错，这里不能定义数据类型
	fmt.Println("num = ", num)
	fmt.Println("num = ", num)
}

• 变量组中不能够使用:=

package main
import "fmt"
func main() {
	var(
		num1 := 5 // 编译报错
	)
	fmt.Println("num1 = ", num)
}

• 通过:=同时定义多个变量, 必须给所有变量初始化

package main
import "fmt"
func main() {
	//num1, num2 := 6,7 // 正确
	num1, num2 := 6 // 报错
	fmt.Printf("%d, %d\n", num1, num2)
}

• 通过:=同时定义多个变量, 只要任意一个变量没有定义过,都会做退化赋值操作

package main
import "fmt"
func main() {
	// 定义一个变量num1
	num1 := 5
	// 同时定义两个变量num1和num2, 由于num2从来没有定义过,
	// 所以对于num1来说:=退化为赋值运算符, 而对于num2来说:=仍然是定义+赋值
	num1, num2 := 6,7 
	fmt.Println("num1 = ", num1)
	fmt.Println("num2 = ", num2)
}

package main
import "fmt"
func main() {
	num1 := 5
	num2 := 6
	// 报错, 因为num1,和num2都已经被定义过
	// 至少要有任意一个变量没有被定义过,才会退化赋值
	num1, num2 := 7, 8
	fmt.Println("num1 = ", num1)
	fmt.Println("num2 = ", num2)
}