保留字

关键字

在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关键字应在文件(除注释以外)的最头部进行定义。

1
package main

Import语法

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

  • 单包导入
1
2
3
package main

import "fmt"
  • 多包导入
1
2
3
4
5
6
package main

import (
  "fmt"
  "os"
)

变量

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

变量声明

  • var [name] [type] = [value]

    • var 关键字用于声明变量
    • [name] 变量名称
    • [type] 变量的类型(可省略，根据变量的值推断类型)
    • [value] 变量的值(可省略，变量的值为默认值)

  • [name] : [value] 短声明，只能在函数中进行申明

    • [name] 变量名称
    • [value] 变量的值(不可省略)

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

1
2
3
4
5
6
7
8
//声明一个变量，不进行赋值，变量为默认值
var variableName1 string
var variableName2

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//声明多个相同类型的变量，不进行赋值
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()新建一个指针变量，返回的是一个指针变量
1
2
3
4
5
//new()函数
func new(Type) *Type
//直接创建一个指针变量
ptr := new(string) //创建一个类型为string的指针变量
*ptr = "test" //为这个指针变量指向的数据赋值
  • &取出某个变量的内存地址
1
2
3
//使用&取出其他变量的地址来创建一个指针变量
variableName := "test"
ptr := &variableName //ptr为variableName的内存地址

创建特殊类型变量

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

1
2
//make函数
func make(t Type, size ...IntegerType) Type
  • 创建slice
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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
1
2
3
4
5
6
7
8
9
10
//创建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
1
2
3
4
5
//创建channel
//创建无缓存通道的channel
chan1 := make(chan int)
//创建有缓存通道的channel
chan2 := make(chan int, 10)

匿名变量

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

1
2
3
4
5
6
7
func test() (int, int) 
  return 1, 2
}
func main(){
  v1, _ = test()
  _, v2 = test()
}

匿名变量的优点：

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

常量

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

1
2
//创建一个常量 type是可以省略的
const identifier [type] = value
  • 声明方式
1
2
3
4
5
6
7
8
9
10
11
//单常量申明
const TEST_VARIABLE1 = 10
const TEST_VARIABLE2 = true
const TEST_VARIABLE3 = "test"

//多常量声明
const (
 TEST_VARIABLE4 = 10
 TEST_VARIABLE5 = true
 TEST_VARIABLE6 = "test"
)
  • iota计数器，可用作枚举
1
2
3
4
5
6
7
8
9
10
11
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

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

1
2
3
4
5
const (
  VARIABLE1 = 1  //1
  VARIABLE2      //1
  VARIABLE3      //1
)