一、变量类型
在这里，我们主要注意的是引用类型：
数组（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个，此时编译会出错，提示我们栈过深：
栈过深的报错
当我们将
a9注释掉，就能正常编译通过，这里我们尝试编译通过的栈深临界点应当是9个，但是有的文章里用的address变量测栈深，测出来的是16个。这应该跟两种变量的长度有关，uint默认为uint256，为256位；而address类型长度为20×8=160位。有关Stack too deep的解决方法，可以看这个网站，这里有详细的解决方案：
https://soliditydeveloper.com/stacktoodeep
三、总结
状态变量的存储方式都是 storage；
局部变量的存储方式可以声明成 storage、memory 或 calldata；
公用函数（public）和外部函数（external）中，函数参数的存储方式只能是 memory 或 calldata；
私有函数（private）和内部函数（internal）中，函数参数的存储方式还可以是 storage；
映射（mapping）只能存储在 storage 中，且不能在函数内部定义，映射一般声明为状态变量；
一般建议将函数参数声明为calldata，因为gas费会比较低。
