Solidity 函数及修改器(modifier)的用法

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

contract Function {
    // 多返回值函数
    function returnMany()
        public
        pure
        returns (
            uint,
            bool,
            uint
        )
    {
        return (1, true, 2);
    }

    // 可以命名返回值
    // 0: uint256: x 1
        // 1: bool: b true
        // 2: uint256: y 2
    function named()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        return (1, true, 2);
    }

    // 返回值可以指定给其名称
    // 在这种情况下，可以省略return语句。
    function assigned()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        x = 1;
        b = true;
        y = 2;
    }

    // 调用另一个函数时使用解构方式赋值
    // 返回多个值的函数。
    function destructuringAssignments()
        public
        pure
        returns (
            uint,
            bool,
            uint,
            uint,
            uint
        )
    {
        (uint i, bool b, uint j) = returnMany();

        // 值可以省略。5,就被忽略了
        (uint x, , uint y) = (4, 5, 6);

        return (i, b, j, x, y);
    }

    //不能将映射用于输入或输出 例如:function mappingInput(mapping m) public {}
    // 可以使用数组进行输入
    function arrayInput(uint[] memory _arr) public {}
}

函数的调用

// 函数的调用
contract XYZ {
    function plus(uint256 x, uint256 y) public pure returns (uint256) {
        return x + y;
    }

    //按顺序调用参数
    function callFunc() external pure returns (uint256) {
        return plus(1, 2);
    }

    //指明 key 值传递入参
    function callFuncWithKeyValue() external pure returns (uint256) {
        return plus({x: 1, y: 2});
    }
}

Solidity 函数修改器 modifier

modifier 类似于代码块,它会嵌入到代码执行逻辑中,应用于重复逻辑判断的抽离

我们先正常写个加减法函数看下返回值

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

contract ModifierTest {
    function plus(uint256 _x, uint256 _y) public pure returns (uint256) {
        require(_x > _y, "x>y");
        return 1 + 1;
    }

    function sub(uint256 _x, uint256 _y) public pure returns (uint256) {
        require(_x > _y, "x>y");
        return 2 - 1;
    }
}

我们发现两个方法都用到了相同的逻辑判断 ​​require(_x > _y, "x>y");​​ 我们可以通过 modifier 抽离出来。

然后我们写一个modifier:

其中​​_;​​ 这个符号表示代码继续执行函数后面的逻辑;

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

contract Owner {
    modifier compare(uint256 _x, uint256 _y) {
        require(_x > _y, "x>y");
        _;
    }

    function plus(uint256 _x, uint256 _y)
        public
        pure
        compare(_x, _y)
        returns (uint256)
    {
        return _x + _y;
    }

    function sub(uint256 _x, uint256 _y)
        public
        pure
        compare(_x, _y)
        returns (uint256)
    {
        return _x - _y;
    }
}

​​_;​​这个符号后面也可以继续写逻辑,后续逻辑会在函数调用后被执行;我们来看一下

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

contract Owner {
    address public owner;
    modifier compare(uint256 _x, uint256 _y) {
        require(_x > _y, "x>y");
        _;
        require(owner == msg.sender,"not owner");
    }
        
    function plus(uint256 _x, uint256 _y)
        public
        compare(_x, _y)
        returns (uint256)
    {
        // 把 owner 设为调用者
        owner = msg.sender;
        return _x + _y;
    }
    // 因为用到了状态变量所以要把 pure 改为 view
    function sub(uint256 _x, uint256 _y)
        public
        view
        compare(_x, _y)
        returns (uint256)
    {
        return _x - _y;
    }
}

我们先来测一下 ​​sub​​ 方法,输入 ​​1,2​​

可以看到错误提示 ​​x>y​​

输入 ​​2,1​​ 看到错误 ​​not owner​​

因为我们的 owner 默认值为 0 所以才会报错.

我们再来点一下 ​​plus​​: 输入 ​​2,1​​,合约调用成功, 我们把 owner 地址赋值为调用者 ​​msg.sender​​ 了

我们再来点击一下 sub 方法试试看看还报不报错.

可以看到,已经可以正常返回了, 因为 owner 被赋值为了调用者.

如果我们切换了账号以后,再点 ​​plus​​方法就会又报错 ​​not owner​​了