关于golang:一-初识Golang

介绍

Go(Golang) 是谷歌开发的一种 动态强类型、编译型、并发型，并具备垃圾回收性能的编程语言。

咱们为什么要学习Go？其实我感觉是因为公司倒退越来越快的一个必然趋势，随着倒退，很多货色是nodejs不肯定能很好的反对。咱们须要后端多样化，以在将来某个时段咱们能有更大的能力去面对未知的事务。

Golang 的Hello World

还记得以前学习C语言的时候，老师都是从Hello World开始讲起，明天咱们也是从这里开始咱们的Golang之旅。

package mainimport "fmt"func main() {  fmt.Println("Hello World")}

和C语言相似，咱们的程序都是从 main 函数开始，应用如下语句进行编译：

$ go build helloworld.go

编译完了之后，会在以后文件生成一个 helloworld 可执行文件，执行改文件即可打印：

$ ./helloworldHello World

下载

官网下载地址(点我)

下载对应零碎的安装包

解压缩：

tar -C /usr/local -xzf go1.15.2.linux-amd64.tar.gz

增加PATH环境变量：

export PATH=$PATH:/usr/local/go/bin

装置好了应用上面命令测试：

$ go versiongo version go1.15.2 linux/amd64

咱们能够应用 go env 查看go的环境变量，咱们先重点关怀这个环境变量：

GOPROXY

Go 除了本身带了很多包，社区也有很多开源我的项目的包，大部门都是在github、google、等域名下面，如果你的terminal没有翻墙，拉取会很慢，这个时候，咱们能够设置这个环境变量(非零碎环境变量)：

$ go env -w GO111MODULE=on$ go env -w GOPROXY=https://goproxy.cn,direct

这样，拉取所有的包都走的是七牛云。

Golang 的语法

Golang 是一门上手十分快、并发性能十分高的语言，咱们先来介绍Go的根本语法。

package

每份 .go 代码，都须要在文件的第一行指定包名，一般来说，都是以后所在文件夹的名字，在同一个文件夹下的Go文件，包名是统一的。包名不能应用特殊字符，比方 - 等,个别都是小写并且简短

其中有个例外，就是 package main ，main 包在一个文件夹下只能有一个。

包的导入有两种形式：

import "github.com/go-redis/redis"import "context"// ORimport (    "github.com/go-redis/redis"    "context")

咱们举荐应用第二种写法，有时候，咱们可能只想援用某个包，让其执行 init 函数，而不会用到包外面的函数，能够这样做:

import (    _ "github.com/go-sql-driver/mysql" // 只会执行 mysql 包下的init函数)

main 函数

main 函数是咱们我的项目的入口程序，如果一个go代码被编译，它没有main函数，是无奈编译出可执行文件的。

main 函数的写法是：

func main() {    // do something}

语句

一个 statement 就是一行，不须要结尾的分号

比方：

func main() {    fmt.Println("Hello Go!") // 这就是一条语句}

正文

和大部分语言的正文一样，Go应用 // 代表单行正文，应用 /** **/ 代表多行正文

比方：

func main() {    // 我是单行的正文    /**    我是    多行    的    正文    **/}

根本类型

Go 是强类型的语言，不会像咱们目前应用的nodejs一样，一个变量能够随便赋任意类型的值。在Go中，一旦定义了某个变量的类型，则这个变量只能赋予该类型的值。

• 布尔类型 bool 布尔的值只能是 true 或者 false，和nodejs不同，0 不代表false。
• 字符串类型 string 字符串必须是由双引号蕴含起来的字符汇合。
• 数字类型 见下

数字类型 能够分为 整数类型、浮点数类型和一些其它非凡意义的类型

整数类型

浮点数类型

其它数字类型

变量

变量名的规定和其它语言都相似, 只能由字母、数字和下划线取名，且不能以数字结尾:

var variable data_types = value

其实申明变量的形式由很多种

// 第一种 这种形式必须要指定类型// 如果a没有被赋值，则a的值默认是该类型的零值，int->0,string->"",bool->falsevar a inta = 1// 第二种 申明的时候间接赋值，如果没有给定类型，会主动推导进去var a int = 1var a = 1 // fmt.Printf("%T", a) => int// 第三种 申明常量,常量申明的时候必须要赋值，类型能够写能够不写，会主动推导，常量不可被批改const a = 1const (    a = 100    b) // a、b都是int 值都是100，只有const能够这样用const (    a = iota  // 0    b         // 1    c         // 2    d = "pdf" // iota+1    e = 100   // iota+1    f = iota  // 5    g         // 6) // iota 是一个非凡常量，z在下一行的时候会主动递增，只在一个const()作用域无效，用作枚举很不便// 第四种 主动推导a := 1a := ""

变量的申明是能够多个变量能够一起申明的:

var (    a,    b,    c int) // a、b、c都被申明为int 类型var (    a,    b,    c int    d,    e,    f string) // a、b、c都被申明为int 类型,d、e、f都被申明为字符串类型a, b := 1, "" // a 是int，b是string，这种形式最罕用，因为函数的返回值能够是多个

运算符

运算符用于程序在执行算术运算或者逻辑运算时应用。

Go内置的运算符有：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其它运算符

算术运算符

假如A=10 B=20

关系运算符

假如A=10 B=20,关系运算符的后果时bool类型的值

// ==fmt.Println(A == B) // false// !=fmt.Println(A != B) // true// > < >= <=fmt.Println(A > B) // falsefmt.Println(A < B) // truefmt.Println(A >= B) // falsefmt.Println(A <= B) // true

逻辑运算符

假如 A = true B = false

// && 逻辑ANDfmt.Println(A && B) // => false// || 逻辑或fmt.Println(A || B) // => ture// ! 逻辑非fmt.Println(!A, !B) // => false true

位运算符

• 按位与 &
• 按位或 |
• 按位异或 ^: 1^1=0;1^0=1;0^0=0;
• 左移 <<
• 右移 >>

赋值运算符

=、+=、-=、*=、=、%=、<<=、>>=、&=、^=、|=

其它运算符

指针取地址: &, 取值 *

条件语句

Go语言提供上面几种条件语句：

• if 语句
• switch 语句
• select 语句

if 语句

Go 语言中，if 语句的语法：

if 布尔条件表达式 {    statement} else if 布尔条件表达式 {    statement} else {    statement}

留神，这里的条件表达式不须要括号，举个实例：

package mainfunc main() {    a := 1    b := 2    if a < b { // if 语句有这样的语法糖 if a:= func(); a < 10 {}        fmt.Println("a < b")    } else if a == b {        fmt.Println("a == b")    } else {        fmt.Println("a >  b")    }}

switch 语句

Go 语言的switch语句很弱小，和nodejs 的不太一样，Go语言中的Switch语法：

switch expression {    case condition:        statement    default:        statement}

首先，expression 能够是任何类型的值，如果没有写，则默认是 true, condition 必须要和expression的类型统一，否则报错，并且condition能够为多个，以逗号隔开，default 子句示意当case都没有满足的条件的时候执行，同时最大的一点不同之处，没有break语句，Go程序的 switch 每一个 case 执行完了就退出 switch 而不会持续向下执行，如果须要向下执行，则须要在case{}中最初加上一句： fallthrough

比方：

switch "2" {    case "1", "2", "3":        fmt.Println("1 2 3")        fallthrough    case "4":        fmt.Println("4")    default:        fmt.Println("default")} // => 1 2 3  // => 4

select 语句

select 语句个别用于超时管制，是Go的一个控制结构，每个case都是一个channel操作，select 将随机选取一个能够运行的case执行，如果没有能够运行的case，则select语句会阻塞，直到有能够执行的case。默认子句总是能够执行的。

语法如下:

select {    case <- ch: // 前面会讲，这个是 channel 这一块的常识        statement    default:        statement}

不过个别咱们都不会用default,就像下面讲的，咱们个别是用来做超时管制的，举个例子：

package mainimport (    "fmt"    "time")func sleep(n int, res chan<- string) {    time.Sleep(time.Duration(n) * time.Second)    res <- "获取到了后果" // 管道外面设置数据}func main() {    timeout := time.After(time.Duration(3) * time.Second)    res := make(chan string)    go sleep(2, res)    select {    case <- timeout:        fmt.Println("超时了")    case val := <- res: // 接管管道的数据        fmt.Println(val)    }}

这里，咱们申请一个函数，同时设置一个3s的超时，如果函数3s内没有返回数据，则select 会执行超时这个case,否则就执行了取后果的数据。当然，这个例子是没有代表性的，因为理论工程上要比这个简单一点，因为要波及到资源的开释之类的，前面会讲到。

循环语句

Go的循环语句和nodejs也不太一样，咱们先看语法：

// 第一种for init; condition; post { // 留神，这里能够省略任意一项，如果只有condition能够不要分号，    statement}// 咱们常常会应用死循环+select来做一下事件for {    select {        case xxx    }}// 第二种 for k,v := range mapValue {     }// 因为Go定义了变量，就必须要应用，所以不须要的变量能够用 _ 代替,比方for _, v := range mapValue {    }

函数

Go 中函数的申明从 func 关键字开始，语法如下：

func funcName(v datatypes) datatypes {    }

func 关键字前面接的是函数名字，函数名字个别是用驼峰命名，如果是小驼峰，则这个函数只能在以后文件被调用，如果是大驼峰，则能够被其它包引入调用。

括号外面的是形参，模式为 变量名 变量类型。Go的返回值也必须要定义类型，定义类返回值类型，则必须要有返回值。

举个例子：

func f1(a int, b string) string {} // 传了一个int, 一个string 返回值是stringfunc f2(a, b int, c, d string) {} // 如果两个参数相邻并且类型统一，则只须要在最初一个变量写类型func f3() (string, string) {} // Go反对返回多个参数，这里返回了两个string类型的值func f4() (a , b int) {} // 这里示意曾经定义好了返回值的变量，只有在代码外面对a,b赋值就能够，如果没有赋值，则返回对应类型的零值

！！！十分重要！！！

函数传参个别有两种：

• 值传递是指在调用函数时将理论参数复制一份传递到函数中，这样在函数中如果对参数进行批改，将不会影响到理论参数
• 援用传递是指在调用函数时将理论参数的地址传递到函数中，那么在函数中对参数所进行的批改，将影响到理论参数。

而Golang应用的是值传递

https://goinbigdata.com/golan...

每个go文件都能够有一个 init 函数，在被导入包的时候就会执行，并且只会执行一次，被屡次导入也只会执行一次。

func init() {    }

数组

数组是一种具备惟一的雷同的数据类型、固定长度的数据项序列，这个类型能够是整型、字符串或者任意自定义的构造体。

定义数组必须要指定长度，语法如下：

var variables [size] variable_type

以下是例子：

var balance [10] float32 // 长度为10的数组，初始值是[0,0,0,0,0,0,0,0,0,0]var balance = [3]int {1, 2, 3} // 初始化,晓得长度var balance = [...]int {1, 2, 3, 4, 5} // 初始化，如果不晓得长度，能够主动推断

指针

和 nodejs 不同的是，Go 是有指针的，和C一样，都是应用 & 进行取地址，应用 * 定义指针变量

举个例子:

var a int = 3var p *int = &a // p := &a

在C语言中，指针属于比拟难的一块，什么是指针？ 一个指针变量，指向了一个值的地址：

比方一个变量 C 保留了字符 'K'，地址在 0x11A，而一个指向c的指针变量p，它的值就是C的地址11A。

通过一个实例来看怎么应用指针：

s := &map[string]string{"a": "a", "b": "b"}v, ok := (*s)["a"]

构造体

构造体是Go中十分重要的一个模块，前面的开发肯定会用的到，不论是创立Service还是创立Orm的model。

数组是只能存储一个类型固定长度的值，构造体呢？能够存储多个不同类型的值，简略来说，构造体就是一系列不同或者雷同类型的汇合。

构造体语法定义如下：

type struct_name struct {    field1 data_types    field2 data_types    ...}

举个例子：

type User struct {    Name string    Age uint8    ID int    Event [10]string}

这样咱们就定义了一个构造体，申明应用如下：

// 不是很举荐的写法user := User{"pdf", 8, 123, [10]string{"a", "b"}} // 按定义程序顺次填入// 举荐写法user := User{    Name: "pdf"    Age: 8，} // 能够疏忽掉不须要的字段，这样没有赋值的就是对应的零值

申明了之后，应用形式如下：

user.Name = "ghj"fmt.Println(user.Age)

这里有一个语法糖，对于指针的，就是说，对于构造体的指针，咱们能够疏忽 * ：

u := &userfmt.Println(u.Name, (*u).Name)

切片(slice)

数组长度是固定的，对于长度不晓得或者不固定的数据，咱们就很难应用数组去实现这种业务。

所以就有了切片(动静数组)，切片长度是不固定的，切片的定义和数组的定义很相似，不过不须要长度

arr := [10]int{}slice := []int{}fmt.Printf("arr: %T, slice: %T", arr, slice) // arr: [10]int, slice: []int// 还能够用make创立切片slice := make([]type, len) // 指定初始长度// 还能够指定容量slice := make([]type, len, cap)

切片初始化和赋值：

a := []int{1, 2} // 申明的时候间接初始化a = append(a, 1) // 追加arr := [10]int{}slice := arr[start:end] // 从数组外面切，从start算，到end-1

当初，咱们说了数组和切片，能够开始说一下长度和容量了。

Go提供了 len(v Type) 和 cap(v Type) 查看数组和切片的长度以及容量

数组的长度和容量都是固定的！

切片的长度示意以后切片值的个数，切片的容量是什么呢？

咱们须要从切片的实质去看：

type SliceHeader struct {    Data uintptr    Len  int    Cap  int}

这个就是切片的构造体，Data 指向数组的指针，Len示意以后切片的长度，Cap示意Data数组的大小。

用一个理论的例子来说：

b := [4]int{}d := b[0: 3]fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ① b=[0 0 0 0], d=[0 0 0], len(d)=3, cap(d)=4d[0] = 1fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ② b=[1 0 0 0], d=[1 0 0], len(d)=3, cap(d)=4d = append(d, 2)fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ③ b=[1 0 0 2], d=[1 0 0 2], len(d)=4, cap(d)=4d[0] = 3fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ④ b=[3 0 0 2], d=[3 0 0 2], len(d)=4, cap(d)=4d = append(d, 4)fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ⑤ b=[3 0 0 2], d=[3 0 0 2 4], len(d)=5, cap(d)=8d[0] = 5fmt.Printf("b=%v, d=%v, len(d)=%v, cap(d)=%v\n",b, d, len(d), cap(d))// ⑥ b=[3 0 0 2], d=[5 0 0 2 4], len(d)=5, cap(d)=8

d是切片，这个时候Data指向的就是b这个数组，一个六个输入，顺次说一下：

1. d切了[0:3],所以长度是3，容量是b数组的长度，也就是4，当没有赋值时，int的默认零值是0，所以b=[0,0,0,0],d=[0,0,0]
2. 因为切片的Data指向了b，所以批改是批改b数组的值，所以 b = [1, 0, 0, 0]，d = [1, 0, 0]
3. append函数用于切片开端追加一个值，留神，这个不是间接批改d，必须要从新用d接管返回值，所以此时d的长度是4，容量也是4，因为d的Data指向b，所以b和d的值都是 [1, 0, 0, 2]
4. 因为d的Data指向b，所以b和d的值都是[3, 0, 0, 2]
5. 这个时候，d再次追加了一个值，这个时候，b=[3,0,0,2],和上一次打印是统一的，而d的值为[3, 0, 0, 2, 4]，追加胜利，并且长度的确加了1，然而容量却从4变为了8.可能看到这里大家就会纳闷了，d的Data不是指向了b吗，为什么这一次b没有被批改呢？这是因为数组是长度不变的，切片是动静数组，当切片容量不够时，就会新申请一片间断的内存作为Data的指向，并且将原来的值复制过来，这个就是切片的扩容(扩容算法不开展讲)，所以一旦产生了扩容，切片的指向就会发生变化
6. 所以这个时候，再次批改d，也不会影响b了，所以b=[3, 0, 0, 2]，d=[5, 0, 0, 2, 4]

切片的零值是 nil

就像下面说的，间接切片一个数组或者别的切片失去的新切片，其实Data指向的还是原来的，然而有时候咱们不要这个援用，因为咱们要传参的时候想要批改这个值然而不能影响实参，所以咱们就须要拷贝切片：

old := []int{1, 2, 3}newSlice := make([]int, len(old), 2 * cap(old)) // 应用make函数，指定长度和容量，留神，长度肯定小于等于容量fmt.Printf("old=%v, newSlice=%v\n", old, newSlice)// old=[1 2 3], newSlice=[0 0 0]copy(newSlice, old) // 应用copy函数复制，第一个参数是指标，第二个参数是被拷贝的值，newSlice的长度至多都要等于old的长度，否则会截断fmt.Printf("old=%v, newSlice=%v\n", old, newSlice)// old=[1 2 3], newSlice=[1 2 3]old[0] = 2fmt.Printf("old=%v, newSlice=%v\n", old, newSlice)// old=[2 2 3], newSlice=[1 2 3]// old批改胜利，然而newSlice不会被批改

Map 汇合

Go 种的Map汇合和咱们应用的Nodejs种的对象相似，它就是一组无序的键值对的汇合。

var m map[string]int m := make(map[string]int)// 键是string类型，值是int类型// 初始化var m = map[string]int{"pdf": 100}m["ghj"] = 99fmt.Println(m) // map[ghj:99 pdf:100]

Map值的获取就比拟有意思了，咱们后面有始终说到，一个变量定义了，它都会有本人对应的零值，所以在map获取值的时候，如果某个key是不存在的，则返回了value类型对应的零值，比方:

v := m["none"]fmt.Println(v) // 0

这个时候是有问题的。大家思考一下

如果我原本就是有一个存在的key，并且值我就是设置为0呢？

m["hz"] = 0v := m["hz"]fmt.Println(v) // 0

这个时候就没有方法辨别这个key的值到底是默认的零值还是咱们本人设置的零值。所以咱们须要用另外一种写法:

if v, ok := m["none"]; ok {    fmt.Println(v)}v, ok := m["none"]fmt.Println(v, ok) // 0 false

还记得if这个写法吗？忘了的同学能够往前面看看。这个时候，咱们多承受了一个ok参数，这个参数的类型是bool，如果为true示意key存在，如果为false示意key不存在，获取的是零值。

map的key是能够用 == 或者 != 作比拟的类型（map和interface{}这两种是我晓得的不可比拟的两种动静类型）。比方：

m := map[bool]bool{true: true}m := map[struct{}]map[string]int

刚刚说过，key存不存在能够用第二个返回值判断，如果说前面咱们须要删掉一个key，能够应用 delete函数：

m := map[string]int{"pdf": 1}delete(m, "pdf")v, ok := m["pdf"]fmt.Println(v, ok)

接口 interface

Go语言提供了另外一种数据类型 即接口，他把所有具备共性的办法定义在一起，任何其它类型只有实现了这些办法(接口定义外面的全副)就相当于实现了这个接口。

比方：

type UserInferface interface { // 定义了一个用户接口    GetUserInfo(userId int) (UserInfoDTO, error)    UpdateUserInfo(vo UserVo) (UserInfoDTO, error)}type UserService struct{} // 定义一个用于实现用户接口的构造体func (service *UserService) GetUserInfo(userId int) (UserInfoDTO, error) {    }func (service *UserService) UpdateUserInfo(vo UserVO) (UserINfoDTO, error) {    }func main () {    s := &UserService{}    s.GetUserInfo()    }

这样，UserService就实现了UserInterface这个接口。

错误处理

Go 语言通过内置的谬误接口提供了非常简单的错误处理机制(Go 中没有所谓try catch)。

error 类型是一个接口类型，定义如下：

type error interface {    Error() string}

通常咱们都会应用 errors 包来返回一个谬误:

func demo() error {    return errors.New("demo 产生谬误")}err := demo()if err != nil {    fmt.Println(err) // fmt.Println(err.Error())}

晓得了 error 类型是一个接口，所以咱们能够自定义error类型:

func (us * User1Service)Error() string {  return us.Name + "又错了"}func demo() error {  return &User1Service{    Name: "pdf",  }}err := demo()fmt.Println(err) // pdf又错了

Go 并发

并发这里，是初识Golang的最初一节，咱们抉择Go的一个很大起因就是Go的并发能力很强，并且应用非常简单！

简略到什么水平？

go someFunc()

就这么简略，只须要被调用函数后面加一个 go 关键字就能够了。

go 关键字其实是开启一个叫做 goroutine 货色，这个其实叫做协程。

main函数就是一个主协程。

举个例子：

func output(intput int)  {  fmt.Println(intput)}func main() {  for i := 0; i < 10; i++ {    go output(i)  }  for i := 10; i < 20; i++ {    go output(i)  }  time.Sleep(time.Duration(1) * time.Second)}

当你运行的时候，能够看到，每一次输入的后果都是不统一的。加一个睡眠是因为，主协程运行完结，则程序就退出了，所以还没有运行完的协程就没有运行机会了。

这样来看，有没有感觉和咱们的异步是一样的，哈哈。

结束语

明天讲的货色，我全副都没有深刻去讲，心愿这一篇文章，能让咱们大家从一个noder，从此也能够叫为 gopher。