Golang

安装

GoPath 目录

• bin
• pkg
• src

环境变量

用户变量

变量	值
GOPATH	*:\*\GoPath
Path	{go安装目录}\bin

全局变量修改（永久）

go env -w GO111MODULE="on"

国内代理

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

配置

go env

新建项目

GoPath/src 目录下

mkdir hello
cd hello

//包管理
go mod init

整理依赖

• 删除不需要的依赖包
• 下载新的依赖包
• 更新go.sum

go mod tidy

输出

换行

fmt.Println("Hello")

fmt.Printf("asdasd %v a%vsda", 123, 123)

防止转义

fmt.Println("asda\asda")

fmt.Println(`asda\asda`)

变量

基本类型

基本类型

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte == uint8
rune == int32 //表示unicode码点
float32 float64
complex64 complex128

类型转换

string 转 int

int,err:=strconv.Atoi(str)

int 转 string

string:=strconv.ltoa(int)

string 转 []byte

var data []byte = []byte(str)

[]byte 转 string

var str string = string(data[:])

float64 互转 string

float,err := strconv.ParseFloat(string,64)
string := strconv.FormatFloat(float64,'E',-1,64)

简短形式

count := 20

var

var count =10

或者

var count int 
count = 1

声明类型

var count float64 = 3.1415
var count float32 = math.Pi
var count float32
var count uint = 123
var count int64 = 123
var count uint64 = 41.3e14
var count float64 = 41.3e19

多变量

var a, b int
var c string
a, b, c = 5, 7, "abc"

var java,c,test=1,"dfrer",true

java,c,test:=1,"dfrer",true

很大的数

SetString(数字，进制)

count := new(big.Int)

count.SetString("20000000000000000000000000000000000000000000000000000000000000000000000000", 10)

或者

count := new(big.Int).SetString("20000000000000000", 10)

随机数

rand.Intn(100)

指针

内存地址

bcd := &abc

fmt.Println(bcd)

内存地址获取变量

bcd := &abc

fmt.Println(*bcd)

常量

const dostamce = 200000000

多个常量

const (
    a = 0
    b = 1
    c = 2
)

if 判断

if command == "go east" {
 fmt.Println("123s")
}
if !(command == "go east") {
 fmt.Println("123s")
}

if commands := "a"; commands == "a" {
 fmt.Println("abc")
}

for 循环

例子

默认

for i := 0; i < 5; i++ {
 println(i)
    if i = 4 {
  break
 }
}

for key, v := range user.User_order {
  fmt.Println(v)
     fmt.Println(key)
 }


for _, v := range user.User_order {
  fmt.Println(v)
  o.LoadRelated(v.User, "User_order")
 }

定义

var count = 10
for count < 50 {//true就进行循环
 println(count)
 count++
}

死循环

for{
    //die
}

switch

自带break

例子

switch command {
case "go east":
 fmt.Println("123s")
case "walk outside":
 fmt.Println("aaaa")
}

执行前先执行语句

switch v:=x+y;v{
}

没有条件的switch

switch {
case command == "go east":
 fmt.Println("1")
case command == "walk outside":
 fmt.Println("2")
    fallthrough //执行下一个(case或default)
 // case command == "a":
 //  fmt.Println("1")
default:
 fmt.Println("default")
}

array 数组

声明

一维数组

var planets [2]string
planets[0] = "a"
planets[1] = "b"

dwarfs := [...]string{
 "a",
 "b"
}

二维数组

a := [2][3]int{{1,1,1},{2,2,2}}

a := [...][2]int{{1,1},{2,2},{3,3},{4,4}}

for循环

一维数组

for i, dwarf := range dwarfs {
 println(i, dwarf)
}

二维数组

a := [2][3]string{{"a", "b", "c"}, {"d", "e", "f"}}

for k1,v1 := range arr{
    fmt.Println(k1,v1)//0 [a b c]
    
    for k2,v2 := range v1{
        fmt.Println(k2,v2)//0 a
    }
}

切片

例子

array := string{"a","b","c"}
terrestrial := array[0:1]

限制切片容量

array := string{"a","b","c"}
terrestrial := array[0:1:2]

预分配

声明长度和容量

//长度10 容量20
var a []int = make([]int, 10, 20)

b := make([]int, 0, 2130)

//省略 长度10 容量10
var a []int = make([]int, 10)
b := make([]int , 10)

append

dwarf := []string{"a", "b", "c"}
dwarf = append(dwarf, "d","e")
fmt.Println(dwarf)

输出

[a b c d e]

长度

现有长度

println(len(array))

容量

数组可存放长度上限

println(cap(array))

map 对象

赋值不会复制，指向同一个内存

obj := map[string]int{
 "code": 200,
 "msg":  123,
}

fmt.Println(obj["code"])
//200

fmt.Println(obj["no"])
//0

简短形式

obj := []float64{
 2.2, 3.4, 123.2,
}

赋值

obj["data"]=123

预声明

tem := make(map[float64]int, 2)
tem[2.2] = 2
tem[2.3] = 3
tem[2.4] = 4

逗号与ok

if data, ok := obj["code"]; ok {
 fmt.Println(data)
} else {
 fmt.Println("?")
}

删除

delete(obj, "msg")

for循环

for _, t := range obj {
 fmt.Println(t)
}

//2.2 3.4 123.2

for a, t := range obj {
 fmt.Println(a)
}
//0 1 2

func 函数

命名

包内可以小写

外部使用必须大写

返回int类型和错误

func funcDemo (a ...interface{}) (int, error) {
 return 1
}

//可变参数

func asad(pre int, word ...string) []string {
 pre++
 return word
}

fmt.Println(asad(2, "aassa", "asd"))

a := []string{"aassa", "asd"}
fmt.Println(asad(2, a...))//函数能修改a

//[aassa asd]

辅助函数

string

断字符串s中是否包含个子串str。包含或者str为空则返回true

var command = "walk outside"
var exit = strings.Contains(command, "outside")
fmt.Println(exit)
//true

休眠

time.Sleep(time.Second)

beego

bee工具创建

new

新建一个 Web 项目

bee new myproject

api

新建一个 Api 项目

bee api apiproject

run

运行

bee run

pack

打包

bee pack

version

版本号

bee version

generate

自动生成代码

migrate

数据库迁移

dockerize

docker化应用

bee dockerize -image="library/golang:1.6.4" -expose=9000