solidity8基础
权限修饰符
public：内部、外部可见
internal：内部可见（当前文件内），不能用 this 调用。
external：仅在外部可见（仅可修饰函数）,即使在合约内，也只能通过this.
private：仅在当前合约可见
全局变量
//常用全局变量
//链id
uint id = block.chainid;
//区块号
uint num = block.number;
//时间戳
uint time = block.timestamp;
//剩余 gas
uint gas = gasleft();
//调用者地址
address sender = msg.sender;
//发送的主币数量
uint value = msg.value;
//完整的 calldata 数据
bytes memory data = msg.data;
//calldata的前 4 个字节
bytes4 sig = msg.sig ;
//指定块的区块hash - 仅最近 256 个区块有效
bytes32 a = blockhash(12);
//当前合约地址
address add = address(this);
view 和 pure
//view: 函数不会修改合约变量，只读，不消耗燃料
//pure: 纯函数，不读写合约变量，只操作函数变量，不消耗燃料，可用于算法计算
function getNum() public view returns(uint8){
return num + 1;
}
function gettNum(uint8 _num) public pure returns(uint8){
return _num + 1;
}
存储memory、storage和calldata
引用类型包括结构，数组和映射，使用引用类型，必须明确指明数据存储位置
string类型实际上是bytes，也属于数组
memory：即数据在内存中，因此数据仅在其生命周期内（函数调用期间）有效。不能用于外部调用。
storage：状态变量保存的位置，只要合约存在就一直存储．
calldata：用来保存函数参数的特殊数据位置，是一个只读位置。
常用数据类型
整型
int：有符号整型，支持int8、int16...int256，8位为步长递增，int默认为int256，默认值为0
uint：无符号整型，支持uint8、uint16...uint256，8位为步长递增，uint默认为uint256，默认值为0
支持 加减乘除、大于小于等于，移位运算和大部分语言相同，不记录
uint a = 10**5;//幂运算 10的五次方 100000
布尔型
bool a;//默认值为false
浮点型
fixed：有符号定长浮点型,支持fixedMxN，fixed默认fixed128x19
ufixed：无符号定长浮点型，支持ufixedMxN，ufixed默认ufixed128x19
M 表示该类型占用的位数，N 表示可用的小数位数，M必须能整除8，即8到256位。N可以是从0到80之间的任意数
枚举类型
enum Names {
TOM,
Jack,
ROSE
}
Names name;
function getName() public view returns(Names){
return name;
}
function setName() public {
name = Names.ROSE;
}
地址类型
address owner;
映射
mapping(address => bool) data;
function get() public view returns(bool a){
a = data[msg.sender];
}
function set(bool _b) public {
data[msg.sender] = _b;
}
数组
//动态数组
uint[] a = [1,2,3];
function push(uint _num) public {
a.push(_num);
}
function get() public view returns(uint[] memory) {
return a;
}
//删除末尾元素
function pop() public {
a.pop();
}
//删除指定位置元素，只是变为0，不会改变数组长度
function del(uint _ind) public {
require(_ind <= a.length -1, "index out of bound");
delete a[_ind];
}
//获取数组长度
function getLength() public view returns(uint l){
l = a.length;
}
//内存数组必须是定长数组，不能修改长度，也不能用push和pop方法
function test() public pure returns(uint[] memory){
uint[] memory list = new uint[](3);
list[0] = 1;
list[1] = 3;
list[2] = 6;
//uint[3] memory list1 = [uint(1),3,6];
return list;
}
结构体
struct Cat{
string name;
uint8 age;
}
Cat public tom;
function set() public {
tom = Cat({
name: "aaa",
age: 18
});
}
function get() public view returns(Cat memory){
return tom;
}
常量&不可变量
//constant：常量，值在编译时确定
uint public constant a = 10;
//immutable：不可变量，值在部署时确定
uint public immutable a = 10;
//gas费比较
uint public a = 10; //114253 gas
uint public constant a = 10; //91875 gas
uint public immutable a = 10; //98492 gas
uint public immutable a; //101013 gas
constructor(uint _a){
a = _a;
}
异常处理
require
function tes(uint _a) public pure {
require(_a > 10, "_a <= 10");
}
revert
function tes1(uint _a) public pure {
if(_a <= 10){
revert("_a <= 10");
}
}
assert
function tes2(uint _a) public pure {
assert(_a > 10);
}
error
error myError(string msg);
function tes3(uint _a) public pure {
if(_a <= 10){
revert myError("_a <= 10");
}
}
构造函数
address owner;
string name;
//部署时执行，且只会被执行一次
constructor(string memory _name){
owner = msg.sender;
name = _name;
}
函数修改器 modifier
bool paused;
// 函数修改器
modifier whenNotPaused(){
require(!paused,"paused");
_; //运行到此处会返回调用方函数继续执行
}
function tes() public whenNotPaused(){
}
继承 is
//virtual 父合约标记
//override 重写父合约
contract A {
function tes() public pure virtual returns (string memory) {
return "A";
}
function tes1() public pure virtual returns (string memory) {
return "A";
}
}
contract B is A{
function tes() public pure override returns (string memory) {
return "B";
}
function tes1() public pure virtual override returns (string memory) {
return "B";
}
constructor(string memory _name){
}
}
contract C is B{
function tes1() public pure override returns (string memory) {
return "C";
}
//向父合约构造函数传递参数
constructor(string memory _name, string memory memo) B(_name) {
}
}