变量

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract HelloWorld {
  5.     string public myString = "hello world"; // 自带get()方法
  6.     bool public b = false; // 默认值 false
  7.     uint public u = 123; // uint8/uint16/uint256 0 to 2^8-1 默认值0
  8.     int public i = -123; // -2^255 to 2^255-1 默认值0
  9.     int public minInt = type(int).min;
  10.     int public maxInt = type(int).max;
  11.     address public addr = 0x0000000000000000000000000000000000000000; // 地址 私钥算公钥，公钥算地址 默认值40个0
  12.     byte32 public b32 = 0x0000000000000000000000000000000000000000000000000000000000000000; // 32位16进制 默认值64个0
  13. }

状态变量&局部变量

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract HelloWorld {
  5.     uint public i;
  6.     bool public b;
  7.     address public myAddress;
  9.     function foo() external {
  10.         uint x = 123;
  11.         bool f = false;
  12.         x += 456;
  13.         f = true;
  15.         i = 123;
  16.         b = true;
  17.         myAddress = address(1);
  18.     }
  19. }

语法 - 图1

全局变量

链上和账户

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract HelloWorld {
  5.     // view 可以读取全局变量和状态变量
  6.     function globalVars() external view returns (address,uint,uint){
  7.         address sender = msg.sender; // 全局变量-账户内容，调用这个函数的地址(上一个调用者，可能是人或合约)是什么
  8.         uint timestamp = block.timestamp; // 区块时间戳，只读。写入方法就是出块的时间
  9.         uint blockNum = block.number;
  10.         return (sender,timestamp,blockNum);
  11.     }
  12. }

语法 - 图2

常量

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. // 21442 gas 常量消耗更少的gas值，不修改的值定义为常量
  5. contract Contracts {
  6.     address public constant MY_ADDRESS = 0x000000000000000000000000000000000000000F;
  7.     uint public constant MY_UINT = 123;
  8. }
  9. // 23575 gas
  10. contract Var {
  11.     address public MY_ADDRESSS = 0x000000000000000000000000000000000000000C;
  12. }

数组

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Array {
  6.     uint[] public nums= [4,2,3];     // 变长数组
  7.     uint[] public nums2 = [1,2,3];     // 变长数组
  8.     uint[3] public numsFixed = [4,5,6];  // 定长数组
  10.     function examples() external {
  11.         nums.push(4);   // 添加元素
  12.         uint x = nums[0]; // 访问元素
  13.         nums[0] = 3; // 修改元素
  14.         delete nums[0]; // 删除元素(不影响数组长度，被删元素位置变成默认值)
  15.         nums.pop(); // 弹出元素
  16.         uint len = nums.length; // 元素长度
  18.         // 内存中创建数组(内存中的数组长度固定)
  19.         uint[] memory a = new uint[](5);
  20.         a[1] = 123;
  22.     }
  24.     // 返回数组
  25.     function returnArray() external view returns (uint[] memory){
  26.         return nums;
  27.     }
  28. }

删除数组元素 | 移动元素

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. // 缺点：浪费gas
  6. // 优点：顺序不变
  7. contract Array {
  8.     uint[] public arr;
  10.     function examples() external {
  11.         arr = [1,2,3];
  12.         delete arr[1]; // [1,0,3]
  14.     }
  16.     function remove(uint _index) public{
  17.         require(_index < arr.length, "index out of bound");
  18.         for(uint i = _index; i < arr.length-1; i++){
  19.             arr[i]=arr[i+1];
  20.         }
  21.         arr.pop();
  22.     }
  24.     // 285955 gas
  25.     function test() external {
  26.         arr = [1,2,3,4,5];
  27.         remove(2);
  28.         //[1,2,4,5]
  29.         assert(arr[0] == 1);
  30.         assert(arr[1] == 2);
  31.         assert(arr[2] == 4);
  32.         assert(arr[3] == 5);
  33.         assert(arr.length == 4);
  35.         arr = [1];
  36.         remove(0);
  37.         assert(arr.length == 0);
  38.     }
  39. }

删除数组元素 | 交换元素

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  6. // 缺点：顺序变化
  7. // 优点：节约gas
  8. contract Array {
  9.     uint[] public arr;
  11.     function examples() external {
  12.         arr = [1,2,3];
  13.         delete arr[1]; // [1,0,3]
  15.     }
  17.     function remove(uint _index) public{
  18.         require(_index < arr.length, "index out of bound");
  19.         arr[_index]=arr[arr.length-1];
  20.         arr.pop();
  21.     }
  23.     // 284651 gas
  24.     function test() external {
  25.         arr = [1,2,3,4,5];
  26.         remove(2);
  27.         //[1,2,5,4]
  28.         assert(arr[0] == 1);
  29.         assert(arr[1] == 2);
  30.         assert(arr[2] == 5);
  31.         assert(arr[3] == 4);
  32.         assert(arr.length == 4);
  34.         arr = [1];
  35.         remove(0);
  36.         assert(arr.length == 0);
  37.     }
  38. }

Map

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Mapping {
  6.     mapping(address => uint) public balances; // 地址余额
  7.     mapping(address => mapping(address => bool)) public isFriend; // 嵌套map
  8.     address public thisAddr;
  9.     address public sender;
  11.     function examples() external {
  12.         balances[msg.sender] = 123; // 设置数据
  13.         uint bal = balances[msg.sender]; // 获取数据
  14.         uint bal2 = balances[address(1)]; // 返回一个不存在的数据，默认值0
  16.         balances[msg.sender] +=456; // 增加数据
  17.         // delete balances[msg.sender]; // 删除数据(数据变为0)
  19.         isFriend[msg.sender][address(this)] = true;
  20.         sender = msg.sender;
  21.         thisAddr = address(this);
  22.     }
  23. }

函数

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract HelloWorld {
  5.     /*
  6.     external 外部函数，只能被外部读取，当前合约内部不能调用
  7.     pure 纯函数，不能读写状态变量，只能读写局部变量，即不会对链上有任何操作
  8.     */
  9.     function add(uint x,uint y) external pure returns (uint){
  10.         return x + y;
  11.     }
  12.     function sub(uint x,uint y) external pure returns (uint){
  13.         return x - y;
  14.     }
  15. }

语法 - 图3

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract HelloWorld {
  5.     uint public count;
  7.     // 因为要读取状态变量，所以不能带 view或者pure
  8.     function inc() external {
  9.         count +=1;
  10.     }
  12.     function dec() external {
  13.         count -=1;
  14.     }
  15. }

函数修改器

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Contracts {
  6.     bool public paused;
  7.     uint public count;
  9.     function setPause(bool _paused) external {
  10.         paused = _paused;
  11.     }
  13.     modifier whenNotPaused(){
  14.         require(!paused,"paused");
  15.         _;
  16.     }
  18.     function inc() external whenNotPaused{
  19.         count += 1;
  20.     }
  22.     function dec() external whenNotPaused{
  23.         count -= 1;
  24.     }
  26.     modifier cap(uint _x){
  27.         require(_x<100,"x >= 100");
  28.         _;
  29.     }
  31.     function incBy(uint _x) external whenNotPaused cap(_x){
  32.         count += _x;
  33.     }
  34. }

构造函数

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. // 仅能执行一次，用于初始化账号地址等
  6. contract Contracts {
  7.    address public owner;
  8.    uint public x;
  9.    constructor(uint _x){
  10.        owner = msg.sender;
  11.        x = _x;
  12.    }
  14. }

返回值

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract FunctionOutputs {
  6.     // 返回值未命名
  7.     function returnMany() public pure returns (uint,bool){
  8.         return (1,true);
  9.     }
  10.     // 返回值被命名-1
  11.     function named() public pure returns (uint x,bool b){
  12.         return (1,true);
  13.     }
  14.     // 返回值被命名-2
  15.     function assigned() public pure returns (uint x,bool b){
  16.         x = 1;
  17.         b = true;
  18.     }
  19.     // 接收返回值
  20.     function destructingAssigments() public pure {
  21.         (uint x,bool b) =  returnMany(); // 接收所有返回值
  22.         (,bool t) =  returnMany();    // 接收部分返回值
  23.     }
  25. }

结构体

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Structs {
  6.     struct Car {
  7.         string model;
  8.         uint year;
  9.         address owner;
  10.     }
  11.     Car public car;
  12.     Car[] public cars;
  13.     mapping(address =>Car[]) public carsByOwner;
  15.     function examples() external {
  16.         Car memory toyota = Car("Toyota", 1990, msg.sender);
  17.         Car memory lambo = Car({model:"Lamorghini", year:1980, owner: msg.sender});
  18.         Car memory tesla;
  19.         tesla.model = "Tesla";
  20.         tesla.year = 2010;
  21.         tesla.owner = msg.sender;
  22.         cars.push(toyota);
  23.         cars.push(lambo);
  24.         cars.push(tesla);
  25.         cars.push(Car("Ferrari", 2020, msg.sender));
  27.         Car memory _car = cars[0]; // memory 不可修改 只可读取
  28.         _car.model;
  29.         _car.year;
  30.         _car.owner;
  32.         Car storage __car = cars[0]; // storage 可修改
  33.         __car.year = 1999;
  35.         delete _car.owner; // 删除一个变量为默认值
  36.         delete cars[1]; // 下标1的元素的所有属性变为默认值
  37.     }
  38. }

枚举

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Enum {
  6.     enum Status {
  7.         None,       // 第一个值为默认值
  8.         Pending,
  9.         Shipped,
  10.         Completed,
  11.         Rejected,
  12.         Canceled
  13.     }
  15.     Status public status;
  17.     struct Order {
  18.         address buyer;
  19.         Status status;
  20.     }
  22.     Order[] public orders;
  24.     function get() view external returns (Status){
  25.         return status;
  26.     }
  28.     function set(Status _status) external {
  29.         status = _status;
  30.     }
  32.     function ship() external {
  33.         status = Status.Shipped;
  34.     }
  36.     function reset() external {
  37.         delete status;
  38.     }
  39. }

结构控制

if else

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract Contracts {
  5.     function example(uint _x) external pure returns (uint){
  6.         if(_x<10){
  7.             return 1;
  8.         } else if (_x<20){
  9.             return 2;
  10.         } else {
  11.             return 3;
  12.         }
  13.     }
  14.     function ternary(uint _x) external pure returns (uint){
  15.         return _x < 10 ? 1 : 2 ;
  16.     }
  17. }

for while

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. contract Contracts {
  5.     function loops() external pure {
  6.         for(uint i=0; i<10; i++){
  7.             if(i==3){
  8.                 continue;
  9.             }
  10.             if(i==8){
  11.                 break;
  12.             }
  13.         }
  15.         uint j = 0;
  16.         while (j < 10){
  17.             j++;
  18.         }
  19.     }
  21. }

报错控制

  1. // SPDX-License-Identifier: GPL-3.0
  2. pragma solidity >=0.7.0 <0.9.0;
  4. // require , revert , assert
  5. // gas费退还，状态回滚
  6. // 8.0可以自定义错误，节约gas
  7. contract Contracts {
  8.     function testRequire(uint _i) public pure {
  9.         require(_i <= 10, "i > 10");
  11.     }
  13.     function testRevert(uint _i) public pure {
  14.         if(_i>10){
  15.             revert("i>10");
  16.         }
  17.     }
  19.     uint public num = 123;
  20.     function testAssert() public view {
  21.         assert(num == 123);
  22.     }
  24.     function foo(uint _i) public {
  25.         num += 1;
  26.         // require(_i<10);
  27.         if(_i>10){
  28.             revert("i>10");
  29.         }
  30.     }
  32.     // 自定义报错
  33.     error MyError(address caller, uint i);
  34.     function testCustomError(uint _i) public view {
  35.         if (_i > 10){
  36.             revert MyError(msg.sender,_i);
  37.         }
  38.     }
  40. }

综合练习 - 权限控制

  1. // SPDX-License-Identifier: GPL-3.0
  3. pragma solidity >=0.7.0 <0.9.0;
  5. contract Ownable {
  6.    address public owner;
  8.    constructor(){
  9.        owner = msg.sender;
  10.    }
  12.    modifier onlyOwner(){
  13.        require(msg.sender == owner,"not owner");
  14.        _;
  15.    }
  17.    function setOwner(address _newOwner) external onlyOwner{
  18.        require(_newOwner != address(0),"invalid address");
  19.        owner = _newOwner;
  20.    }
  22.    function onlyOwnerCanCallThisFunc() external onlyOwner {
  23.        // code
  24.    }
  26.    function anyOneCanCall() external{
  27.        // code
  28.    }
  30. }