Go语言学习笔记—golang基础语法_golang基础语法与高级语法

视频来源：B站《golang入门到项目实战 [2022最新Go语言教程，没有废话，纯干货！]》

文章为自己整理的学习笔记，侵权即删，谢谢支持！

golang基础语法

一、golang标识符、关键字、命名规范

1.1 标识符概念

1. Golang 对各种变量、常量、方法、函数、结构体、数组、切片、接口命名时使用的字符序列称为标识符
2. 凡是自己可以起名字的地方都叫标识符

1.2 标识符命名规则

1. 由 26 个英文字母大小写、0-9 和 _ 组成

2. 数字不可以开头。

3. Golang 中严格区分大小写。

4. 标识符不能包含空格。

5. 下划线_本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用

6. 不能以系统保留关键字作为标识符（一共有 25 个），比如 break，if 等等…

举例：

正确的命名

package main

import "fmt"

func main(){
   
    var name string
    var age int
    var _sys int
}
1
2
3
4
5
6
7
8
9
10

错误的命名

package main

import "fmt"

func main(){
   
    var 1name string
    var &age int
    var !abc
}
1
2
3
4
5
6
7
8
9
10

hello // ok
hello12 //ok
1hello // error ,不能以数字开头
h-b // error ,不能使用 -
x h // error, 不能含有空格

h_4 // ok
_ab // ok
int // ok , 我们要求大家不要这样使用
float32 // ok , 我们要求大家不要这样使用
_ // error
Abc // ok

1.3 关键字

在Go中，为了简化代码编译过程中对代码的解析，其定义保留关键字只有25个，如下

除了以上介绍的这些关键字，Go语言还有36个预定义标识符，其中包含了基本类型的名称和一些基本的内置函数，如下：

1.4 命名规范

命名规范设计变量、常量、全局函数、结构、方法等等的命名。

Go语言从语法层面进行了以下限定：任何需要对外暴露的名字必须以大写字母开头，不需要对外暴露的则以小写字母开头。

当一个命名以一个大写字母开头，如GetUserName，那么使用这种形式的标识符的对象就可以被外部包的代码使用（客户端程序需要先导入这个包），这被称为导出（如面向对象语言中的public）；命名如果以小写字母开头，则对包外是不可兼得，但是他们在整个包的内部是可见的并且可用的（如面向对象语言中的private）

1.4.1包命名

保持package的名字和目录保持一致，尽量采用有意义的包名，简短、有意义且尽量和标准库不要冲突。包命应该为小写单词，不要使用下划线或者混合大小写。

package psych
package service
1
2

1.4.2 文件命名

尽量采用有意义且简短的文件名，应为小写单词，使用下划线分隔各个单词

customer_dao.go
1

1.4.3 结构体命名

采用驼峰命名法，首字母根据访问控制大小写

struct 声明和初始化格式采用多行，例：

type CustomerOrder struct{
   
    Name string
    Address string
}
order := CustomerOder{
   "psych","四川成都"}
1
2
3
4
5
6
7

1.4.4 接口命名

命名规则基本上与上面结构体类似

单个函数的结构名以“er”作为后缀，例如Reader，Writer

type Reader interface{
   
    Read(p []byte)(n int,err error)
}
1
2
3
4

1.4.5 变量命名

和结构体类似，一般遵循驼峰命名法，首字母根据访问控制大小写，但遇到特有名词时，需要遵循以下规则：

如果变量为私有，且特有名词为首个单词，则使用小写，如 appService；若变量为bool类型，则名称应以has、is、can或allow开头

var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool
1
2
3
4

1.4.6 常量命名

常量需使用全部大写字母组成，并使用下划线分词

const APP_URL = "https://www.baidu.com"
1

如果是枚举类型的常量，需要先创建对应类型

type Scheme string

const{
   
    HTTP Scheme = "http"
    HTTPS Scheme = "https"
}
1
2
3
4
5
6
7

1.4.7 错误处理

错误处理的原则是不能丢弃任何有返回err的调用，不要使用_丢弃，必须全部处理。接收到错误，要么返回err，或者使用log记录下来尽早return；一旦有错误发生，马上返回，尽量不要使用panic，除非你知道你在做什么，错误描述如果是英文必须为小写，不需要标点结束，采用独立的错误流进行处理

1.4.8 单元测试

单元测试文件命名规则为example_test.go 测试用例的函数名称必须以Test开头，例如：TestExample每个重要的函数都要首先编写测试用例，测试用例和正规代码一起提交方便进行回归测试

二 golang变量

变量相当于内存中一个数据存储空间的表示，不同的变量保存的数据类型可能会不一样。你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)。

2.1 声明变量

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明，并且Go语言的变量声明后必须使用。

语法

var identifier type
1

var：声明变量关键字

identifier：变量名称

type：变量类型

例如：

package main

import "fmt"

func main（）{
   
    var name string
    var age int
    var married bool
}
1
2
3
4
5
6
7
8
9
10

批量声明

使用一个var关键字，把一些变量写在一个括号()里

package main

import "fmt"

func main（）{
   
    var (
    	name string
    	age int
    	married bool
    )
}
1
2
3
4
5
6
7
8
9
10
11
12

2.2 变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化，每个变量会被初始化成其他类型的默认值，例如：整型和浮点型变量的默认值为0；字符串变量的默认值为空字符串""。bool类型变量默认为false；切片、函数、指针变量的默认值为nil

2.2.1 语法

var 变量名 类型 = 表达式
1

例如：

package main

import "fmt"

func main（）{
   
    var name string = "Psych"
    var age int = 18
    var married bool = False
}
1
2
3
4
5
6
7
8
9
10

2.2.2 初始化多个变量

可一次性初始化多个变量，中间用逗号隔开

package main

import "fmt"

func main（）{
   
 	var name, age, married = "Psych", 18, False   
}
1
2
3
4
5
6
7
8

2.3 短变量声明

在函数内部可以用:=运算符对变量进行声明和初始化

package main

import "fmt"

func main（）{
   
    name := "Psych"
    age := 18
    married := False
}
1
2
3
4
5
6
7
8
9
10

注：此方法只适用于函数内部，函数外部不可使用

2.4 匿名变量

若我们接收到多个变量，有一些变量使用不到，则可使用_表示变量名称，这种变量即为匿名变量

package main

import "fmt"

func getNameAndAge(string, int){
   
    return "Psych", 18
}

func main（）{
   
    name, _ := getNameAndAge()
    fmt.Printf("name: %v\n", name)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三 golang常量

常量即为程序在编译阶段就已经确定的值，而程序运行时则无法改变该值，即一旦定义则无法修改。

在Go中常量可以为数值类型、布尔类型或者字符串类型等。

3.1 定义常量

语法：

const constantName [type] = value
1

const:定义常量的关键字

constantName:常量名称

type：常量类型（可省略）

value:常量的值

举例：

package main

import "fmt"

func main（）{
   
	//单常量声明：
    const PI float64 = 3.14
    const PI2 = 3.1415 //可省略类型
    //多常量声明：
    const （
    	W = 100
    	H = 100
    ）
    //多重赋值
    const i, j = 1, 2
    const a, b, c = 3, 4, "foo"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注：const 同时声明多个常量时，若省略了值则表示和和上面一行值相同

package main

import "fmt"

func main（）{
   
    const （
    	A = 100
    	B 
    	C
    ）
    
    fmt.Printf("A: %v\n", A)
    fmt.Printf("B: %v\n", B)
    fmt.Printf("C: %v\n", C)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

其运行结果为：

A:100
B:100
C:100
1
2
3

3.2 特殊关键字iota

iota可被认为是一个可被编译修改的常量，其默认值为0，每次调用一次则加1，遇到const关键字时被重置为0

package main

import "fmt"

func main（）{
   
    const （
    	A = iota //0
    	B = iota //1(i++)
    	C = iota //2
    ）
    
    fmt.Printf("A: %v\n", A)
    fmt.Printf("B: %v\n", B)
    fmt.Printf("C: %v\n", C)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：

A:0
B:1
C:2
1
2
3

使用_可跳过某些值

package main

import "fmt"

func main（）{
   
    const （
    	A = iota //0
    	_ 		 //1
    	C = iota //2 
    ）
    
    fmt.Printf("A: %v\n", A)
    fmt.Printf("C: %v\n", C)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果为

A:0
C:2
1
2

iota可声明中间插队

package main

import "fmt"

func main（）{
   
    const （
    	A = iota //0
    	B = 100
    	C = iota //2
    ）
    
    fmt.Printf("A: %v\n", A)
    fmt.Printf("B: %v\n", B)
    fmt.Printf("C: %v\n", C)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果为：

A:0
B:100
C:2
1
2
3

四 golang数据类型

4.1 简介

在Go语言中，数据类型用于声明函数和变量。每一种数据都定义了明确的数据类型，在内重中分配了不同大小的内存空间。

Go也有基于架构的类型，例如：int、uint、uintptr

浮点型：

其他数字类型