- 包声明
- 引入包
- 函数
- 变量
- 语句&表达式
- 注释
package main//包声明import "fmt"//引入包
//函数
func main() {/* 这是我的第一个简单的程序 */fmt.Println("Hello, World!")
}
基础语法
标记
go程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。
fmt.Println("Hello,World!")
1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )行分隔符
go程序中，一行代表一个语句结束，每个语句不需要在结尾以分号隔开，但是如果要将多个语句写在一行，那么必须分开。
注释
同Java，c
//
/**/
不多说
标识符
标识符基本同c，字母，数字，下划线，数字不能开头。
字符串连接
同java可以使用+进行连接
关键字和保留字
| 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 |
预定义标识符
| append | bool | byte | cap | close | complex | complex64 | complex128 | uint16 |
|---|---|---|---|---|---|---|---|---|
| copy | false | float32 | float64 | imag | int | int8 | int16 | uint32 |
| int32 | int64 | iota | len | make | new | nil | panic | uint64 |
| println | real | recover | string | true | uint | uint8 | uintptr |
数据类型
- 布尔型：只能为true或者false
- 数字类型：支持复数
- int
- float32
- float64
- 字符串类型：字符串类型就是一串固定长度的字符连接起来的字符序列。Go的字符串是单个字节拼接起来的。go的字符串的字节使用UTF-8编码标识Unicode文本
- 派生类型：
- 指针类型
- 数组类型
- 结构化类型
- Channel类型
- 函数类型
- 切片类型
- 接口类型
- Map类型
数字类型
整型
uint8 | 无符号 8 位整型 |
|---|---|
uint16 | 无符号 16 位整型 |
uint32 | 无符号 32 位整型 |
uint64 | 无符号 64 位整型 |
int8 | 有符号 8 位整型 |
int16 | 有符号 16 位整型 |
int32 | 有符号 32 位整型 |
int64 | 有符号 64 位整型 |
uint | 无符号整型 至少32位 |
int | 整型 至少32位 |
uintptr | 等价于无符号64位整型，但是专用于存放指针运算，用于存放死的指针地址。 |
浮点型
float32 | 32位浮点数 |
|---|---|
float64 | 64位浮点数 |
复数
complex128 | 64位实数和虚数 |
|---|---|
complex64 | 32位实数和虚数 |
常量
常量只能是基本数据类型，不能是
- 除基本类型以外的其它类型，如结构体，接口，切片，数组等
- 函数的返回值
常量声明时需使用const关键字，并且声明时必须指定值。
可以使用括号扣起来指定多个常量
const(Count = 1Name = lbd
)
iota
iota是一个内置的常量标识符，常用于表示一个常量中声明中无类型整数叙述，一般都是在括号中使用。
ps：（我的理解），感觉像是数学中的数列。
变量
声明
声明基本上和Java，c一致。
写一点点区别吧。
- var 变量名 类型名
- 短变量声明 name := 1
条件控制
基本同Java一样
fallthrough关键字
可以执行swtich-case相邻的下一分支
循环控制
格式基本同Java，c，for循环更加简洁，直接取消了for的括号，并且没有while循环，for直接被当作while来使用。
for range
for range可以更加方便的遍历一些可迭代的数据结构，如数组，切片，字符串，映射表，通道。
切片，数组
数组：在go中，数组作为值类型，不是引用数据类型。并且数组是定长的数据结构，长度被指定之后不能修改，而切片是不定长的，在容量不够时会自动进行扩容。
数组
go中的数组是值类型，不是和c一样是指向头部元素的指针。
初始化
数组在声明长度时长度只能是常量，不能是变量
var a [10]int//错误样例len := 10
var b [len]int
但是可以使用常量来进行长度的初始化。
当然使用元素初始化也可以，同Java，c一样。
访问
数组元素的访问和Java一样，只要有数组名和下标就可以进行访问。
切割
切割数组的格式为
arr[startIndex:endIndex],区间为左闭右开
//数组在进行切割之后，就会变成切片类型
fmt.Println("hello")var a [5]intfor i := 0; i < 5; i++ {fmt.Scanf("%d", &a[i])}fmt.Println(a)输出
[5]int
[]int切片
切片用于存放不知道长度的数据，并且后续使用过程中可能会频繁插入数据和删除元素。
初始化
var nums []int // 值
nums := []int{1, 2, 3} // 值
nums := make([]int, 0, 0) // 值
nums := new([]int) // 指针切片的底层实现实际上是数组，但是切片是引用类型，可以理解为指向底层数组的指针。
插入元素
切片元素的插入一般结合append函数使用
- 从头部插入元素
- 中间下标i插入元素
- 尾部插入元素
//头
nums = append([]int{-1, 0}, nums…)
//中间下标i
nums = append(nums[:i+1], append([]int{0, 0}, nums[i+1:]...)...)
//尾部
nums = append(nums, 2, 3)
删除元素
和插入元素一样，都需要结合append函数使用
- 从头部删除n个元素
- 从尾部删除n个元素
- 从中间指定下标i位置开始删除n个元素
- 删除所有元素
//- 从头部删除n个元素
nums = nums[n:]
//- 从尾部删除n个元素
nums = nums[:len(nunms) - n]
//- 从中间指定下标i位置开始删除n个元素
append(nums[:i], nums[i + n]…)
//- 删除所有元素
nums = nums[:0]
字符串
字符串本质上是一个不可变的字节数组，也是一片连续的内存空间。
并且字符串有两种字面量表达方式，分为普通字符串和原生字符串。
普通字符串
普通字符串由双引号表示，支持转义，不支持多行书写。
原生字符串
原生字符串由反引号表示，不支持转义，支持多行书写，原生字符串里面所有的字符都会原封不动的输出，包括换行和缩进。
指针
go语言保留了指针，但是为了保证安全，又限制了指针的使用。
同c语言一样，有取地址符&和解引用符*。但是go语言禁止指针运算，也就是指针无法偏移。
new和make
func new(Type) *Type
- 返回值是指针
- 接收参数是类型
- 用于给指针分配内存空间
func new(Type) *Type
- 返回值是值
- 接收的第一个参数是类型，不定长参数根据传入的类型不同而不同
- 用于给切片，映射表，通道分配内存
new(int) // int指针
new(string) // string指针
new([]int) // 整型切片指针
make([]int, 10, 100) // 长度为10，容量100的整型切片
make(map[string]int, 10) // 容量为10的映射表
make(chan int, 10) // 缓冲区大小为10的通道函数
声明
- 通过func关键字直接声明
- 通过var关键字来声明。
func sum(a int, b int) int {return a + b
}var sum = func(a int, b int) int {return a + b
}
go语言不支持函数重载。
其他基本和Java，c一般，就不再赘述，这里只简单说一下不同
返回值
func Sum(a, b int) int {return a + b
}当没有返回值时，并不需要将int改为void，直接空着就行。
并且go允许有多个返回值，需要用括号将返回值括起来。
func number(a, b int) (int , int) {
return a + b, a - b
}
go语言也支持具名返回值，但是不能与参数名重复，使用具名返回时，return可以不用指定返回值
func Sum(a, b int) (ans int){ans = a+ breturn
}
