保留字

关键字

在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语言还有37个预定义标识符：

常量
- true
- false
- iota
- nil
类型
- int int8 int16 int32 int64
- uint uint8 uint16 uint32 uint64
- float32 float64 complex64 complex128
- uintptr
- bool
- byte
- rune
- string
- error
函数
- make
- len
- cap
- new
- append
- copy
- close
- delete
- complex
- real
- imag
- panic
- recover

符号

最后，go语言也会使用一些符号：


`()`	`[]`	`{}`	`.`	`,`	`;`	`:`	`...`

Package语法

package关键字用作标识一个文件属于哪一个包。package关键字应在文件(除注释以外)的最头部进行定义。

package main

Import语法

import关键字用作导入其他包，放在package关键字下面进行导入。导入包的顺序为：1. 标准库 2. 第三包 3. 项目内其他包或当前包的子包，每种包类型之间以空行分隔。

单包导入

package main

import "fmt"

多包导入

package main

import (
	"fmt"
	"os"
)

变量

变量在使用前需要先申明，声明了类型后，就约定了这个变量只能赋该类型的值。在go语言中，如果申明了一个变量，这个变量必须被使用，否则编译器会报错。

变量声明

var [name] [type] = [value]
- var 关键字用于声明变量
- [name] 变量名称
- [type] 变量的类型(可省略，根据变量的值推断类型)
- [value] 变量的值(可省略，变量的值为默认值)
[name] : [value] 短声明，只能在函数中进行申明
- [name] 变量名称
- [value] 变量的值(不可省略)

如果只声明单个变量，以下有多种方式进行申明

//声明一个变量，不进行赋值，变量为默认值
var variableName1 string
var variableName2

//声明一个变量，进行赋值
var variableName3 string = "test"
var variableName4 = "test"
variableName5 := "test" //只能在函数中进行申明

如果想要申明多个相同类型的变量，可以在一行中进行申明，如果类型不同，可以使用()进行声明。

//声明多个相同类型的变量，不进行赋值
var variableName1, variableName2, variableName3 string
//声明多个相同类型的变量，进行赋值
var variableName4, variableName5, variableName6 = "test1", "test2", "test3"
variableName7, variableName8, variableName9 := "test1", "test2", "test3" //只能在函数中进行申明

//声明多个不同类型的变量，不进行赋值
var (
	variableName10 string
	variableName11 int
	variableName12 bool
)
//声明多个不同类型的变量，进行赋值
var (
	variableName13 = "test"
	variableName14 = 123
	variableName15 = true
)

创建指针变量

一般变量分为两种，一种是普通变量，存放的是数据本身。一种是指针变量，存放的是数据的内存地址。

通过new()新建一个指针变量，返回的是一个指针变量

//new()函数
func new(Type) *Type
//直接创建一个指针变量
ptr := new(string) //创建一个类型为string的指针变量
*ptr = "test" //为这个指针变量指向的数据赋值

&取出某个变量的内存地址

//使用&取出其他变量的地址来创建一个指针变量
variableName := "test"
ptr := &variableName //ptr为variableName的内存地址

创建特殊类型变量

slice，map和channel是go中的引用变量类型，他们的创建和初始化一般使用的make，特别是channel类型只能使用make进行创建。而slice和map可以通过简单的方式创建。make创建出来的变量，是普通变量，而不是指针变量。本章只简单介绍创建这些特别的变量，之后会进行更详细的分析。

//make函数
func make(t Type, size ...IntegerType) Type

创建slice

//slice结构
type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}
//创建slice
//创建一个初始元素长度为5的数据切片，元素初始值为0
slice1 := make([]int, 5)
//创建一个初始元素长度为5的数据切片，元素初始值为0，并预留10个元素的存储空间
slice2 := make([]int, 5, 10)

//不使用make创建
//创建切片容量为5的数组切片，[]中不能写数组容量，否则就不是切片而是数组了
slice3 := []int{1,2,3,4,5}
//初始值为nil，slice4为nil
var slice4 = []int
slice4 = append(s, i) //添加元素

创建map

//创建map
//创建一个键类型为string，值类型为int的map
map1 := make(map[string] int)
//创建一个键类型为string，值类型为int，初始存储能力为100的map
map2 := make(map[string] int, 100)
//直接创建有数据的map
map3 := map[string] int {
	"test1" : 1
	"test2" : 2
}

创建channel

//创建channel
//创建无缓存通道的channel
chan1 := make(chan int)
//创建有缓存通道的channel
chan2 := make(chan int, 10)

匿名变量

匿名变量一般被用作接收函数返回的不必要的参数，当一个函数返回多个变量时，接收这些变量就变得很麻烦，并且如果不需要用这个变量，申明后还可能会造成编译器报错。这个时候我们可以使用匿名变量(_)来代替不用的变量。

func test() (int, int) 
	return 1, 2
}
func main(){
	v1, _ = test()
	_, v2 = test()
}

匿名变量的优点：

不分配内存，不占用内存空间
不需要你为命名无用的变量而烦恼
多次声明不影响

常量

常量时一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型，数字型和字符串型。

//创建一个常量 type是可以省略的
const identifier [type] = value

声明方式

//单常量申明
const TEST_VARIABLE1 = 10
const TEST_VARIABLE2 = true
const TEST_VARIABLE3 = "test"

//多常量声明
const (
 TEST_VARIABLE4 = 10
 TEST_VARIABLE5 = true
 TEST_VARIABLE6 = "test"
)

iota计数器，可用作枚举

const (
	Sunday = iota    //0 iota计数器初始值为0
	Monday           //1
	Tuesday          //2
	test = "test"    //test iota将被+1
	Wednesday = iota //4
	_                // iota将被+1
	Thursday = iota  //6
)
//离开上一个const作用域 iota计数器被重置
const Friday = iota //0

在定义常量组时，如果不定义初始值，则表示使用上行的表达式

const (
	VARIABLE1 = 1  //1
	VARIABLE2      //1
	VARIABLE3      //1
)