手里有只毛毛虫

Golang

安装

屎一样的包管理
垃圾
每个版本都改

GoPath 目录

环境变量

用户变量

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

全局变量修改（永久）

1go env -w GO111MODULE="on"

国内代理

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

配置

1go env

新建项目

GoPath/src 目录下

1mkdir hello
2cd hello
3
4//包管理
5go mod init

整理依赖

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

go mod tidy

输出

换行

1fmt.Println("Hello")

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

防止转义

1fmt.Println("asda\asda")
2
3fmt.Println(`asda\asda`)

变量

基本类型

1bool
2string
3int int8 int16 int32 int64
4uint uint8 uint16 uint32 uint64 uintptr
5byte == uint8
6rune == int32 //表示unicode码点
7float32 float64
8complex64 complex128

类型转换

string 转 int

1int,err:=strconv.Atoi(str)

int 转 string

1string:=strconv.ltoa(int)

string 转 []byte

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

[]byte 转 string

1var str string = string(data[:])

float64 互转 string

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

简短形式

1count := 20

var

1var count =10

或者

1var count int 
2count = 1

声明类型

1var count float64 = 3.1415
2var count float32 = math.Pi
3var count float32
4var count uint = 123
5var count int64 = 123
6var count uint64 = 41.3e14
7var count float64 = 41.3e19

多变量

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

1var java,c,test=1,"dfrer",true
2
3java,c,test:=1,"dfrer",true

很大的数

SetString(数字，进制)

1count := new(big.Int)
2
3count.SetString("20000000000000000000000000000000000000000000000000000000000000000000000000", 10)

或者

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

随机数

1rand.Intn(100)

指针

内存地址

1bcd := &abc
2
3fmt.Println(bcd)

内存地址获取变量

1bcd := &abc
2
3fmt.Println(*bcd)

常量

1const dostamce = 200000000

多个常量

1const (
2    a = 0
3    b = 1
4    c = 2
5)

if 判断

1if command == "go east" {
2 fmt.Println("123s")
3}
4if !(command == "go east") {
5 fmt.Println("123s")
6}

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

for 循环

例子

默认

 1for i := 0; i < 5; i++ {
 2 println(i)
 3    if i = 4 {
 4  break
 5 }
 6}
 7
 8for key, v := range user.User_order {
 9  fmt.Println(v)
10     fmt.Println(key)
11 }
12
13
14for _, v := range user.User_order {
15  fmt.Println(v)
16  o.LoadRelated(v.User, "User_order")
17 }

定义

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

死循环

1for{
2    //die
3}

switch

自带break

例子

1switch command {
2case "go east":
3 fmt.Println("123s")
4case "walk outside":
5 fmt.Println("aaaa")
6}

执行前先执行语句

1switch v:=x+y;v{
2}

没有条件的switch

 1switch {
 2case command == "go east":
 3 fmt.Println("1")
 4case command == "walk outside":
 5 fmt.Println("2")
 6    fallthrough //执行下一个(case或default)
 7 // case command == "a":
 8 //  fmt.Println("1")
 9default:
10 fmt.Println("default")
11}

array 数组

声明

一维数组

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

1dwarfs := [...]string{
2 "a",
3 "b"
4}

二维数组

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

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

for循环

一维数组

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

二维数组

1a := [2][3]string{{"a", "b", "c"}, {"d", "e", "f"}}
2
3for k1,v1 := range arr{
4    fmt.Println(k1,v1)//0 [a b c]
5    
6    for k2,v2 := range v1{
7        fmt.Println(k2,v2)//0 a
8    }
9}

切片

例子

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

限制切片容量

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

预分配

声明长度和容量

1//长度10 容量20
2var a []int = make([]int, 10, 20)
3
4b := make([]int, 0, 2130)
5
6//省略 长度10 容量10
7var a []int = make([]int, 10)
8b := make([]int , 10)

append

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

输出

1[a b c d e]

长度

现有长度

1println(len(array))

容量

数组可存放长度上限

1println(cap(array))

map 对象

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

 1obj := map[string]int{
 2 "code": 200,
 3 "msg":  123,
 4}
 5
 6fmt.Println(obj["code"])
 7//200
 8
 9fmt.Println(obj["no"])
10//0

简短形式

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

赋值

1obj["data"]=123

预声明

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

逗号与ok

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

删除

1delete(obj, "msg")

for循环

 1for _, t := range obj {
 2 fmt.Println(t)
 3}
 4
 5//2.2 3.4 123.2
 6
 7for a, t := range obj {
 8 fmt.Println(a)
 9}
10//0 1 2

func 函数

命名

包内可以小写

外部使用必须大写

返回int类型和错误

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

//可变参数

 1func asad(pre int, word ...string) []string {
 2 pre++
 3 return word
 4}
 5
 6fmt.Println(asad(2, "aassa", "asd"))
 7
 8a := []string{"aassa", "asd"}
 9fmt.Println(asad(2, a...))//函数能修改a
10
11//[aassa asd]

辅助函数

string

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

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

休眠

1time.Sleep(time.Second)

beego

bee工具创建

new

新建一个 Web 项目

1bee new myproject

api

新建一个 Api 项目

1bee api apiproject

run

运行

1bee run

pack

打包

1bee pack

version

版本号

1bee version

generate

自动生成代码

migrate

数据库迁移

dockerize

docker化应用

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

Node Js

浏览量：加载中... 评论数：加载中...