一、变量类型

官方文档在：https://docs.soliditylang.org/en/v0.8.14/types.html

在这里，我们主要注意的是引用类型：

• 数组（string和bytes也是独特的数组）
• 结构体（struct）
• 映射（mapping）

在Solidity中使用引用类型的时候，就需要指定数据的位置。

二、数据存储位置（Data Location）

以太坊中，有两个地方可以存储变量：那就是

• storage
• memory（包括calldata和stack）

将它类比于我们使用的pc构件的话，storage就相当于硬盘空间，memory就是我们的内存空间。区块链中，“硬盘空间” storage 是永久存储在区块链中的变量，而“内存空间” memory 则是临时存储的，当外部函数对合约调用完成时，内存型变量就会被移除。
memory位置还可以细分为calldata和stack两种位置。

1.storage

Storage变量是指永久存储在区块链中的变量。
当我们创建合约时，写的状态变量就默认是storage类型的：

pragma solidity ^0.8.0;

contract Person {
    struct State {
        string name;
        string gender;
    }
    State public state;
}

比如上面这个合约中，state的值就在storage中。
除了用在状态变量意外，对于private和internal的函数中，存储位置可以声明成storage：

contract Person {
    struct State {
        string name;
        string gender;
    }

    State public state;

    function setState(string calldata _name, string calldata _gender) external {
        state.name = _name;
        state.gender = _gender;
    }

    function emptyName() external {
        _emptyName(state);
    }

    function _emptyName(State storage self) internal {
        self.name = "";
    }
}

从上面代码可以看出，storage作为internal函数的参数的用法，这样就相当于c语言中传了个指针进去，这样就能通过传入的指针参数来修改storage中的值了。
试想一下，这里的_emptyName函数参数改成memory或者calldata是个什么样的效果——编译器会提示你，可以加上pure修饰符，pure修饰符即代表这个函数不读取状态状态，也不修改状态变量，可想而知，这里storage的作用在哪儿。
但这里storage的作用体现其实不太明显，因为很显然有更简单的写法——即直接用state来修改。其实storage，平时主要还是搭配library来使用的，这样可以提供更好的抽象，且看以下的代码：

pragma solidity ^0.8.0;

library PersonManager {
    struct State {
        string name;
        string gender;
    }

    function setState(State storage self, string calldata _name, string calldata _gender) public {
        self.name = _name;
        self.gender = _gender;
    }

    function changeName(State storage self, string calldata newName) public {
        self.name = newName;
    }
}

contract Person {
    PersonManager.State public state;

    function initState(string calldata _name, string calldata _gender) external {
        PersonManager.setState(state, _name, _gender);
    }

    function changeName(string calldata _name) external {
        PersonManager.changeName(state, _name);
    }
}

在library中，我们没有定义（也不能定义）状态变量，只有当Person合约用到library的时候，才会把自身的状态变量作为参数值传递进去，这样可以做到修改自身状态变量的作用。
这个案例是storage最常用的场景。

2.memory

Memory 变量则是临时的，当外部函数对某合约调用完成时，内存型变量即被移除。

pragma solidity ^0.8.0;

contract Person {
    struct State {
        string name;
        string gender;
    }

    State public state;

    function setState(string calldata _name, string calldata _gender) external {
        state.name = _name;
        state.gender = _gender;
    }

    // string用作函数返回值的存储位置
    function getName() external view returns (string memory) {
        return state.name;
    }

    // string用作函数内临时变量的存储位置
    function changeGender(uint value) external {
        require(
            value == 0 || value == 1,
            "Person: Input value error"
        );
        string memory newGender;
        if(value == 0) {
            newGender = "female";
        } else {
            state.gender = "male";
        }
        state.gender = newGender;
    }
}

如上述代码所示，memory可用于函数返回值的存储位置，也可以作为函数内临时变量的存储位置，这两个位置如果都是引用类型的数据，而不特别指定为memory的话，是无法通过编译的。

3.calldata

calldata一般作为external或者public函数的参数使用，如上面代码中的setState函数，两个参数_name和_gender，都特别指定了是calldata类型。
在官方文档中，是这么形容calldata类型的：

Calldata is a non-modifiable, non-persistent area where function arguments are stored, and behaves mostly like memory.

calldata有以下特征：

• 它只能用于函数声明参数（而不是函数逻辑）

• 它是不可变的（不能被覆盖和更改）

• 它必须用于external函数的动态参数

• 它是临时的（该值在事务完成后会销毁）

• 它是最便宜的存储位置

这里如果指定为memory类型也是可以的，但是calldata是const的，比较符合我们的需求，而且最为便宜，所以用calldata。

4.stack

stack 保存很小的局部变量，免费使用，但有数量限制。

pragma solidity ^0.8.0;

contract Counter {
    function start() external returns (uint sum) {
        uint a1 = 1;
        uint a2 = 1;
        uint a3 = 1;
        uint a4 = 1;
        uint a5 = 1;
        uint a6 = 1;
        uint a7 = 1;
        uint a8 = 1;
        uint a9 = 1;
        // uint a10 = 1;
        // uint a11 = 1;
        // uint a12 = 1;
        // uint a13 = 1;
        // uint a14 = 1;
        // uint a15 = 1;
        // sum = a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
        sum = a1+a2+a3+a4+a5+a6+a7+a8+a9;
    }

此时所有的stack变量，即非引用型数据，大概有10个，此时编译会出错，提示我们栈过深：

栈过深的报错

三、总结

• 状态变量的存储方式都是 storage；
• 局部变量的存储方式可以声明成 storage、memory 或 calldata；
• 公用函数（public）和外部函数（external）中，函数参数的存储方式只能是 memory 或 calldata；
• 私有函数（private）和内部函数（internal）中，函数参数的存储方式还可以是 storage；
• 映射（mapping）只能存储在 storage 中，且不能在函数内部定义，映射一般声明为状态变量；
• 一般建议将函数参数声明为calldata，因为gas费会比较低。