推荐库一个类型转换库 https://github.com/spf13/cast

    1. package convert
    3. import "strconv"
    5. func StringPtr(value interface{}) *string {
    6.     var res string
    7.     switch val := value.(type) {
    8.     case string:
    9.         res = val
    10.     case bool:
    11.         if val {
    12.             res = "true"
    13.         } else {
    14.             res = "false"
    15.         }
    16.     case int:
    17.         res = strconv.FormatInt(int64(val), 10)
    18.     case uint:
    19.         res = strconv.FormatUint(uint64(val), 10)
    20.     case int8:
    21.         res = strconv.FormatInt(int64(val), 10)
    22.     case uint8:
    23.         res = strconv.FormatUint(uint64(val), 10)
    24.     case int16:
    25.         res = strconv.FormatInt(int64(val), 10)
    26.     case uint16:
    27.         res = strconv.FormatUint(uint64(val), 10)
    28.     case int32:
    29.         res = strconv.FormatInt(int64(val), 10)
    30.     case uint32:
    31.         res = strconv.FormatUint(uint64(val), 10)
    32.     case int64:
    33.         res = strconv.FormatInt(val, 10)
    34.     case uint64:
    35.         res = strconv.FormatUint(val, 10)
    36.     case float32:
    37.         res = strconv.FormatFloat(float64(val), 'f', -1, 64)
    38.     case float64:
    39.         res = strconv.FormatFloat(val, 'f', -1, 64)
    40.     case []byte:
    41.         res = string(val)
    42.     default:
    43.         return nil
    44.     }
    45.     return &res
    46. }
    48. func BoolPtr(value interface{}) *bool {
    49.     var res bool
    50.     switch val := value.(type) {
    51.     case bool:
    52.         res = val
    53.     case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
    54.         res = val != 0
    55.     case float32:
    56.         if val != 0 {
    57.             res = true
    58.         } else {
    59.             res = false
    60.         }
    61.     case float64:
    62.         if val != 0 {
    63.             res = true
    64.         } else {
    65.             res = false
    66.         }
    67.     case string:
    68.         switch val {
    69.         case "1", "true", "TRUE", "True", "On":
    70.             res = true
    71.         case "null":
    72.             return nil
    73.         default:
    74.             res = false
    75.         }
    76.     case []byte:
    77.         switch string(val) {
    78.         case "1", "true", "TRUE", "True", "On":
    79.             res = true
    80.         case "null":
    81.             return nil
    82.         default:
    83.             res = false
    84.         }
    85.     default:
    86.         return nil
    87.     }
    88.     return &res
    89. }
    91. // int
    92. const INT_MAX = int(^uint(0) >> 1)
    93. const INT_MIN = ^INT_MAX
    94. const INT_MAX_64 = int64(INT_MAX)
    95. const INT_MIN_64 = int64(INT_MIN)
    97. // uint
    98. const UINT_MIN uint = 0
    99. const UINT_MAX = ^uint(0)
    100. const UINT_MAX_64 = uint64(UINT_MAX)
    101. const UINT_MIN_64 = uint64(UINT_MIN)
    103. // int8 -127 ~ 128
    104. const INT8_MAX = int8(^uint8(0) >> 1)
    105. const INT8_MIN = ^INT8_MAX
    106. const INT8_MAX_64 = int64(INT8_MAX)
    107. const INT8_MIN_64 = int64(INT8_MIN)
    109. // uint8 0 ~ 255
    110. const UINT8_MAX = ^uint8(0)
    111. const UINT8_MIN = uint8(0)
    112. const UINT8_MAX_64 = uint64(UINT8_MAX)
    113. const UINT8_MIN_64 = uint64(UINT8_MIN)
    115. // int16 -32768 ~ 32767
    116. const INT16_MAX = int16(^uint16(0) >> 1)
    117. const INT16_MIN = ^INT16_MAX
    118. const INT16_MAX_64 = int64(INT16_MAX)
    119. const INT16_MIN_64 = int64(INT16_MIN)
    121. // uint16 0 ~ 65535
    122. const UINT16_MAX = ^uint16(0)
    123. const UINT16_MIN = uint16(0)
    124. const UINT16_MAX_64 = uint64(UINT16_MAX)
    125. const UINT16_MIN_64 = uint64(UINT16_MIN)
    127. // int32 -2147483648 ~ 2147483647
    128. const INT32_MAX = int32(^uint32(0) >> 1)
    129. const INT32_MIN = ^INT32_MAX
    130. const INT32_MAX_64 = int64(INT32_MAX)
    131. const INT32_MIN_64 = int64(INT32_MIN)
    133. // uint32 0 ~ 4294967295
    134. const UINT32_MAX = ^uint32(0)
    135. const UINT32_MIN = uint32(0)
    136. const UINT32_MAX_64 = uint64(UINT32_MAX)
    137. const UINT32_MIN_64 = uint64(UINT32_MIN)
    139. func IntPtr(value interface{}) *int {
    140.     ptr := Int64Ptr(value)
    141.     if ptr == nil || *ptr > INT_MAX_64 || *ptr < INT_MIN_64 {
    142.         return nil
    143.     }
    144.     val := int(*ptr)
    145.     return &val
    146. }
    148. func UintPtr(value interface{}) *uint {
    149.     ptr := Uint64Ptr(value)
    150.     if ptr == nil || *ptr > UINT_MAX_64 || *ptr < UINT_MIN_64 {
    151.         return nil
    152.     }
    153.     val := uint(*ptr)
    154.     return &val
    155. }
    157. func Int8Ptr(value interface{}) *int8 {
    158.     ptr := Int64Ptr(value)
    159.     if ptr == nil || *ptr > INT8_MAX_64 || *ptr < INT8_MIN_64 {
    160.         return nil
    161.     }
    162.     val := int8(*ptr)
    163.     return &val
    164. }
    166. func Uint8Ptr(value interface{}) *uint8 {
    167.     ptr := Uint64Ptr(value)
    168.     if ptr == nil || *ptr > UINT8_MAX_64 || *ptr < UINT8_MIN_64 {
    169.         return nil
    170.     }
    171.     val := uint8(*ptr)
    172.     return &val
    173. }
    175. func Int16Ptr(value interface{}) *int16 {
    176.     ptr := Int64Ptr(value)
    177.     if ptr == nil || *ptr > INT16_MAX_64 || *ptr < INT16_MIN_64 {
    178.         return nil
    179.     }
    180.     val := int16(*ptr)
    181.     return &val
    182. }
    184. func Uint16Ptr(value interface{}) *uint16 {
    185.     ptr := Uint64Ptr(value)
    186.     if ptr == nil || *ptr > UINT16_MAX_64 || *ptr < UINT16_MIN_64 {
    187.         return nil
    188.     }
    189.     val := uint16(*ptr)
    190.     return &val
    191. }
    193. func Int32Ptr(value interface{}) *int32 {
    194.     ptr := Int64Ptr(value)
    195.     if ptr == nil || *ptr > INT32_MAX_64 || *ptr < INT32_MIN_64 {
    196.         return nil
    197.     }
    198.     val := int32(*ptr)
    199.     return &val
    200. }
    202. func Uint32Ptr(value interface{}) *uint32 {
    203.     ptr := Uint64Ptr(value)
    204.     if ptr == nil || *ptr > UINT32_MAX_64 || *ptr < UINT32_MIN_64 {
    205.         return nil
    206.     }
    207.     val := uint32(*ptr)
    208.     return &val
    209. }
    211. func Int64Ptr(value interface{}) *int64 {
    212.     var res int64
    213.     switch val := value.(type) {
    214.     case bool:
    215.         if val {
    216.             res = 1
    217.         } else {
    218.             res = 0
    219.         }
    220.     case int:
    221.         res = int64(val)
    222.     case uint:
    223.         res = int64(val)
    224.     case int8:
    225.         res = int64(val)
    226.     case uint8:
    227.         res = int64(val)
    228.     case int16:
    229.         res = int64(val)
    230.     case uint16:
    231.         res = int64(val)
    232.     case int32:
    233.         res = int64(val)
    234.     case uint32:
    235.         res = int64(val)
    236.     case int64:
    237.         res = val
    238.     case uint64:
    239.         res = int64(val)
    240.     case float32:
    241.         res = int64(val)
    242.     case float64:
    243.         res = int64(val)
    244.     case []byte:
    245.         if ret, err := strconv.ParseInt(string(val), 10, 0); err == nil {
    246.             res = ret
    247.         } else {
    248.             return nil
    249.         }
    250.     case string:
    251.         if ret, err := strconv.ParseInt(val, 10, 0); err == nil {
    252.             res = ret
    253.         } else {
    254.             return nil
    255.         }
    256.     default:
    257.         return nil
    258.     }
    259.     return &res
    260. }
    262. func Uint64Ptr(value interface{}) *uint64 {
    263.     switch val := value.(type) {
    264.     case uint64:
    265.         res := val
    266.         return &res
    267.     case []byte:
    268.         if ret, err := strconv.ParseUint(string(val), 10, 0); err == nil {
    269.             return &ret
    270.         }
    271.     case string:
    272.         if ret, err := strconv.ParseUint(val, 10, 0); err == nil {
    273.             return &ret
    274.         }
    275.     default:
    276.         intVal := Int64Ptr(value)
    277.         if intVal != nil {
    278.             res := uint64(*intVal)
    279.             return &res
    280.         }
    281.     }
    282.     return nil
    283. }
    285. func Float32Ptr(value interface{}) *float32 {
    286.     ptr := Float64Ptr(value)
    287.     if ptr == nil {
    288.         return nil
    289.     }
    290.     val := float32(*ptr)
    291.     return &val
    292. }
    294. func Float64Ptr(value interface{}) *float64 {
    295.     var res float64
    296.     switch val := value.(type) {
    297.     case bool:
    298.         if val {
    299.             res = 1
    300.         } else {
    301.             res = 0
    302.         }
    303.     case int:
    304.         res = float64(val)
    305.     case uint:
    306.         res = float64(val)
    307.     case int8:
    308.         res = float64(val)
    309.     case uint8:
    310.         res = float64(val)
    311.     case int16:
    312.         res = float64(val)
    313.     case uint16:
    314.         res = float64(val)
    315.     case int32:
    316.         res = float64(val)
    317.     case uint32:
    318.         res = float64(val)
    319.     case int64:
    320.         res = float64(val)
    321.     case uint64:
    322.         res = float64(val)
    323.     case float32:
    324.         res = float64(val)
    325.     case float64:
    326.         res = val
    327.     case []byte:
    328.         if ret, err := strconv.ParseFloat(string(val), 10); err == nil {
    329.             res = ret
    330.         } else {
    331.             return nil
    332.         }
    333.     case string:
    334.         if ret, err := strconv.ParseFloat(val, 10); err == nil {
    335.             res = ret
    336.         } else {
    337.             return nil
    338.         }
    339.     default:
    340.         return nil
    341.     }
    342.     return &res
    343. }
    345. func StringVal(value interface{}) (res string) {
    346.     if ptr := StringPtr(value); ptr != nil {
    347.         res = *ptr
    348.     }
    349.     return
    350. }
    352. func BoolVal(value interface{}) (res bool) {
    353.     if ptr := BoolPtr(value); ptr != nil {
    354.         res = *ptr
    355.     }
    356.     return
    357. }
    359. func IntVal(value interface{}) (res int) {
    360.     if ptr := IntPtr(value); ptr != nil {
    361.         res = *ptr
    362.     }
    363.     return
    364. }
    366. func UintVal(value interface{}) (res uint) {
    367.     if ptr := UintPtr(value); ptr != nil {
    368.         res = *ptr
    369.     }
    370.     return
    371. }
    373. func Int8Val(value interface{}) (res int8) {
    374.     if ptr := Int8Ptr(value); ptr != nil {
    375.         res = *ptr
    376.     }
    377.     return
    378. }
    380. func Uint8Val(value interface{}) (res uint8) {
    381.     if ptr := Uint8Ptr(value); ptr != nil {
    382.         res = *ptr
    383.     }
    384.     return
    385. }
    387. func Int16Val(value interface{}) (res int16) {
    388.     if ptr := Int16Ptr(value); ptr != nil {
    389.         res = *ptr
    390.     }
    391.     return
    392. }
    394. func Uint16Val(value interface{}) (res uint16) {
    395.     if ptr := Uint16Ptr(value); ptr != nil {
    396.         res = *ptr
    397.     }
    398.     return
    399. }
    401. func Int32Val(value interface{}) (res int32) {
    402.     if ptr := Int32Ptr(value); ptr != nil {
    403.         res = *ptr
    404.     }
    405.     return
    406. }
    408. func Uint32Val(value interface{}) (res uint32) {
    409.     if ptr := Uint32Ptr(value); ptr != nil {
    410.         res = *ptr
    411.     }
    412.     return
    413. }
    415. func Int64Val(value interface{}) (res int64) {
    416.     if ptr := Int64Ptr(value); ptr != nil {
    417.         res = *ptr
    418.     }
    419.     return
    420. }
    422. func Uint64Val(value interface{}) (res uint64) {
    423.     if ptr := Uint64Ptr(value); ptr != nil {
    424.         res = *ptr
    425.     }
    426.     return
    427. }
    429. func Float32Val(value interface{}) (res float32) {
    430.     if ptr := Float32Ptr(value); ptr != nil {
    431.         res = *ptr
    432.     }
    433.     return
    434. }
    436. func Float64Val(value interface{}) (res float64) {
    437.     if ptr := Float64Ptr(value); ptr != nil {
    438.         res = *ptr
    439.     }
    440.     return
    441. }
    1. package convert
    3. import (
    4.     "github.com/a8m/expect"
    5.     "testing"
    6. )
    8. func TestString(t *testing.T) {
    9.     expect := expect.New(t)
    10.     expect(*StringPtr("str")).To.Equal("str")
    11.     expect(*StringPtr(`str`)).To.Equal("str")
    12.     expect(*StringPtr([]byte(`str`))).To.Equal("str")
    13.     expect(*StringPtr(-1)).To.Equal("-1")
    14.     expect(*StringPtr(2)).To.Equal("2")
    15.     expect(*StringPtr(3.14)).To.Equal("3.14")
    16.     expect(*StringPtr(3888.1455555)).To.Equal("3888.1455555")
    17.     expect(*StringPtr(38881455555.555)).To.Equal("38881455555.555")
    18.     expect(*StringPtr(true)).To.Equal("true")
    19.     expect(*StringPtr(false)).To.Equal("false")
    20.     expect(nil == StringPtr(nil)).To.Equal(true)
    21. }
    23. func TestBool(t *testing.T) {
    24.     expect := expect.New(t)
    25.     expect(*BoolPtr("true")).To.Equal(true)
    26.     expect(*BoolPtr("false")).To.Equal(false)
    27.     expect(nil == BoolPtr("null")).To.Equal(true)
    28.     expect(*BoolPtr("x")).To.Equal(false)
    29.     expect(*BoolPtr(123)).To.Equal(true)
    30.     expect(*BoolPtr(123.4)).To.Equal(true)
    31.     expect(*BoolPtr(0)).To.Equal(false)
    32.     expect(*BoolPtr(0.0000000000000000000001)).To.Equal(true)
    33.     expect(*BoolPtr(0.0000000000000000000000)).To.Equal(false)
    34.     expect(nil == BoolPtr(nil)).To.Equal(true)
    35. }
    37. func TestInt(t *testing.T) {
    38.     expect := expect.New(t)
    39.     expect(nil == Int64Ptr("str")).To.Equal(true)
    40.     expect(nil == Int64Ptr("123.4")).To.Equal(true)
    41.     expect(nil == Uint64Ptr("123.4")).To.Equal(true)
    42.     expect(nil == Uint64Ptr("str")).To.Equal(true)
    44.     expect(-123 == *Int64Ptr("-123")).To.Equal(true)
    45.     expect(123 == *Int64Ptr("0123")).To.Equal(true)
    46.     expect(123456798 == *Int64Ptr("123456798")).To.Equal(true)
    48.     expect(nil == Int8Ptr("123456")).To.Equal(true)
    49.     expect(nil == Int8Ptr(123456)).To.Equal(true)
    50.     expect(-1 == *Int8Ptr("-1")).To.Equal(true)
    51.     expect(0 == *Int8Ptr("0")).To.Equal(true)
    52.     expect(1 == *Int8Ptr("1")).To.Equal(true)
    53.     expect(nil == Int8Ptr(-123456)).To.Equal(true)
    54.     expect(nil == Int8Ptr("-123456")).To.Equal(true)
    56.     expect(nil == Uint8Ptr("123456")).To.Equal(true)
    57.     expect(0 == *Uint8Ptr("0")).To.Equal(true)
    58.     expect(1 == *Uint8Ptr("1")).To.Equal(true)
    59.     expect(nil == Uint8Ptr("-1")).To.Equal(true)
    61.     expect(nil == Int16Ptr("123456798")).To.Equal(true)
    62.     expect(nil == Int16Ptr(123456789)).To.Equal(true)
    63.     expect(-1 == *Int16Ptr("-1")).To.Equal(true)
    64.     expect(0 == *Int16Ptr("0")).To.Equal(true)
    65.     expect(1 == *Int16Ptr("1")).To.Equal(true)
    66.     expect(nil == Int16Ptr(-123456789)).To.Equal(true)
    67.     expect(nil == Int16Ptr("-123456789")).To.Equal(true)
    69.     expect(nil == Uint16Ptr("123456789")).To.Equal(true)
    70.     expect(0 == *Uint16Ptr("0")).To.Equal(true)
    71.     expect(1 == *Uint16Ptr("1")).To.Equal(true)
    72.     expect(nil == Uint16Ptr("-1")).To.Equal(true)
    74.     expect(nil == Int32Ptr("1234567890123456")).To.Equal(true)
    75.     expect(nil == Int32Ptr(1234567890123456)).To.Equal(true)
    76.     expect(-1 == *Int32Ptr("-1")).To.Equal(true)
    77.     expect(0 == *Int32Ptr("0")).To.Equal(true)
    78.     expect(1 == *Int32Ptr("1")).To.Equal(true)
    79.     expect(nil == Int32Ptr(-1234567890123456)).To.Equal(true)
    80.     expect(nil == Int32Ptr("-1234567890123456")).To.Equal(true)
    82.     expect(nil == Uint32Ptr("1234567890123456")).To.Equal(true)
    83.     expect(0 == *Uint32Ptr("0")).To.Equal(true)
    84.     expect(1 == *Uint32Ptr("1")).To.Equal(true)
    85.     expect(nil == Uint32Ptr("-1")).To.Equal(true)
    86. }
    88. func TestFloat(t *testing.T) {
    89.     expect := expect.New(t)
    90.     expect(nil == Float64Ptr("true")).To.Equal(true)
    91.     expect(nil == Float32Ptr("true")).To.Equal(true)
    92.     expect(123 == *Float64Ptr("123")).To.Equal(true)
    93.     expect(123 == *Float32Ptr("123")).To.Equal(true)
    94.     expect(123.4 == *Float64Ptr("123.4")).To.Equal(true)
    95.     expect(123.4 == *Float32Ptr("123.4")).To.Equal(true)
    96.     expect(0 == *Float64Ptr("0")).To.Equal(true)
    97.     expect(0 == *Float32Ptr("0")).To.Equal(true)
    98.     expect(0 == *Float64Ptr(0)).To.Equal(true)
    99.     expect(0 == *Float32Ptr(0)).To.Equal(true)
    100.     expect(123 == *Float64Ptr(123)).To.Equal(true)
    101.     expect(123 == *Float32Ptr(123)).To.Equal(true)
    102.     expect(52 == *Float64Ptr(uint8(52))).To.Equal(true)
    103.     expect(52 == *Float32Ptr(uint8(52))).To.Equal(true)
    104.     expect(0 == *Float64Ptr("0.0000000000000000000001")).To.Equal(false)
    105.     expect(0.0000000000000000000001 == *Float64Ptr("0.0000000000000000000001")).To.Equal(true)
    106.     expect(0 == *Float64Ptr("0.0000000000000000000000")).To.Equal(true)
    108. }