智能合约基础语言（四）：Solidity函数

function关键字声明的，合约中的可执行单元，一个函数的完整定义如下：

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

3

函数的调用方式

在当前的代码单元内，如对合约内函数，引入的库函数，以及父类合约中的函数直接使用即是以internal方式的调用。我们来看个简单的例子：

pragma solidity ^0.4.24;

contract Test {        function f(){}    
        //以internal的方式调用
    function callInternally(){
        f();
    }
}

external调用，实现为合约的外部消息调用。所以在合约初始化时不能external的方式调用自身函数，因为合约还未初始化完成。下面来看一个以external方式调用的例子：

pragma solidity ^0.4.24;

contract A{        function f(){}
}

contract B{        //以external的方式调用另一合约中的函数
    function callExternal(A a){
        a.f();
    }
}

我们可以在合约的调用函数前加this.来强制以external方式的调用。

pragma solidity ^0.4.24;

contract A{       function f() external{}   
        function callExternally(){          this.f();
    }
}

4

函数的可见性

▪ 声明为external的函数可以从其它合约来进行调用，所以声明为external的函数是合约对外接口的一部分。

▪ 不能以internal的方式进行调用。

▪ 有时在接收大的数据数组时性能更好。

pragma solidity ^0.4.24;

contract FuntionTest{         function externalFunc() external{}         function callFunc(){                //以`internal`的方式调用函数报错
        //Error: Undeclared identifier.
        //externalFunc();
        //以`external`的方式调用函数
        this.externalFunc();
    }
}

▪ 函数默认声明为public。

▪ public的函数既允许以internal的方式调用，也允许以external的方式调用。

▪ public的函数由于允许被外部合约访问，是合约对外接口的一部分。

pragma solidity ^0.4.24;

contract FuntionTest{        //默认是public函数
    function publicFunc(){}        function callFunc(){                //以`internal`的方式调用函数
        publicFunc();        
        //以`external`的方式调用函数
        this.publicFunc();
    }
}

在当前的合约或继承的合约中，只允许以internal的方式调用。

pragma solidity ^0.4.24;

contract A{        function internalFunc() internal{}        function callFunc(){                //以`internal`的方式调用函数
        internalFunc();
    }
}
contract B is A{        //子合约中调用
    function callFunc(){
        internalFunc();
    }
}

▪ 只能在当前合约中被访问（不可在被继承的合约中访问）。

▪ 即使声明为private，仍能被所有人查看到里面的数据，但是不能修改数据且不能被其它合约访问。

pragma solidity ^0.4.24;

contract A{      function privateFunc() private{}      function callFunc(){               //以`internal`的方式调用函数
       privateFunc();
    }
}
contract B is A{        //不可调用`private`
    function callFunc(){                //privateFunc();
        //这里无法调用合约A中的内部函数,
        //且在编译阶段就会报错
    }        //但是间接调用private函数，但是需要这个private函数处在public中
    //function callPrivateByPublicFunc(){
    //    callFunc();
    //}}

5

pure（纯函数）

既不从状态读取数据也不写入数据的函数可以被声明为纯函数 除了之前修改状态数据的情况外，我们认为一下情况属于从状态读取数据。

1. 读取状态变量

2. 调用this.balance或者address.balance

3. 调用block、tx、msg的成员

4. 调用任何非纯函数

5. 使用了包含某些操作码的内联汇编

pragma solidity ^0.4.24;

contract C {    function f(uint a, uint b) public pure returns (uint) {            return a * (b + 42);
    }
}

6

constant/view（只读函数）

7

函数修改器

在实际情况中，我们经常需要对调用者进行一些限制。比如，只能是合约的所有者才能改变归属。我们一起来看看如何用函数修改器实现这一限制：

pragma solidity ^0.4.24;

contract Ownable {
  address public owner = msg.sender;    /// 限制只有创建者才能访问  modifier onlyOwner {         if (msg.sender != owner) throw;        _;
  }    /// 改变合约的所有者  function changeOwner(address _newOwner)
  onlyOwner
  {        if(_newOwner == 0x0) throw;
    owner = _newOwner;
  }
}

8

payable（接收以太币函数）

9

回退函数

每一个合约有且仅有一个没有名字的函数。这个函数无参数，也无返回值。如果调用合约时，没有匹配上任何一个函数(或者没有传哪怕一点数据)，就会调用默认的回退函数。

此外，当合约收到ether时（没有任何其它数据），这个函数也会被执行。在此时，一般仅有少量的gas剩余，用于执行这个函数(准确的说，还剩2300gas)。所以应该尽量保证回退函数使用少的gas。

下述提供给回退函数可执行的操作会比常规的花费得多一点。

写入到存储(storage) 创建一个合约 执行一个外部(external)函数调用，会花费非常多的gas 发送ether 请在部署合约到网络前，保证透彻的测试你的回退函数，来保证函数执行的花费控制在2300gas以内。

一个没有定义一个回退函数的合约。如果接收ether，会触发异常，并返还ether（solidity v0.4.0开始）。所以合约要接收ether，必须实现回退函数。下面来看个例子。下面来看个例子：

pragma solidity ^0.4.24;

contract Test {        function() public payable{}    
        function getX() view returns(uint){           return x;
    }    
        function getBalance() view returns(uint){         return this.balance;
    }
}


contract Caller {        function Caller()payable{}        function callTest(Test test) public{
        test.call(0xabcdef01); 
        // test.transfer(2 ether);
    }                function getBalance() view returns(uint){         return this.balance;
    }
}

10

构造函数

构造函数是一个用constructor关键字声明的可选函数，它在创建合约时执行。构造函数可以是public，也可以是internal。如果没有构造函数，则该合约将生成默认构造函数：contructor() public {}。

pragma solidity ^0.4.24;

contract A {        uint public a;

    constructor(uint _a) internal {
        a = _a;
    }
}

在版本0.4.22之前，构造函数被定义为与合同名称相同的特殊函数，有且只能有一个，不允许重载。这个函数将在合约创建时，执行一次，用于初始化一些配置。这个语法现在不推荐使用。

pragma solidity ^0.4.24;

contract ContractConstructor{    uint public counter;    function ContractConstructor(){
    counter++;
  }
}

上述合约在创建成功后，counter的值将为1。说明合约在创建时，被调用了一次。

Solidity函数的输入参数的数量是可选的，也可以有任意数量的返回参数。

入参(Input Parameter)与变量的定义方式一致，稍微不同的是，不会用到的参数可以省略变量名称。一种可接受两个整型参数的函数如下:

pragma solidity ^0.4.0;
contract Simple {        function taker(uint _a, uint) {
        // do something with _a.
    }
}

12

访问函数

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

pragma solidity ^0.4.0;contract C{        uint public c = 10;
}contract D{        C c = new C();    
        function getDataUsingAccessor() returns (uint){         return c.c();
    }
}

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

pragma solidity ^0.4.0;


contract C{
    uint public c = 10;    
        function accessInternal() returns (uint){         return c;
    }    
        function accessExternal() returns (uint){          return this.c();
    }
}

13

抽象函数

是没有函数体的的函数。如下：

pragma solidity ^0.4.0;

contract Feline {        function utterance() returns (bytes32);
}

这样的合约不能通过编译，即使合约内也包含一些正常的函数。但它们可以做为基合约被继承。

pragma solidity ^0.4.0;

contract Feline {        function utterance() returns (bytes32);    
        function getContractName() returns (string){         return "Feline";
    }
}


contract Cat is Feline {        function utterance() returns (bytes32) { return "miaow"; }
}

14

数字和加密函数

以下函数式solidity自带的函数

asser(bool condition):

如果条件不满足，抛出异常。

addmod(uint x, uint y, uint k) returns (uint):

计算(x + y) % k。加法支持任意的精度。但不超过(wrap around？)2**256。

mulmod(uint x, uint y, uint k) returns (uint):

计算(x * y) % k。乘法支持任意精度，但不超过(wrap around？)2**256。

keccak256(...) returns (bytes32):

使用以太坊的（Keccak-256）计算HASH值。紧密打包。

sha3(...) returns (bytes32):

等同于keccak256()。紧密打包。

sha256(...) returns (bytes32):

使用SHA-256计算HASH值。紧密打包。

ripemd160(...) returns (bytes20):

使用RIPEMD-160计算HASH值。紧密打包。

ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address):

通过签名信息恢复非对称加密算法公匙地址。如果出错会返回0，例如:

function verify(bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(bool) {        bytes memory prefix = "x19Ethereum Signed Message:n32";
    bytes32 prefixedHash = keccak256(prefix, hash);
    return ecrecover(prefixedHash, v, r, s) == (Your Address);}

revert()：

取消执行，并回撤状态变化。

需要注意的是参数是“紧密打包（tightly packed）”的，意思是说参数不会补位，就直接连接在一起的。下面来看一个例子:

keccak256("ab", "c")keccak256("abc")//hexkeccak256(0x616263)keccak256(6382179)//asciikeccak256(97, 98, 99)