D语言实现Laravel Str类常用方法：高效便捷的字符串操作

以下是使用D语言实现上述方法的示例代码及注释：

module MyStr;

import std.algorithm : canFind, equal, findSplit, joiner, map, startsWith, strip;
import std.array : array, split;
import std.string : toLower, toUpper;

/**
 * 获取指定字符串之后的所有字符
 *
 * @param str 原字符串
 * @param search 搜索的字符串
 * @return 搜索字符串后面的所有字符
 */
string after(string str, string search)
{
    auto index = str.indexOf(search);
    if (index == -1) {
        return str;
    }

    return str[index + search.length .. $];
}

/**
 * 获取指定字符串最后出现位置之后的所有字符
 *
 * @param str 原字符串
 * @param search 搜索的字符串
 * @return 搜索字符串最后出现位置后面的所有字符
 */
string afterLast(string str, string search)
{
    auto index = str.lastIndexOf(search);
    if (index == -1) {
        return str;
    }

    return str[index + search.length .. $];
}

/**
 * 将字符串转换为 ASCII 码
 *
 * @param str 原字符串
 * @return 转换后的 ASCII 码
 */
string ascii(string str)
{
    // 将字符转换为其 ASCII 码
    return str.map!(c => c.to!string).join('');
}

/**
 * 获取指定字符串之前的所有字符
 *
 * @param str 原字符串
 * @param search 搜索的字符串
 * @return 搜索字符串之前的所有字符
 */
string before(string str, string search)
{
    auto index = str.indexOf(search);
    if (index == -1) {
        return str;
    }

    return str[0 .. index];
}

/**
 * 获取指定字符串最后出现位置之前的所有字符
 *
 * @param str 原字符串
 * @param search 搜索的字符串
 * @return 搜索字符串最后出现位置前面的所有字符
 */
string beforeLast(string str, string search)
{
    auto index = str.lastIndexOf(search);
    if (index == -1) {
        return str;
    }

    return str[0 .. index];
}

/**
 * 获取两个指定字符串之间的所有字符
 *
 * @param str 原字符串
 * @param start 起始字符串
 * @param end 结束字符串
 * @return 起始字符串和结束字符串之间的所有字符
 */
string between(string str, string start, string end)
{
    auto startIndex = str.indexOf(start);
    if (startIndex == -1) {
        return str;
    }

    auto endIndex = str.indexOf(end, startIndex + start.length);
    if (endIndex == -1) {
        return str;
    }

    return str[startIndex + start.length .. endIndex];
}

/**
 * 将字符串转换为驼峰命名法
 *
 * @param value 原字符串
 * @return 转换后的驼峰命名法字符串
 */
string camel(string value)
{
    auto parts = value.split(['_', '-']);
    return parts.map!(p => p.capitalize).join('');
}

/**
 * 检查字符串是否包含指定的子字符串
 *
 * @param haystack 原字符串
 * @param needles 要查找的子字符串
 * @return 是否包含
 */
bool contains(string haystack, string needles)
{
    return haystack.canFind(needles);
}

/**
 * 检查字符串是否包含所有指定的子字符串
 *
 * @param haystack 原字符串
 * @param needles 要查找的子字符串
 * @return 是否包含所有子字符串
 */
bool containsAll(string haystack, string[] needles)
{
    return needles.all!(n => haystack.canFind(n));
}

/**
 * 检查字符串是否以指定的字符串结尾
 *
 * @param haystack 原字符串
 * @param needles 要查找的字符串
 * @return 是否以指定字符串结尾
 */
bool endsWith(string haystack, string needles)
{
    return haystack.endsWith(needles);
}

/**
 * 截取字符串并添加省略号
 *
 * @param value 原字符串
 * @param length 要截取的长度
 * @param end 结尾添加的字符串，默认为 '...' 
 * @return 截取后的字符串
 */
string excerpt(string value, int length, string end = '...')
{
    if (value.length <= length) {
        return value;
    }

    return value[0 .. length].strip ~ end;
}

/**
 * 在字符串末尾添加指定的字符串
 *
 * @param value 原字符串
 * @param cap 添加的字符串
 * @return 添加后的字符串
 */
string finish(string value, string cap)
{
    return value ~ (value.endsWith(cap) ? '' : cap);
}

/**
 * 将字符串转换为标题格式
 *
 * @param value 原字符串
 * @return 转换后的标题格式字符串
 */
string headline(string value)
{
    auto words = value.split(' ');
    return words.map!(w => w.capitalize).join(' ');
}

/**
 * 检查字符串是否与指定的模式匹配
 *
 * @param pattern 匹配模式
 * @param value 原字符串
 * @return 是否匹配
 */
bool is(string pattern, string value)
{
    // 将模式中的通配符转换为正则表达式
    auto regexStr = '^' ~ pattern.replace('*', '.*') ~ '$';
    auto regex = regex(regexStr);
    return regex.match(value).empty;
}

/**
 * 检查字符串是否只包含 ASCII 字符
 *
 * @param value 原字符串
 * @return 是否只包含 ASCII 字符
 */
bool isAscii(string value)
{
    // 将字符串转换为 ASCII 码，并检查是否仍然与原字符串相等
    return value.ascii.toLower == value.toLower;
}

/**
 * 检查字符串是否为 UUID
 *
 * @param value 原字符串
 * @return 是否为 UUID
 */
bool isUuid(string value)
{
    // 将 UUID 分成 5 段，每段长度分别为 8、4、4、4、12
    auto parts = value.split('-');
    if (parts.length != 5) {
        return false;
    }
    if (parts[0].length != 8 || parts[1].length != 4 || parts[2].length != 4 || parts[3].length != 4 || parts[4].length != 12) {
        return false;
    }

    // 检查每段是否都由十六进制数字组成
    return parts.all!(p => p.all!(c => c.isHexDigit));
}

可以将上述代码保存为 MyStr.d 文件并在需要使用的地方导入即可使用。例如：

import MyStr;

void main()
{
    auto str = 'Hello, world!';
    auto after = after(str, 'o');
    auto ascii = ascii(str);
    auto contains = contains(str, 'world');
    // ...
}