git/lancet

Fork 0

mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 12:52:28 +08:00

Files

dudaodong 48519aba2b feat: add MapToStruct

2024-02-23 10:29:46 +08:00

13 KiB

Raw Blame History

Convertor

Package convertor contains some functions for data type convertion.

Source:

https://github.com/duke-git/lancet/blob/v1/convertor/convertor.go

Usage:

import (
    "github.com/duke-git/lancet/convertor"
)

Index

ColorHexToRGB
ColorRGBToHex
ToBool
ToBytes
ToChar
ToChannel
ToFloat
ToInt
ToJson
ToString
StructToMap
MapToStruct
EncodeByte
DecodeByte
DeepClone
CopyProperties
ToInterface
Utf8ToGbk
GbkToUtf8
GbkToUtf8

Documentation

ColorHexToRGB

Convert color hex to color rgb.

Signature:

func ColorHexToRGB(colorHex string) (red, green, blue int)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    colorHex := "#003366"
    r, g, b := ColorHexToRGB(colorHex)
    fmt.Println(r, g, b) //0,51,102
}

ColorRGBToHex

Convert color rgb to color hex.

Signature:

func ColorRGBToHex(red, green, blue int) string

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    r := 0
    g := 51
    b := 102
    colorHex := ColorRGBToHex(r, g, b)

    fmt.Println(colorHex) //#003366
}

ToBool

Convert string to a boolean value. Use strconv.ParseBool

Signature:

func ToBool(s string) (bool, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    v1, _ := convertor.ToBool("1")
    fmt.Println(v1) //true

    v2, _ := convertor.ToBool("true")
    fmt.Println(v2) //true

    v3, _ := convertor.ToBool("True")
    fmt.Println(v3) //true

    v4, _ := convertor.ToBool("123")
    fmt.Println(v4) //false
}

ToBytes

Convert interface to byte slice.

Signature:

func ToBytes(data interface{}) ([]byte, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    bytesData, err := convertor.ToBytes("0")
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(bytesData) //[]bytes{3, 4, 0, 0}
}

ToChar

Convert string to char slice.

Signature:

func ToChar(s string) []string

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    chars := convertor.ToChar("")
    fmt.Println(chars) //[]string{""}

    chars = convertor.ToChar("abc")
    fmt.Println(chars) //[]string{"a", "b", "c"}

    chars = convertor.ToChar("1 2#3")
    fmt.Println(chars) //[]string{"1", " ", "2", "#", "3"}
}

ToChannel

Convert a collection of elements to a read-only channels.

Signature:

func ToChannel(array []interface{}) <-chan interface{}

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    ch := convertor.ToChannel([]int{1, 2, 3})

    val1, _ := <-ch
    fmt.Println(val1) //1

    val2, _ := <-ch
    fmt.Println(val2) //2

    val3, _ := <-ch
    fmt.Println(val3) //3

    _, ok := <-ch
    fmt.Println(ok) //false
}

ToFloat

Convert interface to a float64 value. If param is a invalid floatable, will return 0 and error.

Signature:

func ToFloat(value interface{}) (float64, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    v, err := convertor.ToFloat("")
    if err != nil {
        fmt.Println(err) //strconv.ParseFloat: parsing "": invalid syntax
    }
    fmt.Println(v) //0

    v, _ = convertor.ToFloat("-.11")
    fmt.Println(v) //-0.11
}

ToInt

Convert interface to a int64 value. If param is a invalid intable, will return 0 and error.

Signature:

func ToInt(value interface{}) (int64, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    v, err := convertor.ToInt("")
    if err != nil {
        fmt.Println(err) //strconv.ParseInt: parsing "": invalid syntax
    }
    fmt.Println(v) //0

    v, _ = convertor.ToFloat(1.12)
    fmt.Println(v) //1
}

ToJson

Convert interface to json string. If param can't be converted, will return "" and error.

Signature:

func ToJson(value interface{}) (string, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
    jsonStr, _ := convertor.ToJson(aMap)
    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
}

ToString

Convert interface to string.

Signature:

func ToString(value interface{}) string

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    fmt.Printf("%q", convertor.ToString(1)) //"1"
    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
}

StructToMap

Converts struct to map, only convert exported field, struct field tag `json` should be set.

Signature:

func StructToMap(value interface{}) (map[string]interface{}, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    type People struct {
        Name string `json:"name"`
        age  int
    }
    p := People{
        "test",
        100,
    }
    pm, _ := convertor.StructToMap(p)

    fmt.Printf("type: %T, value: %s", pm, pm) //type: map[string]interface {}, value: map[name:test]
}

MapToStruct

Converts map to struct, only convert exported field, struct field tag `json` should be set.

Signature:

func MapToStruct(m map[string]interface{}, structObj interface{}) error

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    type Address struct {
        Street string `json:"street"`
        Number int    `json:"number"`
    }

    type Person struct {
        Name  string   `json:"name"`
        Age   int      `json:"age"`
        Phone string   `json:"phone"`
        Addr  *Address `json:"address"`
    }

    m := map[string]interface{}{
        "name":  "Nothin",
        "age":   28,
        "phone": "123456789",
        "address": map[string]interface{}{
            "street": "test",
            "number": 1,
        },
    }

    var p Person
    err := MapToStruct(m, &p)
    if err != nil {
        return
    }

    fmt.Printf("p.Addr.Street: %s", p.Addr.Street) //test
}

EncodeByte

Encode data to byte slice.

Signature:

func EncodeByte(data any) ([]byte, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    byteData, _ := convertor.EncodeByte("abc")
    fmt.Println(byteData) //[]byte{6, 12, 0, 3, 97, 98, 99}
}

DecodeByte

Decode byte data to target object. target should be a pointer instance.

Signature:

func DecodeByte(data []byte, target any) error

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    var result string
    byteData := []byte{6, 12, 0, 3, 97, 98, 99}
    convertor.DecodeByte(byteData, &result)
    fmt.Println(result) //"abc"
}

DeepClone

Creates a deep copy of passed item, can't clone unexported field of struct.

Signature:

func DeepClone[T any](src T) T

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    type Struct struct {
        Str        string
        Int        int
        Float      float64
        Bool       bool
        Nil        interface{}
        unexported string
    }

    cases := []interface{}{
        true,
        1,
        0.1,
        map[string]int{
            "a": 1,
            "b": 2,
        },
        &Struct{
            Str:   "test",
            Int:   1,
            Float: 0.1,
            Bool:  true,
            Nil:   nil,
            // unexported: "can't be cloned",
        },
    }

    for _, item := range cases {
        cloned := convertor.DeepClone(item)

        isPointerEqual := &cloned == &item
        fmt.Println(cloned, isPointerEqual)
    }

    // Output:
    // true false
    // 1 false
    // 0.1 false
    // map[a:1 b:2] false
    // &{test 1 0.1 true <nil> } false
}

CopyProperties

Copies each field from the source struct into the destination struct. Use json.Marshal/Unmarshal, so json tag should be set for fields of dst and src struct.

Signature:

func CopyProperties(dst, src interface{}) error

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    type Disk struct {
        Name    string  `json:"name"`
        Total   string  `json:"total"`
        Used    string  `json:"used"`
        Percent float64 `json:"percent"`
    }

    type DiskVO struct {
        Name    string  `json:"name"`
        Total   string  `json:"total"`
        Used    string  `json:"used"`
        Percent float64 `json:"percent"`
    }

    type Indicator struct {
        Id      string    `json:"id"`
        Ip      string    `json:"ip"`
        UpTime  string    `json:"upTime"`
        LoadAvg string    `json:"loadAvg"`
        Cpu     int       `json:"cpu"`
        Disk    []Disk    `json:"disk"`
        Stop    chan bool `json:"-"`
    }

    type IndicatorVO struct {
        Id      string   `json:"id"`
        Ip      string   `json:"ip"`
        UpTime  string   `json:"upTime"`
        LoadAvg string   `json:"loadAvg"`
        Cpu     int64    `json:"cpu"`
        Disk    []DiskVO `json:"disk"`
    }

    indicator := &Indicator{Id: "001", Ip: "127.0.0.1", Cpu: 1, Disk: []Disk{
        {Name: "disk-001", Total: "100", Used: "1", Percent: 10},
        {Name: "disk-002", Total: "200", Used: "1", Percent: 20},
        {Name: "disk-003", Total: "300", Used: "1", Percent: 30},
    }}

    indicatorVO := IndicatorVO{}

    err := convertor.CopyProperties(&indicatorVO, indicator)

    if err != nil {
        return
    }

    fmt.Println(indicatorVO.Id)
    fmt.Println(indicatorVO.Ip)
    fmt.Println(len(indicatorVO.Disk))

    // Output:
    // 001
    // 127.0.0.1
    // 3
}

ToInterface

Converts reflect value to its interface type.

Signature:

func ToInterface(v reflect.Value) (value interface{}, ok bool)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    val := reflect.ValueOf("abc")
    iVal, ok := convertor.ToInterface(val)

    fmt.Printf("%T\n", iVal)
    fmt.Printf("%v\n", iVal)
    fmt.Println(ok)

    // Output:
    // string
    // abc
    // true    
}

Utf8ToGbk

Converts utf8 encoding data to GBK encoding data.

Signature:

func Utf8ToGbk(bs []byte) ([]byte, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
    "github.com/duke-git/lancet/validator"
)

func main() {
    utf8Data := []byte("hello")
    gbkData, _ := convertor.Utf8ToGbk(utf8Data)

    fmt.Println(utf8.Valid(utf8Data))
    fmt.Println(validator.IsGBK(gbkData))

    // Output:
    // true
    // true   
}

GbkToUtf8

Converts GBK encoding data to utf8 encoding data.

Signature:

func GbkToUtf8(bs []byte) ([]byte, error)

Example:

package main

import (
    "fmt"
    "github.com/duke-git/lancet/convertor"
)

func main() {
    gbkData, _ := convertor.Utf8ToGbk([]byte("hello"))
    utf8Data, _ := convertor.GbkToUtf8(gbkData)

    fmt.Println(utf8.Valid(utf8Data))
    fmt.Println(string(utf8Data))

    // Output:
    // true
    // hello   
}

13 KiB Raw Blame History

Convertor

Source:

Usage:

Index

Documentation

ColorHexToRGB

ColorRGBToHex

ToBool

ToBytes

ToChar

ToChannel

ToFloat

ToInt

ToJson

ToString

StructToMap

MapToStruct

EncodeByte

DecodeByte

DeepClone

CopyProperties

ToInterface

Utf8ToGbk

GbkToUtf8

13 KiB

Raw Blame History