diff --git a/README.md b/README.md
index f145b1d..200ff24 100644
--- a/README.md
+++ b/README.md
@@ -12,10 +12,12 @@ Reflux 是一个 Go 语言包,提供了统一的接口用于访问和操作嵌
 - 📋 **深度克隆**: Scope 方法和值传递模式创建深度克隆,修改不影响原始数据
 - 🎭 **灵活模式**: 支持指针和值两种传递方式,提供不同的数据操作语义
 - 🔌 **Interface 支持**: 自动解析 `interface{}` 类型到实际类型
-- 🔤 **大小写不敏感**: 支持使用小写字段名访问和修改结构体字段
+- 🔤 **大小写不敏感**: 支持使用小写字段名访问和修改结构体字段(包括 Map 键名)
 - 🔑 **键名提取**: Keys 方法可获取结构体或 Map 的所有键名
 - 📝 **JSON 集成**: Ptr() 方法返回的指针可直接用于 json.Unmarshal(),实现动态 JSON 反序列化
 - 🎯 **类型安全**: 使用反射但保证类型安全
+- 🔥 **增强类型转换**: 支持切片和结构体之间的智能转换(如 []any -> []T, map -> struct)
+- 🌀 **R 接口集成**: 支持直接传入 R 接口或 []R 切片,无缝集成反射值
 - 🚀 **高性能**: 优化的反射操作,低内存开销
 - 📦 **零依赖**: 仅依赖 Go 标准库和 spf13/cast
 
@@ -157,9 +159,14 @@ value := rfx.Get("Meta", "key").String()
 // 获取 Map 值 - 使用点号
 value := rfx.Get("Meta.key").String()
 
-// 大小写不敏感访问 (自动转换为正确的字段名)
+// 大小写不敏感访问 - 结构体字段和 Map 键名
 name := rfx.Get("name").String()  // 等同于 Get("Name")
 city := rfx.Get("address.city").String()  // 等同于 Get("Address.City")
+
+// Map 类型也支持大小写转换
+config := map[string]string{"Host": "localhost"}
+rfx := reflux.New(&config)
+host := rfx.Get("host").String()  // 自动尝试 "Host"
 ```
 
 ### 3. 作用域 (Scope)
@@ -240,12 +247,154 @@ rfx.Set("address.city", "Shanghai")  // 等同于 Set("Address.City", "Shanghai"
 // 自动类型转换
 rfx.Set("Age", int32(35))  // int32 -> int
 
+// 切片类型转换 - 从通用切片转为具体类型
+rfx.Set("Scores", []any{90, 95, 88})  // []any -> []int
+
+// 结构体类型转换 - 从 map 填充到 struct
+addressMap := map[string]any{
+    "City":   "Shanghai",
+    "Street": "Nanjing Road",
+}
+rfx.Set("Address", addressMap)  // map -> Address struct
+
+// 指针切片赋值 - 保持指针引用
+type Item struct {
+    Name string
+}
+item1 := &Item{Name: "apple"}
+item2 := &Item{Name: "banana"}
+rfx.Set("Items", []*Item{item1, item2})  // 保持原指针地址
+
+// 也支持从 []any 包含指针元素
+rfx.Set("Items", []any{item1, item2})  // 复用指针地址
+
+// R 接口和 []R 切片支持
+rfx1 := reflux.New(data1)
+rfx2 := reflux.New(data2)
+rfx.Set("Item", rfx1)           // 直接传入 R 接口
+rfx.Set("Items", []R{rfx1, rfx2})  // 传入 R 切片
+
 // Map 自动初始化
 rfx.Set("NewMap.key", "value")  // 如果 NewMap 是 nil,会自动初始化
 ```
 
 **注意**: 如果设置失败(路径不存在、类型不匹配等),会 panic。
 
+#### 高级类型转换
+
+Reflux 提供了强大的智能类型转换能力,支持多种复杂场景:
+
+**1. 切片类型转换**
+
+支持从通用切片(如 `[]any`)转换为具体类型切片:
+
+```go
+type Person struct {
+    Scores []int
+    Tags   []string
+}
+
+p := Person{}
+rfx := reflux.New(&p)
+
+// []any -> []int
+rfx.Set("Scores", []any{90, 95, 88})
+// p.Scores = []int{90, 95, 88}
+
+// []any -> []string (自动类型转换)
+rfx.Set("Tags", []any{"go", "rust", 123})
+// p.Tags = []string{"go", "rust", "123"}
+```
+
+**2. 结构体类型转换**
+
+支持从 map 或其他结构体填充到目标结构体:
+
+```go
+type Address struct {
+    City   string
+    Street string
+}
+
+type Person struct {
+    Address Address
+}
+
+p := Person{}
+rfx := reflux.New(&p)
+
+// map -> struct
+addressMap := map[string]any{
+    "City":   "Shanghai",
+    "Street": "Nanjing Road",
+}
+rfx.Set("Address", addressMap)
+// p.Address = Address{City: "Shanghai", Street: "Nanjing Road"}
+
+// struct -> struct (按字段名匹配)
+src := Address{City: "Beijing", Street: "Changan"}
+rfx.Set("Address", src)
+```
+
+**3. 指针切片处理**
+
+对于包含指针的切片,Reflux 会保持指针引用:
+
+```go
+type Fruit struct {
+    Name string
+}
+
+type Basket struct {
+    Fruits []*Fruit
+}
+
+basket := Basket{}
+rfx := reflux.New(&basket)
+
+apple := &Fruit{Name: "apple"}
+banana := &Fruit{Name: "banana"}
+
+// 保持指针引用,不创建新对象
+rfx.Set("Fruits", []*Fruit{apple, banana})
+
+// 修改原指针对象,basket.Fruits 中会看到相同变化
+apple.Name = "green apple"
+// basket.Fruits[0].Name == "green apple"
+
+// 也支持从 []any 赋值,复用指针地址
+rfx.Set("Fruits", []any{apple, banana})
+```
+
+**4. R 接口集成**
+
+支持直接传入 R 接口或 []R 切片:
+
+```go
+// 传入单个 R 接口
+data1 := map[string]string{"key": "value"}
+rfx1 := reflux.New(data1)
+rfx.Set("Item", rfx1)  // 自动提取底层值
+
+// 传入 []R 切片
+data2 := map[string]int{"count": 10}
+rfx2 := reflux.New(data2)
+rfx.Set("Items", []R{rfx1, rfx2})  // 自动转换为底层切片
+```
+
+**5. reflect.Value 支持**
+
+可以直接传入 `reflect.Value`,避免重复封装:
+
+```go
+import "reflect"
+
+val := reflect.ValueOf(someData)
+rfx.Set("Field", val)  // 直接使用,不重复包装
+```
+
+这些高级转换特性使得 Reflux 在处理复杂数据结构和动态类型场景时更加灵活和强大。
+
 #### 切片追加 (Append)
 
 `Append` 用于在当前 `R` 对应的切片上追加一个或多个元素,并支持自动类型转换:
diff --git a/reflux.go b/reflux.go
index d7a0f02..bf3b4be 100644
--- a/reflux.go
+++ b/reflux.go
@@ -131,15 +131,16 @@ type R interface {
 // 也支持 interface 类型以及部分基础类型(string/bool/float),会自动解析到实际类型
 // 返回一个 R 接口实例,可用于访问和操作嵌套的字段、元素和键值对
 func New(v any) R {
-	rv := reflect.ValueOf(v)
+	rv, isPtr, err := normalizeInputValue(v)
+
+	if err != nil {
+		panic(err)
+	}
 
 	if !rv.IsValid() {
 		panic("rfx: invalid value")
 	}
 
-	// 记录原始是否为指针
-	isPtr := rv.Kind() == reflect.Ptr
-
 	// 递归解引用指针和接口,直到获取实际的值类型
 	actualValue := rv
 	for actualValue.Kind() == reflect.Ptr || actualValue.Kind() == reflect.Interface {
diff --git a/rfx.go b/rfx.go
index e2ccb67..05bc931 100644
--- a/rfx.go
+++ b/rfx.go
@@ -20,12 +20,12 @@ type rfx struct {
 
 // Get 通过路径获取嵌套字段的值
 func (r *rfx) Get(p ...string) R {
-	return &rfx{value: r.getValueByPath(p...)}
+	return &rfx{value: getValueByPath(r.value, p...)}
 }
 
 // Scope 创建一个指定路径的作用域视图(深度克隆)
 func (r *rfx) Scope(p ...string) R {
-	v := r.getValueByPath(p...)
+	v := getValueByPath(r.value, p...)
 	if !v.IsValid() {
 		return &rfx{value: reflect.Value{}}
 	}
@@ -35,56 +35,6 @@ func (r *rfx) Scope(p ...string) R {
 	return &rfx{value: cloned}
 }
 
-// getValueByPath 通过路径获取值的辅助方法
-// 支持两种路径格式:
-// 1. 多个参数: Get("Address", "City")
-// 2. 点号分割: Get("Address.City") 或混合使用 Get("Address.City", "ZipCode")
-func (r *rfx) getValueByPath(p ...string) reflect.Value {
-	v := r.value
-	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
-		if v.IsNil() {
-			return reflect.Value{}
-		}
-		v = v.Elem()
-	}
-
-	// 展开所有路径片段,支持点号分割
-	keys := expandPath(p...)
-
-	for _, key := range keys {
-		if !v.IsValid() {
-			return reflect.Value{}
-		}
-
-		switch v.Kind() {
-		case reflect.Struct:
-			v = tryStructField(v, key)
-		case reflect.Map:
-			v = v.MapIndex(reflect.ValueOf(key))
-		case reflect.Slice, reflect.Array:
-			// 尝试将 key 转换为索引
-			idx, err := strconv.Atoi(key)
-			if err == nil && idx >= 0 && idx < v.Len() {
-				v = v.Index(idx)
-			} else {
-				return reflect.Value{}
-			}
-		default:
-			return reflect.Value{}
-		}
-
-		// 解引用指针和接口
-		for v.IsValid() && (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) {
-			if v.IsNil() {
-				return reflect.Value{}
-			}
-			v = v.Elem()
-		}
-	}
-
-	return v
-}
-
 // Set 设置指定路径的值,支持链式调用
 // 如果路径不存在或设置失败,会 panic
 func (r *rfx) Set(key string, v any) R {
@@ -235,7 +185,7 @@ func (r *rfx) getParentValue(p ...string) reflect.Value {
 		}
 		return v
 	}
-	return r.getValueByPath(p...)
+	return getValueByPath(r.value, p...)
 }
 
 // setFieldValue 设置字段值的辅助方法
@@ -315,24 +265,40 @@ func (r *rfx) setFieldValue(target reflect.Value, key string, v any) bool {
 // setValue 设置值的辅助方法
 // 使用 cast 库进行智能类型转换,支持更多的转换场景
 func (r *rfx) setValue(field reflect.Value, v any) bool {
-	val := reflect.ValueOf(v)
+	val, _, err := normalizeInputValue(v)
+
+	if err != nil {
+		return false
+	}
+
+	if !val.IsValid() {
+		return false
+	}
+
+	// 统一解开最外层的 interface 包装,便于后续根据底层实际类型做处理
+	for val.Kind() == reflect.Interface && !val.IsNil() {
+		val = val.Elem()
+	}
+
+	targetType := field.Type()
 
 	// 尝试直接赋值(类型完全匹配)
-	if val.Type().AssignableTo(field.Type()) {
+	if val.Type().AssignableTo(targetType) {
 		field.Set(val)
 		return true
 	}
 
-	// 处理指针类型
-	if field.Type().Kind() == reflect.Ptr {
+	switch targetType.Kind() {
+	case reflect.Ptr:
+		// 处理指针类型
 		// 如果传入的值已经是指针类型,尝试直接赋值
-		if val.Type().AssignableTo(field.Type()) {
+		if val.Type().AssignableTo(targetType) {
 			field.Set(val)
 			return true
 		}
 
 		// 如果传入的值不是指针,创建新指针并设置值
-		elemType := field.Type().Elem()
+		elemType := targetType.Elem()
 		newPtr := reflect.New(elemType)
 
 		// 递归设置指针指向的值
@@ -342,13 +308,56 @@ func (r *rfx) setValue(field reflect.Value, v any) bool {
 
 		field.Set(newPtr)
 		return true
+
+	case reflect.Slice: // 处理切片类型,支持从通用切片(如 []any)转换
+		if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
+			return false
+		}
+
+		newSlice := reflect.MakeSlice(targetType, val.Len(), val.Len())
+
+		for i := 0; i < val.Len(); i++ {
+			if !r.setValue(newSlice.Index(i), val.Index(i)) {
+				return false
+			}
+		}
+
+		field.Set(newSlice)
+
+		return true
+
+	case reflect.Struct:
+		// 遍历目标结构体的字段,从源值(结构体或 map)中按字段名取值并设置
+		// 仅支持从 struct 或 map 填充
+		if val.Kind() != reflect.Struct && val.Kind() != reflect.Map {
+			return false
+		}
+
+		fieldType := field.Type()
+		for i := 0; i < fieldType.NumField(); i++ {
+			dstField := field.Field(i)
+			if !dstField.CanSet() {
+				continue
+			}
+
+			valField := getValueByPath(val, fieldType.Field(i).Name)
+
+			if !valField.IsValid() {
+				continue
+			}
+
+			// 使用 setValue 复用现有的类型转换逻辑,忽略单个字段失败
+			if !r.setValue(dstField, valField) {
+				return false
+			}
+		}
+		return true
+
 	}
 
 	// 优先使用 cast 进行智能类型转换
 	// 这样可以处理 string <-> number, number <-> bool 等常见转换
-	targetType := field.Type()
 	var converted any
-	var err error
 
 	switch targetType.Kind() {
 	case reflect.Bool:
@@ -380,11 +389,6 @@ func (r *rfx) setValue(field reflect.Value, v any) bool {
 	case reflect.String:
 		converted, err = cast.ToStringE(v)
 	default:
-		// 对于 cast 不支持的类型,尝试标准的反射类型转换
-		if val.Type().ConvertibleTo(field.Type()) {
-			field.Set(val.Convert(field.Type()))
-			return true
-		}
 		return false
 	}
 
@@ -398,6 +402,7 @@ func (r *rfx) setValue(field reflect.Value, v any) bool {
 	}
 
 	field.Set(reflect.ValueOf(converted))
+
 	return true
 }
 
@@ -453,8 +458,7 @@ func (r *rfx) Delete(p ...string) R {
 
 // Exists 检查指定路径的值是否存在
 func (r *rfx) Exists(p ...string) bool {
-	v := r.getValueByPath(p...)
-	return v.IsValid()
+	return getValueByPath(r.value, p...).IsValid()
 }
 
 // Array 将当前值转换为 R 切片
diff --git a/rfx_example_test.go b/rfx_example_test.go
index 30100f4..7d75117 100644
--- a/rfx_example_test.go
+++ b/rfx_example_test.go
@@ -5,10 +5,15 @@ import "fmt"
 // ExampleNew_withPointer 演示如何使用 New 函数传入指针
 // 传入指针时,修改会影响原始数据
 func ExampleNew_withPointer() {
+	type Fruit struct {
+		Name string
+	}
+
 	type Person struct {
-		Name  string
-		Age   int
-		Email *string
+		Name   string
+		Age    int
+		Email  *string
+		Fruits []*Fruit
 	}
 
 	email := "alice@example.com"
@@ -22,11 +27,30 @@ func ExampleNew_withPointer() {
 	// 对于指针字段,Set 会设置指针指向的值
 	rfx.Set("Email", "bob@example.com")
 
+	// 切片成员为指针类型的场景
+	apple := &Fruit{Name: "apple"}
+	banana := &Fruit{Name: "banana"}
+	cherry := &Fruit{Name: "cherry"}
+
+	// 传入指针切片
+	rfx.Set("Fruits", []*Fruit{apple, banana, cherry})
+
+	// 也可以传入包含指针的 []any, 会复用指针地址
+	rfx.Set("Fruits", []any{apple, banana, cherry})
+
+	// 修改外部指针元素, person.Fruits 中会看到相同变化(地址传递)
+	apple.Name = "apple to grape"
+
 	// 原始数据已被修改(包括指针字段指向的值)
 	fmt.Printf("Name: %s, Age: %d, Email: %s\n", person.Name, person.Age, *person.Email)
+	fmt.Printf("Fruits: %s, %s, %s\n",
+		person.Fruits[0].Name,
+		person.Fruits[1].Name,
+		person.Fruits[2].Name)
 
 	// Output:
 	// Name: Bob, Age: 35, Email: bob@example.com
+	// Fruits: apple to grape, banana, cherry
 }
 
 // ExampleNew_withPointer_map 演示传入 map 指针
diff --git a/util.go b/util.go
index 50c4c96..e10e2d9 100644
--- a/util.go
+++ b/util.go
@@ -1,7 +1,9 @@
 package reflux
 
 import (
+	"fmt"
 	"reflect"
+	"strconv"
 	"strings"
 	"unicode"
 )
@@ -185,6 +187,55 @@ func expandPath(p ...string) []string {
 	return result
 }
 
+// getValueByPath 通过路径获取值的辅助方法
+// 支持两种路径格式:
+// 1. 多个参数: Get("Address", "City")
+// 2. 点号分割: Get("Address.City") 或混合使用 Get("Address.City", "ZipCode")
+func getValueByPath(v reflect.Value, p ...string) reflect.Value {
+	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
+		if v.IsNil() {
+			return reflect.Value{}
+		}
+		v = v.Elem()
+	}
+
+	// 展开所有路径片段,支持点号分割
+	keys := expandPath(p...)
+
+	for _, key := range keys {
+		if !v.IsValid() {
+			return reflect.Value{}
+		}
+
+		switch v.Kind() {
+		case reflect.Struct:
+			v = tryStructField(v, key)
+		case reflect.Map:
+			v = tryMapField(v, key)
+		case reflect.Slice, reflect.Array:
+			// 尝试将 key 转换为索引
+			idx, err := strconv.Atoi(key)
+			if err == nil && idx >= 0 && idx < v.Len() {
+				v = v.Index(idx)
+			} else {
+				return reflect.Value{}
+			}
+		default:
+			return reflect.Value{}
+		}
+
+		// 解引用指针和接口
+		for v.IsValid() && (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) {
+			if v.IsNil() {
+				return reflect.Value{}
+			}
+			v = v.Elem()
+		}
+	}
+
+	return v
+}
+
 // capitalizeFirst 将字符串首字母转换为大写
 // 用于处理 struct 字段名,使其符合 Go 的公开字段命名规范
 func capitalizeFirst(s string) string {
@@ -196,6 +247,16 @@ func capitalizeFirst(s string) string {
 	return string(runes)
 }
 
+// lowercaseFirst 将字符串首字母转换为小写
+func lowercaseFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	runes := []rune(s)
+	runes[0] = unicode.ToLower(runes[0])
+	return string(runes)
+}
+
 // tryStructField 尝试获取 struct 字段,支持小写字段名自动转大写
 // 1. 首先尝试原始字段名
 // 2. 如果失败且首字母是小写,尝试首字母大写的版本
@@ -217,3 +278,102 @@ func tryStructField(v reflect.Value, fieldName string) reflect.Value {
 
 	return reflect.Value{}
 }
+
+// tryMapField 尝试从 map 中获取值,支持 string 键的小写字段名自动转大写
+// 1. 首先使用原始 key 尝试
+// 2. 如果 map 的键类型为 string 且 key 首字母是大写,再尝试首字母小写的版本
+func tryMapField(m reflect.Value, key string) reflect.Value {
+	if !m.IsValid() || m.Kind() != reflect.Map {
+		return reflect.Value{}
+	}
+
+	keyType := m.Type().Key()
+
+	// 构造原始 key
+	var mapKey reflect.Value
+	if keyType.Kind() == reflect.String {
+		mapKey = reflect.ValueOf(key)
+	} else {
+		// 非 string 键,尽量使用原始字符串构造可转换的 key
+		raw := reflect.ValueOf(key)
+		if raw.Type().AssignableTo(keyType) {
+			mapKey = raw
+		} else if raw.Type().ConvertibleTo(keyType) {
+			mapKey = raw.Convert(keyType)
+		} else {
+			return reflect.Value{}
+		}
+	}
+
+	// 尝试原始 key
+	val := m.MapIndex(mapKey)
+	if val.IsValid() {
+		return val
+	}
+
+	// 如果键类型是 string 且首字母大写,尝试首字母小写版本
+	if keyType.Kind() == reflect.String && len(key) > 0 && unicode.IsUpper(rune(key[0])) {
+		lowercased := lowercaseFirst(key)
+		mapKey = reflect.ValueOf(lowercased)
+		val = m.MapIndex(mapKey)
+		if val.IsValid() {
+			return val
+		}
+	}
+
+	return reflect.Value{}
+}
+
+// normalizeInputValue 规范化传入的任意值为 reflect.Value
+// 返回对应的 reflect.Value 以及是否应被视为指针(isPtr)
+func normalizeInputValue(v any) (reflect.Value, bool, error) {
+	var rv reflect.Value
+	var isPtr bool
+
+	if vv, ok := v.(R); ok {
+		isPtr = true
+		rv = vv.Value()
+	} else if vv, ok := v.([]R); ok {
+		// 支持直接传入 []R,自动转换为底层切片
+		var elemType reflect.Type
+		for _, it := range vv {
+			if it == nil {
+				continue
+			}
+			val := it.Value()
+			if val.IsValid() {
+				elemType = val.Type()
+				break
+			}
+		}
+
+		// 如果所有元素都是 nil 或无效,退回到通用处理
+		if elemType == nil {
+			rv = reflect.ValueOf(v)
+		} else {
+			isPtr = true
+			count := len(vv)
+			rv = reflect.MakeSlice(reflect.SliceOf(elemType), count, count)
+			for i, it := range vv {
+				if it == nil {
+					continue
+				}
+				val := it.Value()
+				if !val.IsValid() {
+					continue
+				}
+				if !val.Type().AssignableTo(elemType) {
+					return rv, isPtr, fmt.Errorf("rfx: []R element type mismatch at index %d: got %s, want %s", i, val.Type(), elemType)
+				}
+				rv.Index(i).Set(val)
+			}
+		}
+	} else if vv, ok := v.(reflect.Value); ok {
+		// 支持直接传入 reflect.Value,避免重复封装
+		rv = vv
+	} else {
+		rv = reflect.ValueOf(v)
+	}
+
+	return rv, isPtr || rv.Kind() == reflect.Ptr, nil
+}