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) // 32、基于内置函数make创建
// 创建一个 int 数组，长度为3，容量为8
var slice = make([]int, 3, 8) // [0,0,0]
len(slice) // 3
cap(slice) // 83、基于数组创建，以数组索引为例，是一个右半开区间
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 程序。
Copyright© 2013-2019