Golang笔记--基础篇汇总
Go程序结构：
- 包名
- 导入其他的包
- 常量的定义
- 全局变量的声明和负责
- 一般类型声明
- 结构的声明
- 接口的声明
- 由main函数作为程序入口启动点
Go别名和省略调用：
在导入包时可以使用别名来防止混淆，或者是使用省略调用来减少代码
别名：
//在导入包时定义别名
import io “fmt”
//使用时直接使用别名，而不是原来的包名
io.Println("Hello World")省略调用（不建议使用，易混淆）：
//在导入包时声明省略调用
import . “fmt”
//使用时直接使用要使用的函数，不用加包名
Println("Hello World")Go中的可见性规则：
使用大小写来决定该常量，变量，类型，接口，结构或者函数是否可以被外部调用。
函数名首字母小写为private函数
函数名首字母大写为public函数
基本类型：
（布尔型）bool：
- 长度：1字节
- 取值范围：true，false（不可以用1，0表示）
（整形型）int/uint：
- 长度：取决于所在平台，32或64位
（8位整型）int8/uint8：
- 长度：1字节
- 取值范围：-128~127/0~255
（字节型） byte（unit8）：
- 长度：1字节
- 取值范围： 0~255
（16位整型）int16/uint16：
- 长度：2字节
- 取值范围：-32768~32768/0~65535
（32位整型）int32（rune）/uint32：
- 长度：4字节
- 取值范围：-(2^31)~(2^31)-1/0~(2^32)-1
（64位整型）int64/uint64：
- 长度：8字节
- 取值范围：-(2^64)~(2^64)-1/0~(2^64)-1
（浮点型）float32/64：
- 长度：4/8字节
- 小数位：精确到7/15位小数位
（复数）complex64/128：
- 长度：8/16字节
（无符号指针）uintptr：
- 长度：可以保存指针的32位或者是64位整型
引用类型：
- slice，map，chan
其他值类型：
- array ，struct，string
接口类型：
- interface
函数类型：
- func
变量的声明和赋值：
单个变量的声明和赋值：
//变量的声明
//(var <变量名称> <变量类型>)
var a int
//变量的赋值
//（<变量名称> = <表达式>）
a = 1
//变量声明同时赋值
//（var <变量名称> [变量类型] = <表达式>）
var a int = 65
//变量声明同时赋值
//（var <变量名称> = <表达式>）
var a = 2
//变量的声明同时赋值
//<变量名> := <表达式>
a := 2多个变量的声明和赋值：
全局变量：
//多个变量的声明
// [变量名1],[变量名2],[变量名3]... <类型名>
var a,b,c,d int
//多个变量的赋值
//[变量名1],[变量名2],[变量名3] = <表达式>，<表达式>，<表达式>...
a,b,c = 1,2,"string"
//多个变量的声明和赋值
//var(<变量名> = <表达式>...)
var(
a = 1
b = "string"
)局部变量：
//多个变量的声明
// [变量名1],[变量名2],[变量名3]... <类型名>
var a,b,c,d int
//多个变量的赋值
//[变量名1],[变量名2],[变量名3] = <表达式>，<表达式>，<表达式>...
a,b,c = 1,2,"string"
//多个变量的声明和赋值
//<变量名><变量名><变量名>... := <表达式><表达式><表达式>...
a,b,c := 1,2,3变量的类型转换：
Go中不存在隐式转换，所有的类型转换都需要显式声明
类型转换只能发生在两个相互兼容的类型之间
类型转换格式：
- < V alueA> [:]= < TypeOfValueA> (< ValueB >)
常量的初始化和枚举
常量的值在编译时就已经确定
常量得到的定义格式与变量基本相同
常量右侧的表达式必须是常量或者是常量表达式
常量表达式中的函数必须是内置函数
在常量组中定义时，若是不提供初始值，则默认使用上一行的表达式
iota是常量的计数器，从0开始，组中每定义一个常量，就会自动增1
每遇到一个const关键字，iota就会重置为0
const (
FIRST = iota //FIRST=0
SECOND //SECOND = 1
THRID //THRID = 2
)运算符
- 所有的运算符从左到右结合
- 优先级从高到低依次是
| 运算符 | 优先级 |
|---|---|
| ^ ! | 一元运算符 |
| * / % << >> & &^ | 二元运算符 |
| + - | ^ | 二元运算符 |
| == != < <= > >= | 二元运算符 |
| <- | 用于channel |
| && | |
| || |
指针
Go中的指针采用”.”选择符来操作指针对象的成员
- 操作符”&”取地址变量，操作符”*”访问目标对象
- 指针的默认值为nil而不是NULL
//指针的定义
var p *[]int
//只针的赋值
p = &a自增/自减运算符
++（自增运算符）和–（自减运算符）不再是作为表达式，而是作为单独的语句出现。也就是说他们都不可以出现在运算符的右侧
//错误使用
a := 1++;
//正确使用
a := 1
a++流程控制语句
if语句
在if之后没有括号，可以直接写判断表达式，而且大括号必须和if在同一行，支持在if语句中进行变量的初始化。
if a, b := 1, 2; a >= 0 || b >= 0 {
fmt.Println(a)
fmt.Println(b)
}for语句
只有for一个循环语句关键字，但是支持3种形式，for中的条件语句每次都会被检查，因此不建议在条件语句中使用函数，同if语句一样，左大括号必须和条件语句在同一行。可以通过break来跳出循环。
for a, b := 1, 2; a >= 0 || b >= 0; {
fmt.Println(a + b)
a--
b--
}switch语句
- 可以使用任何类型或者是表达式作为条件语句
- 不需要写break，符合条件时自动跳出
- 若是希望执行下一个case，需要使用fallthrough语句
- 支持一个初始化表达式（可以是并行方式），右侧需要跟分号
- 左大括号必须和条件语句在一行
//传统使用方式
a := 1
switch a {
case 0:
fmt.Println("a == 0")
case 1:
fmt.Println("a == 1")
default:
}
//在case中使用表达式
a := 1
switch {
case a >= 0:
fmt.Println("a == 0")
fallthrough //这样可以使满足case之后仍然进行判断，而不是直接跳出switch语句
case a >= 1:
fmt.Println("a == 1")
default:
fmt.Println("默认处理方式") //当所有的case都不满足使，会使用default来进行处理
}跳转语句（goto，break，continue）
- 三个语句都可以配合标签使用
- 标签名区分大小写,而且定义了的标签不使用的话会报编译错误
- break和continue可以配合标签来跳出多层的循环
- goto是调整执行的位置，与其他两个语句配合标签的结果不相同
Array数组
- 定义数组的格式为：var <数组名> [数组长度]<数组类型> = 0
- 数组长度也是类型的一部分，具有不同长度的数组为不同类型
- 要区分指向数组的指针和指针数组的区别
- 数组之间可以使用 == 和！=进行比较，但是不可以使用<或者是>比较
- 可以使用new来创建数组，但是返回的只是一个指向数组的指针
- Go支持多维数组
//可以使用数组的下标来指定具体某个数组元素的初始值，若不指定则全部使用类型零值
f := [20]int{19: 1}
for i := 0; i < 20; i++ {
fmt.Println(f[i])
}Slice切片
- 切片本身不是数组，他是一种引用类型，他用来指向底层的数组
- 他可以指向底层数组的全部或者是部分，可以作为可变长数组的替代方案
- 使用len()获取元素个数，使用cap()获取容量大小
- 一般使用make()来创建：make([]T,len,cap)，len表示元素的个数，cap表示切片的容量，cap省略时默认和len值相同
L := [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := L//指向底层数组L的全部
fmt.Println(s1)
//----------
L := [9]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
s1 := L[3:6] //指向底层数组L的部分,指向的是数组中下标为3，4，5的数
fmt.Println(s1)
//-----------
sl := make([]int, 3, 9)//[]int----所指向的类型，3----切片的长度，9----切片容量Reslice
- Reslice时索引以被slice的切片为准
- 索引不可以超过被slice的切片的容量值
- 索引越界不会导致底层数组的重新分配，而是引发错误
L := [9]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
slice := L[2:7] //输出为2，3，4，5，6
reslice := slice[1:4]//在slice的基础上再进行slice，输出为3，4，5
fmt.Println(reslice)
Append
- 可以在slice尾部追加元素
- 可以将一个slice追加在另一个slice的尾部
- 如果最终长度未超过追加到slice的容量，那么就返回原始slice
- 如果最终长度超过最忌到的slice的容量，那么就重新分配数组并拷贝元素数据
L := [9]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
slice := L[2:7]
fmt.Printf("%v %p", slice, slice)
slice = append(slice, 2, 3, 4, 5)
fmt.Printf("%v %p", slice, slice)Copy
L := [9]int{0, 1, 2, 3, 4, 5, 6, 7, 8}
slice := L[2:7]
slice2 := []int{1, 2, 3}
copy(slice, slice2)//将slice2中的元素拷贝到slice中
fmt.Println(slice, slice2)
//slice输出为[1，2，3，3，4，5，6，7，8]Map
- 和其他语言中的哈希表类似，以Key-Value的形式来存储值
- Key必须是支持==或者是！=比较运算的类型，不可以是函数，map，或者是slice
- Map查找比线性搜索快很多，但是比使用索引访问慢很多
- Map使用make创建，支持:=的声明赋值方式
- 使用len()函数获取元素个数，在超出容量之后会自动扩容
- 键值对不存在时自动添加，使用delete删除键值对
- 使用for range对map和slice进行遍历操作
//声明map变量：var关键字 变量名 map关键字 [Key类型]Value类型
var m map[int]string
//初始化map变量
m = map[int]string{1:"ok",2:"hello"}
//或者是
m = make(map[int]string)
//声明并赋值
var m map[int]string := make(map[int]string)
//其实map[int]string整体是作为一个类型名称的
//增加
m[1] = "ok"
//删除
delete(m, 1)
//多层map的嵌套
var m map[int]map[int]string //map的value类型为map
m = make(map[int]map[int]string) //对最外层的map进行初始化
m[1] = make(map[int]string) //对内层中Key为1的map进行初始化
m[1][1] = "hello"
fmt.Println(m[1][1])
//利用多返回值确定map是否初始化
data, ok := m[1][1]
if !ok {
m[1] = make(map[int]string)
}
m[1][1] = "hello"
data, ok = m[1][1]
fmt.Println(data, ok)
//通过for range来遍历map和slice，但是所有对value的操作都是对map和slice拷贝的操作
for k,v := range map{
//k是key，v是value
}Function函数
- 定义函数使用关键字func，左起大括号不能另起一行
- 不支持函数嵌套，重载和默认参数
- 支持的特性：无需声明函数原型，不定长形参，多返回值，命名返回值参数，匿名函数，闭包
- 函数也可以作为一种类型使用，赋值
//func关键字 函数名 形参列表，返回值列表
func A(data1 int,data2 int,data3 int) (a int, b int, c string) {
a, b, c = 1, 2, "hello"
fmt.Println(d)
return a, b, c
}
//go中支持不定长参数
func A(d ...int) (a int, b int, c string) {
//通过在类型名前加...来使用不定长参数，但是不定长参数只能作为参数列表的最后一个参数进行声明
//不定长参数传入的其实是一个slice切片，但是其实际上是传入的一个值拷贝，在函数内修改不会影响原值
}
匿名函数
不给函数指定名称，而是直接将其作为变量类型使用
//匿名函数，直接将函数作为变量进行使用
a := func() {
fmt.Println("匿名函数")
}
a()函数闭包
//定义返回值为一个函数
func closure(x int) func(int) int {
return func(y int) int {
return x + y
}
}
//使用函数
f := closure(10)
fmt.Println(f(1))defer
- 在函数体执行结束之后按照调用顺序的相反顺序逐个执行
- 即使函数发生严重错误也会执行
- 支持匿名函数的调用
- 常用于资源释放，清理等工作
- 在函数return之后还可以对函数的计算结果进行修改
//打印结果会是a，c，b
func main{
fmt.Println("a")
defer fmt.Println("b")
defer fmt.Println("c")
}
//打印结果是3，3，3，因为传入的是一个引用，所以当循环体执行完之后i指向的是3，然后开始反向的顺序执行defer，所以会是3，3，3
func main(){
for i := 0; i < 3; i++ {
defer func() {
fmt.Println(i)
}()
}
}Panic/Recover：
go中没有try/catch语句来进行异常处理，都是用panic和recover来就进行
panic可以在需要的地方将程序中断，不再执行
，可以在任何地方引发recover可以配合defer函数来进行程序的恢复运行，但是只有在defer调用的函数中有效
func main(){
B()
C()
D()
}
func B() {
fmt.Println("B")
}
func C() {
//defer函数必须在panic之前，不然无法注册的defer函数
//recover只能在defer调用的函数内使用
defer func() {
if err := recover(); err != nil {
fmt.Println("Recover in C")
}
}()
panic("Panic in c")
}
func D() {
fmt.Println("D")
}Struct
- 定义方法：type< Name > struct{}，和C语言很相似
- 结构之间可以相互的组合，但是没有继承
- 同样遵循命名的可见性规则
type Person struct {
Name string
Age int
}
//匿名结构，不需要为定义的结构命名，直接定义好结构之后使用
a := struct {
Name string
Color string
}{
Name: "cai",
Color: "Red",
}
//在初始化时，内部的匿名结构不可以通过指定字段名来命名，只能通过操作符'.'来初始化。
type Person struct {
Name string
Age int
Family struct {
Mom string
}
}
//对结构体进行初始化
per := Person{
Name: "wqc",
Age: 10,
}
//只能这样初始化内部的结构体
per.Family.Mom = "妈妈"
struct中的面向对象
在Go中不存在继承关系，主要是通过组合的方式来实现一些公有属性的抽象。
type People struct {
Name string
Age int
Sex int
}
type Student struct {
People
Sid int
}
//对使用结构组合的结构进行初始化
xiaoMing := Student{
Sid: 123,
People: People{
Name: "xiaoMing",
Age: 12,
Sex: 1,
},
}
xiaoMing.Age = 100
xiaoMing.Name = "whh"
xiaoMing.Sex = 11
fmt.Println(xiaoMing)Method方法
Go中通过显式说明receiver来实现与某个类型的组合
只能为同一个包中的类型定义方法
Receiver可以是类型的值或者是指针
不存在方法的重载
可以使用值或者是指针来调用方法，编译器会自动完成转换
如果外部结构和嵌入结构存在同名方法，则优先调用外部结构的方法
类型别名不会拥有底层类型所附带的方法
方法可以使用结构中非公开的字段
//方法的定义方式
type A struct {
Name string
}
//func（要绑定的结构名） 函数名（参数列表）（返回值列表）
//值传递方式传入的只是一个拷贝，无法对外部的值产生影响
func (a A) Print(x int) (flag bool) {
fmt.Println("1")
}
//指针传递，传入的是一个地址的拷贝，可以修改外部的值
func (a *A) Print(x int) (flag bool) {
fmt.Println("1")
}
//在Go中不允许方法重载，以上边为例：也就是说结构体A只能有一个叫Print的方法。Interface接口
接口是一个或者是多个方法签名的集合
只要某个类型拥有该接口的所有方法签名，计算实现该接口，无需显示声明实现了那个接口，称为structural Typing
接口只有方法声明，没有实现，没有字段
接口可以嵌入其他接口或者是结构中去
只有当接口存储的类型和对象都为nil时接口才等于nil
将对象赋值给接口时会发生拷贝，而接口内部存储的是指向这个复制品的指针，既然无法修改复制品的状态，也无法回去指针
空接口可以最为任何类型数据的容器
//定义接口
type USB interface {
Name() string
Connect()
}
//定义结构
type PhoneConnector struct {
name string
}
//为结构声明实现了接口的方法
func (pc PhoneConnector) Name() string {
fmt.Println("Name ")
return pc.name
}
//为结构声明实现了接口的方法
func (pc PhoneConnector) Connect() {
fmt.Println("Connect...", pc.name)
}
类型断言
- 通过类型断言的ok patteern可以判断接口中的数据类型
- 使用type switch则可以针对空接口进行比较全面的类型判断
接口转换
- 可以将拥有超集的接口转换为子集的接口
Reflecttion反射
- 反射可以提高程序的灵活性，使得interface有更大的发挥余地
- 方式使用TypeOf和ValueOf函数重接口中获取目标对象信息
- 反射会将匿名字段作为独立字段
- 想要利用反射修改对象状态，前提是interface.data是settable
- 可以通过反射动态调用方法
package main
import (
"fmt"
"reflect"
)
type User struct {
Id int
Name string
Age int
}
func (user User) Hello() {
fmt.Println("Hello World")
}
func Info(o interface{}) {
t := reflect.TypeOf(o)
fmt.Println(t.Name())
//获取所包含的字段的信息
v := reflect.ValueOf(o)
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
val := v.Field(i).Interface()
fmt.Println(f.Name, f.Type, val)
}
//获取所包含的方法信息
for i := 0; i < t.NumMethod(); i++ {
m := t.Method(i)
fmt.Println(m.Name, m.Type)
}
}
func main() {
u := User{1, "ok", 12}
Info(u)
}
可以通过使用反射来获取变量的地址信息，然后直接对地址中所存的信息进行修改
x := 9
v := reflect.ValueOf(&x)
v.Elem().SetInt(999)
fmt.Println(x)
通过反射来修改接口中的字段值
- 首先判断是否获取到字段，而且值可以被修改
- 然后检验是否获取到所需要的字段
- 修改字段值
func Set(o interface{}) {
//获取接口中的字段值
v := reflect.ValueOf(o)
//检验是否获取正确
if v.Kind() == reflect.Ptr && !v.Elem().CanSet() {
fmt.Println("XXX")
return
} else {
v = v.Elem()
}
//获取具体某一字段
f := v.FieldByName("Name")
//检验是否成功获取到
if !f.IsValid() {
fmt.Println("错误")
}
//通过set方法修改字段值
if f.Kind() == reflect.String {
f.SetString("正确")
}
}Concurrency并发
高并发是Go的核心亮点，其实goroutine是官方实现的“超级线程池”，每个实例4-5KB的占内存占用和由于实现机制而大幅减少的创建和销毁开销。通过通讯来进行消息交互，而不是通过共享内存来通讯。
通讯方式Channel
Channel是goroutine沟通的桥梁，大都是阻塞同步的
通过make创建，通过close关闭
可以使用for range来迭代不断操作Channel
可以设置通道为单项或者是双向
可以设置缓存大小，在未被填满前不会发生阻塞
func main() {
//声明一个通道
channel := make(chan bool)
go func() {
fmt.Println("Go Go Go")
//向通道中写入数据
channel <- true
//关闭通道
close(channel)
}()
//通过for range从通道中读取数据
for v := range channel {
fmt.Println(v)
}
}Select
可以处理一个或多个channel的发送和接收
同时有多个可用的channel是按随机顺序处理
可用空的select来阻塞main函数
可设置超时机制