Value() 添加对数组的支持

Author: caixw

obj.go

@@ -11,7 +11,7 @@ import (
 )
 
 // FieldConvert 字段转换
-// 用于 map 转换到一个对象实例或是从一个对象实例转换到 map
+// 用于 map 转换到一个对象实例或是从一个对象实例转换到 map 时，字段名称的转换。
 type FieldConvert func(src string) (dest string)
 
 // FieldConvert 的默认实现
@@ -84,7 +84,7 @@ func Map2Obj(src interface{}, dest interface{}, conv FieldConvert) error {
 		k := keys[i]
 
 		if k.Kind() != reflect.String {
-			return errors.New("src必须为map[string]interface{}类型")
+			return errors.New("src 必须为 map[string]interface{} 类型")
 		}
 
 		srcItemVal := srcVal.MapIndex(k)
@@ -135,13 +135,13 @@ func Map2Obj(src interface{}, dest interface{}, conv FieldConvert) error {
 func map2ObjCheck(src interface{}, dest interface{}, conv FieldConvert) (srcVal reflect.Value, destVal reflect.Value, fun FieldConvert, err error) {
 	destVal = reflect.ValueOf(dest)
 	if destVal.Kind() != reflect.Ptr {
-		err = fmt.Errorf("dest必须为一个struct对象的指针，实际类型为[%v]", destVal.Type())
+		err = fmt.Errorf("dest 必须为一个 struct 对象的指针，实际类型为[%v]", destVal.Type())
 		return
 	}
 
 	destVal = destVal.Elem()
 	if destVal.Kind() != reflect.Struct {
-		err = fmt.Errorf("dest必须为一个struct对象的指针，实际类型为[%v]", destVal.Type())
+		err = fmt.Errorf("dest 必须为一个 struct 对象的指针，实际类型为[%v]", destVal.Type())
 		return
 	}
 
@@ -152,7 +152,7 @@ func map2ObjCheck(src interface{}, dest interface{}, conv FieldConvert) (srcVal
 	}
 
 	if srcVal.Kind() != reflect.Map {
-		err = fmt.Errorf("src必须为map类型或是map指针，实际类型为[%v]", srcVal.Type())
+		err = fmt.Errorf("src 必须为 map 类型或是 map 指针，实际类型为[%v]", srcVal.Type())
 		return
 	}
 

value.go

@@ -67,14 +67,68 @@ func Value(source interface{}, target reflect.Value) error {
 			return err
 		}
 		target.SetString(val)
-	default:
-		sourceValue := reflect.ValueOf(source)
-		targetType := target.Type()
-		if !sourceValue.Type().ConvertibleTo(targetType) {
-			return typeError(source, targetType.String())
+	case reflect.Slice:
+		s := reflect.ValueOf(source)
+		sk := s.Kind()
+		tek := target.Type().Elem().Kind()
+
+		// []byte []rune 和 string 之间可以互相转换
+		if sk == reflect.String && (tek == reflect.Uint8 || tek == reflect.Int32) {
+			return valueDefault(source, target)
+		}
+
+		if sk != reflect.Array && sk != reflect.Slice {
+			return typeError(source, "slice")
+		}
+
+		l := s.Len()
+		tmp := reflect.MakeSlice(target.Type(), l, l)
+		for i := 0; i < l; i++ {
+			si := s.Index(i).Interface()
+			if err := Value(si, tmp.Index(i)); err != nil {
+				return err
+			}
+		}
+		target.Set(tmp)
+	case reflect.Array:
+		s := reflect.ValueOf(source)
+		sk := s.Kind()
+		tek := target.Type().Elem().Kind()
+
+		// []byte []rune 和 string 之间可以互相转换
+		if sk == reflect.String && (tek == reflect.Uint8 || tek == reflect.Int32) {
+			return valueDefault(source, target)
+		}
+
+		if sk != reflect.Array && sk != reflect.Slice {
+			return typeError(source, "array")
 		}
-		target.Set(sourceValue.Convert(targetType))
+
+		l := s.Len()
+		if l != target.Len() {
+			return fmt.Errorf("两者长度不一样，无法转换 %d: %d", l, target.Len())
+		}
+
+		for i := 0; i < l; i++ {
+			si := s.Index(i).Interface()
+			if err := Value(si, target.Index(i)); err != nil {
+				return err
+			}
+		}
+	default:
+		return valueDefault(source, target)
+	}
+
+	return nil
+}
+
+func valueDefault(source interface{}, target reflect.Value) error {
+	sourceValue := reflect.ValueOf(source)
+	targetType := target.Type()
+	if !sourceValue.Type().ConvertibleTo(targetType) {
+		return typeError(source, targetType.String())
 	}
+	target.Set(sourceValue.Convert(targetType))
 
 	return nil
 }

value_test.go

@@ -73,6 +73,29 @@ func TestValue(t *testing.T) {
 	a.NotError(Value(nil, reflect.ValueOf(&t12)))
 	a.Equal("", t12)
 
+	s13 := []string{"4", "5", "6"}
+	t13 := []int{1, 2}
+	a.NotError(Value(s13, reflect.ValueOf(&t13)))
+	a.Equal([]int{4, 5, 6}, t13)
+
+	// array 转换
+	s14 := []string{"4", "5"}
+	t14 := [2]int{1, 2}
+	a.NotError(Value(s14, reflect.ValueOf(&t14)))
+	a.Equal([]int{4, 5}, t14)
+
+	// array 长度不一样，无法转换
+	s15 := []string{"4", "5", "6"}
+	t15 := [2]int{1, 2}
+	a.Error(Value(s15, reflect.ValueOf(&t15)))
+	a.Equal([]int{1, 2}, t15)
+
+	// slice 长度不同，可以转换
+	s16 := []string{"4", "5"}
+	t16 := []int{1, 2, 3}
+	a.NotError(Value(s16, reflect.ValueOf(&t16)))
+	a.Equal([]int{4, 5}, t16)
+
 	// 无法转换的
 	s20 := "1a23"
 	t20 := 444