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

Go语言程序组成

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

---

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

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

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

---

Go语言HelloWorld

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

---

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个关键字

---

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

---

标识符

• 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 第一个变量 + 第二个变量
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47

---

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

Go语言数据类型

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

• 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))

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

---

• 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,
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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

---

Go语言中的变量

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

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

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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

  • 方式一, 连续定义

  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)
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

  • 方式二, 变量组

  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)
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35

---

Go语言变量定义注意点

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12

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

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

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

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

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

package main
import "fmt"
func main() {
	var(
		num1 := 5 // 编译报错
	)
	fmt.Println("num1 = ", num)
}
1
2
3
4
5
6
7
8

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

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

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

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)
}
1
2
3
4
5
6
7
8
9
10
11

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