UFL12-3——秒转时间字符串相关

秒转时分秒 的方法

我们在游戏开发中界面显示时，经常可能会有这样的需求，要在界面中显示 n时n分n秒​ 的倒计时，
而一般都是根据倒计时剩余秒数进行转换的，因此我们可以将其封装为一个常用方法

需求：

  1. 函数有两个参数：秒数 和 是否忽略0（若为 0时0分53秒 前面的0应该不拼接 直接显示53秒）
  2. 可以传入用于拼接的 时分秒 字符
  3. 当忽略0时，如果存在时，分和秒也必须显示；如果存在分，秒也必须显示（避免出现 1时53秒、1时5分 这种显示）

由于常常会拼接字符串，为了节约性能，我们在这里可以使用StringBuilder​，返回时再转为字符串传递出去

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
private static StringBuilder resultStr = new StringBuilder("");

/// <summary>
/// 将秒数转换为时分秒字符串
/// </summary>
/// <param name="timeSec">秒数</param>
/// <param name="egZero">是否忽略0</param>
/// <param name="hourStr">显示小时使用的字符</param>
/// <param name="minuteStr">显示分钟使用的字符</param>
/// <param name="secondStr">显示秒数使用的字符</param>
/// <returns>转换好的字符串</returns>
public static string SecondTOHMS(int timeSec, bool egZero = false, string hourStr = "时", string minuteStr = "分", string secondStr = "秒")
{

    //计算小时
    int hour = timeSec / 3600;
    //计算分钟
    //除去小时后的剩余秒
    int second = timeSec % 3600;
    //剩余秒转分钟数
    int minute = second / 60;
    //计算秒
    second = timeSec % 60;
    //拼接
    resultStr.Clear();
    //如果小时不为0，或者不忽略0
    if (hour != 0 || !egZero)
    {
        resultStr.Append(hour);     //具体几个小时
        resultStr.Append(hourStr);
    }
    //如果分钟不为0，或者不忽略0，或者小时不为0
    if (minute != 0 || !egZero || hour != 0)
    {
        resultStr.Append(minute);   //具体几分钟
        resultStr.Append(minuteStr);
    }
    //如果秒不为0 或者 不忽略0 或者 小时和分钟都不为0
    if (second != 0 || !egZero || hour != 0 || minute != 0)
    {
        resultStr.Append(second);       //具体多少秒
        resultStr.Append(secondStr);
    }

    //如果传入的是0秒，则需要特别输出一个0秒
    if (resultStr.Length == 0)
    {
        resultStr.Append(0);
        resultStr.Append(secondStr);
    }

    return resultStr.ToString();
}

使用示例

1
2
3
4
5
6
7
8
9
void Start()
{
    print(TextUtil.SecondTOHMS(0, true));
    print(TextUtil.SecondTOHMS(3600, true));
    print(TextUtil.SecondTOHMS(60, true));
    print(TextUtil.SecondTOHMS(123456789));
    print(TextUtil.SecondTOHMS(34645));
    print(TextUtil.SecondTOHMS(98796, false, "h", "m", "s"));
}

输出：image​

秒转 00:00:00 的方法

我们可以基于秒转时分秒的方法的代码进行修改 提供一个 秒转 00:00:00​ 的方法

需求：在上节课的需求基础上加入

  1. 用 :​ 作为间隔符进行封装
  2. 每个位置的格式为最少2位（即存在这样的格式 01:05:35​ 秒）

现在原来的秒转时分秒的基础上添加一个可以控制是否最短显示两位的参数，再基于秒转时分秒封装一个 00:00:00​ 的方法

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
private static StringBuilder resultStr = new StringBuilder("");

/// <summary>
/// 返回类似于00:00:00这样格式的时间字符串
/// </summary>
/// <param name="s">要转换的字符串</param>
/// <param name="egZero">是否忽略0</param>
/// <returns>转换出来的字符串</returns>
public static string SecondToColonStr(int s, bool egZero = false)
{
    return SecondToHMS(s, egZero, true, ":", ":", "");
}

/// <summary>
/// 将秒数转换为时分秒字符串
/// </summary>
/// <param name="timeSec">秒数</param>
/// <param name="egZero">是否忽略0</param>
/// <param name="isKeepLength">是否保留最短两位长度，即存在类似与这样的格式"01:05:35"</param>
/// <param name="hourStr">小时的拼接字符</param>
/// <param name="minuteStr">分钟的拼接字符</param>
/// <param name="secondStr">秒数的拼接字符</param>
/// <returns>转换好的时间字符串</returns>
public static string SecondToHMS(int timeSec, bool egZero = false, bool isKeepLength = false, string hourStr = "时", string minuteStr = "分", string secondStr = "秒")
{
    //时间不会有负数，如果发现了负数，就直接归0
    if (timeSec < 0)
        timeSec = 0;

    //计算小时
    int hour = timeSec / 3600;
    //计算分钟
    //除去小时后的剩余秒
    int second = timeSec % 3600;
    //剩余秒转分钟数
    int minute = second / 60;
    //计算秒
    second = timeSec % 60;
    //拼接
    resultStr.Clear();
    //如果小时不为0，或者不忽略0
    if (hour != 0 || !egZero)
    {
        //具体几个小时
        resultStr.Append(isKeepLength ? GetNumStr(hour, 2) : hour);
        resultStr.Append(hourStr);
    }
    //如果分钟不为0，或者不忽略0，或者小时不为0
    if (minute != 0 || !egZero || hour != 0)
    {
        //具体几分钟
        resultStr.Append(isKeepLength ? GetNumStr(minute, 2) : minute);
        resultStr.Append(minuteStr);
    }
    //如果秒不为0 或者 不忽略0 或者 小时和分钟都不为0
    if (second != 0 || !egZero || hour != 0 || minute != 0)
    {
        //具体多少秒
        resultStr.Append(isKeepLength ? GetNumStr(second, 2) : second);
        resultStr.Append(secondStr);
    }

    //如果传入的是0秒，则需要特别输出一个0秒
    if (resultStr.Length == 0)
    {
        resultStr.Append(0);
        resultStr.Append(secondStr);
    }

    return resultStr.ToString();
}

使用示例

1
2
3
4
5
6
7
8
void Start()
{
    print(TextUtil.SecondToColonStr(0));
    print(TextUtil.SecondToColonStr(60, true));
    print(TextUtil.SecondToColonStr(3600));
    print(TextUtil.SecondToColonStr(5742381));
    print(TextUtil.SecondToColonStr(82781));
}

输出：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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Events;

/// <summary>
/// 用于处理字符串的一些公共功能
/// </summary>
public class TextUtil
{
    #region 字符串拆分相关
    /// <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]);
        }
    }
    #endregion

    #region 数值转字符串相关
    /// <summary>
    /// 将数值转换为字符串，可以指定长度，长度不足时自动在前面补充0
    /// </summary>
    /// <param name="value">要转换的数值</param>
    /// <param name="len">最短长度，传入的数值长度不足时会补充0</param>
    /// <returns>转换出来的字符串</returns>
    public static string GetNumStr(int value, int len)
    {
        //int.ToString如果传入一个"Dn"（n是数值）的字符串，
        //代表想要将数值转换为长度为n的字符串，如果长度不够，会在前面补充0
        return value.ToString($"D{len}");
    }

    /// <summary>
    /// 让指定的浮点数保留小数点后n位
    /// </summary>
    /// <param name="value">要转换的浮点数</param>
    /// <param name="len">保留小数位数</param>
    /// <returns>转换出来的字符串</returns>
    public static string GetDecimalStr(float value, int len)
    {
        //float.ToString如果传入一个"Fn"（n是数值）的字符串，
        //代表想要保留小数点后几位小数
        return value.ToString($"F{len}");
    }
    #endregion

    #region 时间转化相关
    private static StringBuilder resultStr = new StringBuilder("");

    /// <summary>
    /// 将秒数转换为时分秒字符串
    /// </summary>
    /// <param name="timeSec">秒数</param>
    /// <param name="egZero">是否忽略0</param>
    /// <param name="isKeepLength">是否保留最短两位长度，即存在类似与这样的格式"01:05:35"</param>
    /// <param name="hourStr">小时的拼接字符</param>
    /// <param name="minuteStr">分钟的拼接字符</param>
    /// <param name="secondStr">秒数的拼接字符</param>
    /// <returns>转换好的时间字符串</returns>
    public static string SecondToHMS(int timeSec, bool egZero = false, bool isKeepLength = false, string hourStr = "时", string minuteStr = "分", string secondStr = "秒")
    {
        //时间不会有负数，如果发现了负数，就直接归0
        if (timeSec < 0)
            timeSec = 0;

        //计算小时
        int hour = timeSec / 3600;
        //计算分钟
        //除去小时后的剩余秒
        int second = timeSec % 3600;
        //剩余秒转分钟数
        int minute = second / 60;
        //计算秒
        second = timeSec % 60;
        //拼接
        resultStr.Clear();
        //如果小时不为0，或者不忽略0
        if (hour != 0 || !egZero)
        {
            //具体几个小时
            resultStr.Append(isKeepLength ? GetNumStr(hour, 2) : hour);
            resultStr.Append(hourStr);
        }
        //如果分钟不为0，或者不忽略0，或者小时不为0
        if (minute != 0 || !egZero || hour != 0)
        {
            //具体几分钟
            resultStr.Append(isKeepLength ? GetNumStr(minute, 2) : minute);
            resultStr.Append(minuteStr);
        }
        //如果秒不为0 或者 不忽略0 或者 小时和分钟都不为0
        if (second != 0 || !egZero || hour != 0 || minute != 0)
        {
            //具体多少秒
            resultStr.Append(isKeepLength ? GetNumStr(second, 2) : second);
            resultStr.Append(secondStr);
        }

        //如果传入的是0秒，则需要特别输出一个0秒
        if (resultStr.Length == 0)
        {
            resultStr.Append(0);
            resultStr.Append(secondStr);
        }

        return resultStr.ToString();
    }

    /// <summary>
    /// 返回类似于00:00:00这样格式的时间字符串
    /// </summary>
    /// <param name="s">要转换的字符串</param>
    /// <param name="egZero">是否忽略0</param>
    /// <returns>转换出来的字符串</returns>
    public static string SecondToColonStr(int s, bool egZero = false)
    {
        return SecondToHMS(s, egZero, true, ":", ":", "");
    }
    #endregion
}