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)
}
这个反序列化 竟然 大小写不敏感
原文地址：https://blog.csdn.net/zhouhe_/article/details/138217973
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！