gconv

Documentation

Overview

Package gconv implements powerful and easy-to-use converting functionality for any types of variables.

Index

• func Bool(i interface{}) bool
• func Byte(i interface{}) byte
• func Bytes(i interface{}) []byte
• func Convert(i interface{}, t string, params ...interface{}) interface{}
• func Duration(i interface{}) time.Duration
• func Float32(i interface{}) float32
• func Float32s(i interface{}) []float32
• func Float64(i interface{}) float64
• func Float64s(i interface{}) []float64
• func Floats(i interface{}) []float64
• func GTime(i interface{}, format ...string) *gtime.Time
• func Int(i interface{}) int
• func Int16(i interface{}) int16
• func Int32(i interface{}) int32
• func Int32s(i interface{}) []int32
• func Int64(i interface{}) int64
• func Int64s(i interface{}) []int64
• func Int8(i interface{}) int8
• func Interfaces(i interface{}) []interface{}
• func Ints(i interface{}) []int
• func Map(value interface{}, tags ...string) map[string]interface{}
• func MapDeep(value interface{}, tags ...string) map[string]interface{}
• func MapStrStr(value interface{}, tags ...string) map[string]string
• func MapStrStrDeep(value interface{}, tags ...string) map[string]string
• func MapToMap(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func MapToMapDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func MapToMaps(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func MapToMapsDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func Maps(value interface{}, tags ...string) []map[string]interface{}
• func MapsDeep(value interface{}, tags ...string) []map[string]interface{}
• func Rune(i interface{}) rune
• func Runes(i interface{}) []rune
• func SliceAny(i interface{}) []interface{}
• func SliceFloat(i interface{}) []float64
• func SliceFloat32(i interface{}) []float32
• func SliceFloat64(i interface{}) []float64
• func SliceInt(i interface{}) []int
• func SliceInt32(i interface{}) []int32
• func SliceInt64(i interface{}) []int64
• func SliceMap(i interface{}) []map[string]interface{}
• func SliceMapDeep(i interface{}) []map[string]interface{}
• func SliceStr(i interface{}) []string
• func SliceStruct(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)
• func SliceStructDeep(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)
• func SliceUint(i interface{}) []uint
• func SliceUint32(i interface{}) []uint32
• func SliceUint64(i interface{}) []uint64
• func String(i interface{}) string
• func Strings(i interface{}) []string
• func Struct(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func StructDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error
• func Structs(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)
• func StructsDeep(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)
• func Time(i interface{}, format ...string) time.Time
• func Uint(i interface{}) uint
• func Uint16(i interface{}) uint16
• func Uint32(i interface{}) uint32
• func Uint32s(i interface{}) []uint32
• func Uint64(i interface{}) uint64
• func Uint64s(i interface{}) []uint64
• func Uint8(i interface{}) uint8
• func Uints(i interface{}) []uint
• func UnsafeBytesToStr(b []byte) string
• func UnsafeStrToBytes(s string) []byte

Functions

func Bool

func Bool(i interface{}) bool

Bool converts <i> to bool. It returns false if <i> is: false, "", 0, "false", "off", "no", empty slice/map.

func Byte

func Byte(i interface{}) byte

Byte converts <i> to byte.

func Bytes

func Bytes(i interface{}) []byte

Bytes converts <i> to []byte.

func Convert

func Convert(i interface{}, t string, params ...interface{}) interface{}

Convert converts the variable <i> to the type <t>, the type <t> is specified by string. The optional parameter <params> is used for additional parameter passing.

func Duration

func Duration(i interface{}) time.Duration

Duration converts <i> to time.Duration. If <i> is string, then it uses time.ParseDuration to convert it. If <i> is numeric, then it converts <i> as nanoseconds.

func Float32

func Float32(i interface{}) float32

Float32 converts <i> to float32.

func Float32s

func Float32s(i interface{}) []float32

Float32s converts <i> to []float32.

func Float64

func Float64(i interface{}) float64

Float64 converts <i> to float64.

func Float64s

func Float64s(i interface{}) []float64

Float64s converts <i> to []float64.

func Floats

func Floats(i interface{}) []float64

Floats converts <i> to []float64.

func GTime

func GTime(i interface{}, format ...string) *gtime.Time

GTime converts <i> to *gtime.Time. The parameter <format> can be used to specify the format of <i>. If no <format> given, it converts <i> using gtime.NewFromTimeStamp if <i> is numeric, or using gtime.StrToTime if <i> is string.

func Int

func Int(i interface{}) int

Int converts <i> to int.

func Int16

func Int16(i interface{}) int16

Int16 converts <i> to int16.

func Int32

func Int32(i interface{}) int32

Int32 converts <i> to int32.

func Int32s

func Int32s(i interface{}) []int32

Int32s converts <i> to []int32.

func Int64

func Int64(i interface{}) int64

Int64 converts <i> to int64.

func Int64s

func Int64s(i interface{}) []int64

Int64s converts <i> to []int64.

func Int8

func Int8(i interface{}) int8

Int8 converts <i> to int8.

func Interfaces

func Interfaces(i interface{}) []interface{}

Interfaces converts <i> to []interface{}.

func Ints

func Ints(i interface{}) []int

Ints converts <i> to []int.

func Map

func Map(value interface{}, tags ...string) map[string]interface{}

Map converts any variable <value> to map[string]interface{}. If the parameter <value> is not a map/struct/*struct type, then the conversion will fail and returns nil.

If <value> is a struct/*struct object, the second parameter <tags> specifies the most priority tags that will be detected, otherwise it detects the tags in order of: gconv, json, field name.

func MapDeep

func MapDeep(value interface{}, tags ...string) map[string]interface{}

MapDeep does Map function recursively, which means if the attribute of <value> is also a struct/*struct, calls Map function on this attribute converting it to a map[string]interface{} type variable. Also see Map.

func MapStrStr

func MapStrStr(value interface{}, tags ...string) map[string]string

MapStrStr converts <value> to map[string]string. Note that there might be data copy for this map type converting.

func MapStrStrDeep

func MapStrStrDeep(value interface{}, tags ...string) map[string]string

MapStrStrDeep converts <value> to map[string]string recursively. Note that there might be data copy for this map type converting.

func MapToMap

func MapToMap(params interface{}, pointer interface{}, mapping ...map[string]string) error

MapToMap converts map type variable <params> to another map type variable <pointer> using reflect. The elements of <pointer> should be type of *map.

func MapToMapDeep

func MapToMapDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error

MapToMapDeep recursively converts map type variable <params> to another map type variable <pointer> using reflect. The elements of <pointer> should be type of *map.

func MapToMaps

func MapToMaps(params interface{}, pointer interface{}, mapping ...map[string]string) error

MapToMaps converts map type variable <params> to another map type variable <pointer>. The elements of <pointer> should be type of []map/*map.

func MapToMapsDeep

func MapToMapsDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error

MapToMapsDeep recursively converts map type variable <params> to another map type variable <pointer>. The elements of <pointer> should be type of []map/*map.

func Maps

func Maps(value interface{}, tags ...string) []map[string]interface{}

Maps converts <i> to []map[string]interface{}.

func MapsDeep

func MapsDeep(value interface{}, tags ...string) []map[string]interface{}

MapsDeep converts <i> to []map[string]interface{} recursively.

func Rune

func Rune(i interface{}) rune

Rune converts <i> to rune.

func Runes

func Runes(i interface{}) []rune

Runes converts <i> to []rune.

func SliceAny

func SliceAny(i interface{}) []interface{}

SliceAny is alias of Interfaces.

func SliceFloat

func SliceFloat(i interface{}) []float64

SliceFloat is alias of Floats.

func SliceFloat32

func SliceFloat32(i interface{}) []float32

SliceFloat32 is alias of Float32s.

func SliceFloat64

func SliceFloat64(i interface{}) []float64

SliceFloat64 is alias of Float64s.

func SliceInt

func SliceInt(i interface{}) []int

SliceInt is alias of Ints.

func SliceInt32

func SliceInt32(i interface{}) []int32

SliceInt32 is alias of Int32s.

func SliceInt64

func SliceInt64(i interface{}) []int64

SliceInt is alias of Int64s.

func SliceMap

func SliceMap(i interface{}) []map[string]interface{}

SliceMap is alias of Maps.

func SliceMapDeep

func SliceMapDeep(i interface{}) []map[string]interface{}

SliceMapDeep is alias of MapsDeep.

func SliceStr

func SliceStr(i interface{}) []string

SliceStr is alias of Strings.

func SliceStruct

func SliceStruct(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)

SliceStruct is alias of Structs.

func SliceStructDeep

func SliceStructDeep(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)

SliceStructDeep is alias of StructsDeep.

func SliceUint

func SliceUint(i interface{}) []uint

SliceUint is alias of Uints.

func SliceUint32

func SliceUint32(i interface{}) []uint32

SliceUint32 is alias of Uint32s.

func SliceUint64

func SliceUint64(i interface{}) []uint64

SliceUint64 is alias of Uint64s.

func String

func String(i interface{}) string

String converts <i> to string. It's most common used converting function.

func Strings

func Strings(i interface{}) []string

Strings converts <i> to []string.

func Struct

func Struct(params interface{}, pointer interface{}, mapping ...map[string]string) error

Struct maps the params key-value pairs to the corresponding struct object's properties. The third parameter <mapping> is unnecessary, indicating the mapping rules between the custom key name and the attribute name(case sensitive).

Note:

1. The <params> can be any type of map/struct, usually a map.
2. The second parameter <pointer> should be a pointer to the struct object.
3. Only the public attributes of struct object can be mapped.
4. If <params> is a map, the key of the map <params> can be lowercase. It will automatically convert the first letter of the key to uppercase in mapping procedure to do the matching. It ignores the map key, if it does not match.

func StructDeep

func StructDeep(params interface{}, pointer interface{}, mapping ...map[string]string) error

StructDeep do Struct function recursively. See Struct.

func Structs

func Structs(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)

Structs converts any slice to given struct slice.

func StructsDeep

func StructsDeep(params interface{}, pointer interface{}, mapping ...map[string]string) (err error)

StructsDeep converts any slice to given struct slice recursively.

func Time

func Time(i interface{}, format ...string) time.Time

Time converts <i> to time.Time.

func Uint

func Uint(i interface{}) uint

Uint converts <i> to uint.

func Uint16

func Uint16(i interface{}) uint16

Uint16 converts <i> to uint16.

func Uint32

func Uint32(i interface{}) uint32

Uint32 converts <i> to uint32.

func Uint32s

func Uint32s(i interface{}) []uint32

Uint32s converts <i> to []uint32.

func Uint64

func Uint64(i interface{}) uint64

Uint64 converts <i> to uint64.

func Uint64s

func Uint64s(i interface{}) []uint64

Uint64s converts <i> to []uint64.

func Uint8

func Uint8(i interface{}) uint8

Uint8 converts <i> to uint8.

func Uints

func Uints(i interface{}) []uint

Uints converts <i> to []uint.

func UnsafeBytesToStr

func UnsafeBytesToStr(b []byte) string

UnsafeBytesToStr converts []byte to string without memory copy. Note that, if you completely sure you will never use <s> in the feature, you can use this unsafe function to implement type conversion in high performance.

func UnsafeStrToBytes

func UnsafeStrToBytes(s string) []byte

UnsafeStrToBytes converts string to []byte without memory copy. Note that, if you completely sure you will never use <s> in the feature, you can use this unsafe function to implement type conversion in high performance.