package crud // //import ( // "context" // "errors" // "fmt" // "reflect" // "strings" // // "git.magicany.cc/black1552/gin-base/orm" //) // //// 定义上下文别名，保持原代码风格 //type ctx = context.Context // //// Paginate -------------------------- 分页结构体定义 -------------------------- //// Paginate 分页参数结构体（补全原代码中缺失的定义，保持功能完整） //type Paginate struct { // Page int // 页码（从1开始） // Limit int // 每页条数 //} // //// -------------------------- 全局常量 -------------------------- //// 分页相关字段，用于清理请求参数 //var pageInfo = []string{ // "page", // "size", // "num", // "limit", // "pagesize", // "pageSize", // "page_size", // "pageNum", // "pagenum", // "page_num", //} // //// Crud -------------------------- 泛型CURD核心结构体 -------------------------- //// Crud GORM 版本的泛型CURD封装，R为对应的模型结构体， C为对应模型结构体的字段结构体 //type Crud[R any] struct { // Dao orm.IDao[R] //} // //// -------------------------- 工具方法：字段名转换（保持原代码的命名风格转换） -------------------------- //// caseConvert 字段名风格转换（下划线 <-> 小驼峰） //func caseConvert(key string, toSnake bool) string { // if toSnake { // // 驼峰转下划线 // return toSnakeCase(key) // } // // 下划线转小驼峰 // return toCamelCase(key) //} // //// toSnakeCase 驼峰转下划线 //func toSnakeCase(s string) string { // if s == "" { // return "" // } // // var result strings.Builder // for i, r := range s { // if r >= 'A' && r <= 'Z' { // if i > 0 { // result.WriteRune('_') // } // result.WriteRune(r + 'a' - 'A') // } else { // result.WriteRune(r) // } // } // return result.String() //} // //// toCamelCase 下划线转小驼峰 //func toCamelCase(s string) string { // if s == "" { // return "" // } // // var result strings.Builder // upperNext := false // for i, r := range s { // if r == '_' && i < len(s)-1 { // upperNext = true // continue // } // if upperNext { // if r >= 'a' && r <= 'z' { // result.WriteRune(r - 'a' + 'A') // } else { // result.WriteRune(r) // } // upperNext = false // } else { // result.WriteRune(r) // } // } // return result.String() //} // //// BuildWhere -------------------------- 原BuildWhere对应实现：构建查询条件map -------------------------- //func (c Crud[R]) BuildWhere(req any, changeWhere any, subWhere any, removeFields []string, isSnake ...bool) map[string]any { // // 默认使用小写下划线方式 // toSnake := true // if len(isSnake) > 0 && !isSnake[0] { // toSnake = false // } // // // 1. 转换req为map并清理无效数据 // reqMap := convToMap(req) // cleanedReq := make(map[string]any) // // for k, v := range reqMap { // // 清理空值 // if isEmpty(v) { // continue // } // // 清理分页字段 // if strInArray(pageInfo, k) { // continue // } // // 清理指定移除字段 // if len(removeFields) > 0 && strInArray(removeFields, k) { // continue // } // // 转换字段名风格并存入 // cleanedReq[caseConvert(k, toSnake)] = v // } // // // 2. 处理changeWhere（修改查询操作符，如：eq -> gt） // if changeWhere != nil { // changeMap := convToMap(changeWhere) // for k, v := range changeMap { // // 跳过不存在于cleanedReq的字段 // if _, exists := cleanedReq[k]; !exists { // continue // } // // 跳过指定移除的字段 // if len(removeFields) > 0 && strInArray(removeFields, k) { // continue // } // // vMap := convToMap(v) // value, hasValue := vMap["value"] // op, hasOp := vMap["op"] // // if hasValue { // // 存在操作符则重构字段名（GORM支持 "字段名 >" 这种格式作为where key） // if hasOp && op != "" { // newKey := fmt.Sprintf("%s %s", k, op) // delete(cleanedReq, k) // cleanedReq[newKey] = value // } else { // cleanedReq[k] = value // } // } // } // } // // // 3. 字段名风格最终转换（确保一致性） // resultMap := make(map[string]any) // for k, v := range cleanedReq { // // 拆分字段名和操作符 // parts := strings.SplitN(k, " ", 2) // fieldName := parts[0] // opStr := "" // if len(parts) == 2 { // opStr = parts[1] // } // // // 转换字段名风格 // convertedField := caseConvert(fieldName, toSnake) // // // 重构带操作符的key // if opStr != "" { // resultMap[fmt.Sprintf("%s %s", convertedField, opStr)] = v // } else { // resultMap[convertedField] = v // } // } // // // 4. 合并subWhere附加条件 // if subWhere != nil { // subMap := convToMap(subWhere) // for k, v := range subMap { // resultMap[caseConvert(k, toSnake)] = v // } // } // // return resultMap //} // //// BuildMap -------------------------- 原 BuildMap 对应实现：构建变更条件 map -------------------------- //func (c Crud[R]) BuildMap(op string, value any, field ...string) map[string]any { // res := map[string]any{ // "op": op, // "field": "", // "value": value, // } // if len(field) > 0 { // res["field"] = field[0] // } // return res //} // //// WhereCondition -------------------------- AND/OR 查询条件结构体 -------------------------- //// WhereCondition 用于构建复杂的 AND/OR 查询条件 //type WhereCondition struct { // AND []interface{} // AND 条件列表 // OR []interface{} // OR 条件列表 //} // //// BuildWhereAndOr -------------------------- 新增：支持 AND 和 OR 的查询条件构建 -------------------------- //// BuildWhereAndOr 构建支持 AND 和 OR 混合使用的查询条件 //// 用法示例： //// //// where := crud.BuildWhereAndOr(). //// AND(map[string]any{"status": 1}). //// OR( //// map[string]any{"age": 18}, //// map[string]any{"name": "test"}, //// ). //// AND(map[string]any{"deleted": 0}). //// Build() //func (c Crud[R]) BuildWhereAndOr() *WhereBuilder[R] { // return &WhereBuilder[R]{ // conditions: make([]WhereCondition, 0), // crud: Crud[R]{ // Dao: c.Dao, // }, // } //} // //// WhereBuilder -------------------------- WHERE 条件构建器 -------------------------- //// WhereBuilder 流式构建 WHERE 条件（R 为模型类型参数） //type WhereBuilder[R any] struct { // conditions []WhereCondition // crud Crud[R] //} // //// AND 添加 AND 条件 //func (wb *WhereBuilder[R]) AND(conditions ...interface{}) *WhereBuilder[R] { // if len(conditions) > 0 { // wb.conditions = append(wb.conditions, WhereCondition{ // AND: conditions, // }) // } // return wb //} // //// OR 添加 OR 条件（OR 条件内部是或关系） //func (wb *WhereBuilder[R]) OR(conditions ...interface{}) *WhereBuilder[R] { // if len(conditions) > 0 { // wb.conditions = append(wb.conditions, WhereCondition{ // OR: conditions, // }) // } // return wb //} // //// Build 构建最终的查询条件 //// 返回格式：map[string]any 或者可以直接用于 GORM 的 Where 子句 //func (wb *WhereBuilder[R]) Build() interface{} { // if len(wb.conditions) == 0 { // return nil // } // // // 如果只有一个条件组，直接返回 // if len(wb.conditions) == 1 { // cond := wb.conditions[0] // if len(cond.AND) == 1 && len(cond.OR) == 0 { // return cond.AND[0] // } // if len(cond.OR) > 0 && len(cond.AND) == 0 { // return wb.buildORCondition(cond.OR) // } // } // // // 构建复杂的 AND/OR 混合条件 // var andConditions []interface{} // // for _, cond := range wb.conditions { // // 处理 AND 条件 // for _, andCond := range cond.AND { // andConditions = append(andConditions, andCond) // } // // // 处理 OR 条件（将 OR 条件作为一个整体添加到 AND 中） // if len(cond.OR) > 0 { // orCondition := wb.buildORCondition(cond.OR) // andConditions = append(andConditions, orCondition) // } // } // // // 如果只有一个条件，直接返回 // if len(andConditions) == 1 { // return andConditions[0] // } // // // 返回 AND 条件数组 // return andConditions //} // //// buildORCondition 构建 OR 条件 //func (wb *WhereBuilder[R]) buildORCondition(orConds []interface{}) map[string]interface{} { // if len(orConds) == 0 { // return nil // } // // // 如果只有一个 OR 条件，直接返回 // if len(orConds) == 1 { // return map[string]interface{}{ // "OR": orConds[0], // } // } // // // 多个 OR 条件 // return map[string]interface{}{ // "OR": orConds, // } //} // //// BuildWhereGORM -------------------------- 新增：GORM 原生语法构建 WHERE 条件（支持 AND/OR） -------------------------- //// BuildWhereGORM 使用 GORM 原生语法构建复杂的 AND/OR 查询条件 //// 用法示例 1 - 纯 AND 条件： //// //// db.Where("age > ?", 18).Where("status = ?", 1) //// //// 用法示例 2 - OR 条件： //// //// db.Where(db.Where("name = ?", "john").Or("name = ?", "jane")) //// //// 用法示例 3 - 混合使用： //// //// db.Where("status = ?", 1). //// Where(db.Where("age >= ?", 18).Or("age < ? AND vip = ?", 18, true)). //// Find(&users) //func (c Crud[R]) BuildWhereGORM(query interface{}, args ...interface{}) *GORMWhereBuilder[R] { // return &GORMWhereBuilder[R]{ // Pool: c.Dao.DB(), // crud: c, // query: query, // args: args, // } //} // //// GORMWhereBuilder -------------------------- GORM 原生 WHERE 构建器 -------------------------- //// GORMWhereBuilder 使用 GORM 原生 API 构建复杂查询（R 为模型类型参数） //type GORMWhereBuilder[R any] struct { // *orm.Pool // crud Crud[R] // query interface{} // args []interface{} //} // //// Where 添加 WHERE 条件（AND 关系） //func (gwb *GORMWhereBuilder[R]) Where(query interface{}, args ...interface{}) *GORMWhereBuilder[R] { // // 如果当前已经有查询条件，先应用 // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // gwb.query = nil // gwb.args = nil // } // return gwb.Where(query, args...) //} // //// Or 添加 OR 条件 //func (gwb *GORMWhereBuilder[R]) Or(query interface{}, args ...interface{}) *GORMWhereBuilder[R] { // // 如果当前有未应用的查询条件，先应用 // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // gwb.query = nil // gwb.args = nil // } // return gwb.Or(query, args...) //} // //// Not 添加 NOT 条件 //func (gwb *GORMWhereBuilder[R]) Not(query interface{}, args ...interface{}) *GORMWhereBuilder[R] { // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // gwb.query = nil // gwb.args = nil // } // gwb = gwb.Not(query, args...) // return gwb //} // //// Find 执行查询并返回结果 //func (gwb *GORMWhereBuilder[R]) Find(items interface{}) error { // // 应用剩余的查询条件 // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // } // return gwb.Model(new(R)).Find(items).Error //} // //// First 查询第一条记录 //func (gwb *GORMWhereBuilder[R]) First(result interface{}) error { // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // } // // return gwb.Model(new(R)).First(result) //} // //// Count 统计记录数 //func (gwb *GORMWhereBuilder[R]) Count(count *int64) error { // if gwb.query != nil { // gwb = gwb.Where(gwb.query, gwb.args...) // } // result := gwb.Model(new(R)).Count(count) // return result.Error //} // //// ClearField -------------------------- 原ClearField对应实现：清理请求参数并返回有效map -------------------------- //func (c Crud[R]) ClearField(req any, delField []string, subField ...map[string]any) map[string]any { // reqMap := convToMap(req) // resultMap := make(map[string]any) // // // 过滤无效数据和指定删除字段 // for k, v := range reqMap { // if isEmpty(v) { // continue // } // if strInArray(pageInfo, k) { // continue // } // if len(delField) > 0 && strInArray(delField, k) { // continue // } // resultMap[k] = v // } // // // 合并附加字段 // if len(subField) > 0 && subField[0] != nil { // for k, v := range subField[0] { // resultMap[k] = v // } // } // // return resultMap //} // //// ClearFieldPage -------------------------- 原 ClearFieldPage 对应实现：清理参数 + 分页查询 -------------------------- //func (c Crud[R]) ClearFieldPage(ctx ctx, req any, delField []string, where any, page *Paginate, order string, with map[string]interface{}) (items []*R, total int64, err error) { // // 1. 清理请求参数 // filterMap := c.ClearField(req, delField) // // // 2. 初始化 ORM 查询 // db := c.Dao.Ctx(ctx) // // // 注意：orm 包不支持 Preload，如需关联查询需手动处理 // _ = with // 忽略 with 参数 // // // 3. 构建查询条件 // db = db.Where(filterMap) // if where != nil { // db = db.Where(where) // } // // // 4. 排序 // if order != "" { // db = db.OrderBy(order) // } // // // 5. 统计总数 // total, err = db.Count(&total) // if err != nil { // return nil, 0, err // } // // // 6. 分页查询 // if page != nil && page.Limit > 0 { // offset := (page.Page - 1) * page.Limit // db = db.Offset(offset).Limit(page.Limit) // } // // // 7. 执行查询 // results, err := db.Find(&items) // if err != nil { // return nil, 0, results.Error // } // return //} // //// ClearFieldList -------------------------- 原 ClearFieldList 对应实现：清理参数 + 列表查询（不分页） -------------------------- //func (c Crud[R]) ClearFieldList(ctx ctx, req any, delField []string, where any, order any, with map[string]interface{}) (items []*R, err error) { // filterMap := c.ClearField(req, delField) // db := c.Dao.Ctx(ctx) // // // 注意：orm 包不支持 Preload // _ = with // // if where != nil { // db = db.Where(where) // } // if order != nil { // db = db.OrderBy(order) // } // // results, err := db.Where(filterMap).Find(&items) // if err != nil { // return nil, results.Error // } // return //} // //// ClearFieldOne -------------------------- 原 ClearFieldOne 对应实现：清理参数 + 单条查询 -------------------------- //func (c Crud[R]) ClearFieldOne(ctx ctx, req any, delField []string, where any, order any, with map[string]interface{}) (item *R, err error) { // item = new(R) // filterMap := c.ClearField(req, delField) // db := c.Dao.Ctx(ctx) // // // 注意：orm 包不支持 Preload // _ = with // // if where != nil { // db = db.Where(where) // } // if order != nil { // db = db.OrderBy(order) // } // // err = db.Where(filterMap).First(item) // if err != nil { // panic("未找到数据") // } // return //} // //// Value -------------------------- 原Value对应实现：查询单个字段值 -------------------------- //func (c Crud[R]) Value(ctx ctx, where any, field any) (interface{}, error) { // var result interface{} // db := c.Dao.Ctx(ctx).Model(new(R)).Where(where) // // // 处理字段参数 // if field != nil { // fieldStr, ok := field.(string) // if !ok || fieldStr == "" { // fieldStr = "*" // } // db = db.Select(fieldStr) // } else { // db = db.Select("*") // } // // // 执行查询（取第一条记录的指定字段） // err := db.First(&result).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic("未找到数据") // } // return result, err //} // //// DeletePri -------------------------- 原DeletePri对应实现：按主键删除 -------------------------- //func (c Crud[R]) DeletePri(ctx ctx, primaryKey any) error { // db := c.Dao.Ctx(ctx).Model(new(R)) // // 按主键字段构建查询 // pk := c.Dao.PrimaryKey() // if pk == "" { // panic("主键字段未配置") // } // return db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).Delete(new(R)).Error //} // //// DeleteWhere -------------------------- 原DeleteWhere对应实现：按条件删除 -------------------------- //func (c Crud[R]) DeleteWhere(ctx ctx, where any) error { // return c.Dao.Ctx(ctx).Model(new(R)).Where(where).Delete(new(R)).Error //} // //// Sum -------------------------- 原Sum对应实现：字段求和 -------------------------- //func (c Crud[R]) Sum(ctx ctx, where any, field string) float64 { // var sum float64 // if field == "" { // panic("求和字段不能为空") // } // // err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Select(fmt.Sprintf("SUM(%s) as sum", field)).Scan(&sum).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic("未找到数据") // } // return sum //} // //// ArrayField -------------------------- 原ArrayField对应实现：查询指定字段数组 -------------------------- //func (c Crud[R]) ArrayField(ctx ctx, where any, field any) []interface{} { // var result []interface{} // db := c.Dao.Ctx(ctx).Model(new(R)).Where(where) // // // 处理字段参数 // if field != nil { // fieldStr, ok := field.(string) // if !ok || fieldStr == "" { // fieldStr = "*" // } // db = db.Select(fieldStr) // } else { // db = db.Select("*") // } // // // 执行查询 // err := db.Find(&result).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic("未找到数据") // } // return result //} // //// FindPri -------------------------- 原FindPri对应实现：按主键查询单条记录 -------------------------- //func (c Crud[R]) FindPri(ctx ctx, primaryKey any, with map[string]func(db *gorm.DB) *gorm.DB) (model *R) { // model = new(R) // db := c.Dao.Ctx(ctx).Model(model) // pk := c.Dao.PrimaryKey() // // if pk == "" { // panic("主键字段未配置") // } // if with != nil { // for k, v := range with { // db = db.Preload(k, v) // } // } // // // 按主键查询 // err := db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).First(model).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic("未找到数据") // } // return //} // //// -------------------------- 原First对应实现：按条件查询第一条记录 -------------------------- //func (c Crud[R]) First(ctx ctx, where any, order any, with map[string]func(db *gorm.DB) *gorm.DB) (model *R) { // model = new(R) // db := c.Dao.Ctx(ctx).Model(model) // // if with != nil { // for k, v := range with { // db = db.Preload(k, v) // } // } // if where != nil { // db = db.Where(where) // } // if order != nil { // db = db.Order(order) // } // // err := db.First(model).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic("未找到数据") // } // return //} // //// -------------------------- 原Exists对应实现：判断记录是否存在 -------------------------- //func (c Crud[R]) Exists(ctx ctx, where any) (exists bool) { // var count int64 // err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Count(&count).Error // if err != nil { // panic(fmt.Sprintf("Exists查询错误: %v", err)) // } // return count > 0 //} // //// -------------------------- 原All对应实现：查询所有符合条件的记录 -------------------------- //func (c Crud[R]) All(ctx ctx, where any, order any, with map[string]func(db *gorm.DB) *gorm.DB) (items []*R) { // db := c.Dao.Ctx(ctx).Model(new(R)) // // if with != nil { // for k, v := range with { // db = db.Preload(k, v) // } // } // if where != nil { // db = db.Where(where) // } // if order != nil { // db = db.Order(order) // } // // err := db.Find(&items).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic(fmt.Sprintf("All查询错误: %v", err)) // } // return //} // //// -------------------------- 原Count对应实现：统计记录总数 -------------------------- //func (c Crud[R]) Count(ctx ctx, where any) (count int64) { // err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Count(&count).Error // if errors.Is(err, gorm.ErrRecordNotFound) { // panic(fmt.Sprintf("Count查询错误: %v", err)) // } // return //} // //// -------------------------- 原Save对应实现：新增/更新记录（对应GORM的Save） -------------------------- //func (c Crud[R]) Save(ctx ctx, data any) { // err := c.Dao.Ctx(ctx).Model(new(R)).Create(data).Error // if err != nil { // panic(fmt.Sprintf("Save保存错误: %v", err)) // } //} // //// -------------------------- 原Update对应实现：按条件更新记录 -------------------------- //func (c Crud[R]) Update(ctx ctx, where any, data any) (count int64) { // result := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Updates(data) // if errors.Is(result.Error, gorm.ErrRecordNotFound) { // panic(fmt.Sprintf("Update更新错误: %v", result.Error.Error())) // } // return result.RowsAffected //} // //// -------------------------- 原UpdatePri对应实现：按主键更新记录 -------------------------- //func (c Crud[R]) UpdatePri(ctx ctx, primaryKey any, data any) (count int64) { // db := c.Dao.Ctx(ctx).Model(new(R)) // pk := c.Dao.PrimaryKey() // // if pk == "" { // panic("主键字段未配置") // } // // result := db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).Updates(data) // if errors.Is(result.Error, gorm.ErrRecordNotFound) { // panic(fmt.Sprintf("UpdatePri更新错误: %v", result.Error.Error())) // } // return result.RowsAffected //} // //// -------------------------- 原Paginate对应实现：分页查询 -------------------------- //func (c Crud[R]) Paginate(ctx context.Context, where any, p Paginate, with map[string]func(db *gorm.DB) *gorm.DB, order any) (items []*R, total int64) { // db := c.Dao.Ctx(ctx).Model(new(R)) // // // 1. 构建查询条件 // if where != nil { // db = db.Where(where) // } // // // 2. 统计总数 // if err := db.Count(&total).Error; err != nil { // panic(fmt.Sprintf("Paginate查询错误: %v", err)) // } // // // 3. 关联查询 // if with != nil { // for k, v := range with { // db = db.Preload(k, v) // } // } // // // 4. 排序 // if order != nil { // db = db.Order(order) // } // // // 5. 分页（offset = (页码-1)*每页条数） // if p.Limit > 0 { // offset := (p.Page - 1) * p.Limit // db = db.Offset(offset).Limit(p.Limit) // } // // // 6. 执行查询 // err := db.Find(&items).Error // if err != nil || errors.Is(err, gorm.ErrRecordNotFound) { // panic(fmt.Sprintf("Paginate查询错误: %v", err)) // } // return //} // //// -------------------------- 内部辅助工具函数 -------------------------- //// convToMap 将任意类型转换为map[string]any（简化版，适配常见场景） //func convToMap(v any) map[string]any { // if v == nil { // return make(map[string]any) // } // // val := reflect.ValueOf(v) // // 处理指针类型 // if val.Kind() == reflect.Ptr { // val = val.Elem() // } // // // 只处理结构体和map类型 // if val.Kind() != reflect.Struct && val.Kind() != reflect.Map { // return make(map[string]any) // } // // result := make(map[string]any) // // if val.Kind() == reflect.Map { // // 处理map类型 // for _, key := range val.MapKeys() { // keyStr, ok := key.Interface().(string) // if !ok { // continue // } // result[keyStr] = val.MapIndex(key).Interface() // } // } else { // // 处理结构体类型 // typ := val.Type() // for i := 0; i < val.NumField(); i++ { // field := typ.Field(i) // fieldVal := val.Field(i) // // // 获取json标签作为key（优先），否则用字段名 // jsonTag := field.Tag.Get("json") // if jsonTag == "" || jsonTag == "-" { // jsonTag = field.Name // } else { // // 分割json标签（忽略omitempty等选项） // jsonTag = strings.Split(jsonTag, ",")[0] // } // // result[jsonTag] = fieldVal.Interface() // } // } // // return result //} // //// isEmpty 判断值是否为空 //func isEmpty(v any) bool { // if v == nil { // return true // } // // val := reflect.ValueOf(v) // switch val.Kind() { // case reflect.String: // return val.String() == "" // case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: // return val.Int() == 0 // case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: // return val.Uint() == 0 // case reflect.Float32, reflect.Float64: // return val.Float() == 0 // case reflect.Bool: // return !val.Bool() // case reflect.Slice, reflect.Array, reflect.Map, reflect.Chan: // return val.Len() == 0 // case reflect.Ptr, reflect.Interface: // return val.IsNil() // default: // return false // } //} // //// strInArray 判断字符串是否在数组中 //func strInArray(arr []string, str string) bool { // for _, v := range arr { // if strings.EqualFold(v, str) { // 忽略大小写比较 // return true // } // } // return false //}