介绍

//pragma solidity ^0.4.0; 表示不超过0.5.0版本，即0.4.0 ~ 0.4.9 之间
pragma solidity >=0.8.0;
// import "filename";
// import * as symbolName from "filename";
// import "./x";
// uint storedData;，声明了一个名为storedData的状态变量，类型为uint, set和get函数可用于修改或检索变量的值
contract SimpleStorage {
    uint storedData;
    function set(uint x) public {
        storedData = x;
    }
    function get() public view returns (uint) {
        return storedData;
    }
}

pragma solidity ^0.4.0;
 
contract ArrayContract {
    uint[2**20] m_aLotOfIntegers;
    bool[2][] m_pairsOfFlags;
 
    // newpair存储在内存中——这是函数参数的默认存储位置
    function setAllFlagPairs(bool[2][] newPairs) {
        // 对存储数组赋值，替换传入的整个数组
        m_pairsOfFlags = newPairs;
    }
 
    function setFlagPair(uint index, bool flagA, bool flagB) {
        // 访问不存在的索引将引发异常
        m_pairsOfFlags[index][0] = flagA;
        m_pairsOfFlags[index][1] = flagB;
    }
 
    function changeFlagArraySize(uint newSize) {
        // 如果newSize更小，则删除的数组元素将被清除
        m_pairsOfFlags.length = newSize;
    }
 
    function clear() {
        // 完全清除数组
        delete m_pairsOfFlags;
        delete m_aLotOfIntegers;
        // 效果相同
        m_pairsOfFlags.length = 0;
    }
 
    bytes m_byteData;
 
    function byteArrays(bytes data) {
        // byte 数组 ("bytes") 存储时没有填充(padding),
        // 但是可以与“uint8[]”相同处理
        m_byteData = data;
        m_byteData.length += 7;
        m_byteData[3] = 8;
        delete m_byteData[2];
    }
 
    function addFlag(bool[2] flag) returns (uint) {
        return m_pairsOfFlags.push(flag);
    }
 
    function createMemoryArray(uint size) returns (bytes) {
        // 使用“new”创建动态内存数组:
        uint[2][] memory arrayOfPairs = new uint[2][](size);
        // 创建一个动态byte数组:
        bytes memory b = new bytes(200);
        for (uint i = 0; i < b.length; i++)
            b[i] = byte(i);
        return b;
    }
}
 
contract Test {   
   function callAddMod() public pure returns(uint){
      return addmod(4, 5, 3);
   }
   function callMulMod() public pure returns(uint){
      return mulmod(4, 5, 3);
   }
   function callKeccak256() public pure returns(bytes32 result){
      return keccak256("ABC");
   }
}

(A & B) // 2
(A | B) // 3
(A ^ B) // 1.
(~B) // -4.
(A << 1) // 4
(A >> 1) // 1

pragma solidity ^0.5.0;

contract Vendor {
   address public seller;
   modifier onlySeller() {
      require(msg.sender == seller, "Only seller can call this.");
      _;
   }
   function sell(uint amount) public payable onlySeller { 
      if (amount > msg.value / 2 ether)
         revert("Not enough Ether provided.");
      // 执行销售操作
   }
    function buy1(address payable addr) public {
        addr.transfer(1 ether);
        assert(addr.balance > 1 ether);
    }
    function buy(uint amount) public {
        require(amount < 1, "amount must be greater than 1");
    }
    // function buy1(uint amount) public {
    //     if(amount < 1) {
    //         revert(amount > 1, "amount must be greater than 1"); 
    //     }
    // }
}

pragma solidity ^0.5.0;  

contract MyContract {
  uint256[] arr1; // arr1 存储在 storage 中
  
  function fn1(uint256[] memory arr2) public {
      arr1 = arr2;// memory 赋值到 storage 中，创建拷贝
      uint256[] storage arr4 = arr1;// stoarge 赋值到 本地 storage 中，创建引用
      arr4.pop(); // pop 会同时影响 arr1
      delete arr1; // 清空 arr1，同时会影响 arr4
      // storage 是静态分配内存，所以不可以直接从 memory 赋值到本地 storage 中
      // arr4 = arr2;
      // 因为没有指向存储位置，所以无法重置指针
      // delete arr4;
      fn3(arr1); // storage 之间传递引用
      fn4(arr1);  // storage 到 memory 会拷贝
  }
  
  function fn2(uint256[] calldata arr3) external {}

  function fn3(uint256[] storage arr5) internal pure {}

  function fn4(uint256[] memory arr6) public pure {}

}

1 wei 等于 1。
1 gwei 等于 1e9。
1 ether = 1e18。
用代码表示如下：
assert(1 wei == 1);
assert(1 gwei == 1e9);
assert(1 ether == 1e18);

seconds：秒
minutes：分
hours：时
days：天
weeks：周
years：年，不推荐使用。

用代码表示如下：
assert(1 seconds == 1);
assert(1 minutes == 60 seconds);
assert(1 hours == 60 minutes);
assert(1 days == 24 hours);
assert(1 weeks == 7 days);