Solidity 中的高级模式匹配：提升代码的可读性和可维护性

天涯学馆2025-08-02 19:30

Solidity 是以太坊智能合约开发的首选语言，其代码的可读性和可维护性直接影响项目的安全性、开发效率和长期维护成本。今天我们来聊聊Solidity 中的高级模式匹配这个东西。

高级模式匹配（Pattern Matching）是一种结构化编程技术，通过清晰的代码组织和逻辑分离，提升 Solidity 合约的可读性和可维护性。虽然 Solidity 本身并不直接支持传统意义上的模式匹配（如函数式语言中的 match 表达式），但可以通过特定的设计模式和编程实践实现类似的效果。

模式匹配的概念与 Solidity 的实现

模式匹配

模式匹配是一种编程范式，允许开发者通过匹配数据结构或状态来执行相应的逻辑。它的核心目标是：

  • 提高可读性：通过清晰的条件分支和逻辑分离，使代码易于理解。
  • 增强可维护性：将复杂逻辑分解为可重用的模块，降低修改成本。
  • 减少错误：通过结构化设计避免遗漏条件或重复代码。

在 Solidity 中，模式匹配可以通过以下方式实现：

  • 状态机：使用枚举和条件逻辑管理合约状态。
  • 多态性：通过接口和继承实现灵活的功能扩展。
  • 条件逻辑优化：使用映射、事件和函数修饰符简化分支。
  • 模块化设计：将逻辑拆分为库和合约，提升复用性。

Solidity 中的模式匹配挑战

Solidity 的区块链环境引入了独特约束：

  • Gas 成本：复杂的条件逻辑可能增加 Gas 消耗。
  • 不可变性：部署后合约代码难以修改，需确保模式设计健壮。
  • 安全性：模式匹配需防止重入、溢出等漏洞。
  • 存储限制：状态变量的存储成本高，需优化数据结构。

通过以下高级模式，开发者可以在 Solidity 中实现高效的模式匹配。

状态机模式

状态机模式通过定义明确的状态和转换规则，管理合约的生命周期，提高可读性和可预测性。

实现状态机

使用 enum 定义状态，结合 require 或修饰符控制状态转换。

示例：一个简单的拍卖合约：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

/// @title A simple auction contract using state machine
contract Auction is Ownable {
    enum AuctionState { Created, Started, Ended, Cancelled }
    AuctionState public state;

    uint256 public highestBid;
    address public highestBidder;
    uint256 public endTime;

    event StateChanged(AuctionState newState);
    event BidPlaced(address indexed bidder, uint256 amount);

    constructor() Ownable(msg.sender) {
        state = AuctionState.Created;
    }

    modifier onlyInState(AuctionState _state) {
        require(state == _state, "Invalid state");
        _;
    }

    /// @notice Starts the auction
    function start(uint256 duration) public onlyOwner onlyInState(AuctionState.Created) {
        endTime = block.timestamp + duration;
        state = AuctionState.Started;
        emit StateChanged(state);
    }

    /// @notice Places a bid
    function bid() public payable onlyInState(AuctionState.Started) {
        require(block.timestamp < endTime, "Auction ended");
        require(msg.value > highestBid, "Bid too low");
        
        if (highestBidder != address(0)) {
            payable(highestBidder).transfer(highestBid); // Refund previous bidder
        }
        
        highestBid = msg.value;
        highestBidder = msg.sender;
        emit BidPlaced(msg.sender, msg.value);
    }

    /// @notice Ends the auction
    function end() public onlyOwner onlyInState(AuctionState.Started) {
        require(block.timestamp >= endTime, "Auction not yet ended");
        state = AuctionState.Ended;
        emit StateChanged(state);
    }

    /// @notice Cancels the auction
    function cancel() public onlyOwner onlyInState(AuctionState.Started) {
        state = AuctionState.Cancelled;
        if (highestBidder != address(0)) {
            payable(highestBidder).transfer(highestBid); // Refund bidder
        }
        emit StateChanged(state);
    }
}

模式匹配特性：

  • 使用 enum 定义状态（Created, Started, Ended, Cancelled）。
  • 使用 onlyInState 修饰符匹配当前状态，限制函数调用。
  • 事件（StateChanged, BidPlaced）记录状态转换和关键操作。
  • 清晰的状态转换逻辑提高可读性和可维护性。

优点：

  • 防止非法状态转换（如在 Ended 状态下调用 bid）。
  • 明确的状态定义便于审计和测试。
  • 事件驱动设计便于前端集成。

注意事项：

  • 确保所有状态转换路径都经过测试。
  • 使用 revert 或自定义错误处理非法状态。
  • 避免状态爆炸，保持状态数量合理。

多态性与接口模式

多态性通过接口和继承实现功能复用和逻辑分离，类似于模式匹配中的类型匹配。

使用接口

接口定义标准功能，允许不同合约实现相同的接口。

示例：一个代币接收器接口：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @title Interface for token receivers
interface ITokenReceiver {
    /// @notice Called when tokens are received
    function onTokenReceived(address sender, uint256 amount, bytes calldata data) external returns (bool);
}

contract Token {
    function transferWithCallback(address to, uint256 amount, bytes memory data) public {
        // 假设已实现 ERC20 转移逻辑
        _transfer(msg.sender, to, amount);
        
        if (isContract(to)) {
            bool success = ITokenReceiver(to).onTokenReceived(msg.sender, amount, data);
            require(success, "Receiver rejected tokens");
        }
    }

    function _transfer(address from, address to, uint256 amount) internal {
        // 简化实现
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
}

contract Receiver is ITokenReceiver {
    event TokensReceived(address sender, uint256 amount, bytes data);

    function onTokenReceived(address sender, uint256 amount, bytes calldata data)
        external
        override
        returns (bool)
    {
        emit TokensReceived(sender, amount, data);
        // 处理逻辑
        return true;
    }
}

模式匹配特性：

  • ITokenReceiver 接口定义标准行为，允许不同合约实现 onTokenReceived。
  • isContract 检查目标地址是否为合约，确保安全调用。
  • 使用事件记录回调结果，便于调试。

优点：

  • 实现松耦合，接收器合约可独立开发。
  • 提高可扩展性，支持不同类型的接收逻辑。
  • 类似于模式匹配中的类型分派。

注意事项：

  • 验证外部合约调用的返回值。
  • 防止重入攻击，使用 ReentrancyGuard。
  • 测试所有实现接口的合约。

使用继承

继承允许通过父合约定义通用逻辑，子合约实现特定行为。

示例：一个多态的投票系统：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

/// @title Base voting contract
abstract contract Voting is Ownable {
    mapping(address => uint256) public votes;

    event VoteCast(address indexed voter, uint256 amount);

    function castVote(uint256 amount) public virtual {
        votes[msg.sender] += amount;
        emit VoteCast(msg.sender, amount);
    }

    function getTotalVotes() public view virtual returns (uint256);
}

contract SimpleVoting is Voting {
    uint256 public totalVotes;

    constructor() Ownable(msg.sender) {}

    function castVote(uint256 amount) public override {
        require(amount > 0, "Invalid vote amount");
        totalVotes += amount;
        super.castVote(amount);
    }

    function getTotalVotes() public view override returns (uint256) {
        return totalVotes;
    }
}

contract WeightedVoting is Voting {
    mapping(address => uint256) public weights;

    constructor() Ownable(msg.sender) {}

    function setWeight(address voter, uint256 weight) public onlyOwner {
        weights[voter] = weight;
    }

    function castVote(uint256 amount) public override {
        require(weights[msg.sender] > 0, "No voting weight");
        uint256 weightedAmount = amount * weights[msg.sender];
        super.castVote(weightedAmount);
    }

    function getTotalVotes() public view override returns (uint256) {
        uint256 total = 0;
        // 假设有限数量的投票者
        // 在实际应用中需优化存储和遍历
        return total;
    }
}

模式匹配特性：

  • Voting 抽象合约定义通用接口和逻辑。
  • SimpleVoting 和 WeightedVoting 通过重写 castVote 和 getTotalVotes 实现不同投票逻辑。
  • 类似于模式匹配中的多态分派。

优点：

  • 提高代码复用性，减少重复逻辑。
  • 支持不同投票机制的扩展。
  • 清晰的继承结构便于维护。

注意事项：

  • 确保子合约正确实现父合约的抽象函数。
  • 避免继承链过深，增加复杂性。
  • 测试所有子合约的行为。

条件逻辑优化

复杂的条件逻辑可能导致代码冗长和难以维护。以下是优化条件逻辑的模式匹配技术。

使用映射替代多重 if-else

映射（mapping）可以将条件逻辑简化为键值查询。

示例：权限管理系统：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Permission {
    enum Role { None, User, Admin, SuperAdmin }
    mapping(address => Role) public roles;

    event RoleAssigned(address indexed user, Role role);

    modifier onlyRole(Role requiredRole) {
        require(roles[msg.sender] >= requiredRole, "Insufficient role");
        _;
    }

    function assignRole(address user, Role role) public onlyRole(Role.SuperAdmin) {
        roles[user] = role;
        emit RoleAssigned(user, role);
    }

    function accessResource() public onlyRole(Role.User) {
        // 访问逻辑
    }

    function adminFunction() public onlyRole(Role.Admin) {
        // 管理逻辑
    }
}

模式匹配特性：

  • 使用 mapping 和 enum 替代多重 if-else 判断角色。
  • onlyRole 修饰符匹配用户角色，简化权限检查。
  • 事件记录角色分配，便于跟踪。

优点：

  • 减少条件分支，提高可读性。
  • 映射查询 Gas 成本低。
  • 易于扩展新角色。

注意事项：

  • 初始化默认角色（None）以防止未授权访问。
  • 测试所有角色权限边界。
  • 避免过多的映射操作，优化 Gas。

使用函数分派

通过函数选择器分派逻辑，类似于模式匹配的函数重载。

示例：多功能处理器：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Processor {
    enum Operation { Add, Subtract, Multiply, Divide }
    
    function process(uint256 a, uint256 b, Operation op) public pure returns (uint256) {
        if (op == Operation.Add) {
            return a + b;
        } else if (op == Operation.Subtract) {
            require(a >= b, "Subtraction underflow");
            return a - b;
        } else if (op == Operation.Multiply) {
            return a * b;
        } else if (op == Operation.Divide) {
            require(b != 0, "Division by zero");
            return a / b;
        } else {
            revert("Invalid operation");
        }
    }
}

模式匹配特性：

  • 使用 enum 定义操作类型，匹配不同逻辑。
  • 单一函数入口，分支处理不同操作。
  • 类似于模式匹配中的值匹配。

优点：

  • 集中式逻辑管理，减少函数数量。
  • 易于扩展新操作。
  • 清晰的错误处理。

注意事项：

  • 使用自定义错误替代字符串错误，节省 Gas。
  • 测试所有操作分支。
  • 避免过多分支，防止 Gas 超限。

事件驱动模式

事件驱动模式通过事件记录状态变化，结合前端或链下系统实现异步处理，类似于模式匹配中的事件分派。

5.1 使用事件简化状态管理

事件记录关键操作，前端或链下服务根据事件执行后续逻辑。

示例：订单管理系统：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract OrderManager is ReentrancyGuard {
    enum OrderStatus { Pending, Shipped, Delivered, Cancelled }
    struct Order {
        uint256 id;
        address buyer;
        uint256 amount;
        OrderStatus status;
    }

    mapping(uint256 => Order) public orders;
    uint256 public orderCount;

    event OrderCreated(uint256 indexed id, address indexed buyer, uint256 amount);
    event OrderStatusUpdated(uint256 indexed id, OrderStatus status);

    function createOrder(uint256 amount) public payable nonReentrant {
        require(amount > 0 && msg.value == amount, "Invalid amount");
        uint256 orderId = orderCount++;
        orders[orderId] = Order(orderId, msg.sender, amount, OrderStatus.Pending);
        emit OrderCreated(orderId, msg.sender, amount);
    }

    function updateStatus(uint256 orderId, OrderStatus status) public nonReentrant {
        require(orderId < orderCount, "Invalid order ID");
        require(orders[orderId].status < status, "Invalid status transition");
        orders[orderId].status = status;
        emit OrderStatusUpdated(orderId, status);
    }

    function cancelOrder(uint256 orderId) public nonReentrant {
        require(orderId < orderCount, "Invalid order ID");
        require(orders[orderId].buyer == msg.sender, "Not buyer");
        require(orders[orderId].status == OrderStatus.Pending, "Cannot cancel");
        orders[orderId].status = OrderStatus.Cancelled;
        payable(msg.sender).transfer(orders[orderId].amount);
        emit OrderStatusUpdated(orderId, OrderStatus.Cancelled);
    }
}

模式匹配特性：

  • 使用 enum 和 struct 定义订单状态和结构。
  • 事件（OrderCreated, OrderStatusUpdated）匹配状态变化。
  • 状态转换规则通过 require 强制执行。

优点：

  • 事件驱动设计便于链下系统集成。
  • 状态机模式确保状态转换的正确性。
  • 提高可审计性，事件记录所有操作。

注意事项：

  • 确保事件与状态一致。
  • 使用 nonReentrant 防止重入攻击。
  • 测试所有状态转换路径。

模块化设计模式

模块化设计通过将逻辑拆分为库、接口和合约，减少代码耦合，提升可维护性。

6.1 使用库

库封装通用逻辑，减少重复代码。

示例：数学运算库：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

library MathUtils {
    error DivisionByZero();

    function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "Addition overflow");
        return c;
    }

    function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) revert DivisionByZero();
        return a / b;
    }
}

contract Calculator {
    using MathUtils for uint256;

    function calculate(uint256 a, uint256 b, bool add) public pure returns (uint256) {
        return add ? a.safeAdd(b) : a.safeDiv(b);
    }
}

模式匹配特性：

  • MathUtils 库封装安全运算逻辑。
  • 使用 using ... for 实现函数分派。
  • 类似于模式匹配中的逻辑分离。

优点：

  • 提高代码复用性。
  • 减少合约大小，节省 Gas。
  • 便于测试和审计。

注意事项：

  • 库函数应为 internal 或 pure。
  • 确保库的安全性，避免漏洞。
  • 测试库函数的边界条件。

使用代理模式

代理模式通过分离存储和逻辑，支持合约升级。

示例：可升级的计数器：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

contract CounterStorage {
    uint256 public count;
}

contract CounterLogic is UUPSUpgradeable, OwnableUpgradeable {
    CounterStorage public storageContract;

    function initialize(address _storage) public initializer {
        storageContract = CounterStorage(_storage);
        __Ownable_init(msg.sender);
        __UUPSUpgradeable_init();
    }

    function increment() public {
        storageContract.count++;
    }

    function getCount() public view returns (uint256) {
        return storageContract.count;
    }

    function _authorizeUpgrade(address) internal override onlyOwner {}
}

模式匹配特性：

  • 存储和逻辑分离，类似于模式匹配中的数据与行为分离。
  • 使用 UUPSUpgradeable 支持升级。
  • 单一入口点（increment, getCount）匹配功能需求。

优点：

  • 支持合约升级，增强可维护性。
  • 逻辑清晰，易于扩展。
  • 降低存储冲突风险。

注意事项：

  • 确保存储布局一致。
  • 测试升级过程中的状态保持。
  • 使用 OpenZeppelin 的 Upgrades 插件部署。

测试与验证

模式匹配的实现需要全面测试以确保正确性和安全性。

单元测试

使用 Hardhat 和 Mocha/Chai 测试状态机和条件逻辑。

示例：测试拍卖合约：

javascript 复制代码 
const { expect } = require("chai");

describe("Auction", function () {
    let Auction, auction, owner, bidder1;

    beforeEach(async function () {
        Auction = await ethers.getContractFactory("Auction");
        [owner, bidder1] = await ethers.getSigners();
        auction = await Auction.deploy();
        await auction.deployed();
    });

    it("should start auction correctly", async function () {
        await auction.start(3600); // 1 hour
        expect(await auction.state()).to.equal(1); // Started
    });

    it("should allow bidding in Started state", async function () {
        await auction.start(3600);
        await auction.connect(bidder1).bid({ value: ethers.utils.parseEther("1") });
        expect(await auction.highestBidder()).to.equal(bidder1.address);
    });

    it("should revert bidding in Created state", async function () {
        await expect(
            auction.connect(bidder1).bid({ value: ethers.utils.parseEther("1") })
        ).to.be.revertedWith("Invalid state");
    });
});

覆盖率测试

使用 hardhat coverage 确保所有状态和分支被覆盖：

bash 复制代码 
npx hardhat coverage

静态分析

使用 Slither 检测模式匹配中的潜在漏洞：

bash 复制代码 
slither contracts/Auction.sol

模糊测试

使用 Echidna 测试状态机的鲁棒性：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./Auction.sol";

contract AuctionEchidna is Auction {
    constructor() Auction() {}

    function echidna_invalid_state_transition() public view returns (bool) {
        return state == AuctionState.Created || state == AuctionState.Started ||
               state == AuctionState.Ended || state == AuctionState.Cancelled;
    }

    function echidna_valid_bid() public view returns (bool) {
        if (state == AuctionState.Started) {
            return highestBidder == address(0) || highestBid > 0;
        }
        return true;
    }
}

运行：

bash 复制代码 
echidna-test contracts/AuctionEchidna.sol

Gas 优化与模式匹配

模式匹配的实现需考虑 Gas 成本，以下是优化建议：

减少状态转换

  • 合并状态检查，减少 require 语句：

    solidity 复制代码 
    modifier validState() {
    require(state == AuctionState.Started || state == AuctionState.Created, "Invalid state");
    _;
}

使用映射高效查询

  • 优先使用 mapping 而非数组遍历：

    solidity 复制代码 
    mapping(uint256 => bool) public validOrders;

function isValidOrder(uint256 orderId) public view returns (bool) {
    return validOrders[orderId];
}

事件替代存储

  • 使用事件记录非关键数据：

    solidity 复制代码 
    event LogAction(address indexed user, string action);

function performAction() public {
    emit LogAction(msg.sender, "Action performed");
}

综合案例：高级状态机的众筹合约

以下是一个综合应用模式匹配的众筹合约：

solidity 复制代码 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/// @title A crowdfunding contract with state machine
contract Crowdfunding is Ownable, ReentrancyGuard {
    enum CampaignState { Open, Success, Failed, Closed }
    struct Campaign {
        address creator;
        uint256 goal;
        uint256 raised;
        uint256 deadline;
        CampaignState state;
    }

    mapping(uint256 => Campaign) public campaigns;
    mapping(uint256 => mapping(address => uint256)) public contributions;
    uint256 public campaignCount;

    event CampaignCreated(uint256 indexed id, address creator, uint256 goal, uint256 deadline);
    event ContributionMade(uint256 indexed id, address contributor, uint256 amount);
    event CampaignStateChanged(uint256 indexed id, CampaignState state);

    error InvalidState();
    error InvalidAmount();
    error DeadlinePassed();
    error NotCreator();

    modifier onlyInState(uint256 id, CampaignState state) {
        if (campaigns[id].state != state) revert InvalidState();
        _;
    }

    /// @notice Creates a new campaign
    function createCampaign(uint256 goal, uint256 duration) public {
        uint256 id = campaignCount++;
        campaigns[id] = Campaign({
            creator: msg.sender,
            goal: goal,
            raised: 0,
            deadline: block.timestamp + duration,
            state: CampaignState.Open
        });
        emit CampaignCreated(id, msg.sender, goal, duration);
    }

    /// @notice Contributes to a campaign
    function contribute(uint256 id) public payable nonReentrant onlyInState(id, CampaignState.Open) {
        if (msg.value == 0) revert InvalidAmount();
        if (block.timestamp > campaigns[id].deadline) revert DeadlinePassed();
        
        campaigns[id].raised += msg.value;
        contributions[id][msg.sender] += msg.value;
        emit ContributionMade(id, msg.sender, msg.value);

        if (campaigns[id].raised >= campaigns[id].goal) {
            campaigns[id].state = CampaignState.Success;
            emit CampaignStateChanged(id, CampaignState.Success);
        }
    }

    /// @notice Closes a campaign and transfers funds
    function closeCampaign(uint256 id) public nonReentrant onlyInState(id, CampaignState.Open) {
        Campaign storage campaign = campaigns[id];
        if (msg.sender != campaign.creator) revert NotCreator();
        if (block.timestamp < campaign.deadline) revert DeadlinePassed();

        campaign.state = campaign.raised >= campaign.goal ? CampaignState.Success : CampaignState.Failed;
        emit CampaignStateChanged(id, campaign.state);

        if (campaign.state == CampaignState.Success) {
            payable(campaign.creator).transfer(campaign.raised);
        } else {
            // Refund logic in a separate function to avoid Gas issues
        }
        campaign.state = CampaignState.Closed;
    }

    /// @notice Refunds contributors if campaign failed
    function refund(uint256 id) public nonReentrant onlyInState(id, CampaignState.Failed) {
        uint256 amount = contributions[id][msg.sender];
        require(amount > 0, "No contribution");
        contributions[id][msg.sender] = 0;
        payable(msg.sender).transfer(amount);
    }
}

模式匹配特性：

  • 使用 enum 和 struct 定义状态和数据结构。
  • onlyInState 修饰符匹配状态，防止非法操作。
  • 事件驱动设计记录所有关键操作。
  • 分离退款逻辑，优化 Gas 和可读性。

测试用例：

javascript 复制代码 
const { expect } = require("chai");

describe("Crowdfunding", function () {
    let Crowdfunding, crowdfunding, owner, contributor;

    beforeEach(async function () {
        Crowdfunding = await ethers.getContractFactory("Crowdfunding");
        [owner, contributor] = await ethers.getSigners();
        crowdfunding = await Crowdfunding.deploy();
        await crowdfunding.deployed();
    });

    it("should create a campaign", async function () {
        await crowdfunding.createCampaign(ethers.utils.parseEther("10"), 3600);
        const campaign = await crowdfunding.campaigns(0);
        expect(campaign.goal).to.equal(ethers.utils.parseEther("10"));
        expect(campaign.state).to.equal(0); // Open
    });

    it("should allow contributions", async function () {
        await crowdfunding.createCampaign(ethers.utils.parseEther("10"), 3600);
        await crowdfunding.connect(contributor).contribute(0, { value: ethers.utils.parseEther("5") });
        expect(await crowdfunding.contributions(0, contributor.address)).to.equal(ethers.utils.parseEther("5"));
    });

    it("should revert invalid contributions", async function () {
        await crowdfunding.createCampaign(ethers.utils.parseEther("10"), 3600);
        await expect(
            crowdfunding.connect(contributor).contribute(0, { value: 0 })
        ).to.be.revertedWithCustomError(crowdfunding, "InvalidAmount");
    });

    it("should close campaign and transfer funds on success", async function () {
        await crowdfunding.createCampaign(ethers.utils.parseEther("10"), 3600);
        await crowdfunding.connect(contributor).contribute(0, { value: ethers.utils.parseEther("10") });
        await ethers.provider.send("evm_increaseTime", [3600]);
        await crowdfunding.closeCampaign(0);
        expect(await crowdfunding.campaigns(0).state).to.equal(3); // Closed
    });
});
相关推荐
追逐时光者44 分钟前
推荐 12 款开源美观、简单易用的 WPF UI 控件库，让 WPF 应用界面焕然一新！
后端·.net
Jagger_44 分钟前
敏捷开发流程-精简版
前端·后端
苏打水com2 小时前
数据库进阶实战：从性能优化到分布式架构的核心突破
数据库·后端
间彧3 小时前
Spring Cloud Gateway与Kong或Nginx等API网关相比有哪些优劣势？
后端
间彧3 小时前
如何基于Spring Cloud Gateway实现灰度发布的具体配置示例？
后端
间彧3 小时前
在实际项目中如何设计一个高可用的Spring Cloud Gateway集群？
后端
间彧3 小时前
如何为Spring Cloud Gateway配置具体的负载均衡策略？
后端
间彧3 小时前
Spring Cloud Gateway详解与应用实战
后端
EnCi Zheng4 小时前
SpringBoot 配置文件完全指南-从入门到精通
java·spring boot·后端
烙印6014 小时前
Spring容器的心脏：深度解析refresh()方法（上）
java·后端·spring
热门推荐
01BongoCat - 跨平台键盘猫动画工具02两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答03GitHub 镜像站点04UV安装并设置国内源05智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践0646个Nano-banana 精选提示词，持续更新中07Cursor Plan Mode：AI 终于知道先想后做了08Linux下V2Ray安装配置指南09GitLab 零基础入门指南：从安装到项目管理全流程10一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示