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

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/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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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
}

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/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,
            // 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.

Signature:

func CopyProperties[T, U any](dst T, src U) (err error)

Example:

package main

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

func main() {
    type Address struct {
        Country string
        ZipCode string
    }

    type User struct {
        Name   string
        Age    int
        Role   string
        Addr   Address
        Hobbys []string
        salary int
    }

    type Employee struct {
        Name   string
        Age    int
        Role   string
        Addr   Address
        Hobbys []string
        salary int
    }

    user := User{Name: "user001", Age: 10, Role: "Admin", Addr: Address{Country: "CN", ZipCode: "001"}, Hobbys: []string{"a", "b"}, salary: 1000}

    employee1 := Employee{}
    CopyProperties(&employee1, &user)

    employee2 := Employee{Name: "employee001", Age: 20, Role: "User",
        Addr: Address{Country: "UK", ZipCode: "002"}, salary: 500}

    CopyProperties(&employee2, &user)

    fmt.Println(employee1)
    fmt.Println(employee2)

    // Output:
    // {user001 10 Admin {CN 001} [a b] 0}
    // {user001 10 Admin {CN 001} [a b] 500}
}

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

DeepClone

CopyProperties

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

DeepClone

CopyProperties