go

• 静态类型、编译型
• 支持两种范式
• 特点
  • 原生并发支持

概念

package

• 基本的分发单位、依赖关系的体现
• 每个源码文件都必须声明package
• 要生成可执行程序，必须要有main的package，并且还需要有main函数
• 同一个路径下只能存在一个package

源码文件

• 命令源码文件、库源码文件
• 测试源码文件

命令行工具

• go build 编译
• go run 编译并运行
• go get获取远程代码包

语法

• 注释

// single row/*multi row*/

• 基础结构

package main // 程序所属包import "fmt" // 导入依赖包const NAME = "cxk" // 常量定义type myInt int // 一般类型声明// 结构体声明type user struct { }// 接口声明type UserService interface { }// 入口函数func main(){  var a = "cxk"  fmt.Println(a+NAME)}

import

• 不能导入源码中没有使用的package

// 另外一种语法import (   "fmt"  "time")

原理

• 如果一个main导入其他包,包将被顺序导入;
• 如果导入的包中依赖其它包(包B) ,会首先导入B包,然后初始化B包中常量和变量,最后如果B包中有init ,会自动执行init() ;
• 所有包导入完成后才会对main中常量和变量进行初始化,然后执行main中的init函数(如果存在) , 最后执行main函数;
• 如果一个包被导入多次则该包只会被导入一次;

别名

• 别名操作的含义是:将导入的包命名为另- -个容易记忆的别名;

import pk "awesomeProject/pkg1"pk.F()

• 点(.)操作的含义是:点(.)标识的包导入后,调用该包中函数时可以省略前缀包名;

import . "awesomeProject/pkg1"F()

• 下划线(_ )操作的含义是:导入该包,但不导入整个包,而是执行该包中的init函数,因此无法通过包名来调用包中的其他函数。使用下划线(_ ) 操作往往是为了注册包里的引擎,让外部可以方便地使用;

import _ "awesomeProject/pkg1"

数据类型

• 数值类型,字符串类型和布尔型;
• 派生类型;

var i uint32 = 2fmt.Println(unsafe.Sizeof(i)) // 4var i1 int = 2fmt.Println(unsafe.Sizeof(i1)) // 8var i2 float32 = 1.0fmt.Println(unsafe.Sizeof(i2)) // 4var i3 bool = truefmt.Println(unsafe.Sizeof(i3)) // 1var i4 byte = 1fmt.Println(unsafe.Sizeof(i4)) // 1

变量

• 变量的声明格式: var <变量名称> [变量类型]
• 变量的赋值格式: <变量名称> = <值 ,表达式,函数等>
• 声明和赋值同时进行: var <变量名称> [变量类型]= <值 ,表达式，函数等>
• 分组声明格式:

var(i intj float32name string)

• 同一行声明多个变量和赋值

var a, b, c int = 1,2,3// 或者var a,b,c = 1,2,3// 省略vara,b,c := 1,2,3

• 全局变量的声明必须使用var关键词，局部变量则可以省略

var a=1func main(){    b:=2    fmt.Println(a,b)}

• 特殊变量下划线 ”_”

var _ = 2// 无法使用_

• Go中不存在隐式转换,类型转换必须是显式的;

var a =1var b  = float32(a)

• 类型转换只能发生在两种兼容类型之间;

• 大写字母开头的变量是可导出的,也就是其它包可以读取的,是公用变量;

• 小写字母开头的就是不可导出的,是私有变量。

// pkg1func F1(){}func f1(){}// mainfunc main(){    pkg1.F1()    //pkg1.f1() 无法访问}

常量

显式: const identifier [type] = value隐式: const identifier = value ( 通常叫无类型常量)

const name = "cxk"const age int = 18const (    habbit1 = "sing"    habbit2 = "rap")

常量可以使用内置表达式定义,例如: len()，unsafe.Sizeof()等 ;常量范围目前只支持布尔型、数字型(整数型、浮点型和复数)和字符串型;

特殊常量iota

• iota在const关键字出现时将被重置为0
• const中每新增一行常量 声明将使iota计数自增1次

const a = iotaconst b = iotaconst (    c = iota    d = iota)func main(){    fmt.Println(a,b) // 0 0    fmt.Println(c,d) // 0 1}

• iota常见使用法:

1)跳值使用法;

const (    c = iota    _ = iota    d = iota)func main(){    fmt.Println(c,d) // 0 2}

2)插队使用法;

const (    c = iota    d = 3    e = iota)func main(){    fmt.Println(c,d,e) // 0 3 2}

3 )表达式隐式使用法;

const (    c = iota *2    d // 没有指定值，默认会继承之前的表达式    e)func main(){    fmt.Println(c,d,e) // 0 2 4}

4)单行使用法;

const (    a ,b = iota,iota+3    c,d)func main(){    fmt.Println(a,b,c,d) // 0 3 1 4}

运算符

a := 1b := 2a++ // ++运算符只能这样用println(a)b-- // --运算符只能这样用println(b)

控制语句

• 条件控制

a := 0if a>=1 {    println("true")}else if a <= 0 {    println("false")}

• 选择语句

a := 10switch a {case 1:    {        println("1")    }case 2:    {        println("2")    }default:    {        println("default")    }}

• 循环语句

// 死循环for {    println("run")    time.Sleep(1*time.Second)}// 经典for循环for i:=1;i<10;i++ {    println("run",i)}// foreacha := []string{"cxk", "jntm"}for key, value := range a {    println(key, value)}

• goto

if true {    goto label2}else {    goto label1}label1:    println("label1")label2:    println("label2")

• break

a := []string{"cxk", "jntm"}for key, value := range a {    println(key, value)    if key == 0 {        break    }}

内建方法

make

// slice类似于数组slice := make([]string,3)slice[0] = "cxk"slice[1] = "cxk2"slice[2] = "cxk3"for k,v := range slice {    println(k,v)}println("---")// mapaMap := make(map[string]string,3)aMap["a"]="1"aMap["b"]="2"for k,v := range aMap {    println(k,v)}println("---")// channel 类似缓冲区aChan := make(chan int,3)close(aChan)

new

// 返回一个指针aMap := new(map[string]string)fmt.Println(reflect.TypeOf(aMap)) // *map[string]string

append & copy & delete

slice :=make ([]string,2)slice[0]="1"slice[1]="2"slice = append(slice,"3")fmt.Println(slice) // 1 2 3

slice1 :=make ([]string,2)slice1[0]="1"slice1[1]="2"slice2 :=make([]string,2)copy(slice2,slice1)fmt.Println(slice2) // 1 2

aMap := make(map[string]string)aMap["1"]="a"aMap["2"]="b"delete(aMap,"1")fmt.Println(aMap) // 2:b

异常

func main() {    defer func() {        // 异常处理        msg := recover()        fmt.Println("msg:",msg)    }()    // 抛出异常    panic("异常")}

len && cap && close

slice := make([]int,3,5)println(len(slice)) // 3println(cap(slice)) // 5aChan := make(chan int,1)aChan <- 1close(aChan)

结构体

// 定义结构体type Person struct {    Name string    Age int}func main(){    var p Person // 声明结构体变量    p.Age = 18 // 结构体成员赋值    p1 := Person{Name: "cxk"} // 另外一种方式    p2 := new(Person) // 返回一个Person指针    p.Name = "cxk"    fmt.Println(p)}

属性及函数

• 两种作用域，大写开头为公开，小写开头为私有

// 定义Person的一个公开成员方法func (p *Person)Say(){    fmt.Println("person say")}

组合

type Animal struct {    Type string}type Dog struct {    Animal // 组合animal，Dog继承Animal的属性    Name string}

并发

• 协程

func main(){    go run()    go run()    time.Sleep(time.Second*5)}func run(){    for i:=1;i<10;i++ {        time.Sleep(time.Millisecond*2)        print(i)    }    println()}

• 协程通讯

var chanInt = make(chan int,10)func main(){    go send()    go receive()    time.Sleep(5*time.Second)}func send(){    chanInt <- 1    chanInt <- 2    chanInt <- 3}func receive(){    num := <- chanInt    fmt.Println(num)    num = <- chanInt    fmt.Println(num)    num = <- chanInt    fmt.Println(num)}

• 使用select

var chanInt = make(chan int,10)var chan1 = make(chan int,10)func send(){    for i:=0;i<10;i++ {        chanInt <- i        chan1 <- i*i    }}func receive(){    for {        select {        case num := <- chanInt:            fmt.Println(num)        case num := <- chan1:            fmt.Println(num)        }    }}

select可以随机在多个channel中取数据

• 同步

func main(){    makeFood(10)    go eatFood(10)    waitGroup.Wait()}var waitGroup sync.WaitGroupfunc makeFood(i int){    for j:=0;j<i;j++ {        waitGroup.Add(1)        fmt.Println("make food",j)    }}func eatFood(i int){    for j:=0;j<i;j++ {        fmt.Println("eat food",j)        waitGroup.Done() // countdown    }}

指针

i:=20var pi *int=&i // pi指向ifmt.Println(*pi) // 读取pi所指向的内容fmt.Println(pi == nil) // 判断是否为空a,b :=1,2pa := [...]*int{&a,&b} // 指针数组(元素为指针的数组)fmt.Println(pa)arr := [...]int{1,2,3}ap := &arr // 数组指针（指向一个数组的指针）fmt.Println(ap)

json

• 序列化

setting := Setting{Menu:"menu",Count: 15}byte,err:=json.Marshal(setting)if err!=nil {    fmt.Println(err)}else {    fmt.Println(string(byte))}

• tag

type Setting struct {    Menu string `json:"menu"` // 指定序列后的字段名字    Count int}

• 反序列化

str := "{\"menu\":\"menu\",\"Count\":15}\n"var setting Settingerr := json.Unmarshal([]byte(str),&setting)if err != nil {    fmt.Println(err)}else {    fmt.Println(setting)}

module

• 初始化项目

go mod init

• 输出项目依赖

go mod graph