AlicizaX/Client/Packages/com.alicizax.unity/Runtime/Extension/Extension/StringExtensions.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

[UnityEngine.Scripting.Preserve]
public static class StringExtension
{
    /// <summary>
    /// 快速比较两个字符串内容是否一致
    /// </summary>
    /// <param name="self">当前字符串</param>
    /// <param name="target">对比的目标字符串</param>
    /// <returns></returns>
    /// <exception cref="ArgumentNullException">当前对象为空</exception>
    public static bool EqualsFast(this string self, string target)
    {
        if (self == null)
        {
            return target == null;
        }

        if (target == null)
        {
            return false;
        }

        if (self.Length != target.Length)
        {
            return false;
        }

        int ap = self.Length - 1;
        int bp = target.Length - 1;

        while (ap >= 0 && bp >= 0 && self[ap] == target[bp])
        {
            ap--;
            bp--;
        }

        return (bp < 0);
    }

    /// <summary>
    /// 判断字符串是否以目标字符串结尾
    /// </summary>
    /// <param name="self"></param>
    /// <param name="target">目标字符串</param>
    /// <returns></returns>
    public static bool EndsWithFast(this string self, string target)
    {
        int ap = self.Length - 1;
        int bp = target.Length - 1;

        while (ap >= 0 && bp >= 0 && self[ap] == target[bp])
        {
            ap--;
            bp--;
        }

        return (bp < 0);
    }

    /// <summary>
    /// 判断字符串是否以目标字符串开始
    /// </summary>
    /// <param name="self"></param>
    /// <param name="target">目标字符串</param>
    /// <returns></returns>
    public static bool StartsWithFast(this string self, string target)
    {
        int aLen = self.Length;
        int bLen = target.Length;

        int ap = 0;
        int bp = 0;

        while (ap < aLen && bp < bLen && self[ap] == target[bp])
        {
            ap++;
            bp++;
        }

        return (bp == bLen);
    }

    /// <summary>
    /// 字符串转字符数组
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static IEnumerable<byte> ToBytes(this string self)
    {
        byte[] byteArray = Encoding.Default.GetBytes(self);
        return byteArray;
    }

    /// <summary>
    /// 字符串转字符数组
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static byte[] ToByteArray(this string self)
    {
        byte[] byteArray = Encoding.Default.GetBytes(self);
        return byteArray;
    }

    /// <summary>
    /// 字符串转UTF8字符数组
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static byte[] ToUtf8(this string self)
    {
        byte[] byteArray = Encoding.UTF8.GetBytes(self);
        return byteArray;
    }

    /// <summary>
    /// 16进制字符串转字节数组
    /// </summary>
    /// <param name="hexString">字符串</param>
    /// <returns></returns>
    /// <exception cref="ArgumentException">字符串字符数不是偶数引发异常</exception>
    public static byte[] HexToBytes(this string hexString)
    {
        if (hexString.Length % 2 != 0)
        {
            throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "The binary key cannot have an odd number of digits: {0}",
                                                      hexString));
        }

        var hexAsBytes = new byte[hexString.Length / 2];
        for (int index = 0; index < hexAsBytes.Length; index++)
        {
            string byteValue = "";
            byteValue += hexString[index * 2];
            byteValue += hexString[index * 2 + 1];
            hexAsBytes[index] = byte.Parse(byteValue, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
        }

        return hexAsBytes;
    }

    /// <summary>
    /// 指定的字符串是 null、空还是仅由空白字符组成。
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static bool IsNullOrWhiteSpace(this string self)
    {
        const string nullString = "null";
        return self.EqualsFast(nullString) || string.IsNullOrWhiteSpace(self);
    }

    /// <summary>
    /// 指定的字符串是 null 还是 Empty 字符串。
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static bool IsNullOrEmpty(this string self)
    {
        return string.IsNullOrEmpty(self);
    }

    /// <summary>
    /// 指定的字符串[不]是 null、空还是仅由空白字符组成。
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static bool IsNotNullOrWhiteSpace(this string self)
    {
        return !self.IsNullOrWhiteSpace();
    }

    /// <summary>
    /// 指定的字符串[不]是 null 还是 Empty 字符串。
    /// </summary>
    /// <param name="self"></param>
    /// <returns></returns>
    public static bool IsNotNullOrEmpty(this string self)
    {
        return !self.IsNullOrEmpty();
    }

    /// <summary>
    /// 格式化
    /// </summary>
    /// <param name="text"></param>
    /// <param name="args"></param>
    /// <returns></returns>
    public static string Format(this string text, params object[] args)
    {
        return string.Format(text, args);
    }

    /// <summary>
    /// 将[\n、\t、\r、空格]替换为空,并返回
    /// </summary>
    /// <param name="self">原始字符串</param>
    /// <returns></returns>
    public static string TrimEmpty(this string self)
    {
        self = self.Replace("\n", string.Empty).Replace(" ", string.Empty).Replace("\t", string.Empty).Replace("\r", string.Empty);
        return self;
    }


    /// <summary>
    /// 匹配中文正则表达式
    /// </summary>
    private static readonly Regex CnReg = new Regex(@"[\u4e00-\u9fa5]");

    /// <summary>
    /// 替换中文为空字符串
    /// </summary>
    /// <param name="self">原始字符串</param>
    /// <returns></returns>
    public static string TrimZhCn(this string self)
    {
        self = CnReg.Replace(self, string.Empty);
        return self;
    }

    public static int[] SplitToIntArray(this string str, char sep = '+')
    {
        if (string.IsNullOrEmpty(str))
            return Array.Empty<int>();

        var arr = str.Split(sep);
        int[] ret = new int[arr.Length];
        for (int i = 0; i < arr.Length; ++i)
        {
            if (int.TryParse(arr[i], out var t))
                ret[i] = t;
        }

        return ret;
    }

    public static int[][] SplitTo2IntArray(this string str, char sep1 = ';', char sep2 = '+')
    {
        if (string.IsNullOrEmpty(str))
            return Array.Empty<int[]>();

        var arr = str.Split(sep1);
        if (arr.Length <= 0)
            return Array.Empty<int[]>();

        int[][] ret = new int[arr.Length][];

        for (int i = 0; i < arr.Length; ++i)
            ret[i] = arr[i].SplitToIntArray(sep2);
        return ret;
    }

    /// <summary>
    /// 根据字符串创建目录,递归
    /// </summary>
    public static void CreateAsDirectory(this string path, bool isFile = false)
    {
        if (isFile)
        {
            path = Path.GetDirectoryName(path);
        }

        if (!Directory.Exists(path))
        {
            CreateAsDirectory(path, true);
            Directory.CreateDirectory(path);
        }
    }

    /// <summary>
    /// 从指定字符串中的指定位置处开始读取一行。
    /// </summary>
    /// <param name="rawString">指定的字符串。</param>
    /// <param name="position">从指定位置处开始读取一行，读取后将返回下一行开始的位置。</param>
    /// <returns>读取的一行字符串。</returns>
    public static string ReadLine(this string rawString, ref int position)
    {
        if (position < 0)
        {
            return null;
        }

        int length = rawString.Length;
        int offset = position;
        while (offset < length)
        {
            char ch = rawString[offset];
            switch (ch)
            {
                case '\r':
                case '\n':
                    if (offset > position)
                    {
                        string line = rawString.Substring(position, offset - position);
                        position = offset + 1;
                        if ((ch == '\r') && (position < length) && (rawString[position] == '\n'))
                        {
                            position++;
                        }

                        return line;
                    }

                    offset++;
                    position++;
                    break;

                default:
                    offset++;
                    break;
            }
        }

        if (offset > position)
        {
            string line = rawString.Substring(position, offset - position);
            position = offset;
            return line;
        }

        return null;
    }
}