go基础(flag、json)

基础

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 := 10
	f := float64(i)
	fmt.Println(f)
	// 基本类型转string 方式1
	strBool := fmt.Sprintf("%v", true)
	fmt.Println(strBool)
	// 基本类型转string 方式2
	formatInt := 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 := 10
	f := 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 string
	age 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 main

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name     string
	Age      int
	Birthday string
	Sal      float64
	Skill    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 Monster
	err := 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)
}

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