convertor.md

Convertor

Package convertor contains some functions for data type convertion.

Source:

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

Usage:

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

Index

ColorHexToRGB
ColorRGBToHex
ToBool
ToBytes
ToChar
ToChannel
ToFloat
ToInt
ToJson
ToMap
ToPointer
ToString
StructToMap
MapToSlice
EncodeByte
DecodeByte
DeepClone
CopyProperties
ToInterface
Utf8ToGbk
GbkToUtf8
ToStdBase64
ToUrlBase64
ToRawStdBase64
ToRawUrlBase64

Documentation

ColorHexToRGB

Convert color hex to color rgb.

Signature:

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

Example:Run

package main

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

func main() {
    colorHex := "#003366"
    r, g, b := convertor.ColorHexToRGB(colorHex)

    fmt.Println(r, g, b)

    // Output:
    // 0 51 102
}

ColorRGBToHex

Convert color rgb to color hex.

Signature:

func ColorRGBToHex(red, green, blue int) string

Example:Run

package main

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

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

    fmt.Println(colorHex)

    // Output:
    // #003366
}

ToBool

Convert string to bool. Use strconv.ParseBool.

Signature:

func ToBool(s string) (bool, error)

Example:Run

package main

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

func main() {
    cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"}

    for i := 0; i < len(cases); i++ {
        result, _ := convertor.ToBool(cases[i])
        fmt.Println(result)
    }

    // Output:
    // true
    // true
    // true
    // false
    // false
    // false
    // false
    // false
    // false
}

ToBytes

Convert value to byte slice.

Signature:

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

Example:Run

package main

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

func main() {
    bytesData, err := convertor.ToBytes("abc")
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(bytesData)

    // Output:
    // [97 98 99]
}

ToChar

Convert string to char slice.

Signature:

func ToChar(s string) []string

Example:Run

package main

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

func main() {
    result1 := convertor.ToChar("")
    result2 := convertor.ToChar("abc")
    result3 := convertor.ToChar("1 2#3")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // []
    // [a b c]
    // [1   2 # 3]
}

ToChannel

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

Signature:

func ToChannel[T any](array []T) <-chan T

Example:Run

package main

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

func main() {
    ch := convertor.ToChannel([]int{1, 2, 3})
    result1 := <-ch
    result2 := <-ch
    result3 := <-ch

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

    // Output:
    // 1
    // 2
    // 3
}

ToFloat

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

Signature:

func ToFloat(value any) (float64, error)

Example:Run

package main

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

func main() {
    result1, _ := convertor.ToFloat("")
    result2, err := convertor.ToFloat("abc")
    result3, _ := convertor.ToFloat("-1")
    result4, _ := convertor.ToFloat("-.11")
    result5, _ := convertor.ToFloat("1.23e3")
    result6, _ := convertor.ToFloat(true)

    fmt.Println(result1)
    fmt.Println(result2, err)
    fmt.Println(result3)
    fmt.Println(result4)
    fmt.Println(result5)
    fmt.Println(result6)

    // Output:
    // 0
    // 0 strconv.ParseFloat: parsing "": invalid syntax
    // -1
    // -0.11
    // 1230
    // 0
}

ToInt

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

Signature:

func ToInt(value any) (int64, error)

Example:Run

package main

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

func main() {
    result1, _ := convertor.ToInt("123")
    result2, _ := convertor.ToInt("-123")
    result3, _ := convertor.ToInt(float64(12.3))
    result4, err := convertor.ToInt("abc")
    result5, _ := convertor.ToInt(true)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4, err)
    fmt.Println(result5)

    // Output:
    // 123
    // -123
    // 12
    // 0 strconv.ParseInt: parsing "": invalid syntax
    // 0
}

ToJson

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

Signature:

func ToJson(value any) (string, error)

Example:Run

package main

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

func main() {
    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
    result, err := ToJson(aMap)

    if err != nil {
        fmt.Printf("%v", err)
    }

    fmt.Println(result)

    // Output:
    // {"a":1,"b":2,"c":3}
}

ToMap

Convert a slice of structs to a map based on iteratee function.

Signature:

func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V

Example:Run

package main

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

func main() {
    type Message struct {
        name string
        code int
    }
    messages := []Message{
        {name: "Hello", code: 100},
        {name: "Hi", code: 101},
    }

    result := convertor.ToMap(messages, func(msg Message) (int, string) {
        return msg.code, msg.name
    })

    fmt.Println(result)

    // Output:
    // map[100:Hello 101:Hi]
}

ToPointer

Returns a pointer to passed value.

Signature:

func ToPointer[T any](value T) *T

Example:Run

package main

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

func main() {
    result := convertor.ToPointer(123)
    fmt.Println(*result)

    // Output:
    // 123
}

ToString

ToString convert value to string, for number, string, []byte, will convert to string. For other type (slice, map, array, struct) will call json.Marshal

Signature:

func ToString(value any) string

Example:Run

package main

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

func main() {
    result1 := convertor.ToString("")
    result2 := convertor.ToString(nil)
    result3 := convertor.ToString(0)
    result4 := convertor.ToString(1.23)
    result5 := convertor.ToString(true)
    result6 := convertor.ToString(false)
    result7 := convertor.ToString([]int{1, 2, 3})

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)
    fmt.Println(result5)
    fmt.Println(result6)
    fmt.Println(result7)

    // Output:
    //
    //
    // 0
    // 1.23
    // true
    // false
    // [1,2,3]
}

StructToMap

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

Signature:

func StructToMap(value any) (map[string]any, error)

Example:Run

package main

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

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

    fmt.Println(pm)

    // Output:
    // map[name:test]
}

MapToSlice

Convert a map to a slice based on iteratee function.

Signature:

func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T

Example:Run

package main

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

func main() {
    aMap := map[string]int{"a": 1, "b": 2, "c": 3}
    result := MapToSlice(aMap, func(key string, value int) string {
        return key + ":" + strconv.Itoa(value)
    })

    fmt.Println(result) //[]string{"a:1", "b:2", "c:3"}
}

EncodeByte

Encode data to byte slice.

Signature:

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

Example:Run

package main

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

func main() {
    byteData, _ := convertor.EncodeByte("abc")
    fmt.Println(byteData)

    // Output:
    // [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:Run

package main

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

func main() {
    var result string
    byteData := []byte{6, 12, 0, 3, 97, 98, 99}

    err := convertor.DecodeByte(byteData, &result)
    if err != nil {
        return
    }

    fmt.Println(result)

    // Output:
    // abc
}

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[T, U any](dst T, src U) (err error)

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/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
}

Utf8ToGbk

Converts utf8 encoding data to GBK encoding data.

Signature:

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

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/convertor"
    "github.com/duke-git/lancet/v2/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:Run

package main

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

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

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

    // Output:
    // true
    // hello   
}

ToStdBase64

Convert a value to a string encoded in standard Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.

Signature:

func ToStdBase64(value any) string

Example:Run

package main

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

func main() {
    afterEncode := convertor.ToStdBase64(nil)
    fmt.Println(afterEncode)

    afterEncode = convertor.ToStdBase64("")
    fmt.Println(afterEncode)

    stringVal := "hello"
    afterEncode = convertor.ToStdBase64(stringVal)
    fmt.Println(afterEncode)

    byteSliceVal := []byte("hello")
    afterEncode = convertor.ToStdBase64(byteSliceVal)
    fmt.Println(afterEncode)

    intVal := 123
    afterEncode = convertor.ToStdBase64(intVal)
    fmt.Println(afterEncode)

    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
        A string
        B int
    }{"hello", 3}}
    afterEncode = convertor.ToStdBase64(mapVal)
    fmt.Println(afterEncode)

    floatVal := 123.456
    afterEncode = convertor.ToStdBase64(floatVal)
    fmt.Println(afterEncode)

    boolVal := true
    afterEncode = convertor.ToStdBase64(boolVal)
    fmt.Println(afterEncode)

    errVal := errors.New("err")
    afterEncode = convertor.ToStdBase64(errVal)
    fmt.Println(afterEncode)

    // Output:
    //
    //
    // aGVsbG8=
    // aGVsbG8=
    // MTIz
    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
    // MTIzLjQ1Ng==
    // dHJ1ZQ==
    // ZXJy
}

ToUrlBase64

Convert a value to a string encoded in url Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.

Signature:

func ToUrlBase64(value any) string

Example:Run

package main

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

func main() {
    afterEncode := convertor.ToUrlBase64(nil)
    fmt.Println(afterEncode)


    stringVal := "hello"
    afterEncode = convertor.ToUrlBase64(stringVal)
    fmt.Println(afterEncode)

    byteSliceVal := []byte("hello")
    afterEncode = convertor.ToUrlBase64(byteSliceVal)
    fmt.Println(afterEncode)

    intVal := 123
    afterEncode = convertor.ToUrlBase64(intVal)
    fmt.Println(afterEncode)

    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
        A string
        B int
    }{"hello", 3}}
    afterEncode = convertor.ToUrlBase64(mapVal)
    fmt.Println(afterEncode)

    floatVal := 123.456
    afterEncode = convertor.ToUrlBase64(floatVal)
    fmt.Println(afterEncode)

    boolVal := true
    afterEncode = convertor.ToUrlBase64(boolVal)
    fmt.Println(afterEncode)

    errVal := errors.New("err")
    afterEncode = convertor.ToUrlBase64(errVal)
    fmt.Println(afterEncode)

    // Output:
    //
    // aGVsbG8=
    // aGVsbG8=
    // MTIz
    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ==
    // MTIzLjQ1Ng==
    // dHJ1ZQ==
    // ZXJy
}

ToRawStdBase64

Convert a value to a string encoded in raw standard Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.

Signature:

func ToRawStdBase64(value any) string

Example:Run

package main

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

func main() {

    stringVal := "hello"
    afterEncode := convertor.ToRawStdBase64(stringVal)
    fmt.Println(afterEncode)

    byteSliceVal := []byte("hello")
    afterEncode = convertor.ToRawStdBase64(byteSliceVal)
    fmt.Println(afterEncode)

    intVal := 123
    afterEncode = convertor.ToRawStdBase64(intVal)
    fmt.Println(afterEncode)

    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
        A string
        B int
    }{"hello", 3}}
    afterEncode = convertor.ToRawStdBase64(mapVal)
    fmt.Println(afterEncode)

    floatVal := 123.456
    afterEncode = convertor.ToRawStdBase64(floatVal)
    fmt.Println(afterEncode)

    boolVal := true
    afterEncode = convertor.ToRawStdBase64(boolVal)
    fmt.Println(afterEncode)

    errVal := errors.New("err")
    afterEncode = convertor.ToRawStdBase64(errVal)
    fmt.Println(afterEncode)

    // Output:
    // aGVsbG8
    // aGVsbG8
    // MTIz
    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
    // MTIzLjQ1Ng
    // dHJ1ZQ
    // ZXJy
}

ToRawUrlBase64

Convert a value to a string encoded in raw url Base64. Error data of type "error" will also be encoded, and complex structures will be converted to a JSON formatted string.

Signature:

func ToRawUrlBase64(value any) string

Example:Run

package main

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

func main() {

    stringVal := "hello"
    afterEncode := convertor.ToRawUrlBase64(stringVal)
    fmt.Println(afterEncode)

    byteSliceVal := []byte("hello")
    afterEncode = convertor.ToRawUrlBase64(byteSliceVal)
    fmt.Println(afterEncode)

    intVal := 123
    afterEncode = convertor.ToRawUrlBase64(intVal)
    fmt.Println(afterEncode)

    mapVal := map[string]any{"a": "hi", "b": 2, "c": struct {
        A string
        B int
    }{"hello", 3}}
    afterEncode = convertor.ToRawUrlBase64(mapVal)
    fmt.Println(afterEncode)

    floatVal := 123.456
    afterEncode = convertor.ToRawUrlBase64(floatVal)
    fmt.Println(afterEncode)

    boolVal := true
    afterEncode = convertor.ToRawUrlBase64(boolVal)
    fmt.Println(afterEncode)

    errVal := errors.New("err")
    afterEncode = convertor.ToRawUrlBase64(errVal)
    fmt.Println(afterEncode)

    // Output:
    // aGVsbG8
    // aGVsbG8
    // MTIz
    // eyJhIjoiaGkiLCJiIjoyLCJjIjp7IkEiOiJoZWxsbyIsIkIiOjN9fQ
    // MTIzLjQ1Ng
    // dHJ1ZQ
    // ZXJy
}

DeepClone

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

Signature:

func DeepClone[T any](src T) T

Example:Run

package main

import (
    "fmt"
    "github.com/duke-git/lancet/v2/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,
        },
    }

    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
}

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

convertor.md

convertor.md

Convertor

Source:

Usage:

Index

Documentation

ColorHexToRGB

ColorRGBToHex

ToBool

ToBytes

ToChar

ToChannel

ToFloat

ToInt

ToJson

ToMap

ToPointer

ToString

StructToMap

MapToSlice

EncodeByte

DecodeByte

CopyProperties

Utf8ToGbk

GbkToUtf8

ToStdBase64

ToUrlBase64

ToRawStdBase64

ToRawUrlBase64

DeepClone

Files

convertor.md

Latest commit

History

convertor.md

File metadata and controls

Convertor

Source:

Usage:

Index

Documentation

ColorHexToRGB

ColorRGBToHex

ToBool

ToBytes

ToChar

ToChannel

ToFloat

ToInt

ToJson

ToMap

ToPointer

ToString

StructToMap

MapToSlice

EncodeByte

DecodeByte

CopyProperties

Utf8ToGbk

GbkToUtf8

ToStdBase64

ToUrlBase64

ToRawStdBase64

ToRawUrlBase64

DeepClone