# golang_tools

**Repository Path**: yw-seventy-seven/golang_tools

## Basic Information

- **Project Name**: golang_tools
- **Description**: golang工具库，包含一些常用的数据处理方法，一个万能的数据结构和基于该结构的众多方法
- **Primary Language**: Go
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-11-18
- **Last Updated**: 2024-03-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: SQL, 数据存储, 通用数据结构

## README

# golang_tools

#### 介绍
golang工具库
```
supervalue 通用数据结构，基本支持golang的所有数据结构,提供大量快速处理数据的方法,支持json字符串解析为supervalue
```
```
sqlpase    基于supervalue,目标是通过配置或特定的字符串将参数自动转化为sql条件语句，并是实现sql的执行和字段的快速映射
```
#### 软件架构
软件架构说明




#### 使用说明
supervalue
	

//创建数组
```
	a := NewSVArray()
	//默认所有向数组添加的元素的方法会将当前的数据类型转变为数组
	//顺序添加元素
	a.ArrayAppendValue("abc")
	//批量添加
	a.ArrayAppendValues("abc", 123, &[]interface{}{1, 2, "efg"}, struct {
		Ts int
	}{1}, map[int]string{1: "aaa"})
	//fmt.Println(a)
	//按下标添加
	a.SetIndexValue(0, "mn")
	//fmt.Println(a)
	//对象数组或字符串的长度
	fmt.Println(a.Length())
	//获取下标元素
	s := a.ValueByIndex(0)
	fmt.Println("s的值：", s)
	//按类型获取下标元素
	c := a.AsStringByIndex(2, "")
	//或者
	d := a.ValueByIndex(2).String()
	fmt.Println("c的值:", c, "d的值:", d)
	//按浮点型根据指定精度获取下标元素
	//四舍五入保留一位小数
	a.ValueByIndex(2).Round(1)
	//向下取整保留小数点前1位
	a.ValueByIndex(2).Ceil(-1)
	//向上取整保留小数点前一位
	a.ValueByIndex(2).Floor(-1)
	//判断元素是否与supervalue等价,可比较复合类型
	res := a.ValueByIndex(4).IsEquaEx(map[string]int{"Ts": 1})
	fmt.Println(res)
	//查找元素在数组中的位置不论层级,不存在时返回nil
	aa := a.SearchFilesEX("efg")
	//fmt.Println(aa)
	//返回当前元素的上级,不存在时返回nil
	fmt.Println(aa.Super())
	//直接给当前元素赋值,当前元素会根据变量自动转化类型
	aa.Super().SetValue(123)
	fmt.Println(a)
	//将supervalue转化为基本数据结构 map,array和基本数据类型
	fmt.Println(a.Interface())
	//移除下标元素
	fmt.Println(a.RemoveIndexFile(0))
	//获取子切片
	fmt.Println(a.Child(0, 2))
```
//创建对象
	
```
a := NewSVObject()
	//创建对象的同时添加元素
	a = NewSVObjByKeyValues("ef", 1234, "abc", "222")
	//向对象中添加元素
	a.SetKeyValue("a", 123)
	//移除键值对
	a.RemoveFiles("a")
	//批量添加
	a.SetKeyValues("a", 123, "e", []string{"123", "456", "345"})
	//修改对象键值的名称
	a.ChangValueName(func(m map[string]string) {
		m["ef"] = "1"
		m["abc"] = "2"
	})
	fmt.Println(a)
	//按键值获取对象
	a.ValueByName("1")
	//按指定类型获取键值
	a.StringByName("1", "")
	//查找元素在对象中的位置
	s := a.SearchKeysEx("1", 1234)
	fmt.Println(s, s.Super())
	//获取数组或对象中第一个元素和最后一个元素
	fmt.Println(a.GetFirstValue(), a.GetLastValue())
	//检查指定的键值是否存,不存在时可以创建
	a.CheckKeysExists("2;3", func(s string) interface{} {
		fmt.Println(s)
		return nil
	})
```
//其他

```
a := NewSVArray().SetValue([]interface{}{"-4", "9", "1", 2, "3", 4.5, 4.5, 2, "3"})
	//合并一个数组或对象
	a.Merge([]string{"90", "10"})
	//去重,对复合类型同样适用
	fmt.Println(a.DedupArry())
	//遍历数组或对象
	a.Range(func(key string, val *SuperValue) bool {
		fmt.Println(val)
		return true
	})
	//指定条件获取数组最大值和最小值
	fmt.Println(a.Max(0, func(f float64) bool {
		if f > 3 {
			return false
		}
		return true
	}), a.Min(0, func(f float64) bool {
		if f < 2 {
			return false
		}
		return true
	}))
	//求和,平均
	fmt.Println(a.Total(), a.Average())
	//按指定条件过滤数组或对象数据求和
	fmt.Println(a.TotalByFilterSV(func(s string, value *SuperValue) bool {
		if value.Int() > 1 {
			return true
		}
		return false
	}))
	//数组或对象排序,过滤
	fmt.Println(a.Sort(func(key1, key2 string, val1, val2 SuperValue) bool {
		return val1.Float64() < val2.Float64()
	}).Filter(func(key string, val *SuperValue) bool {
		if val.Float64() > 0 {
			return true
		}
		return false
	}))
```
//json解析

```
	str := `{
    "code": 0,
    "data": [
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        },
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        },
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        },
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        },
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        },
        {
            "fid": "01\u53F7\u670D",
            "fe": "nan",
            "fn": "nan",
            "fu": "nan"
        }
    ],
    "total": 9615
}`
	a := NewSVArray()
	err := a.JsonParseFromByteEX([]byte(str))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	//fmt.Println(a)
	as, _ := a.ValueByName("data").DivKDatas("fid,fe", "_", -1, -1)
	fmt.Println(as)
```

sqlparse 

```
	str := `{
		"a":[1,3,4,5],
		"b":"",
		"c":"c,c,c",
		"d":[],
		"e":[1,2,34,4]
	   }`
	data := NewSVArray()
	data.JsonParseFromByteEX([]byte(str))
	stl := NewSqlParse(data)
	/*
	   语法解析器   注意函数的所有小（）变为{} 默认排除所有空字符串
	   ! % ^abc  [,1] >=< :func{} %    结束符号[&,|,(,)]|$
	   取反 前端模糊匹配 字段值 连接符号 数据库字段名称 [数组转化方式 下标]
	*/
	stl.Table(func(tb *SqlParse) {
		tb.Table("efg").Select("*").Set("id=?", nil, 1)
	}, "asg").Select().SetStrCondition("(!a%&b)|(c[,0]|!e[1]>=:replace{id,'a',''})*1")
	fmt.Println(stl.Res(false))
	// 转化sql: select a,b,c,d,e from ( select * from efg   where id=? ) asg  where (  a not like ? and a not like ? and a not like ? and a not like ? ) or  (   c  = ?  or   replace{id,'a',''})*1  <= ?   )
	// 占位参数: [1 1% 3% 4% 5% c 2]
	stl.Clear()
	//或者
	stl.Table(func(tb *SqlParse) {
		tb.Table("efg").Select("*").Set("id=?", nil, 1)
	}, "asg").Select().Bracket(func(t *SqlParse) {
		t.Set("a", &ParamsConfig{
			Negate:   true,
			SufMatch: true,
			Ignore:   true,
			Index:    -1,
		}).AndSet("b", NewParamsConfig())
	}).OrBracket(func(t *SqlParse) {
		t.Set("c", &ParamsConfig{
			Index:  0,
			Split:  []string{","},
			Ignore: true,
		}).OrSet("e", &ParamsConfig{
			Negate: true,
			Index:  1,
			DBName: " replace{id,'a',''})*1",
		})
	})
	fmt.Print(stl.Res(false))
	//测试
		str1 := `{
    "fid":"1111",
    "fpass":"9999"
}`
	data1 := NewSVArray()
	data1.JsonParseFromByteEX([]byte(str1))
	sel := NewSqlParse(data1).ConfigDBCon("mysql", "supportAdmin:Kpl#2023!@tcp(xxxxx:xxxx)/xxxxxx?charset=utf8&parseTime=true&loc=Local")
	defer sel.Close()
	res := sel.Table("gnss_data").Select("fname,fpassword").Limit("1").OrderBy("fname desc").GroupBy("fname,fpassword").Exec()
	fmt.Println(res.ReName("fname", "name").Fileter("fpassword").MapFiles()) //修改字段名称,过滤字段,映射查询结果
	fmt.Println(res.Row())    //根据sql的类型结果不同,select 返回结果为数据的总数量,其他返回影响行数

```
文本编辑功能
```
	a := NewTXSave("ax")
	a.Write("abc.txt",[]map[string]int{{"aa":1,"bb":2,"cc":3},{"aa":12,"bb":22,"cc":32}})
	a.RemoveKeyValues("abc.txt", func(s string, value *SuperValue) bool {
	if value.StringByName("aa","")=="1"{
		return true
	}
		return false
	})
	a.ReadByFunc("satc2327923279.SIS", func(str string) []string {
		l := strings.Split(str, " ")
		var res []string
		for _, v := range l {
			if v != "" {
				res = append(res, v)
			}
		}
		return res
	}, func(line int, str string) []string {
		l := strings.Split(str, " ")
		var res []string
		for _, v := range l {
			if v != "" {
				res = append(res, v)
			}

		}
		return append([]string{res[0] + " " + res[1]}, res[2:]...)
	})
	fmt.Println(a.ReadFile.File)
```