基础

main函数

package main
import "log"
func main() {log.Println("hello world")
}

cd 到 main 文件夹下 go build 将会得到 exe的可执行文件;
go install 将会在GOPATH/bin 目录下得到exe可执行文件;
测试环境下,使用go run运行.

编译重命名：go build -o hello.sh main.go

数据类型

我不喜欢把按照基本数据类型和复杂数据类型来划分，我更喜欢把go划分为值类型和引用数据类型

• 值类型
  整型(int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte)
  浮点型(float32,float64)
  字符型byte
  布尔型bool
  字符串string
  数组
  结构体
• 引用类型
  指针
  数组
  切片
  函数
  map

类型转换

必须强制转换

import ("fmt""strconv"
)func main() {// 基本数据类型转换i := 10f := float64(i)fmt.Println(f)// 基本类型转string 方式1strBool := fmt.Sprintf("%v", true)fmt.Println(strBool)// 基本类型转string 方式2formatInt := strconv.FormatInt(10, 10) // 转换的值,进制fmt.Println(formatInt)formatFloat := strconv.FormatFloat(10.0, 'f', 10, 64) // 转换的值，常规格式，小数点后几位,精度fmt.Println(formatFloat)// string转基本数据类型parseInt, _ := strconv.ParseInt("2555", 10, 64) // 转换的值,进制,精度fmt.Println(parseInt)parseFloat, _ := strconv.ParseFloat("3.23", 64)fmt.Println(parseFloat)
}

switch

不需要break默认就有，存在常规写法
穿透使用 fallthrough

函数

闭包

package main
import "fmt"
func main() {i := 10f := add(i)fmt.Println(f(2, 3))fmt.Println(f(2, 3))
}
func add(value int) func(a int, b int) int {return func(a int, b int) int {value += (a + b)return value}
}

func makeSuffix(suffix string) func(fileName string) string {return func(fileName string) string {fileSuffix := strings.Split(fileName, ".")[1]if fileSuffix == suffix {return fileName} else {return fmt.Sprintf("%s.%s", strings.Split(fileName, ".")[0], suffix)}}
}

其实 此时不用闭包也能完成，不过传入一次，可以反复使用

计算效率

func main() {now := time.Now()str := ""for i := 0; i < 10000000; i++ {str += strconv.Itoa(i)}since := time.Since(now)fmt.Println("time: ", since.Seconds())
}

go中实现工厂模式

type student struct {name stringage int
}func NewStudent(name string, age int) *student {return &student{name, age,}
}

switch

func TypeJudge(items ...interface{}) {for index, x := range items {switch x.(type) {case bool:fmt.Println("第%v个参数是bool 类型 ，值是%v\n", index, x)case float32:fmt.Println("第%v个参数是float32 类型 ，值是%v\n", index, x)default:fmt.Println("不确定")}}
}

flag 解析命令行参数

链接: flag解析命令行参数

json

结构体序列化

package mainimport ("encoding/json""fmt"
)type Monster struct {Name     stringAge      intBirthday stringSal      float64Skill    string
}func main() {// 这里的tag 必然是反射，用到的地方还有很多，比如说参数校验、orm字段映射// 这里类似java的注解，java里面也是使用反射实现type Monster struct {Name     string  `json:"name"`Age      int     `json:"age"`Birthday string  `json:"birthday"`Sal      float64 `json:"sal"`Skill    string  `json:"skill"`}marshal, err := json.Marshal(monster)if err != nil {fmt.Println(err)return}fmt.Println(string(marshal))
}

map序列化

m := map[string]interface{}{"name": "张三","age":  13,}marshal, err := json.Marshal(m)if err != nil {fmt.Println(err)return}fmt.Println(string(marshal))

struct 反序列化

type Monster struct {Name     string  `json:"username"`Age      int     `json:"age"`Birthday string  `json:"birthday"`Sal      float64 `json:"sal"`Skill    string  `json:"skill"`
}func main() {jsonData := []byte(`{"USERname":"Monster","age":100,"Birthday":"2000-01-01","Sal":9999.99,"Skill":"Coding"}`)var monster Monstererr := json.Unmarshal(jsonData, &monster)if err != nil {fmt.Println("Error:", err)return}fmt.Println("Deserialized Monster:")fmt.Println("Name:", monster.Name)fmt.Println("Age:", monster.Age)fmt.Println("Birthday:", monster.Birthday)fmt.Println("Sal:", monster.Sal)fmt.Println("Skill:", monster.Skill)
}

这个反序列化 竟然 大小写不敏感