03 进阶篇

3高级语法

自动推导类型

为了方便，并不总是需要明确指定一个变量的类型，编译器会通过第一个向这个对象赋予的值的类型来进行推断.

例如：

uint24 x = 0x123; var y = x;

需要特别注意的是，由于类型推断是根据第一个变量进行的赋值。所以下面的代码将是一个无限循 环，因为⼀一个uint8的i的将小于2000。

for (var i = 0; i < 2000; i++) { //uint8 -> 255 //越界归0 //无限循环 }

全局变量/函数

区块和交易的属性：

代码：

 

pragma solidity ^0.4.24;
contract Test {
​
    bytes32 public blockhash;
    address public coinbase;
    uint public difficulty;
    uint public gaslimit;
    uint public blockNum;
    uint public timestamp;
    bytes public calldata;
    uint public gas;
    address public sender;
    bytes4 public sig;
    uint public msgValue;
    uint public now;
    uint public gasPrice;
    address public txOrigin;
    
function tt (){
        //给定区块号的哈希值，只支持最近256个区块，且不包含当前区块
        blockhash = block.blockhash(block.number - 1);
        coinbase = block.coinbase ;//当前块矿工的地址。
        difficulty = block.difficulty;//当前块的难度。
        gaslimit = block.gaslimit;// (uint)当前块的gaslimit。
        blockNum = block.number;// (uint)当前区块的块号。
        timestamp = block.timestamp;// (uint)当前块的时间戳。
        calldata = msg.data;// (bytes)完整的调⽤用数据（calldata）。
        gas = msg.gas;// (uint)当前还剩的gas。
        sender = msg.sender; // (address)当前调用发起人的地址。
        sig = msg.sig;// (bytes4)调用数据的前四个字节（函数标识符）。
        msgValue = msg.value;// (uint)这个消息所附带的货币量，单位为wei。
        now = now;// (uint)当前块的时间戳，等同于block.timestamp
        gasPrice = tx.gasprice;// (uint) 交易的gas价格。
        txOrigin = tx.origin;// (address)交易的发送者（完整的调用链）  
    }
}
 

---

货币单位

⼀一个字面量的数字，可以使用后缀 wei ， finney ， szabo 或 ether 来在不同面额中转换； 不含任何后缀的默认单位是 wei 。如1 ether == 1000 finney 的结果是 true 。

代码：

 

pragma solidity ^0.4.24;
contract EthUnit{
    uint  a = 1 ether;
    uint  b = 10 ** 18 wei;
    uint  c = 1000 finney;
    uint  d = 1000000 szabo;
function f1() constant public returns (bool){
    return a == b;
}
​
function f2() constant public returns (bool){
    return a == c;
}
​
function f3() constant public returns (bool){
    return a == d;
}
​
 function f4() constant public returns (bool){
        return 1 ether == 100 wei;
    }
  }

时间单位

seconds，minutes，hours，days，weeks，years均可做为后缀，默认是seconds为单位。 1 = 1 seconds 1 minutes = 60 seconds 1 hours = 60 minutes 1 days = 24 hours 1 weeks = 7 days 1 years = 365 days

代码：

 

pragma solidity ^0.4.24;
contract TimeUnit{
    function f1() pure public returns (bool) {
        return 1 == 1 seconds;
    }
    
function f2() pure public returns (bool) {
    return 1 minutes == 60 seconds;
}
​
function f3() pure public returns (bool) {
    return 1 hours == 60 minutes;
}
​
function f4() pure public returns (bool) {
    return 1 days == 24 hours;
}
​
function f5() pure public returns (bool) {
    return 1 weeks == 7 days;
}
 function f6() pure public returns (bool) {
        return 1 years == 365 days;
    }
}
 

事件（event）

 

pragma solidity ^0.4.24;
contract evnetTest{
    mapping(address=>uint256)public personToMoney;
//定义一个时间事件,时间事件是一个语句，在后面要加分号，与结构体不同；
/*
1.定义一个时间事件，使用圆括号，后面加分号
2.使用emit关键字
3.在web3调用时可以监听到事件
4.相当于日志
*/
event playEnent(address,uint256,uint256);
​
function paly()public payable
{
    require(msg.value==100);
    personToMoney[msg.sender]=msg.value;
    
    //emit:关键字表示发射时间;出发触发事件
    emit playEnent(msg.sender,msg.value,block.timestamp);
}
​
function getBalance()public view returns(uint256){
    return address(this).balance;
}
}

结果：

访问函数

-编译器为自动为所有的 public的状态变量 创建访问函数。下面的合约例子中，编译器会生成一个名叫data的无参，返回值是uint的类型的值data。状态变量的初始化可以在定义时完成。

-访问函数有外部(external)可见性。如果通过内部(internal)的方式访问，比如直接访问，你可以直接把它当一个变量进行使用，但如果使用外部(external)的方式来访问，如通过this.，那么它必须通过函数的方式来调用。

  1.加public的常态变量，solidity会自动的生成一个同名的访问函数
  2.在合约内部使用这个状态变量的时候，直接当变量使用即可
  3.在合约外部访问这个public变量（data ），就需要使用xx .data()形式

代码：

pragma solidity ^0.4.24;
​
 contract test {
     uint256 public data =200;
 function getData()public view returns(uint256){
     return data;
 } 
 
 //this 代表合约本身，如果在合约内部使用this自身的方法的话，相当于外部调用
 function getData1()public view returns(uint256){
     return this.data();
 }
  }
 contract test1{
 function getData()public returns(uint256){
  test t=new test();
 return t.data();
  }
 }
 

 

修饰器

程序运行流程

修改器(Modifiers)可以用来轻易的改变一个函数的行为。⽐比如⽤用于在函数执行前检查某种前置条件。 修改器是一种合约属性，可被继承，同时还可被派生的合约重写(override)。下面我们来看一段示例代 码：

1.可以传递参数
2._;
3.放到是函数后面

pragma solidity ^0.4.24;
​
contract ModifyTest{
    uint256 public value;
    address public owner;
    //构造函数
    constructor()public{
        owner=msg.sender;
    }
 
    //修饰器其器器,可以进行传参
    modifier onlyOwner{
    require(msg.sender==owner);
    //_;表示这个修饰其器所修饰的函数代码
    _;
    
    }
    
    //使用修饰器，在将仅管理员可以执行的限定放到函数外面
    function changeValue(uint256 _value)onlyOwner public{
        //传参，一般前面加下滑县
        value=_value;
    }    
}
​

错误处理

传统方法：采用 throw 和 if ... throw 模式(已过时)，例如合约中有一些功能，只能被授权为拥有者的 地址才能调用

if(msg.sender != owner) { throw; }

等价于如下任意一种形式：

if(msg.sender != owner) { revert(); }

assert(msg.sender == owner);

require(msg.sender == owner);

 

代码：

pragma solidity ^0.4.24;
contract HasAnOwner {
    address public owner;
    uint public a ;
constructor() public {
    owner = msg.sender;
}
​
function useSuperPowers()  public { 
    require(msg.sender == owner);
    /*
    if (msg.sender != owner){
        throw;
    }
    */
    
    a = 10;
   // do something only the owner should be allowed to do
}
}

合约

合约的创建：

 

pragma solidity ^0.4.24;
​
  contract C1{
      uint256 public value;
      constructor (uint256 _input)public{
          value=_input;
      }
      function getValue()public pure returns(uint256){
          return 100;
      }
      
  }
  contract C2{
      C1 public c1;
      C1 public c11;
      function getValue1()public returns(uint256){
          //创建一个合约，返回一个地址
      address addr=new C1(10 );
     // 地址需要显示的转换为特定类型，才可以正常使用
     c1= C1(addr);
     return c1.getValue();
      
  }    
  
  function getValue2()public returns(uint256){
      //定义的时候，同时完成转换
      c11=new C1(20 );
      return c11.getValue();
  } 
  
  C1 public c13;
  function getValue3(address _addr)public returns(uint256){
     //当传入地址是时，需要显示的转换，否则不可以用
      c13=C1(_addr);
      return c13.getValue();
  }
    }

合约继承 is关键字；最远继承

pragma solidity ^0.4.0;

contract Base1{

　　function data() pure returns(uint){

　　　　 return 1;　

　　}

}

contract Base2{

　　 function data() pure returns(uint){

　　　　 return 2;

　　 }

}

//继承base2的data方法

contract MostDerived1 is Base1, Base2{ }

//继承base1的data方法

contract MostDerived2 is Base2, Base1{

}

可以指定某个父合约

pragma solidity ^0.4.0;

contract Base1{

　　 function data() pure returns(uint){

　　　　 return 1;

　　 }

}

contract Base2{

　　　　 function data() pure returns(uint){

　　　　 return 2;

　　 }

}

contract MostDerived1 is Base1, Base2{

　　　　function mydata() pure returns(uint){

　　　　　　 return Base1.data();

　　　　 }

}

contract MostDerived2 is Base2, Base1{

　　　　 function mydata() pure returns(uint){ return Base2.data();

　　}

}

外部调用

 pragma solidity ^0.4.24;​

contract InfoFeed{

function info()public payable returns(uint256 ret){
     return 42;
 }
 function getBalance()public view returns(uint256){
     return address(this).balance;
 }
  }  
​
 contract Consumer{
     InfoFeed feed;
     function setFeed(address addr)public{
         feed=InfoFeed(addr);
     }
     function callFeed()public{
     //给Info合约转账10wei ,汽油费上线上限800
     //合约转账语法
     feed.info.value(10).gas(800)();
 }
 
 function()payable public{
     
 }
 
function getBalance()public view returns(uint256){
     return address(this).balance;
 } 
  }

元祖

return（a, b, c） solidity无法返回自定义的数据结构，所以若想返回一个自定义结构的数据，需要在函数中一次返回多个值，即元组。元组是一个数据集合，类似于字典但是无法修改数据，使用圆括号包括多种数据类型。

 //1. 返回⼀一个Student结构
    function getLily() public view returns(string, uint, uint, string) 
{
        Student memory lily = Students[0];
        return (lily.name, lily.age, lily.score, lily.sex);
    }
}

内置数学函数

ripemd160，keccak256，addmod，ecrecover

代码：

pragma solidity ^0.4.24;
​
contract operation{
function Hash()public pure returns(bytes32){
    //先编码。后运算
    bytes memory v1=abi.encodePacked("hello",uint256(1),"world");
    return keccak256(v1);
    }
​
function Test()public pure returns(bytes32){
    bytes32 hash=sha3("hello",uint256(1),"world");//以前的用法，不推荐使用了，和keccak256效果一样
    return keccak256("hello",uint256(1),"world");
　　}
}

delete

delete操作符可以用于任何变量量，将其设置成默认值 如果对动态数组使用delete，则删除所有元素，其长度变为0 如果对静态数组使用delete，则重置所有索引的值

1.new 创建对象、合约
2.delete操作符可以用于任何变量，将其设置为默认值
3.如果对动态数组使用delete，删除所有的元素，其长度变为零
4.如果读静态数组使用delete，则重置所有的索引值（根据元素类型）
5.如果对map 类型使用delete，什么都不会发生
6.但如果对map 类型中的一个兼职键值使用delete，则删除与该键相关的值

 

pragma solidity ^0.4.24;
contract Delet{
//1.string
string public str ="hello";
function deleteDtring()public{
    //删除之后n便变为0
    delete str;
}
​
//2.array，对于固定长度的数组。则会想删除每个元素的值，但是数组的元素不变
int256[10] public arr=[1,2,3,4,5];
function deleteFixArray()public{
    delete arr;
}
​
//3.array new 
uint256[]  arr1=new uint256[](10);
function setArray()public{
    for (uint256 i=0; i< arr1.length; i++){
        arr1[i]=i;
    }
    
}
function deleteArray()public{
    delete arr1;
    
}
function getArray()public view returns(uint256[]){
    return arr1;
}
​
//mapping
mapping(uint256=>string)m1;
function setMaping()public{
    m1[1]="hello";
    m1[2]="world";
}
function deleteMapping()public{
    //delete m1;不允许，只能删除键值内容
    
    delete m1[1];
}
function getMapping(uint256 _index)public view returns(string){
    return m1[_index];
    }
}

 补充：被internal修饰的函数，可以被内部合约调用，也可以被子合约调用，外部合约无法调用

ECR20：代币编写规范   推荐：https://www.jianshu.com/p/a5158fbfaeb9