UFL12-1——字符串拆分方法

前置知识点：string​ 中 Split​ 相关知识点（C#四部曲中）

实现文本工具类中的 字符串拆分方法

我们在配置表中，经常会配置如下格式的字符串数据，例如：

  • ​1,10;2,4;32,1​
  • 2,11|3,12|4,55​

遇到这种数据时，我们往往会使用string​中的Split​方法进行拆分

我们想要通过封装满足以下的需求

  1. 避免符号填写错误，英文字符填写成中文字符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    /// <summary>
    /// 拆分字符串，返回字符串数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static string[] SplitStr(string str, int type = 1)
    {
        if (str == "")
            return new string[0];
        string newStr = str;
        if (type == 1)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("；") != -1)
            {
                newStr = newStr.Replace("；", ";");
            }
            return newStr.Split(';');
        }
        else if (type == 2)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("，") != -1)
            {
                newStr = newStr.Replace("，", ",");
            }
            return newStr.Split(',');
        }
        else if (type == 3)
        {
            return newStr.Split('%');
        }
        else if (type == 4)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("：") != -1)
            {
                newStr = newStr.Replace("：", ":");
            }
            return newStr.Split(':');
        }
        else if (type == 5)
        {
            return newStr.Split(' ');
        }
        else if (type == 6)
        {
            return newStr.Split('|');
        }
        else if (type == 7)
        {
            return newStr.Split('_');
        }
        return new string[0];
    }

  2. 能够直接拆分获取到int​数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /// <summary>
    /// 拆分字符串 返回整形数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static int[] SplitStrToIntArr(string str, int type = 1)
    {
        string[] strs = SplitStr(str, type);
        if (str.Length == 0)
            return new int[0];
        //将字符串数组转换为整形数组
        return Array.ConvertAll<string, int>(strs, (str) =>
        {
            return int.Parse(str);
        });
    }

使用示例

1
2
3
4
5
6
7
8
9
10
11
void Start()
{
    string str = "1,10;2,4;32,1";
    string[] strs = TextUtil.SplitStr(str, 1);
    for (int i = 0; i < strs.Length; i++)
    {
        int[] ints = TextUtil.SplitStrToIntArr(strs[i], 2);
        print("道具ID：" + ints[0]);
        print("道具数量：" + ints[1]);
    }
}

输出：​image​

补充：拆分数值对的方法

由于类似于"1,10;2,4;32,1"​拆分为一个个键值对的需求较多，因此可以补充实现拆分键值对的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/// <summary>
/// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的数值对信息，并将其转换为整形数
/// </summary>
/// <param name="str">待拆分的字符串</param>
/// <param name="typeOne">数值对的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
/// <param name="typeTwo">数值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
/// <param name="callBack">传递数值对的回调函数</param>
public static void SplitStrToIntArrTwice(string str, int typeOne, int typeTwo, UnityAction<int, int> callBack)
{
    string[] strs = SplitStr(str, typeOne);
    if (strs.Length == 0)
        return;
    int[] ints;
    for (int i = 0; i < strs.Length; i++)
    {
        ints = SplitStrToIntArr(strs[i], typeTwo);
        if (ints.Length == 0)
            continue;
        callBack.Invoke(ints[0], ints[1]);
    }
}

/// <summary>
/// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的键值对信息，拆分为字符串
/// </summary>
/// <param name="str">待拆分的字符串</param>
/// <param name="typeOne">键值对分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
/// <param name="typeTwo">键值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
/// <param name="callBack">传递字符串对的回调函数</param>
public static void SplitStrwice(string str, int typeOne, int typeTwo, UnityAction<string, string> callBack)
{
    string[] strs1 = SplitStr(str, typeOne);
    if (strs1.Length == 0)
        return;
    string[] strs2;
    for (int i = 0; i < strs1.Length; i++)
    {
        strs2 = SplitStr(strs1[i], typeTwo);
        if (strs2.Length == 0)
            continue;
        callBack.Invoke(strs2[0], strs2[1]);
    }
}

使用示例：

1
2
3
4
5
6
7
8
9
void Start()
{
    string str = "1,10;2,4;32,1";
    TextUtil.SplitStrToIntArrTwice(str, 1, 2, (id, num) =>
    {
        print("道具ID" + id);
        print("道具数量" + num);
    });
}

输出：image​

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

/// <summary>
/// 用于处理字符串的一些公共功能
/// </summary>
public class TextUtil
{
    /// <summary>
    /// 拆分字符串，返回字符串数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static string[] SplitStr(string str, int type = 1)
    {
        if (str == "")
            return new string[0];
        string newStr = str;
        if (type == 1)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("；") != -1)
            {
                newStr = newStr.Replace("；", ";");
            }
            return newStr.Split(';');
        }
        else if (type == 2)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("，") != -1)
            {
                newStr = newStr.Replace("，", ",");
            }
            return newStr.Split(',');
        }
        else if (type == 3)
        {
            return newStr.Split('%');
        }
        else if (type == 4)
        {
            //为了避免英文符号填成中文符号，我们先进行一个替换
            while (newStr.IndexOf("：") != -1)
            {
                newStr = newStr.Replace("：", ":");
            }
            return newStr.Split(':');
        }
        else if (type == 5)
        {
            return newStr.Split(' ');
        }
        else if (type == 6)
        {
            return newStr.Split('|');
        }
        else if (type == 7)
        {
            return newStr.Split('_');
        }
        return new string[0];
    }

    /// <summary>
    /// 拆分字符串 返回整形数组
    /// </summary>
    /// <param name="str">想要被拆分的字符串</param>
    /// <param name="type">拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <returns>拆分出来的数组</returns>
    public static int[] SplitStrToIntArr(string str, int type = 1)
    {
        string[] strs = SplitStr(str, type);
        if (str.Length == 0)
            return new int[0];
        //将字符串数组转换为整形数组
        return Array.ConvertAll<string, int>(strs, (str) =>
        {
            return int.Parse(str);
        });
    }

    /// <summary>
    /// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的数值对信息，并将其转换为整形数
    /// </summary>
    /// <param name="str">待拆分的字符串</param>
    /// <param name="typeOne">数值对的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="typeTwo">数值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="callBack">传递数值对的回调函数</param>
    public static void SplitStrToIntArrTwice(string str, int typeOne, int typeTwo, UnityAction<int, int> callBack)
    {
        string[] strs = SplitStr(str, typeOne);
        if (strs.Length == 0)
            return;
        int[] ints;
        for (int i = 0; i < strs.Length; i++)
        {
            ints = SplitStrToIntArr(strs[i], typeTwo);
            if (ints.Length == 0)
                continue;
            callBack.Invoke(ints[0], ints[1]);
        }
    }

    /// <summary>
    /// 专门用来处理拆分类似于"1,10;2,20;3,30"这样的键值对信息，拆分为字符串
    /// </summary>
    /// <param name="str">待拆分的字符串</param>
    /// <param name="typeOne">键值对分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="typeTwo">键值对内部的分隔符，拆分字符类型：1-; 2-, 3-% 4-: 5-空格 6-| 7-_</param>
    /// <param name="callBack">传递字符串对的回调函数</param>
    public static void SplitStrwice(string str, int typeOne, int typeTwo, UnityAction<string, string> callBack)
    {
        string[] strs1 = SplitStr(str, typeOne);
        if (strs1.Length == 0)
            return;
        string[] strs2;
        for (int i = 0; i < strs1.Length; i++)
        {
            strs2 = SplitStr(strs1[i], typeTwo);
            if (strs2.Length == 0)
                continue;
            callBack.Invoke(strs2[0], strs2[1]);
        }
    }
}