标签：function 01 return Solidity8.0 uint external address public

对应崔棉大师 1-25课程
https://www.bilibili.com/video/BV1yS4y1N7yu/?spm_id_from=333.788&vd_source=c81b130b6f8bb3082bdb42226729d69c

solidity8.0新特性

1.安全数学
unit 溢出 unchecked {x--;}

2.自定义异常
error Unauthorized(address caller);

revert(msg.sender);

3.合约外函数类似library

4.起别名 as

5.create2

HellowWorld
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract HelloWorld{
string public myStirng = "'hello world123'";
}

类型
1.bool
2.uint
3.int
type(int).min
type(int).max
4.address
5.bytes32

函数

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract Func{ function add(uint x , uint y) external pure returns(uint){ return x +y; } function sub(uint x,uint y) external pure returns(uint) { return x-y; } } 状态变量/局部变量/全局变量 // SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract Variable{ //状态变量 bool public b; uint public u; address public add; function get() external returns(bool,uint,address,uint,bool,address,uint,uint) { b = true; u = 111; add = address(2); //局部变量 uint c = 122; bool g = false; //全局变量 address send = msg.sender; uint times = block.timestamp; uint numer = block.number; return (b,u,add,c,g,send,times,numer); } } 只读函数/纯函数

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

contract ViewAndPure {
uint public x = 1;

　　// 读取了状态变量
　　function addToX(uint y) public view returns (uint) {
　　　　return x + y;
　　}

　　// 没有读取状态变量
　　function add(uint i, uint j) public pure returns (uint) {
　　　　return i + j;
　　}
}

计数器合约

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract counter{ uint public count; function inc() external{ count +=1; } function dec() external{ count -=1; } } 默认值 // SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract counter{ bool public bool_value; //false uint public uint_value; //0 address public address_value; //0x0000000000000000000000000000000000000000 bytes32 public bytes32_value; //0x0000000000000000000000000000000000000000000000000000000000000000 } 常量 // SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract Constants { // coding convention to uppercase constant variables address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc; uint public constant MY_UINT = 123; } contract Var { // coding convention to uppercase constant variables address public MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc; uint public MY_UINT = 123; } 节省gas:部署时gas不同,写入函数去读取时区分是否是常量节省gas 结构控制/三元运算符 // SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract IfElse { function foo(uint x) public pure returns (uint) { if (x < 10) { return 0; } else if (x < 20) { return 1; } else { return 2; } }
function ternary(uint _x) public pure returns (uint) { // if (_x < 10) { // return 1; // } // return 2;
// shorthand way to write if / else statement return _x < 10 ? 1 : 2; } }

循环

// SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract Loop { function loop() public { // for loop for (uint i = 0; i < 10; i++) { if (i == 3) { // Skip to next iteration with continue continue; } if (i == 5) { // Exit loop with break break; } }
// while loop uint j; while (j < 10) { j++; } } } 报错控制 // SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract Error { function testRequire(uint _i) public pure { // 退回剩余gas require(_i > 10, "Input must be greater than 10"); }
function testRevert(uint _i) public pure { // 退回剩余gas,复杂逻辑使用revert if (_i <= 10) { revert("Input must be greater than 10"); } }
uint public num;
function testAssert() public view { // 不退回gas assert(num == 0); }
// custom error error InsufficientBalance(uint balance, uint withdrawAmount);
function testCustomError(uint _withdrawAmount) public view { uint bal = address(this).balance; if (bal < _withdrawAmount) { revert InsufficientBalance({balance: bal, withdrawAmount: _withdrawAmount}); } } } 节省gas:revert,require 退回剩余gas 函数修改器/构造函数
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract FunctionModifier {
address public owner; 　　//构造函数
constructor() { owner = msg.sender; }
　　//定义函数修改器
modifier onlyOwner() { require(msg.sender == owner, "Not owner"); _; }
　　//定义函数修改器
modifier validAddress(address _addr) { require(_addr != address(0), "Not valid address"); _; } 　　//使用函数修改器
function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) { owner = _newOwner; }
}

Ownable合约

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract Ownable{ address public owner; constructor(){ owner = msg.sender; }
modifier onlyOwner(){ require(msg.sender == owner, "not owner"); _; } function setOwner(address newOwner) external onlyOwner(){ require(msg.sender != address(0),"not address 0!"); owner = newOwner; } function ownerCall() external onlyOwner(){ } function anyoneCall() external { } } 函数返回值 // SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract output{
function returnMany() public pure returns(uint ,bool){ return (1,true); } function returnMany1() external pure returns(uint ,bool){ return (1,true); } function returnMany2() external pure returns(uint x ,bool b){ return (1,true); } function returnMany3() external pure returns(uint x ,bool b){ x = 1; b = true; } function callReturnMany() public pure returns(uint x ,bool b){ (uint x1,bool b1) = returnMany(); return (x1,b1); } function callReturnManyOne() public pure returns(uint x ,bool b){ (,bool b1) = returnMany(); return (x, b1); }
function callReturnManyOne1() public pure returns(uint x ,bool b){ return returnMany(); }
}

数组

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract Array{ uint[] public nums = [1,2,3]; uint[3] public numsFixed = [4,5,6]; uint public len; function examples() external returns(uint){ nums.push(123); //[1,2,3,123] uint x = nums[1]; // x = 2 nums[2] =999; //[1,2,999,123] delete nums[0]; //[0,2,999,123] nums.pop(); //[0,2,999] len = nums.length; // len = 3 //局部变量数组必须是定长数组不能使用push pop uint[] memory num_memory = new uint[](10); num_memory[1] =111; return x; } function returnArray() external view returns(uint[] memory){ return nums; } function returnArray1() external view returns(uint){ return nums[1]; } }

数组删除元素通过移动位置

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract deleteArray1{ uint[] public nums = [ 1,2,3,4,5,6]; function remove(uint _index) public { require(_index<nums.length,"_index out of bound"); 　　　　　//指定位置后的元素左移一位然后弹出最后一个元素 for (uint i = _index;i<nums.length -1 ;i++){ nums[i] = nums[i+1]; } nums.pop(); } function setNums(uint[] memory input) external {
nums = input; } function test() external view returns(uint[] memory arr){ arr = nums; }

}

删除数组元素通过替换

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7;
contract deleteArray2 { uint256[] public nums = [1, 2, 3, 4, 5, 6];
function remove(uint256 _index) public { require(_index < nums.length, "_index out of bound"); nums[_index] = nums[nums.length - 1]; nums.pop(); }
function test() external view returns (uint256[] memory arr) { arr = nums; } }

映射(字典)

// SPDX-License-Identifier: MIT pragma solidity ^0.8.10;
contract Mapping { // Mapping from address to uint mapping(address => uint) public myMap;
function get(address _addr) public view returns (uint) { // Mapping always returns a value. // If the value was never set, it will return the default value. return myMap[_addr]; }
function set(address _addr, uint _i) public { // Update the value at this address myMap[_addr] = _i; }
function remove(address _addr) public { // Reset the value to the default value. delete myMap[_addr]; } }
contract NestedMapping { // Nested mapping (mapping from address to another mapping) mapping(address => mapping(uint => bool)) public nested;
function get(address _addr1, uint _i) public view returns (bool) { // You can get values from a nested mapping // even when it is not initialized return nested[_addr1][_i]; }
function set( address _addr1, uint _i, bool _boo ) public { nested[_addr1][_i] = _boo; }
function remove(address _addr1, uint _i) public { delete nested[_addr1][_i]; } }

映射迭代

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract IterableMapping{ mapping(address => uint) public balances; mapping(address => bool) public inserted; address[] public keys; function set(address _key,uint val) external { balances[_key] = val; if(!inserted[_key]){ inserted[_key] = true; keys.push(_key); } } function get(uint _index) external view returns(uint){ require(_index<keys.length,"out of bound keys"); return balances[keys[_index]]; } function getSize() external view returns(uint){ return keys.length; }
}

结构体

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract structs{ struct Car { string model; uint year; address owner; } Car public car; Car[] public cars; mapping(address => Car[]) public carsByOwner; function temp1() external { Car memory toyota = Car("Toyota",1990,msg.sender); Car memory audi = Car({model:"audi",year:1919,owner:msg.sender}); Car memory tesla; tesla.model = "Tesla"; tesla.year = 2020; tesla.owner = msg.sender; cars.push(toyota); cars.push(audi); cars.push(tesla); cars.push(Car("ferrari",2020,msg.sender)); carsByOwner[msg.sender] = cars; } function test() external{ Car storage _car = cars[0]; _car.year = 2101; delete _car.owner; delete cars[1]; }

}

枚举

// SPDX-License-Identifier: MIT pragma solidity ^0.8.7;
contract Enum { 　　//枚举实际显示的是数字索引默认值是0 enum Status { None, Pending, Rejected, Canceled } Status public status; struct Order{ address buyer; Status status; } Order[] public orders; function get() external view returns(Status){ return status; } function set(Status _status) external { status = _status; } function cancel( ) external { status = Status.Canceled; } function reset( ) external { delete status; } function test( ) external { orders.push(Order(msg.sender,Status.Pending)); } }

标签：function,01,return,Solidity8.0,uint,external,address,public
From： https://www.cnblogs.com/cuinima/p/17137864.html

Solidity8.0-01