gookit / goutil Goto Github PK

// Check if value is zero of its type. string => "", number => 0, pointer => nil, etc...
reflect.ValueOf(anyVal).IsZero()

        //...

        v, ok = maputil.GetByPath("key2", mp)
	assert.True(t, ok)
	assert.Equal(t, mp["key2"], v)

	v, ok = maputil.GetByPath("key2.0", mp)
	assert.True(t, ok)
	assert.Equal(t, "sv1", v)

	v, ok = maputil.GetByPath("key2.1", mp)
	assert.True(t, ok)
	assert.Equal(t, "sv2", v)

	v, ok = maputil.GetByPath("key4.0", mp)
	assert.True(t, ok)
	assert.Equal(t, 1, v)

	v, ok = maputil.GetByPath("key4.1", mp)
	assert.True(t, ok)
	assert.Equal(t, 2, v)

	v, ok = maputil.GetByPath("key5.0", mp)
	assert.True(t, ok)
	assert.Equal(t, 1, v)

	v, ok = maputil.GetByPath("key5.1", mp)
	assert.True(t, ok)
	assert.Equal(t, "2", v)

	v, ok = maputil.GetByPath("key5.2", mp)
	assert.True(t, ok)
	assert.Equal(t, true, v)

	// Out of bound value
	v, ok = maputil.GetByPath("key2.2", mp)
	assert.False(t, ok)
	assert.Nil(t, v)

        //...

&fatal error: concurrent map read and map write


To see all goroutines, visit https://github.com/maruel/panicparse#gotraceback

1: running
    runtime :0 throw()
runtime.throw({0x10490cd05, 0x21})
        /usr/local/go/src/runtime/panic.go:1198 +0x54 fp=0x140003dfa70 sp=0x140003dfa40 pc=0x1046d9c34
runtime.mapaccess2(0x104997d80, 0x1400044c3f0, 0x140003dfaf0)
        /usr/local/go/src/runtime/map.go:469 +0x228 fp=0x140003dfab0 sp=0x140003dfa70 pc=0x1046b31f8
github.com/gookit/goutil/dump.(*Dumper).checkCyclicRef(0x14000146180, {0x1049f0bd0, 0x1049d2980}, {0x1049d2980, 0x14000384420, 0x199})
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dumper.go:403 +0x6c fp=0x140003dfb30 sp=0x140003dfab0 pc=0x1047c8bcc
github.com/gookit/goutil/dump.(*Dumper).printRValue(0x14000146180, {0x1049f0bd0, 0x10497f860}, {0x10497f860, 0x14000384420, 0x16})
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dumper.go:309 +0x121c fp=0x140003dfeb0 sp=0x140003dfb30 pc=0x1047c799c
github.com/gookit/goutil/dump.(*Dumper).printOne(0x14000146180, {0x10497f860, 0x14000384420})
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dumper.go:229 +0x118 fp=0x140003dff30 sp=0x140003dfeb0 pc=0x1047c6718
github.com/gookit/goutil/dump.(*Dumper).dump(0x14000146180, {0x140003dffa8, 0x1, 0x1})
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dumper.go:171 +0x120 fp=0x140003dff80 sp=0x140003dff30 pc=0x1047c5e20
github.com/gookit/goutil/dump.(*Dumper).Println(...)
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dumper.go:136
github.com/gookit/goutil/dump.Println(...)
        /{$GOPATH}/pkg/mod/github.com/gookit/goutil@v0.5.5/dump/dump.go:96
main.(*SimpleTradeSpi).OnRtnTrade(0x104bdd850, 0x14000384420)
        /{$GOPATH}/sample/main.go:274 +0x5c fp=0x140003dffc0 sp=0x140003dff80 pc=0x10490021c
runtime.goexit()
        /usr/local/go/src/runtime/asm_arm64.s:1133 +Failed: failed to parse int on line: "runtime.throw({0x10490cd05, 0x21})"

func (d *Dumper) checkCyclicRef(t reflect.Type, v reflect.Value) (goon bool) {
	addr := v.UnsafeAddr()
	vis := visit{addr, t}

	if vd, ok := d.visited[vis]; ok && vd < d.MaxDepth { <------- here
		d.indentPrint(t.String(), "{(!CYCLIC REFERENCE!)}\n")
		return false // don't print v again
	}

	// record
	d.visited[vis] = d.curDepth
	return true
}

func ReadOrErr(in any) ([]byte, error) {
        // 传入字符串会读取文件，转换为 []byte 后，file 没有close 
	r, err := NewIOReader(in)
	if err != nil {
		return nil, err
	}
	return io.ReadAll(r)
}

func ExtensionsByType(typ string) string

"application/vnd.ms-excel" => ".xls"
"application/pdf" => ".pdf"
"text/plain" => ".txt"
[...]

func NewApp(fn ...func(a *App)) *App {
	app := &App{
		Args: os.Args,
		Name: "GCli App",
		Logo: Logo{Style: "info"},
		// set a default version
		Version: "1.0.0",
		// internal
		// cmdLine: CLI,
		core: core{
			cmdLine: CLI,
			gFlags: NewFlags("appGlobalOpts").WithOption(FlagsOption{
				WithoutType: true,
				NameDescOL:  true,
				Alignment:   AlignLeft,
				TagName:     FlagTagName,
			}),
		},
		// config
		ExitOnEnd: true,
		// commands
		commands: make(map[string]*Command),
		// group
		moduleCommands: make(map[string]map[string]*Command),
		// some default values
		nameMaxLen:  12,
		Description: "This is my CLI application",
	}

	if len(fn) > 0 {
		fn[0](app)
	}

	return app
}

const (
	AlignLeft  = strutil.PosRight
	AlignRight = strutil.PosLeft
	// FlagTagName on struct
	FlagTagName = "flag"
	// default desc
	defaultDesc = "No description"
)

// PosFlag type
type PosFlag uint8

// Position for padding/resize string
const (
	PosLeft PosFlag = iota
	PosRight
	PosMiddle
)

test := mathutil.QuietFloat(math.NaN) //=> test = NaN, I want it to always be a float type instead (0.0 if failed).

utils.FloatOrDefault(in any, default float64)
test := utils.FloatOrDefault("test", 0.0) //=> Error, return test = 0.0

utils.StringOrDefault(in any, default string)
test := utils.StringOrDefault(nil, "hello") //=> Error, return test = "hello"

...

obj := map[string]any{
	"name": "Desk",
	"new": map[string]any{
		"foo": "bar",
	},
}

Delete(obj, "new.foo")

// After deletion, the map should look like:
// obj = map[string]any{
// 	"name": "Desk",
// 	"new":  map[string]any{},
// }

// Delete the key "foo" from the nested map "new"

for i := 0; i < rt.NumField(); i++{
if err := reflects.SetValue(fv, val); err != nil {
->line 143			return err
		}
}

func TestRandStr(t *testing.T) {
	a := strutil.RandomCharsV2(32)
	t.Log(a)
}

obj := map[string]any{
	"framework.developers": map[string]any{
		"name": "Krishan",
		"lang": "Golang",
	},
}
maputil.GetByPath("framework.developers.name", obj)
// output: <nil>, false
// expected: "Krishan", true

package main

import (
	"fmt"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/gookit/goutil/dump"
	"github.com/gookit/validate"
)

func main() {
	binding.Validator = &customValidator{}
	r := gin.Default()
	r.POST("/user/list", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBindJSON(&user)
		if err != nil {
			dump.P(err)
			ctx.String(400, "出错"+err.Error())
			return
		}
		ctx.String(200, fmt.Sprintf("验证通过:%v", user.Time))
	})

	r.Run(":8080")
}

type User struct {
	Time time.Time `json:"time" validate:"required" filter:"str2time"`
}

type customValidator struct{}

func (c *customValidator) ValidateStruct(ptr interface{}) error {
	v := validate.Struct(ptr)
	v.Validate() // do validating

	if v.Errors.Empty() {
		return nil
	}

	return v.Errors
}

func (c *customValidator) Engine() interface{} {
	return nil
}

var tcBody := map[string]any{
	"success":                  true,
	"result.records.0.id": "59fab0fa-8f0a-4065-8863-1dae40166015",
	"result.records.1.id": "7c1bd7f9-2ef4-44c8-9756-2e85156ca58f",
}

body, _ := io.ReadAll(response.Body)
var resp map[string]any
json.Unmarshal(body, &resp)
for key, want := range tcBody {
	val, _ := maputil.GetByPath(key, resp)
	if val != want {
		t.Errorf("Body key [%v] was incorrect, got: %v, want: %v", key, val, want)
	}
}

var tcBody := map[string]any{
"success":                 true,
"result.records.*.id": []String{
	"59fab0fa-8f0a-4065-8863-0dae40166015",
	"7c1bd7f9-2ef4-44c8-9756-0e85156ca58f",
}

body, _ := io.ReadAll(response.Body)
var resp map[string]any
json.Unmarshal(body, &resp)
for key, want := range tcBody {
	val, _ := maputil.GetByPath(key, resp)
	if val != want {
		t.Errorf("Body key [%v] was incorrect, got: %v, want: %v", key, val, want)
	}
}