导表支持忽略注释行

package/excel/excel.go

@@ -69,6 +69,10 @@ func (s *Excel) ExcelLoad(ctx context.Context, fileItem *FileItem, mainPath stri
 		fileBytes := gfile.GetBytes(filepath)
 		arr, _ := gjson.DecodeToJson(fileBytes)
 		list := arr.Array()
+
+		//排除注释行
+		list = s.RemoveComments(list, fileItem.Json)
+
 		//格式化item格式
 		if len(fileItem.Items) > 0 {
 			list = s.itemsFormat(list, fileItem.Items)
@@ -98,105 +102,193 @@ func (s *Excel) ExcelLoad(ctx context.Context, fileItem *FileItem, mainPath stri
 	return
 }
 
+//排除配置中注释行
+func (s *Excel) RemoveComments(list []interface{}, json []string) []interface{} {
+	var temp = make([]interface{}, 0)
+	// 遍历列表中的每个元素
+	for _, v2 := range list {
+		var add = true
+		// 遍历当前元素的每个键值对
+		for _, v3 := range v2.(g.Map) {
+			// 如果字符串中存在//则跳过不写入temp
+			if gstr.Contains(gconv.String(v3), "//") {
+				//delKey = append(delKey, k2)
+				add = false
+				break
+			}
+		}
+		if add {
+			temp = append(temp, v2)
+		}
+
+	}
+	return temp
+}
+
+// itemsFormat 格式化列表中的道具字段
+// 参数:
+//   - list: 待处理的列表，包含多个元素，每个元素是一个 g.Map 类型
+//   - Items: 包含需要处理的道具字段名称的切片
+// 返回值:
+//   - 处理后的列表
 func (s *Excel) itemsFormat(list []interface{}, Items []string) []interface{} {
+	// 遍历列表中的每个元素
 	for k2, v2 := range list {
+		// 遍历当前元素的每个键值对
 		for k3, v3 := range v2.(g.Map) {
+			// 检查当前键是否在需要处理的道具字段列表中
 			if gstr.InArray(Items, k3) {
+				// 检查当前值是否为字符串类型
 				if _, ok := v3.(string); ok {
+					// 如果是字符串类型，调用 Spilt2Item 函数将其转换为 [][]int64 类型，并更新到列表中
 					list[k2].(g.Map)[k3] = Spilt2Item(v3.(string))
 				} else {
+					// 如果不是字符串类型，记录错误日志
 					g.Log().Errorf(gctx.New(), "当前类型断言失败:%v,list=%v", v3, v2)
 				}
 			}
 		}
 	}
+	// 返回处理后的列表
 	return list
 }
 
+// itemsMapFormat 将列表中指定字段的道具信息转换为映射格式
+// 参数:
+//   - list: 待处理的列表，包含多个元素，每个元素是一个 g.Map 类型
+//   - Items: 包含需要处理的道具字段名称的切片
+// 返回值:
+//   - 处理后的列表
 func (s *Excel) itemsMapFormat(list []interface{}, Items []string) []interface{} {
+	// 遍历列表中的每个元素
 	for k2, v2 := range list {
+		// 遍历当前元素的每个键值对
 		for k3, v3 := range v2.(g.Map) {
+			// 检查当前键是否在需要处理的道具字段列表中
 			if gstr.InArray(Items, k3) {
+				// 检查当前值是否为字符串类型
 				if _, ok := v3.(string); ok {
+					// 如果是字符串类型，调用 Spilt2Item 函数将其转换为 [][]int64 类型
 					get := Spilt2Item(v3.(string))
+					// 调用 Items2Map 函数将 [][]int64 类型的数据转换为映射格式，并更新到列表中
 					list[k2].(g.Map)[k3] = s.Items2Map(get)
 				} else {
+					// 如果不是字符串类型，记录错误日志
 					g.Log().Errorf(gctx.New(), "当前类型断言失败:%v,list=%v", v3, v2)
 				}
 			}
 		}
 	}
+	// 返回处理后的列表
 	return list
 }
 
+// sliceFormat 格式化列表中指定字段为切片格式
+// 参数:
+//   - list: 待处理的列表，包含多个元素，每个元素是一个 g.Map 类型
+//   - Slice: 一个映射，键为需要处理的字段名，值为目标类型（如 "int", "int64", "float64"）
+// 返回值:
+//   - 处理后的列表
 func (s *Excel) sliceFormat(list []interface{}, Slice map[string]string) []interface{} {
+	// 遍历 Slice 映射中的每个键值对
 	for s1, s2 := range Slice {
+		// 遍历列表中的每个元素
 		for k2, v2 := range list {
+			// 遍历当前元素的每个键值对
 			for k3, v3 := range v2.(g.Map) {
-				//判断是否存在
+				// 判断当前键是否与 Slice 中的键匹配
 				if s1 != k3 {
+					// 不匹配则跳过当前循环
 					continue
 				}
+				// 检查当前值是否为空字符串
 				if gconv.String(v3) == "" {
+					// 若为空，则将该字段设置为空字符串切片
 					list[k2].(g.Map)[k3] = []string{}
+					// 跳过当前循环
 					continue
 				}
+				// 用于存储分割后的字符串切片
 				var parts []string
-				//断言是否成功
+				// 断言当前值是否为字符串类型
 				if get, ok := v3.(string); !ok {
-					//g.Log().Errorf(gctx.New(), "当前类型断言失败:%v", v3)
+					// 若断言失败，将当前值转换为字符串并作为唯一元素存入 parts
 					parts = []string{gconv.String(v3)}
-
 				} else {
+					// 若为字符串类型，将字符串中的特殊字符替换为 "|"
 					for _, v := range shadiao {
 						get = strings.ReplaceAll(get, v, "|")
 					}
-					parts = strings.Split(get, "|") // 分割字符串
+					// 按 "|" 分割字符串
+					parts = strings.Split(get, "|")
 				}
 
+				// 根据 Slice 映射中的值进行类型转换
 				switch s2 {
 				case "int":
+					// 创建一个长度为 parts 的 int 切片
 					var temp = make([]int, len(parts))
+					// 遍历 parts 切片，将每个元素转换为 int 类型
 					for k, v := range parts {
 						temp[k], _ = strconv.Atoi(v)
 					}
+					// 将转换后的切片存入列表中
 					list[k2].(g.Map)[k3] = temp
 				case "int64":
+					// 创建一个长度为 parts 的 int64 切片
 					var temp = make([]int64, len(parts))
+					// 遍历 parts 切片，将每个元素转换为 int64 类型
 					for k, v := range parts {
 						temp[k], _ = strconv.ParseInt(v, 10, 64)
 					}
 				case "float64":
+					// 创建一个长度为 parts 的 float64 切片
 					var temp = make([]float64, len(parts))
+					// 遍历 parts 切片，将每个元素转换为 float64 类型
 					for k, v := range parts {
 						temp[k], _ = strconv.ParseFloat(v, 64)
 					}
+					// 将转换后的切片存入列表中
 					list[k2].(g.Map)[k3] = temp
 				default:
+					// 若未匹配到指定类型，直接将 parts 存入列表中
 					list[k2].(g.Map)[k3] = parts
 				}
-
 			}
-
 		}
 	}
-
+	// 返回处理后的列表
 	return list
 }
 
+// jsonFormat 将列表中指定字段的 JSON 字符串解析为 Go 数据结构
+// 参数:
+//   - list: 待处理的列表，包含多个元素，每个元素是一个 g.Map 类型
+//   - Items: 包含需要处理的 JSON 字段名称的切片
+// 返回值:
+//   - 处理后的列表
 func (s *Excel) jsonFormat(list []interface{}, Items []string) []interface{} {
+	// 遍历列表中的每个元素
 	for k2, v2 := range list {
+		// 遍历当前元素的每个键值对
 		for k3, v3 := range v2.(g.Map) {
+			// 检查当前键是否在需要处理的 JSON 字段列表中
 			if gstr.InArray(Items, k3) {
+				// 检查当前值是否为字符串类型
 				if _, ok := v3.(string); ok {
+					// 用于存储解析后的 JSON 数据
 					var get interface{}
+					// 将字符串解析为 JSON 数据
 					json.Unmarshal([]byte(v3.(string)), &get)
+					// 将解析后的 JSON 数据更新到列表中
 					list[k2].(g.Map)[k3] = get
 				} else {
+					// 如果不是字符串类型，记录错误日志
 					g.Log().Errorf(gctx.New(), "当前类型断言失败:%v,list=%v", v3, v2)
 				}
 			}
 		}
 	}
+	// 返回处理后的列表
 	return list
 }