331 lines
7.5 KiB
Go
331 lines
7.5 KiB
Go
package stringUtil
|
||
|
||
import (
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"goutil/mathUtil"
|
||
)
|
||
|
||
// 使用多分隔符来进行分割(默认分隔符为：",", ";", ":", "|", "||")
|
||
// eg:1,2;3|4||5,6;7|8||9
|
||
// 返回值:
|
||
// []string
|
||
func Split(s string, seps []string) []string {
|
||
retList := make([]string, 0, 32)
|
||
|
||
// 如果seps为nil，则使用默认值
|
||
if seps == nil {
|
||
seps = []string{",", ";", ":", "|", "||"}
|
||
}
|
||
|
||
// 根据所有的分隔符来一点一点地切割字符串，直到不可切割为止
|
||
for {
|
||
startIndex := len(s) - 1
|
||
endIndex := 0
|
||
exists := false
|
||
|
||
// 遍历，找到第一个分割的位置
|
||
for _, sep := range seps {
|
||
index := strings.Index(s, sep)
|
||
|
||
// 如果找到有匹配项，则寻找最小的pos，如果有多个相同的pos，则使用长度最长的分隔符
|
||
if index > -1 {
|
||
exists = true
|
||
|
||
// 说明有多个有效的分隔符，如|和||
|
||
if index < startIndex {
|
||
startIndex = index
|
||
endIndex = startIndex + len(sep) - 1
|
||
} else if index == startIndex {
|
||
if startIndex+len(sep)-1 > endIndex {
|
||
endIndex = startIndex + len(sep) - 1
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有找到匹配的pos，则分割过程结束
|
||
if !exists {
|
||
retList = append(retList, s)
|
||
break
|
||
}
|
||
|
||
// 切割字符串
|
||
sub := s[:startIndex]
|
||
if sub != "" {
|
||
retList = append(retList, sub)
|
||
}
|
||
s = s[endIndex+1:]
|
||
}
|
||
|
||
return retList
|
||
}
|
||
|
||
// 将字符串切割为[]int
|
||
// str:输入字符串
|
||
// 返回值:
|
||
// []int
|
||
// error
|
||
func SplitToIntSlice(s, sep string) ([]int, error) {
|
||
// 先按照分隔符进行切割
|
||
strSlice := strings.Split(s, sep)
|
||
|
||
// 定义int slice
|
||
intSlice := make([]int, 0, len(strSlice))
|
||
for _, value := range strSlice {
|
||
// 去除空格
|
||
if value = strings.TrimSpace(value); value == "" {
|
||
continue
|
||
}
|
||
|
||
if value_int, err := strconv.Atoi(value); err != nil {
|
||
return nil, err
|
||
} else {
|
||
intSlice = append(intSlice, value_int)
|
||
}
|
||
}
|
||
|
||
return intSlice, nil
|
||
}
|
||
|
||
// 将字符串切割为[]int32
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// []int
|
||
// error
|
||
func SplitToInt32Slice(s, sep string) ([]int32, error) {
|
||
// 先获得int slice
|
||
count := 0
|
||
intSlice, err := SplitToIntSlice(s, sep)
|
||
if err != nil {
|
||
return nil, err
|
||
} else {
|
||
count = len(intSlice)
|
||
}
|
||
|
||
// 定义int32 slice
|
||
int32Slice := make([]int32, 0, count)
|
||
for _, item := range intSlice {
|
||
int32Slice = append(int32Slice, int32(item))
|
||
}
|
||
|
||
return int32Slice, nil
|
||
}
|
||
|
||
// 将字符串切割为[]int64
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// []int64
|
||
// error
|
||
func SplitToInt64Slice(s, sep string) ([]int64, error) {
|
||
// 先获得int slice
|
||
count := 0
|
||
intSlice, err := SplitToIntSlice(s, sep)
|
||
if err != nil {
|
||
return nil, err
|
||
} else {
|
||
count = len(intSlice)
|
||
}
|
||
|
||
// 定义int32 slice
|
||
int64Slice := make([]int64, 0, count)
|
||
for _, item := range intSlice {
|
||
int64Slice = append(int64Slice, int64(item))
|
||
}
|
||
|
||
return int64Slice, nil
|
||
}
|
||
|
||
// 将字符串切割为[]float64
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// []float64
|
||
// error
|
||
func SplitToFloat64Slice(s, sep string) ([]float64, error) {
|
||
// 先按照分隔符进行切割
|
||
strSlice := strings.Split(s, sep)
|
||
|
||
// 定义float64 slice
|
||
floatSlice := make([]float64, 0, len(strSlice))
|
||
for _, value := range strSlice {
|
||
// 去除空格
|
||
if value = strings.TrimSpace(value); value == "" {
|
||
continue
|
||
}
|
||
|
||
if value_float, err := strconv.ParseFloat(value, 64); err != nil {
|
||
return nil, err
|
||
} else {
|
||
floatSlice = append(floatSlice, value_float)
|
||
}
|
||
}
|
||
|
||
return floatSlice, nil
|
||
}
|
||
|
||
// 将字符串切割为map[int32]int32
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// map[int32]float32
|
||
// error
|
||
func SplitToDict_KintVint(s, outerSep, innerSep string) (map[int32]int32, error) {
|
||
// 先按照分隔符进行切割
|
||
outerSlice := strings.Split(s, outerSep)
|
||
|
||
// 定义map[int32]float32
|
||
floatMap := make(map[int32]int32, len(outerSlice))
|
||
for _, itemStr := range outerSlice {
|
||
innerSlice := strings.Split(strings.TrimSpace(itemStr), innerSep)
|
||
key := strings.TrimSpace(innerSlice[0])
|
||
value := strings.TrimSpace(innerSlice[1])
|
||
|
||
key_int, err := strconv.Atoi(key)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
value_int, err := strconv.Atoi(value)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
floatMap[int32(key_int)] = int32(value_int)
|
||
}
|
||
return floatMap, nil
|
||
}
|
||
|
||
// 将字符串切割为map[int32]string
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// map[int32]string
|
||
// error
|
||
func SplitToDict_KintVstring(s, outerSep, innerSep string) (map[int32]string, error) {
|
||
// 先按照分隔符进行切割
|
||
outerSlice := strings.Split(s, outerSep)
|
||
|
||
// 定义map[int32]string
|
||
resultMap := make(map[int32]string, len(outerSlice))
|
||
for _, itemStr := range outerSlice {
|
||
innerSlice := strings.Split(strings.TrimSpace(itemStr), innerSep)
|
||
key := strings.TrimSpace(innerSlice[0])
|
||
value := strings.TrimSpace(innerSlice[1])
|
||
|
||
key_int, err := strconv.Atoi(key)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
resultMap[int32(key_int)] = value
|
||
}
|
||
return resultMap, nil
|
||
}
|
||
|
||
// 将字符串切割为map[int32]float32
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// map[int32]float32
|
||
// error
|
||
func SplitToDict_KintVfloat(s, outerSep, innerSep string) (map[int32]float32, error) {
|
||
// 先按照分隔符进行切割
|
||
outerSlice := strings.Split(s, outerSep)
|
||
|
||
// 定义map[int32]float32
|
||
floatMap := make(map[int32]float32, len(outerSlice))
|
||
for _, itemStr := range outerSlice {
|
||
innerSlice := strings.Split(strings.TrimSpace(itemStr), innerSep)
|
||
key := strings.TrimSpace(innerSlice[0])
|
||
value := strings.TrimSpace(innerSlice[1])
|
||
|
||
key_int, err := strconv.Atoi(key)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
value_float, err := strconv.ParseFloat(value, 64)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
floatMap[int32(key_int)] = float32(value_float)
|
||
}
|
||
return floatMap, nil
|
||
}
|
||
|
||
// 将字符串切割为map[int32]float32
|
||
// s:输入字符串
|
||
// 返回值:
|
||
// map[int32]float32
|
||
// error
|
||
func SplitToDict_KintVfloat64(s, outerSep, innerSep string) (map[int32]float64, error) {
|
||
// 先按照分隔符进行切割
|
||
outerSlice := strings.Split(s, outerSep)
|
||
|
||
// 定义map[int32]float32
|
||
floatMap := make(map[int32]float64, len(outerSlice))
|
||
for _, itemStr := range outerSlice {
|
||
innerSlice := strings.Split(strings.TrimSpace(itemStr), innerSep)
|
||
key := strings.TrimSpace(innerSlice[0])
|
||
value := strings.TrimSpace(innerSlice[1])
|
||
|
||
key_int, err := strconv.Atoi(key)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
value_float, err := strconv.ParseFloat(value, 64)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
floatMap[int32(key_int)] = float64(value_float)
|
||
}
|
||
return floatMap, nil
|
||
}
|
||
|
||
// 将字符串切割为IntRegion列表
|
||
// s:输入字符串，形如：1-200,201-400,401-1000
|
||
// outerSep:外部分隔符
|
||
// innerSep:内部分隔符
|
||
// 返回值：
|
||
// IntRegion列表
|
||
// 错误对象
|
||
func SplitToIntRegion(s, outerSep, innerSep string) (intRegionList []*mathUtil.IntRegion, err error) {
|
||
if s == "" {
|
||
err = fmt.Errorf("Input is empty")
|
||
return
|
||
}
|
||
|
||
outerRegionList := make([]string, 0, 4)
|
||
outerRegionList = strings.Split(s, outerSep)
|
||
if len(outerRegionList) == 0 {
|
||
err = fmt.Errorf("%s:Format invalid. Such as:1-100,101-200", s)
|
||
return
|
||
}
|
||
|
||
for _, item := range outerRegionList {
|
||
innerRegionList := make([]string, 0, 2)
|
||
innerRegionList = strings.Split(item, innerSep)
|
||
if len(innerRegionList) != 2 {
|
||
err = fmt.Errorf("%s:Format invalid. Such as:1-100", item)
|
||
return
|
||
}
|
||
|
||
var lower, upper int
|
||
lower, err = strconv.Atoi(innerRegionList[0])
|
||
if err != nil {
|
||
return
|
||
}
|
||
upper, err = strconv.Atoi(innerRegionList[1])
|
||
if err != nil {
|
||
return
|
||
}
|
||
if lower > upper {
|
||
err = fmt.Errorf("lower:%d should less than upper:%d", lower, upper)
|
||
return
|
||
}
|
||
|
||
intRegionList = append(intRegionList, mathUtil.NewIntRegion(lower, upper))
|
||
}
|
||
|
||
return
|
||
}
|