Solidity

状态变量会永久地保存在合约的存储中，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract SimpleStorage {
    uint storedData;          // State variable
    // ...
}

函数可以定义在合约内，也可以定义在合约外，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.1 <0.9.0;

contract SimpleAuction {
    function bid() public payable { // Function
        // ...
    }
}

// Helper function defined outside of a contract
function helper(uint x) pure returns (uint) {
    return x * 2;
}

函数修饰器可以用来以声明的方式改良函数语义，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.7.0;

contract Purchase {
    address public seller;

    modifier onlySeller() {        // 这是函数修饰器的定义
        require(
            msg.sender == seller,
            "Only seller can call this."
        );
        _;
    }

    function abort() public view onlySeller { // 使用函数修饰器
        // ...
    }
}

通过事件（Event）可以使用以太坊虚拟机的日志功能。

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.21 <0.7.0;

contract SimpleAuction {
    event HighestBidIncreased(address bidder, uint amount); // 声明 Event

    function bid() public payable {
        // ...
        emit HighestBidIncreased(msg.sender, msg.value); // 触发 Event
    }
}

在 Solidity 0.8.4 中引入了 error 关键字，可以用于定义错误，在 revert 语句中可以使用这个错误，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

/// Not enough funds for transfer. Requested `requested`,
/// but only `available` available.
error NotEnoughFunds(uint requested, uint available);

contract Token {
    mapping(address => uint) balances;
    function transfer(address to, uint amount) public {
        uint balance = balances[msg.sender];
        if (balance < amount)
            revert NotEnoughFunds(amount, balance);
        balances[msg.sender] -= amount;
        balances[to] += amount;
        // ...
    }
}

在引入 error 关键字之前，我们可以直接使用 revert 来报告一个错误消息，如：

revert("Not enough Ether provided.");

但这种方式只接受一个字符串参数，不方便接受额外的信息，如还想报告“请求的数量”及“当前可用余额”就很麻烦。使用 error 关键字定制错误则可以解决这个问题。

结构体可以组织多种类型为一个新类型，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract Ballot {
    struct Voter {          // Struct
        uint weight;
        bool voted;
        address delegate;
        uint vote;
    }
}

除了在 contract 中定义结构体外，也可以直接在源文件中定义结构体，即和 contract 平级定义。

枚举用于定义一组有限的常量，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract Purchase {
    enum State { Created, Locked, Inactive }    // Enum
}

枚举和整数之间不会进行隐式地转换，不过你可以显式地在枚举和整数之间做转换。枚举中首个常量是 0（而不是 1）。

关键字 bool 用于声明布尔值，有两个字面常量： true, false 。

整数和无符号整数可以分别用下面关键字声明：

int8, int16, int24, int32, int40, ..., int256
uint8, uint16, uint24, uint32, uint40, ..., int256

注， int 和 uint 分别是 int256, uint256 的别名。

每种类型都有相应的表示范围，如 int32 的范围为 -2**31 到 2**31-1；而 uint32 的范围为 0 到 2**32-1。

整数支持下面运算符：

• 比较运算符： <=, <, ==, !=, >=, >
  
• 按位运算符： &~， ~|, ^, ~
  
• 移位运算符： <<, >>
  
• 算术运算符： +, -, *, /, % (Remainder), ** (Exponentiation)
  

10**18 = 1e18, 2e5 = 2 * 10 ** 5, 123_000 等都是整数字面量的例子。整数字面量具有任意的精度，比如 (2**800 + 1) - 2**800 会得到整数 1；又如 0.5 * 8 会得到整数 4。

Solidity 支持两种地址类型：

• address ：存储 20 字节的地址（这是以太坊地址的大小）；
  
• address payable ：和 address 相同，但支持更多的成员（transfer 和 send）。
  

类型 address payable 可以隐式地转换为 address ；而类型 address 到 address payable 的转换需要用 payable(<address>) 显式地进行。

类型 address 和 address payable 支持的成员如表 1 所示。

下面是满足指定条件下从当前合约地址转账 10 wei 给地址 x 的例子：

address payable x = payable(0x123);
address myAddress = address(this);
if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);

地址类型也有 literal 表达，如下所示：

contract Sample {
  payable address myAddress = payable(0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF); // 必须是大小写混合形式（EIP-55）
}

值类型 bytes1, bytes2, bytes3, …, bytes32 表示字节序列，其大小分别占 1 到 32 字节。

注： byte 是 bytes1 的别名。

为 bytes1, bytes2, bytes3, …, bytes32 赋值时，必须宽度匹配，不过 0 或者 0x0 可以转换为任意宽度，如：

bytes2 a = 54321; // not allowed
bytes2 b = 0x12; // not allowed
bytes2 c = 0x123; // not allowed
bytes2 d = 0x1234; // fine
bytes2 e = 0x0012; // fine
bytes4 f = 0; // fine
bytes4 g = 0x0; // fine

字符串或者 hex 字符串，如果宽度匹配，则可以隐式转换为 bytes1, bytes2, bytes3, …, bytes32 ，如：

bytes2 a = hex"1234"; // fine
bytes2 b = "xy"; // fine
bytes2 c = hex"12"; // not allowed
bytes2 d = hex"123"; // not allowed
bytes2 e = "x"; // not allowed
bytes2 f = "xyz"; // not allowed

对于引用类型的变量，需要声明数据保存在什么位置，有三个可能的保存位置：

• memory，仅在函数调用期间有效，是易失的；
  
• storage，和整个合约的生命周期一样；
  
• calldata，这是个特别的地方，保存函数参数，这个位置的数据是只读的。
  

数组可以在编译时就确定大小，也可以在运行时确定大小。

下面是数组的例子：

contract C {
    int[] x;       // 动态大小
    int[10] y;     // 固定大小
}

如果数组保存在 storage 中，则可以直接使用 .push() 方法往往数组后面增加新元素。如果数组保存在 memory 中，则不能使用 .push() 来改变其大小，参考节 3.2.2.2 。

Array slices are a view on a contiguous portion of an array. They are written as x[start:end], the first element of the slice is x[start] and the last element is x[end - 1].

As of now, array slices are only implemented for calldata arrays.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.7.0;

contract Proxy {
    /// @dev Address of the client contract managed by proxy i.e., this contract
    address client;

    constructor(address _client) public {
        client = _client;
    }

    /// Forward call to "setOwner(address)" that is implemented by client
    /// after doing basic validation on the address argument.
    function forward(bytes calldata _payload) external {
        // Since ABI decoding requires padded data, we cannot
        // use abi.decode(_payload[:4], (bytes4)).
        bytes4 sig =
            _payload[0] |
            (bytes4(_payload[1]) >> 8) |
            (bytes4(_payload[2]) >> 16) |
            (bytes4(_payload[3]) >> 24);
        if (sig == bytes4(keccak256("setOwner(address)"))) {
            address owner = abi.decode(_payload[4:], (address));
            require(owner != address(0), "Address of owner cannot be zero.");
        }
        (bool status,) = client.delegatecall(_payload);
        require(status, "Forwarded call failed.");
    }
}

下面是结构体的实例：

contract C {
    struct Person {
        string name;
        uint age;
    }

    function f() public pure {
        Person memory p1 = Person("David", 10);
    }
}

在创建结构体变量时，不用使用 new 关键字。 new 用于创建合约实例，或者动态数组。

使用语法 mapping(_KeyType => _ValueType) _VariableName 可以创建 Mapping 变量。其中 _KeyType 可以是任何内置的值类型、 bytes 、 string 或者合约或者枚举，但 _KeyType 不能是用户定义的复杂类型，不能是 Mapping，不能是 struct，不能是其它数组类型。 _ValueType 可以是任意类型。

Mapping 可以认为是其它语言中的 Hash Table。 Mapping 中并不会保存 Key 本身，而是使用 Key 的 keccak256 哈希进行查询和定位。如果 Key 不在 Mapping 中，那么你会得到 Value 对应类型的默认值（比如整数默认就是 0）。也就是说，没有办法区分下面两种情况：1、Key 不存在于 Mapping 中，2、Key 存在，但其 Value 为对应类型的默认值。

Mapping 只能保存在 storage 中，不能保存在 memory 或者 calldata 中。

delete a 的作用是把 a 赋值为其对应类型的默认值。

如果 a 是整数，则 delete a 相当于 a=0 （0 是整数的默认值）。
如果 a 是动态数组，则 delete a 是把 a 赋值为大小为 0 的动态数组。
如果 a 是固定大小的数组，则 delete a 是把 a 中的每个元素都赋值为对应类型的默认值。
如果 a 是数组， delete a[x] 的作用是删除下标为 x 的元素，但整个数组的长度不变，其元素也不变。这相当于数组出现了空洞。注：如果你想删除元素，mapping 是更好的选择。
如果 a 是结构体，则 delete a 会让其每个成员（mapping 类型的成员除外）都赋值为对应类型的默认值。
如果 a 是 mapping，则 delete a 没有效果，编译器会报错。
如果 a 是 mapping，则 delete a[x] 相当于设置 a 中 Key x 对应的 Value 为类型默认值。

下面再看一个例子：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract DeleteExample {
    uint data;
    uint[] dataArray;

    function f() public {
        uint x = data;
        delete x; // sets x to 0, does not affect data
        delete data; // sets data to 0, does not affect x
        uint[] storage y = dataArray;
        delete dataArray; // this sets dataArray.length to zero, but as uint[] is a complex object, also
        // y is affected which is an alias to the storage object
        // On the other hand: "delete y" is not valid, as assignments to local variables
        // referencing storage objects can only be made from existing storage objects.
        assert(y.length == 0);
    }
}

在上面例子中，不能使用 delete y ，这相同于把 y 赋值为大小为 0 的动态数组，但 y 是 local storage 变量，我们只能够把一个事先存在的 storage 变量赋值给 local storage 变量，所以不能使用 delete y 。

下面是“内部函数调用”的例子：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.7.0;

contract C {
    function g(uint a) public pure returns (uint ret) { return a + f(); }
    function f() internal pure returns (uint ret) { return uint(100); }
}

These function calls are translated into simple jumps inside the EVM. This has the effect that the current memory is not cleared, i.e. passing memory references to internally-called functions is very efficient. Only functions of the same contract instance can be called internally.

You should still avoid excessive recursion, as every internal function call uses up at least one stack slot and there are only 1024 slots available.

this.g(8); 或者 c.g(2); （这里 c 是合约实例）的形式是“外部函数调用”形式。

For an external call, all function arguments have to be copied to memory.

When calling functions of other contracts, you can specify the amount of Wei or gas sent with the call with the special options {value: 10, gas: 10000}.

下面例子中， feed.info{value: 20}(); 外部函数调用，且在调用的同时转账了 20 wei 以太给被调用合约。需要说明的是 info 必须声明为 payable ，否则它不能接收以太。

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.2 <0.7.0;

contract InfoFeed {
    function info() public payable returns (uint ret) { return 42; }
}

contract Consumer {
    InfoFeed feed;
    function setFeed(InfoFeed addr) public { feed = addr; }
    function callFeed() public {
        feed.info{value: 20}();       // 外部函数调用，同时转账了 20 wei
    }
}

在调用函数时，可以使用 {arg1: val1, arg2: val2} 语法指定参数名称，这时参数顺序就不无谓了，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract C {
    mapping(uint => uint) data;

    function f() public {
        set({value: 2, key: 3});       // 相当于 set(3, 2);
    }

    function set(uint key, uint value) public {
        data[key] = value;
    }

}

函数执行失败会回滚整个交易。但是，这个规则有两个例外：
1. 函数 send 出现异常后，不会 bubble up 异常，而是通过 send 的返回值来告诉调用者是否执行成功
2. 函数 call/delegatecall/staticcall 出现异常，也不会 bubble up 异常，而是通过它们的第 1 个返回值来告诉调用者是否执行成功

所以，我们需要检查 send 和 call/delegatecall/staticcall 的返回值，才知道它们是否执行成功。比如：

require(address(test1).send(1 ether));  // 检查 send 的返回值，确保它执行成功，如果失败则回滚整个交易
                                        // 如果担心忘记检查，建议使用 transfer 函数，因为它失败时会 bubble up 异常（transfer 没有返回值）
                                        // 上面的 send 调用等价于 address(test1).transfer(1 ether);

(bool success,) = address(test1).call(abi.encodeWithSignature("func1()"));
require(success);                       // 检查 call 的第 1 个返回值，确保它执行成功，如果失败则回滚整个交易

参考：https://docs.soliditylang.org/en/latest/control-structures.html#error-handling-assert-require-revert-and-exceptions

Assert should only be used to test for internal errors, and to check invariants. 换句话说， assert 如果失败了，一定是其它地方有 bug。 如：

Require 一般用于检查函数参数，或者调用完其它函数后检查它的返回值。 require(condition, "description") 等价于 if (!condition) revert Error("description") ，如：

    function buy(uint amount) public payable {
        if (amount > msg.value / 2 ether)
            revert("Not enough Ether provided.");

        // Alternative way to do it:
        require(
            amount <= msg.value / 2 ether,
            "Not enough Ether provided."
        );

        // Perform the purchase.
	// ......
    }

Solidity v0.6.0 中引入了 try/catch 语句， try 后面可以跟两类语句：external function 和合约创建语句。

下面是 try 后面跟 external function 的使用例子：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.1;

interface DataFeed { function getData(address token) external returns (uint value); }

contract FeedConsumer {
    DataFeed feed;
    uint errorCount;
    function rate(address token) public returns (uint value, bool success) {
        // Permanently disable the mechanism if there are
        // more than 10 errors.
        require(errorCount < 10);
        try feed.getData(token) returns (uint v) {
            return (v, true);
        } catch Error(string memory /*reason*/) {
            // This is executed in case
            // revert was called inside getData
            // and a reason string was provided.
            errorCount++;
            return (0, false);
        } catch Panic(uint /*errorCode*/) {
            // This is executed in case of a panic,
            // i.e. a serious error like division by zero
            // or overflow. The error code can be used
            // to determine the kind of error.
            errorCount++;
            return (0, false);
        } catch (bytes memory /*lowLevelData*/) {
            // This is executed in case revert() was used.
            errorCount++;
            return (0, false);
        }
    }
}

下面是 try 后面跟合约创建语句的使用例子：

pragma solidity <0.7.0;

contract CalledContract {

    constructor() public {
        // Code that reverts
        revert();
    }

    // ...
}

contract TryCatcher {

    // ...

    function execute() public {
        try new CalledContract() {
            emit SuccessEvent();
        } catch {
            emit CatchEvent();
        }
    }
}

需要注意的是， try 只会捕获它后面的 external function 调用或者合约创建语句中抛出的错误； try 语句块内部（即后面第一个大括号中的内容）的错误并不会被捕获，如：

function execute() public {
    try externalContract.someFunction() {    // someFunction 中的错误会被 try/catch 捕获
        // this will revert the execution of the transaction even if the external call succeeded
        revert();                            // 注意：这个 revert 在 try 语句第一个大括号中，并不会被捕获
    } catch {
       ...
    }
}

当函数的参数是大数组时， external 会比 public 消耗 gas 更少。这是因为 public 可见性的函数，会把参数从 calldata 复制到 memory 中；而 external 可见性的函数，则不会进行这个复制。

下面例子中，test2 比 test 消耗 gas 更少：

pragma solidity^0.4.12;

contract Test {
    function test(uint[20] a) public returns (uint){      // 消耗 496 gas
         return a[10]*2;
    }

    function test2(uint[20] a) external returns (uint){   // 消耗 261 gas
         return a[10]*2;
    }
}

参考：https://ethereum.stackexchange.com/questions/19380/external-vs-public-best-practices

编译器自动为所有 public 可见性的状态变量创建 getter 函数，如：

contract SimpleStorage {
    uint public storedData;

    /* 编译器自动为 public 状态变量storedData 创建的 getter 函数
    function storedData () public view returns (uint) {
        return storedData;
    }
    */
}

注意： 如果状态变量是数组，则自动生成的 getter 函数并不会返回整个数组，而是接收一个参数，返回指定参数下标的元素。 如果你想返回整个数组，则需要自己编写相应函数，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.7.0;

contract arrayExample {
    // public state variable
    uint[] public myArray;

    // Getter function generated by the compiler
    /*
    function myArray(uint i) public view returns (uint) {
        return myArray[i];
    }
    */

    // function that returns entire array
    function getArray() public view returns (uint[] memory) {
        return myArray;
    }
}

下面是一个更复杂的例子：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.7.0;

contract Complex {
    struct Data {
        uint a;
        bytes3 b;
        mapping (uint => uint) map;
    }
    mapping (uint => mapping(bool => Data[])) public data;
}

其中， data 是 public 可见性的状态变量，编译器为它生成的 getter 函数如下所示：

function data(uint arg1, bool arg2, uint arg3) public returns (uint a, bytes3 b) {
    a = data[arg1][arg2][arg3].a;
    b = data[arg1][arg2][arg3].b;
}

用 view 声明的函数，表示其不会修改状态变量，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;

contract C {
    function f(uint a, uint b) public view returns (uint) {
        return a * (b + 42) + now;
    }
}

下面这些语句被认为是修改状态变量：

1. Writing to state variables.
   
2. Emitting events.
   
3. Creating other contracts.
   
4. Using selfdestruct.
   
5. Sending Ether via calls.
   
6. Calling any function not marked view or pure.
   
7. Using low-level calls.
   
8. Using inline assembly that contains certain opcodes.
   

constant 可以作为 view 的别名，不过在 Solidity 0.5.0 中被废弃了。

用 pure 声明的函数，表示其读取、也不会修改状态变量，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.7.0;

contract C {
    function f(uint a, uint b) public pure returns (uint) {
        return a * (b + 42);
    }
}

下面这些语句被认为是读取状态变量：

1. Reading from state variables.
   
2. Accessing address(this).balance or <address>.balance.
   
3. Accessing any of the members of block, tx, msg (with the exception of msg.sig and msg.data).
   
4. Calling any function not marked pure.
   
5. Using inline assembly that contains certain opcodes.
   

receive() 是一个特别的函数，它不使用关键字 function 。

如果调用合约时， calldata 为空，则这个函数会被调用。 例如，使用 .send() 或 .transfer() 往该合约转入以太时（数量可以是 0），这个函数会被调用。

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

// This contract keeps all Ether sent to it with no way
// to get it back.
contract Sink {
    event Received(address, uint);
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }
}

在 Solidity 0.6.0 以前，合约收到以太的回调函数是下面的形式：

function() external payable {   // 这是过时的用法，从 0.6.0 开始不支持，请使用 receive()
    // ......
}

fallback() 是一个特别的函数，它不使用关键字 function 。

如果调用合约时，找不到其它合适函数，这个方法会被调用。 可以分两种情况：

1. 调用合约时，calldata 为空，但 receive() 函数没有在合约中定义，那么 fallback() 会被调用；
   
2. 调用合约时，calldata 不为空，会使用 calldata 的前 4 个字节寻找函数，如果合约中找不到匹配的函数（即调用一个不存在的函数），那么 fallback() 会被调用。
   

当函数参数不一样，可以实现函数的重载，如：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.7.0;

contract A {
    function f(uint _in) public pure returns (uint out) {
        out = _in;
    }

    function f(uint _in, bool _really) public pure returns (uint out) {
        if (_really)
            out = _in;
    }
}

下面是函数重载的例子：

// SPDX-License-Identifier: GPL-3.0
pragma solidity >0.6.99 <0.8.0;

contract Base
{
    function foo() virtual external view {}   // virtual 关键字表示函数 foo 可以被子合约重载
}

contract Middle is Base {}

contract Inherited is Middle
{
    function foo() override public pure {}    // override 关键字表示重载函数 foo 的实现
}

使用 super 可以访问父合约，如：

pragma solidity >=0.6.0;

contract C {
  uint public u;
  function f() virtual public {           // virtual 表示可以被子合约（即 B）重载
    u = 1;
  }
}

contract B is C {
  function f() override virtual public {  // override 表示 f 是一个重载实现，virtual 表示可以被子合约（即 A）重载
    u = 2;
  }
}

contract A is B {
  function f() override public {  // will set u to 3
    u = 3;
  }

  function f1() public {     // will set u to 2
    super.f();               // same as B.f();
  }

  function f2() public {     // will set u to 2
    B.f();
  }

  function f3() public {     // will set u to 1
    C.f();
  }
}