Fast conversions across various Go types with a simple API.
Fast conversions across various Go types with a simple API.
Get:
go get -u github.com/cstockton/go-convExample:
// Basic types if got, err := conv.Bool(`TRUE`); err == nil { fmt.Printf("conv.Bool(`TRUE`)\n -> %v\n", got) } if got, err := conv.Duration(`1m2s`); err == nil { fmt.Printf("conv.Duration(`1m2s`)\n -> %v\n", got) } var date time.Time err := conv.Infer(&date, `Sat Mar 7 11:06:39 PST 2015`) fmt.Printf("conv.Infer(&date, `Sat Mar 7 11:06:39 PST 2015`)\n -> %v\n", got)Output:
conv.Bool(`TRUE`) -> true conv.Duration(`1m2s`) -> 1m2s conv.Infer(&date, `Sat Mar 7 11:06:39 PST 2015`) -> 2015-03-07 11:06:39 +0000 PST
Notice: If you begin getting compilation errors use the v1 import path gopkg.in/cstockton/go-conv.v1 for an immediate fix and to future-proof.
Package conv provides fast and intuitive conversions across Go types. This library uses reflection to be robust but will bypass it for common conversions, for example string conversion to any type will never use reflection. All functions are safe for concurrent use by multiple Goroutines.
All conversion functions accept any type of value for conversion, if unable to find a reasonable conversion path they will return the target types zero value and an error.
Example:
…Output:
0 cannot convert "Foo" (type string) to int 42 42 42
Bool conversion supports all the paths provided by the standard libraries strconv.ParseBool when converting from a string, all other conversions are simply true when not the types zero value. As a special case zero length map and slice types are also false, even if initialized.
Example:
…Output:
true false true false true false true false true false false cannot convert struct { string }{string:""} (type struct { string }) to bool
Duration conversion supports all the paths provided by the standard libraries time.ParseDuration when converting from strings, with a couple enhancements outlined below.
Example:
…Output:
1h1m0.1s 1h1m0.1s 1h1m0.1s 1h1m0.1s 1h1m0.1s 1h1m0.1s 1ns 1ns
Float64 conversion from other float values of an identical type will be returned without modification. Float64 from other types follow the general numeric rules.
Example:
fmt.Println(conv.Float64(float64(123.456))) // 123.456 fmt.Println(conv.Float64("-123.456")) // -123.456 fmt.Println(conv.Float64("1.7976931348623157e+308"))Output:
123.456 -123.456 1.7976931348623157e+308
Infer will perform conversion by inferring the conversion operation from
a pointer to a supported T of the into param. Since the value is assigned
directly only a error value is returned, meaning no type assertions needed.
Example:
// Infer requires a pointer to all types. var into int if err := conv.Infer(into, `42`); err != nil { fmt.Println(err) } if err := conv.Infer(&into, `42`); err == nil { fmt.Println(into) } // Same as above but using new() truth := new(bool) if err := conv.Infer(truth, `TRUE`); err != nil { fmt.Println("Failed!")Output:
cannot infer conversion for unchangeable 0 (type int) 42
Int conversions follow the the general numeric rules.
Example:
fmt.Println(conv.Uint("123.456")) // 123 fmt.Println(conv.Uint("-123.456")) // 0 fmt.Println(conv.Uint8(uint64(math.MaxUint64))) // 255Output:
123 0 255
String conversion from any values outside the cases below will simply be the result of calling fmt.Sprintf("%v", value), meaning it can not fail. An error is still provided and you should check it to be future proof.
Example:
// String conversion from other string values will be returned without // modification. fmt.Println(conv.String("Foo")) // As a special case []byte will also be returned after a Go string conversion // is applied. fmt.Println(conv.String([]byte("Foo"))) // String conversion from types that do not have a valid conversion path will // still have sane string conversion for troubleshooting. fmt.Println(conv.String(struct{ msg string }{"Foo"}))Output:
Foo Foo {Foo}
Time conversion from other time values will be returned without modification.
Example:
…Output:
Times: 2006-01-02 15:04:05 +0000 UTC Strings: 2006-01-02 15:04:05 +0000 UTC 2006-01-02 15:04:05 +0000 UTC 2006-01-02 15:04:05 +0000 UTC 2006-01-02 15:04:05 +0000 UTC 2006-01-02 15:04:00 +0000 UTC 2006-01-02 15:04:05 +0000 UTC 2006-01-02 15:04:05 +0000 UTC Errors: 0001-01-01 00:00:00 +0000 UTC cannot convert 1 (type int) to time.Time 0001-01-01 00:00:00 +0000 UTC cannot convert true (type bool) to time.Time
Uint conversions follow the the general numeric rules.
Example:
fmt.Println(conv.Uint("123.456")) // 123 fmt.Println(conv.Uint("-123.456")) // 0 fmt.Println(conv.Uint8(uint64(math.MaxUint64))) // 255Output:
123 0 255
Numeric conversion from other numeric values of an identical type will be returned without modification. Numeric conversions deviate slightly from Go when dealing with under/over flow. When performing a conversion operation that would overflow, we instead assign the maximum value for the target type. Similarly, conversions that would underflow are assigned the minimun value for that type, meaning unsigned integers are given zero values instead of spilling into large positive integers.
Example:
// For more natural Float -> Integer when the underlying value is a string. // Conversion functions will always try to parse the value as the target type // first. If parsing fails float parsing with truncation will be attempted. fmt.Println(conv.Int("-123.456")) // -123 // This does not apply for unsigned integers if the value is negative. Instead // performing a more intuitive (to the human) truncation to zero. fmt.Println(conv.Uint("-123.456")) // 0Output:
-123 0
In short, panics should not occur within this library under any circumstance. This obviously excludes any oddities that may surface when the runtime is not in a healthy state, i.e. uderlying system instability, memory exhaustion. If you are able to create a reproducible panic please file a bug report.
Example:
// The zero value for the target type is always returned. fmt.Println(conv.Bool(nil)) fmt.Println(conv.Bool([][]int{})) fmt.Println(conv.Bool((chan string)(nil))) fmt.Println(conv.Bool((*interface{})(nil))) fmt.Println(conv.Bool((*interface{})(nil))) fmt.Println(conv.Bool((**interface{})(nil)))Output:
false cannot convert (type ) to bool false false false cannot convert (*interface {})(nil) (type *interface {}) to bool false cannot convert (*interface {})(nil) (type *interface {}) to bool false cannot convert (**interface {})(nil) (type **interface {}) to bool
Feel free to create issues for bugs, please ensure code coverage remains 100% with any pull requests.
Feel free to report bugs and submit pull requests.
bugs:
patches:
No open issues yet, or sync has not completed.