Solidity字符串拆分及列表元素存在性判断需求咨询

需求一：字符串拆分为两个部分 #

Solidity 没有内置的字符串拆分函数，我们可以通过字节数组操作实现按指定位置拆分字符串的功能。以下是实现代码：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract StringUtils {
    // 将字符串按指定位置拆分为两部分
    function splitString(string memory _str, uint256 _splitPos) public pure returns (string memory, string memory) {
        bytes memory strBytes = bytes(_str);
        uint256 strLength = strBytes.length;

        // 处理拆分位置超出字符串长度的边界情况
        if (_splitPos >= strLength) {
            return (_str, "");
        }

        // 截取前半部分
        bytes memory firstPart = new bytes(_splitPos);
        for (uint256 i = 0; i < _splitPos; i++) {
            firstPart[i] = strBytes[i];
        }

        // 截取后半部分
        bytes memory secondPart = new bytes(strLength - _splitPos);
        for (uint256 i = _splitPos; i < strLength; i++) {
            secondPart[i - _splitPos] = strBytes[i];
        }

        return (string(firstPart), string(secondPart));
    }
}

说明 #

• 函数接收原字符串和拆分位置两个参数，返回拆分后的两个字符串
• 若拆分位置大于等于字符串长度，直接返回原字符串和空字符串
• 通过将字符串转换为bytes类型进行逐字节操作，最后再转回string

需求二：列表匹配判断逻辑 #

我们需要判断字符串列表中的所有单词，是否在元组列表的首个元素中至少出现一次。这里需要注意大小写匹配规则，示例中"HEllO"和"HELLO"属于大小写不同的字符串，以下实现提供大小写敏感和不敏感两种版本：

实现代码 #

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ListMatcher {
    // 定义元组结构体（模拟元组列表）
    struct Tuple {
        string key;
        uint256 value;
    }

    // 辅助函数：将字符串转为大写（用于大小写不敏感匹配）
    function toUpperCase(string memory _str) public pure returns (string memory) {
        bytes memory strBytes = bytes(_str);
        for (uint256 i = 0; i < strBytes.length; i++) {
            // 仅处理小写字母（a-z）
            if (strBytes[i] >= 0x61 && strBytes[i] <= 0x7A) {
                strBytes[i] = bytes1(uint8(strBytes[i]) - 32);
            }
        }
        return string(strBytes);
    }

    // 大小写敏感的匹配判断
    function isAllWordsPresentSensitive(string[] memory wordList, Tuple[] memory tupleList) public pure returns (bool) {
        // 将元组的key存入映射，快速查找
        mapping(string => bool) keyExists;
        for (uint256 i = 0; i < tupleList.length; i++) {
            keyExists[tupleList[i].key] = true;
        }

        // 遍历单词列表，检查每个单词是否存在
        for (uint256 i = 0; i < wordList.length; i++) {
            if (!keyExists[wordList[i]]) {
                return false;
            }
        }
        return true;
    }

    // 大小写不敏感的匹配判断
    function isAllWordsPresentInsensitive(string[] memory wordList, Tuple[] memory tupleList) public pure returns (bool) {
        mapping(string => bool) keyExists;
        for (uint256 i = 0; i < tupleList.length; i++) {
            keyExists[toUpperCase(tupleList[i].key)] = true;
        }

        for (uint256 i = 0; i < wordList.length; i++) {
            if (!keyExists[toUpperCase(wordList[i])]) {
                return false;
            }
        }
        return true;
    }
}

针对示例的测试结果 #

• 示例输入：wordList = ["HEllO","HI","GREAT"]，tupleList = [("HELLO",123),("HI",2134),("HELLO",65)]
  • 大小写敏感版本："HEllO"与"HELLO"不匹配，"GREAT"不存在，返回false
  • 大小写不敏感版本："HEllO"转大写后匹配"HELLO"，但"GREAT"仍不存在，返回false

说明 #

• 使用结构体Tuple模拟元组列表，包含字符串key和数值value
• 借助mapping实现O(1)时间复杂度的查找，提升效率
• 提供大小写敏感/不敏感两个版本，可根据需求选择

内容的提问来源于stack exchange，提问作者imhans4305