goProject/trunk/goutil/stringUtil/split.go

331 lines
7.5 KiB
Go
Raw Permalink Normal View History

2025-01-06 16:01:02 +08:00
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
}