uint test

README.cn.md

@@ -127,19 +127,34 @@ func IsPassword(password string) bool
 
 ```go
 // StrToInt string转int
-func StrToInt(str string) int 
+func StrToInt(str string) int
 
 // StrToInt8 string转int8
-func StrToInt8(str string) int8 
+func StrToInt8(str string) int8
 
 // StrToInt16 string转int16
-func StrToInt16(str string) int16 
+func StrToInt16(str string) int16
 
 // StrToInt32 string转int32
-func StrToInt32(str string) int32 
+func StrToInt32(str string) int32
 
 // StrToInt64 string转int64
-func StrToInt64(str string) int64 
+func StrToInt64(str string) int64
+
+// StrToUint string转uint
+func StrToUint(str string) uint
+
+// StrToUint8 string转uint8
+func StrToUint8(str string) uint8
+
+// StrToUint16 string转uint16
+func StrToUint16(str string) uint16
+
+// StrToUint32 string转uint32
+func StrToUint32(str string) uint32
+
+// StrToUint64 string转uint64
+func StrToUint64(str string) uint64
 
 // StrToBytes 字符串转字节数组
 func StrToBytes(data string) []byte 
@@ -304,21 +319,6 @@ func MapKeyExists(m map[string]interface{}, key string) bool
 ### intUtil 数值型处理
 
 ```go
-// StrToInt 将string类型转换为int类型
-func StrToInt(s string) (int, error)
-
-// StrToInt8 将string类型转换为int8类型
-func StrToInt8(s string) (int8, error)
-
-// StrToInt16 将string类型转换为int16类型
-func StrToInt16(s string) (int16, error)
-
-// StrToInt32 将string类型转换为int32类型
-func StrToInt32(s string) (int32, error)
-
-// StrToInt64 将string类型转换为int64类型
-func StrToInt64(s string) (int64, error)
-
 // IntToString 将int类型转换为string类型
 func IntToString(n int) string
 

anyUtil/any_to_int_x.go

@@ -1,17 +1,22 @@
 package anyUtil
 
 import (
+	"errors"
 	"fmt"
-	"strconv"
+	"math"
+	"reflect"
 )
 
 // AnyToInt 将给定的值转换为 int
 func AnyToInt(input interface{}) (int, error) {
-	value, err := AnyToInt64(input)
+	v, err := AnyToInt64(input)
 	if err != nil {
 		return 0, err
 	}
-	return int(value), nil
+	if v < int64(^int(0)+1) || v > int64(^int(0)) {
+		return 0, errors.New("value out of range")
+	}
+	return int(v), nil
 }
 
 // AnyToInt8 将给定的值转换为 int8
@@ -20,7 +25,7 @@ func AnyToInt8(input interface{}) (int8, error) {
 	if err != nil {
 		return 0, err
 	}
-	if value < -128 || value > 127 {
+	if value < math.MinInt8 || value > math.MaxInt8 {
 		return 0, fmt.Errorf("%d out of int8 range", value)
 	}
 	return int8(value), nil
@@ -32,7 +37,7 @@ func AnyToInt16(input interface{}) (int16, error) {
 	if err != nil {
 		return 0, err
 	}
-	if value < -32768 || value > 32767 {
+	if value < math.MinInt16 || value > math.MaxInt16 {
 		return 0, fmt.Errorf("%d out of int16 range", value)
 	}
 	return int16(value), nil
@@ -44,46 +49,64 @@ func AnyToInt32(input interface{}) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	if value < -2147483648 || value > 2147483647 {
+	if value < math.MinInt32 || value > math.MaxInt32 {
 		return 0, fmt.Errorf("%d out of int32 range", value)
 	}
 	return int32(value), nil
 }
 
 // AnyToInt64 将给定的值转换为 int64
-func AnyToInt64(input interface{}) (int64, error) {
+func AnyToInt64(value interface{}) (int64, error) {
-	switch input.(type) {
+	//switch input.(type) {
-	case int:
+	//case int:
-		return int64(input.(int)), nil
+	//	return int64(input.(int)), nil
-	case int8:
+	//case int8:
-		return int64(input.(int8)), nil
+	//	return int64(input.(int8)), nil
-	case int16:
+	//case int16:
-		return int64(input.(int16)), nil
+	//	return int64(input.(int16)), nil
-	case int32:
+	//case int32:
-		return int64(input.(int32)), nil
+	//	return int64(input.(int32)), nil
-	case int64:
+	//case int64:
-		return input.(int64), nil
+	//	return input.(int64), nil
-	case uint:
+	//case uint:
-		return int64(input.(uint)), nil
+	//	return int64(input.(uint)), nil
-	case uint8:
+	//case uint8:
-		return int64(input.(uint8)), nil
+	//	return int64(input.(uint8)), nil
-	case uint16:
+	//case uint16:
-		return int64(input.(uint16)), nil
+	//	return int64(input.(uint16)), nil
-	case uint32:
+	//case uint32:
-		return int64(input.(uint32)), nil
+	//	return int64(input.(uint32)), nil
-	case uint64:
+	//case uint64:
-		return int64(input.(uint64)), nil
+	//	return int64(input.(uint64)), nil
-	case string:
+	//case string:
-		val, err := strconv.ParseInt(input.(string), 10, 64)
+	//	val, err := strconv.ParseInt(input.(string), 10, 64)
-		if err != nil {
+	//	if err != nil {
-			return 0, err
+	//		return 0, err
+	//	}
+	//	return val, nil
+	//case float32:
+	//	return int64(input.(float32)), nil
+	//case float64:
+	//	return int64(input.(float64)), nil
+	//default:
+	//	return 0, fmt.Errorf("unsupported type %T", input)
+	//}
+
+	switch reflect.TypeOf(value).Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return reflect.ValueOf(value).Int(), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		v := reflect.ValueOf(value).Uint()
+		if v > uint64(^int64(0)) {
+			return 0, errors.New("value out of range")
 		}
-		return val, nil
+		return int64(v), nil
-	case float32:
+	case reflect.Float32, reflect.Float64:
-		return int64(input.(float32)), nil
+		v := reflect.ValueOf(value).Float()
-	case float64:
+		if v < float64(^int64(0))+1 || v > float64(^int64(0)) {
-		return int64(input.(float64)), nil
+			return 0, errors.New("value out of range")
-	default:
+		}
-		return 0, fmt.Errorf("unsupported type %T", input)
+		return int64(v), nil
 	}
+	return 0, errors.New("unsupported type")
 }

anyUtil/any_to_int_x_test.go

@@ -135,3 +135,7 @@ func TestAnyToInt64(t *testing.T) {
 		})
 	}
 }
+
+func TestName(t *testing.T) {
+	fmt.Println(uint64(^int64(0)))
+}

anyUtil/any_to_uint_x.go

@@ -1,26 +1,31 @@
 package anyUtil
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+)
 
 // AnyToUint 将给定的值转换为 uint
 func AnyToUint(input interface{}) (uint, error) {
-	value, err := AnyToInt(input)
+	v, err := AnyToUint64(input)
 	if err != nil {
 		return 0, err
 	}
-	if value < 0 {
+	if v > uint64(^uint(0)) {
-		return 0, fmt.Errorf("%d is negative", value)
+		return 0, errors.New("value out of range")
 	}
-	return uint(value), nil
+	return uint(v), nil
 }
 
 // AnyToUint8 将给定的值转换为 uint8
 func AnyToUint8(input interface{}) (uint8, error) {
-	value, err := AnyToUint(input)
+	value, err := AnyToUint64(input)
 	if err != nil {
 		return 0, err
 	}
-	if value > 255 {
+	if value > math.MaxUint8 {
 		return 0, fmt.Errorf("%d out of uint8 range", value)
 	}
 	return uint8(value), nil
@@ -28,11 +33,11 @@ func AnyToUint8(input interface{}) (uint8, error) {
 
 // AnyToUint16 将给定的值转换为 uint16
 func AnyToUint16(input interface{}) (uint16, error) {
-	value, err := AnyToUint(input)
+	value, err := AnyToUint64(input)
 	if err != nil {
 		return 0, err
 	}
-	if value > 65535 {
+	if value > math.MaxUint16 {
 		return 0, fmt.Errorf("%d out of uint16 range", value)
 	}
 	return uint16(value), nil
@@ -40,21 +45,33 @@ func AnyToUint16(input interface{}) (uint16, error) {
 
 // AnyToUint32 将给定的值转换为 uint32
 func AnyToUint32(input interface{}) (uint32, error) {
-	value, err := AnyToUint(input)
+	value, err := AnyToUint64(input)
 	if err != nil {
 		return 0, err
 	}
-	if value > 4294967295 {
+	if value > math.MaxUint32 {
 		return 0, fmt.Errorf("%d out of uint32 range", value)
 	}
 	return uint32(value), nil
 }
 
 // AnyToUint64 将给定的值转换为 uint64
-func AnyToUint64(input interface{}) (uint64, error) {
+func AnyToUint64(value interface{}) (uint64, error) {
-	value, err := AnyToUint(input)
+	switch reflect.TypeOf(value).Kind() {
-	if err != nil {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return 0, err
+		return reflect.ValueOf(value).Uint(), nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		v := reflect.ValueOf(value).Int()
+		if v < 0 {
+			return 0, errors.New("cannot convert negative value to unsigned integer")
+		}
+		return uint64(v), nil
+	case reflect.Float32, reflect.Float64:
+		v := reflect.ValueOf(value).Float()
+		if v < 0 {
+			return 0, errors.New("cannot convert negative value to unsigned integer")
+		}
+		return uint64(v), nil
 	}
-	return uint64(value), nil
+	return 0, errors.New("unsupported type")
 }

intUtil/README.md

@@ -1,21 +1,6 @@
 ### intUtil 数值型处理
 
 ```go
-// StrToInt 将string类型转换为int类型
-func StrToInt(s string) (int, error)
-
-// StrToInt8 将string类型转换为int8类型
-func StrToInt8(s string) (int8, error)
-
-// StrToInt16 将string类型转换为int16类型
-func StrToInt16(s string) (int16, error)
-
-// StrToInt32 将string类型转换为int32类型
-func StrToInt32(s string) (int32, error)
-
-// StrToInt64 将string类型转换为int64类型
-func StrToInt64(s string) (int64, error)
-
 // IntToString 将int类型转换为string类型
 func IntToString(n int) string
 

strUtil/README.md

@@ -14,7 +14,22 @@ func StrToInt16(str string) int16
 func StrToInt32(str string) int32 
 
 // StrToInt64 string转int64
-func StrToInt64(str string) int64 
+func StrToInt64(str string) int64
+
+// StrToUint string转uint
+func StrToUint(str string) uint
+
+// StrToUint8 string转uint8
+func StrToUint8(str string) uint8
+
+// StrToUint16 string转uint16
+func StrToUint16(str string) uint16
+
+// StrToUint32 string转uint32
+func StrToUint32(str string) uint32
+
+// StrToUint64 string转uint64
+func StrToUint64(str string) uint64
 
 // StrToBytes 字符串转字节数组
 func StrToBytes(data string) []byte 

strUtil/string_to_byte.go

@@ -0,0 +1,8 @@
+package strUtil
+
+import "unsafe"
+
+// StrToBytes 字符串转字节数组
+func StrToBytes(data string) []byte {
+	return *(*[]byte)(unsafe.Pointer(&data))
+}

strUtil/string_to_byte_test.go

@@ -0,0 +1,14 @@
+package strUtil
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestStrToBytes(t *testing.T) {
+	expected := []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f}
+	result := StrToBytes("hello")
+	if !bytes.Equal(result, expected) {
+		t.Errorf("StrToBytes test failed, expected %v but got %v", expected, result)
+	}
+}

strUtil/string_to_int_x.go

@@ -2,7 +2,6 @@ package strUtil
 
 import (
 	"strconv"
-	"unsafe"
 )
 
 // StrToInt string转int
@@ -49,53 +48,3 @@ func StrToInt64(str string) int64 {
 	}
 	return i
 }
-
-// StrToUint string转uint
-func StrToUint(str string) uint {
-	i, err := strconv.ParseUint(str, 10, 0)
-	if err != nil {
-		return 0
-	}
-	return uint(i)
-}
-
-// StrToUint8 string转uint8
-func StrToUint8(str string) uint8 {
-	i, err := strconv.ParseUint(str, 10, 8)
-	if err != nil {
-		return 0
-	}
-	return uint8(i)
-}
-
-// StrToUint16 string转uint16
-func StrToUint16(str string) uint16 {
-	i, err := strconv.ParseUint(str, 10, 16)
-	if err != nil {
-		return 0
-	}
-	return uint16(i)
-}
-
-// StrToUint32 string转uint32
-func StrToUint32(str string) uint32 {
-	i, err := strconv.ParseUint(str, 10, 32)
-	if err != nil {
-		return 0
-	}
-	return uint32(i)
-}
-
-// StrToUint64 string转uint64
-func StrToUint64(str string) uint64 {
-	i, err := strconv.ParseUint(str, 10, 64)
-	if err != nil {
-		return 0
-	}
-	return i
-}
-
-// StrToBytes 字符串转字节数组
-func StrToBytes(data string) []byte {
-	return *(*[]byte)(unsafe.Pointer(&data))
-}

strUtil/string_to_int_x_test.go

@@ -1,7 +1,6 @@
 package strUtil
 
 import (
-	"bytes"
 	"testing"
 )
 
@@ -44,106 +43,3 @@ func TestStrToInt64(t *testing.T) {
 		t.Errorf("StrToInt64 test failed, expected %d but got %d", expected, result)
 	}
 }
-
-func TestStrToBytes(t *testing.T) {
-	expected := []byte{0x68, 0x65, 0x6c, 0x6c, 0x6f}
-	result := StrToBytes("hello")
-	if !bytes.Equal(result, expected) {
-		t.Errorf("StrToBytes test failed, expected %v but got %v", expected, result)
-	}
-}
-
-func TestStrToUint(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected uint
-	}{
-		{"123", 123},
-		{"0", 0},
-		{"-1", 0},
-	}
-
-	for _, test := range tests {
-		result := StrToUint(test.input)
-		if result != test.expected {
-			t.Errorf("StrToUint(%s) = %d; expected %d", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestStrToUint8(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected uint8
-	}{
-		{"123", 123},
-		{"0", 0},
-		{"-1", 0},
-		{"256", 0},
-	}
-
-	for _, test := range tests {
-		result := StrToUint8(test.input)
-		if result != test.expected {
-			t.Errorf("StrToUint8(%s) = %d; expected %d", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestStrToUint16(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected uint16
-	}{
-		{"12345", 12345},
-		{"0", 0},
-		{"-1", 0},
-		{"65536", 0},
-	}
-
-	for _, test := range tests {
-		result := StrToUint16(test.input)
-		if result != test.expected {
-			t.Errorf("StrToUint16(%s) = %d; expected %d", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestStrToUint32(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected uint32
-	}{
-		{"1234567", 1234567},
-		{"0", 0},
-		{"-1", 0},
-		{"4294967296", 0},
-	}
-
-	for _, test := range tests {
-		result := StrToUint32(test.input)
-		if result != test.expected {
-			t.Errorf("StrToUint32(%s) = %d; expected %d", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestStrToUint64(t *testing.T) {
-	testCases := []struct {
-		input          string
-		expectedOutput uint64
-	}{
-		{"12345", 12345},
-		{"0", 0},
-		{"18446744073709551615", 18446744073709551615},
-		{"-1", 0},
-		{"not a number", 0},
-	}
-
-	for _, tc := range testCases {
-		output := StrToUint64(tc.input)
-		if output != tc.expectedOutput {
-			t.Errorf("StrToUint64(%q) = %d; want %d", tc.input, output, tc.expectedOutput)
-		}
-	}
-}

strUtil/string_to_uint_x.go

@@ -0,0 +1,48 @@
+package strUtil
+
+import "strconv"
+
+// StrToUint string转uint
+func StrToUint(str string) uint {
+	i, err := strconv.ParseUint(str, 10, 0)
+	if err != nil {
+		return 0
+	}
+	return uint(i)
+}
+
+// StrToUint8 string转uint8
+func StrToUint8(str string) uint8 {
+	i, err := strconv.ParseUint(str, 10, 8)
+	if err != nil {
+		return 0
+	}
+	return uint8(i)
+}
+
+// StrToUint16 string转uint16
+func StrToUint16(str string) uint16 {
+	i, err := strconv.ParseUint(str, 10, 16)
+	if err != nil {
+		return 0
+	}
+	return uint16(i)
+}
+
+// StrToUint32 string转uint32
+func StrToUint32(str string) uint32 {
+	i, err := strconv.ParseUint(str, 10, 32)
+	if err != nil {
+		return 0
+	}
+	return uint32(i)
+}
+
+// StrToUint64 string转uint64
+func StrToUint64(str string) uint64 {
+	i, err := strconv.ParseUint(str, 10, 64)
+	if err != nil {
+		return 0
+	}
+	return i
+}

strUtil/string_to_uint_x_test.go

@@ -0,0 +1,98 @@
+package strUtil
+
+import "testing"
+
+func TestStrToUint(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected uint
+	}{
+		{"123", 123},
+		{"0", 0},
+		{"-1", 0},
+	}
+
+	for _, test := range tests {
+		result := StrToUint(test.input)
+		if result != test.expected {
+			t.Errorf("StrToUint(%s) = %d; expected %d", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestStrToUint8(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected uint8
+	}{
+		{"123", 123},
+		{"0", 0},
+		{"-1", 0},
+		{"256", 0},
+	}
+
+	for _, test := range tests {
+		result := StrToUint8(test.input)
+		if result != test.expected {
+			t.Errorf("StrToUint8(%s) = %d; expected %d", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestStrToUint16(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected uint16
+	}{
+		{"12345", 12345},
+		{"0", 0},
+		{"-1", 0},
+		{"65536", 0},
+	}
+
+	for _, test := range tests {
+		result := StrToUint16(test.input)
+		if result != test.expected {
+			t.Errorf("StrToUint16(%s) = %d; expected %d", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestStrToUint32(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected uint32
+	}{
+		{"1234567", 1234567},
+		{"0", 0},
+		{"-1", 0},
+		{"4294967296", 0},
+	}
+
+	for _, test := range tests {
+		result := StrToUint32(test.input)
+		if result != test.expected {
+			t.Errorf("StrToUint32(%s) = %d; expected %d", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestStrToUint64(t *testing.T) {
+	testCases := []struct {
+		input          string
+		expectedOutput uint64
+	}{
+		{"12345", 12345},
+		{"0", 0},
+		{"18446744073709551615", 18446744073709551615},
+		{"-1", 0},
+		{"not a number", 0},
+	}
+
+	for _, tc := range testCases {
+		output := StrToUint64(tc.input)
+		if output != tc.expectedOutput {
+			t.Errorf("StrToUint64(%q) = %d; want %d", tc.input, output, tc.expectedOutput)
+		}
+	}
+}