Go 语言入门

Go 语言是诞生于 2009 年的编程语言，发展到今天已经有过去了 15 年。目前 Go 语言在国内外的社区都非常热门，很多著名的开源框架，例如：Docker、k8s、 Prometheus 等都使用 Go 语言开发，越来越多的公司也将 Go 作为技术选型之一。

下面我们一起来了解下 Go 语言的一些知识，帮助大家快速入门 Go 语言

数据类型

在介绍数据类型之前，我们先来看下变量以及常量的使用，通常用他们用来存储以及表示数据

变量

变量是一段或多段用来存储数据的内存，go 中使用 var 关键字来定义变量

var a int      // 自动初始化为 0
var d = true    // 自动推导类型为 bool

也可以一次定义多个变量

var a, b int
var c, d = "123", true

多行变量定义，建议使用组的方式声明

var (
    a, b int
    c, d = "123", true
)

变量也可以不使用 var 关键字来声明，称简短模式

func main(){
    a := 123
}

简短模式非常方便，但是有几个限制，从以上声明可以看出来 1、必须在函数内使用，上面我们放在 main 方法中使用 2、不能给类型，且必须提供初始值

常量

常量表示运行时不可修改的值(只读)，通常是一些字面量，必须是在编译期可确定的字符、数字或布尔值 go 中使用 const 来定义常量，与变量 var 类似的声明形式

const a int = 888
const a, b int
const a, b = 888, 666
const (
    a = 888
    b = 666
)

go 当中的数据类型，这里罗列4类，基础类型，聚合类型，引用类型，接口类型

基础类型

其中基础类型包括：数字 number，字符串 string，布尔 bool 其中数字又分为以下多种

类型长度默认值说明int, uint4, 80根据底层架构，32位或64位 ｜int8, uint810-128 ~ 127, 0 ~ 255int16, uint1620-32,768 ~ 32,767, 0 ~ 65,535int32, uint3240-2^31 ~ 2^31-1, 0 ~ 2^32-1int64, uint6480-2^63 ~ 2^63-1, 0 ~ 2^64-1byte10uint8float3240.0浮点数精度范围float6480.0双精度精度范围

聚合类型

聚合类型包括：数组 array，结构体 struct

数组

数组是一组固定长度的数据集合，数组中的元素类型必须是同类型的，其长度声明后就不可变，可以使用内置函数len()函数来获取数组长度，下面我们来看下如何声明一个数组

 // 一维数组
    var arr [1]int                       // 只声明类型
    var arr2 = [2]int{1, 2}              // 直接初始化（自动推导类型）
    var arr3 [3]int = [3]int{1, 2, 3}    // 声明类型 + 初始化
    var arr4 [4]int = [...]int{1, 2, 3, 4}  // 字面量前长度可省略为 ...
    // 多维数组
    var matrix [3][2]int = {{1,2},{3,4},{5,6}}
    var matrix [...][2]int = {{1,2},{3,4},{5,6}}

上面我们声明了 一维数组：类型为 int 的数组，有三种方式声明，其中可以使用...来省略长度，长度由后面的字面量长度决定 二维数组：其中只有第一维度能使用...来省略长度

遍历数组

// 一维数组
arr := [4]int{1, 2, 3, 4}

for i := 0; i < len(arr); i++ {
        fmt.Println(i, arr[i])
}

for i, v := range arr {
        fmt.Println("i", i, "v", v)
}

// 二维数组
matrix := [3][2]int{{1, 2}, {3, 4}, {5, 6}}

for i, v := range matrix {
    fmt.Println("i", i, "v", v)
    for j, v2 := range v {
            fmt.Println("i", i, "j", j, "v2", v2)
    }
}

结构体

还记得刚才我们怎么声明多个变量的，结构体就是帮助我们将多个变量声明，组合在一起，再起一个名字，叫做结构体， 我们以声明 name age 变量为例来看一下 普通变量声明

var name string
var age int

结构体声明

type user struct {
    name string
    age  int
}

初始化结构体

var u1 = user{
    name: "小明"
    age: 18
}
var u2 = user{"小红", 18}

有两种方式初始化，可以带上成员变量名，也可以不带，推荐使用第一种，带具体的变量名

使用结构体使用 . 访问成员变量

 u1.name // 小明
     
    u1.name = "小花"  // 修改成员变量值
    u1.name // 小花

结构体嵌套 结构体本身是变量，而结构体又是变量的集合，所以结构体之间是可以相互嵌套的

type admin{
    u user
    weight int
}
// 初始化
a := admin{
    u: u1,
    weight: 100
}
// 使用
a.u.name // 小花

嵌套结构体使用起来不太方便，需要先访问两层，匿名变量刚好可以解决这个问题

type admin{
    user
    weight int
}
// 初始化
a := admin{
    user: u1,
    weight: 100
}
// 使用
a // {{小花, 18}, 100}
a.name // 小花

引用类型

引用类型包括：切片 slice，字典 map，通道 channel

切片

切片弥补了数组不能动态修改的缺点，其内部通过指针引用数组，切片结构类似以下

type slice struct{
    array  pointer  // 指针
    len    int      // 长度 切片的元素个数
    cap    int      // 容量 切片的起始到其底层数组的结束区间内的元素个数
}

创建切片

1、直接声明

var slice = []int{1,2,3} // [1,2,3]
len(slice) // 3
cap(slice) // 3

2、基于内置函数make创建

// 创建一个 int 数组，长度为3，容量为8
var slice = make([]int, 3, 8) // [0,0,0]
len(slice) // 3
cap(slice) // 8

3、基于数组创建，以数组索引为例，是一个右半开区间

var array = [...]int{1,2,3,4,5,6,7,8}
var slice = array[2:5]  // [3,4,5]
len(slice) // 3
cap(slice) // 8
slice = array[2:]       // [3,4,5,6,7,8]
slice = array[:5]       // [1,2,3,4,5]
slice = array[:]        // [1,2,3,4,5,6,7,8]

操作切片

// 声明切片 slice
var slice = []int{1,2,3}
// 追加元素 4
slice = append(slice, 4) // [1,2,3,4]
// 追加切片
var slice2 = []int{5,6,7}
slice = append(slice, slice2...) // [1,2,3,4,5,6,7]
// 删除元素 以删除 4 为例
slice = append(slice[:3], slice[4:]...) // [1,2,3,5,6,7]

字典

字典（哈希表）是一个无序的键值对集合，其中 key 是不重复的，且 key 必须是能够支持相等 == !=运算符的数据类型，比如：数字，字符串，指针，数组等等

创建字典 1、直接声明

ages := map[string]int{
    "小明": 18,
    "小花": 28
}

2、使用内置函数make创建

ages := make(map[string]int)
ages["小明"] = 18
ages["小花"] = 28

操作字典

// 新增键值对
ages["小李"] = 38
// 删除键值对
delete(ages, "小花")
// 遍历
for k, v := range ages {
    fmt.Println(k, v) // 小明 18 小李 38
}

通道

见并发章节

函数

函数通常包含以下部分：func关键字，函数名，参数列表，返回列表，函数体

func intro(name string) string{
    return name
}

其中参数类型可以简写，相同类型的参数写一次就行

func intro(name, job string) string{}

同样支持不定参数 ...type，但必须是同类型，且必须是函数最后一个参数

func intro(args ...string) string{}
intro("Tom", "Coder")

函数的返回值可以有一个，也可以是多个，用，分割返回列表

func intro(name, job string) (string, string){
    return name, job
}

其中返回值参数是支持命名的，这样在函数体返回时直接return即可

func intro(name, job string) (name1, job1 string){
    name1, job1 = name, job
    return
}

函数还提供了匿名函数的写法，在声明函数时可以不提供函数名，直接赋值给一个变量

var getName = func(){
    fmt.Println("Tom")
}
getName()

匿名函数也可以是一个自执行函数IIFE，需要在函数最后添加一对小括号()

func(){
    fmt.Println("Jack")
}()

方法

如果了解面向对象编程，大都知道方法这个词，是用来维护和展示对象的自身状态。虽然go不是面向对象编程，但也借鉴了其一些思想，在 go 中，方法的声明与函数类似，但方法名之前多了一个接收器

type person struct{
    name string
}

func (p person) say() {
    fmt.Println("你好", p.name)
}

var student = person{name: "Jack"}
student.say()

上面我们新建了person结构体，并为结构体声明了say方法，将name打印出来，是不是有种面向对象的感觉了。

接口

接口 interface 是多个方法声明的集合，在 go 中，接口只声明方法，不实现方法，任何类型只要实现了接口中定义的所有方法，就表示实现了该接口

我们定义一个接口 coder，包含 getLanguage 方法

type coder interface {
    getLanguage()
}

实现接口，定义Fe,Be两个结构体，分别实现coder接口，调用其方法

type Fe struct{}

func (f Fe) getLanguage(){
    return "Javascript"
}

type Be struct{}

func (b Be) getLanguage(){
    return "Golang"
}

func get(c coder) {
    c.getLanguage()
}

get(Fe) // Fe: Javascript
get(Be) // Be: Golang

以上定义了两个结构体，分别实现了getLanguage方法，也就是实现了coder接口

并发

go的高并发是go的语言特色，其引入协程(goroutine)的概念来实现并发，开启一个协程非常简单，只需要在函数调用前使用关键字go，就代表创建了一个并发任务

创建后被放置在系统队列中，等调度器分配线程执行，当前流程不会阻塞，等到真正执行的时候才会分配内存，这里一个goroutine的默认单元是2KB（可以调整），所以可以轻松的创建成千上万个goroutine，而且因为是单线程中执行，也不存在线程之间切换的开销，执行效率也非常高

go func (){
    fmt.Println("hello goroutine")
}()

一般写多进程程序时，都会遇到一个场景：进程间通信。常见的通信方式有信号，共享内存等。而 goroutine 之间的通信机制是通道 channel

通道

通道是一种特殊类型，遵循先进先出（FIFO）原则，下面我们使用 make 创建一个类型为 chan int 的通道。

make 函数接受两个参数，第二个参数是可选参数，表示通道容量。不传或者传 0 表示创建了一个无缓冲通道。

// 使用 make 创建一个类型为 chan int 的通道
ch := make(chan int)
ch <- 1    // 发送数据
x  = <- ch // 接收通道数据
<- ch      // 接收数据，丢弃结果
close(ch)  // 关闭通道

无缓冲通道

无缓冲通道上的发送操作将会阻塞，直到另一个 goroutine 在对应的通道上执行接收操作。相反，如果接收先执行，那么接收 goroutine 将会阻塞，直到另一个 goroutine 在对应通道上执行发送。

所以，无缓冲通道也是一种同步通道。

func main() {
    ch := make(chan int)
    go func(c chan int) {
        res := <-c
 fmt.Println("接收成功", res)
    }(ch)
    ch <- 1
    fmt.Println("发送成功")
}
// 接收成功 1
// 发送成功

缓冲通道

缓冲通道的发送操作在通道尾部插入一个元素，接收操作从通道的头部移除一个元素。如果通道满了，发送会阻塞，直到另一个 goroutine 执行接收。相反，如果通道是空的，接收会阻塞，直到另一个 goroutine 执行发送。

// 创建一个 容量为10的缓冲通道
func main(){
    ch := make(chan int, 10)
    ch <- 10
    // 获取通道元素数量
    fmt.Println(len(ch))
    // 获取通道容量
    fmt.Println(cap(ch))
}

通过本文的学习，我们对 Go 语言中的基础有了全面的了解。从基本数据类型，到数组、结构体等聚合类型，再到切片、字典和通道这些引用类型，以及函数、方法、接口、并发编程等，帮助大家写出更加健壮的go 程序。