智能合約語言 Solidity 教程系列3 - 函數類型

時間 2019-11-19

標籤智能合約語言 solidity 教程系列函數類型简体版

原文原文鏈接

本文首發於深刻淺出區塊鏈社區原文連接:智能合約語言 Solidity 教程系列3 - 函數類型原文已更新，請讀者前往原文閱讀html

Solidity 教程系列第三篇 - Solidity 函數類型介紹。 Solidity 系列完整的文章列表請查看分類-Solidity。編程

寫在前面

Solidity 是以太坊智能合約編程語言，閱讀本文前，你應該對以太坊、智能合約有所瞭解，若是你還不瞭解，建議你先看以太坊是什麼oracle

本文前半部分是參考Solidity 官方文檔（當前最新版本：0.4.20）進行翻譯，後半部分函數可見性（ public, external, internal, privite ）深度分析（僅針對專欄訂閱用戶）。編程語言

函數類型（Function Types）

函數也是一種類型，且屬於值類型。能夠將一個函數賦值給一個函數類型的變量。還能夠將一個函數做爲參數進行傳遞。也能夠在函數調用中返回一個函數。函數類型有兩類:內部(internal)和外部(external)函數函數

內部(internal)函數只能在當前合約內被調用（在當前的代碼塊內，包括內部庫函數，和繼承的函數中）。 外部(external)函數由地址和函數方法簽名兩部分組成，可做爲外部函數調用的參數，或返回值。學習

函數類型定義以下：區塊鏈

function (<parameter types>) {internal|external} [pure|constant|view|payable] [returns (<return types>)]

若是函數不須要返回，則省去returns (<return types>) 函數類型默認是internal，所以internal能夠省去。但以此相反，合約中函數自己默認是public的，僅僅是看成類型名使用時默認是internal的。ui

有兩個方式訪問函數，一種是直接用函數名f, 一種是this.f，前者用於內部函數，後者用於外部函數。this

若是一個函數變量沒有初始化，直接調用它將會產生異常。若是delete了一個函數後調用，也會發生一樣的異常。編碼

若是外部函數類型在Solidity的上下文環境之外的地方使用，他們會被視爲function類型。它會編碼爲20字節的函數所在地址，和在它以前的4字節的函數方法簽名一塊兒做爲bytes24類型。合約中的public的函數，可使用internal和external兩種方式來調用。 internal訪問形式爲f, external訪問形式爲this.f

成員: 屬性 selector

public (或 external) 函數有一個特殊的成員selector, 它對應一個ABI 函數選擇器。 ```js pragma solidity ^0.4.16;

contract Selector {
function f() public view returns (bytes4) {
    return this.f.selector;
}
}
```

下面的代碼顯示內部（internal）函數類型的使用：

pragma solidity ^0.4.16;

library ArrayUtils {
  // internal functions can be used in internal library functions because
  // they will be part of the same code context
  function map(uint[] memory self, function (uint) pure returns (uint) f)
    internal
    pure
    returns (uint[] memory r)
  {
    r = new uint[](self.length);
    for (uint i = 0; i < self.length; i++) {
      r[i] = f(self[i]);
    }
  }
  function reduce(
    uint[] memory self,
    function (uint, uint) pure returns (uint) f
  )
    internal
    pure
    returns (uint r)
  {
    r = self[0];
    for (uint i = 1; i < self.length; i++) {
      r = f(r, self[i]);
    }
  }
  function range(uint length) internal pure returns (uint[] memory r) {
    r = new uint[](length);
    for (uint i = 0; i < r.length; i++) {
      r[i] = i;
    }
  }
}

contract Pyramid {
  using ArrayUtils for *;
  function pyramid(uint l) public pure returns (uint) {
    return ArrayUtils.range(l).map(square).reduce(sum);
  }
  function square(uint x) internal pure returns (uint) {
    return x * x;
  }
  function sum(uint x, uint y) internal pure returns (uint) {
    return x + y;
  }
}

下面的代碼顯示外部（external）函數類型的使用：

pragma solidity ^0.4.11;

contract Oracle {
  struct Request {
    bytes data;
    function(bytes memory) external callback;
  }
  Request[] requests;
  event NewRequest(uint);
  function query(bytes data, function(bytes memory) external callback) public {
    requests.push(Request(data, callback));
    NewRequest(requests.length - 1);
  }
  function reply(uint requestID, bytes response) public {
    // Here goes the check that the reply comes from a trusted source
    requests[requestID].callback(response);
  }
}

contract OracleUser {
  Oracle constant oracle = Oracle(0x1234567); // known contract
  function buySomething() {
    oracle.query("USD", this.oracleResponse);
  }
  function oracleResponse(bytes response) public {
    require(msg.sender == address(oracle));
    // Use the data
  }
}