🐭3 其它类型

[TOC]

其它类型

函数类型

数类型是一种表示函数的类型。

• 可以将一个函数赋值给另一个函数类型的变量，也可以将一个函数作为参数进行传递，还能在函数调用中返回函数类型变量。

• 函数类型有两类：内部（internal） 函数类型 和 外部（external） 函数类型。

• 内部函数只能在当前合约内被调用（更具体来说，在当前代码块内，包括内部库函数和继承的函数中），因为它们不能在当前合约上下文的外部被执行。 调用一个内部函数是通过跳转到它的入口标签来实现的，就像在当前合约的内部调用一个函数。

• 外部函数由一个地址和一个函数签名组成，可以通过外部函数调用传递或者返回。

• 函数类型默认是内部函数，因此不需要声明 internal 关键字。

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

枚举类型

枚举是在Solidity中创建用户定义类型的一种方法， 它们可以显式所有整型相互转换，但不允许隐式转换。

• 从整型显式转换枚举，会在运行时检查在枚举范围内，否则会导致异常（ Panic异常 ）。

• 枚举需要至少一个成员，默认值是第一个成员，枚举不能多于 256 个成员。

    enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
    ActionChoices choice;
    ActionChoices constant defaultChoice = ActionChoices.GoStraight;

    function setGoStraight() public {
        choice = ActionChoices.GoStraight;
    }

    // 由于枚举类型不属于 |ABI| 的一部分，因此对于所有来自 Solidity 外部的调用，
    // "getChoice" 的签名会自动被改成 "getChoice() returns (uint8)"。

    function getChoice() public view returns (ActionChoices) {
        return choice;
    }

    function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
    }
`

基本类型之间的转换

隐式转换

编译器自动进行隐式类型转换

• 在赋值、参数传递给函数以及应用运算符时，如果符合值类型隐式转换的条件，就会进行隐式类型转换。

• uint8 可以转换成 uint16，int128 转换成 int256，但 int8 不能转换成 uint256 （因为 uint256 不能涵盖某些值，例如，-1）。

• 将运算符应用于不同的类型，编译器将尝试将其中一个操作数隐式转换为另一个操作数的类型（赋值也是如此）。 这意味着操作始终以操作数之一的类型执行。

• uint8 可以被隐式转换为 uint16，相反却不可以，因为 uint8 不如 uint16 范围大。

显式转换

编译器不支持隐式转换，但是编程者知道一定可以转换，这种情况下用显式转换。

int8 x = 10;
uint8 y = uint8(x);

以太币 Ether 单位

• 以太币 Ether 单位之间的换算就是在数字后边加上 wei、gwei 或 ether 来实现的，如果后面没有单位，缺省为 wei。例如 2 ether == 2000 finney 的逻辑判断值为 true。

• 从0.7.0开始 finney 和 szabo 被移除了。

字面量数字使用后缀wei、finney、szabo 或 ether 在不同面额中转换。

• 1 ether = 1000 finney，10的3次方

• 1 ether = 1000 000 szabo，10的6次方

• 1 ether = 1000 000 000 000 000 000 wei，10的18次方

• 以太币单位是以密码学家的名字命名，wei：WeiDai 戴伟，finney：Hal Finney 芬尼，szabo：Nick Szabo 尼克萨博。

• 从wei开始往上增加

单位	说明
wei	1 wei，最小单位
kwi(babbage)	1 wei = 1000 wei，10的3次方
Mwei(lovelace)	1 Mwei = 1000 000 wei，10的6次方
Gwei(shannon)	1 Gwei = 1000 000 000 wei，10的9次方
microether(szabo)	1 szabo = 1000 000 000 000 wei，10的12次方
milliether(finney)	1 finney = 1000 000 000 000 000 wei，10的15次方
ether	1 eth = 1000 000 000 000 000 000 wei，10的18次方

时间单位

秒是缺省时间单位，在时间单位之间，数字后面带有 seconds、 minutes、 hours、 days 和 weeks 的可以进行换算，基本换算关系如下：

• 1 == 1 seconds

• 1 minutes == 60 seconds

• 1 hours == 60 minutes

• 1 days == 24 hours

• 1 weeks == 7 days

• 由于闰秒造成的每年不都是 365 天、每天不都是 24 小时 leap seconds，所以如果使用这些单位计算日期和时间，注意因为闰秒是无法预测的，所以需要借助外部的预言机（oracle，是一种链外数据服务）来对一个确定的日期代码库进行时间矫正。

• years 已经在 0.5.0 版本去除了，因为闰年的原因。

• 这些后缀不能直接用在变量后边。如果想用时间单位（例如 days）来将输入变量换算为时间，可以用如下方式来完成：

function f(uint start, uint daysAfter) public {
    if (block.timestamp >= start + daysAfter * 1 days) {
        // ...
    }
}

操作符

操作符	说明
++，--	自增，自减。
+，-，*，/	运算符加减乘除
%	取模
delete	一元删除
&，	，!
~	位操作非
^	异或
<<，>>	左右位移

，<，>= ，<= | 大于，小于，大于等于，小于等于 ==，!= | 等于，不等于 &&，|| | 逻辑并且，逻辑或者 条件 ? 成立执行 : 不成立执行 | 三元操作符 *** | 求幂

求幂

• 求幂仅适用于指数中的无符号类型。求幂的结果类型始终等于基数的类型。要注意其大小足以容纳结果，并为潜在的断言失败或包装行为做好准备。

• 在选中模式下，求幂仅使用相对便宜的 exp 用于小型基地的操作码。对于： x**3 ，xxx 可能会更便宜。在任何情况下，汽油成本测试和优化器的使用都是可取的。

• 注意 0**0 由EVM定义为 1 .

字符串

字符串比较

Solidity 不支持字符串的 == 比较。出于性能的考虑，可以首先对字符串的长度进行比较，然后再比较内容或 Hash 值。先对长度进行比较再比较 string 的 Hash 值是最优的选择。

比较 string 的哈希值。

    function test2(string memory s1,string memory s2) public pure returns(bool){
        return keccak256(bytes(s1)) == keccak256(bytes(s2));
    }

先比较 string 的长度，再比较每个对应位置的字母是否相同。

    function test3(string memory s1,string memory s2) public pure returns(bool){
        if (bytes(s1).length != bytes(s2).length) {
            return false;
        }
        for (uint i = 0; i < bytes(s1).length; i ++) {
            if(bytes(s1)[i] != bytes(s2)[i]) {
                return false;
            }
        }
        return true;
    }

先比较 string 的长度，再比较 string 的哈希值 是最优选择。

    function test4(string memory s1,string memory s2) public pure returns(bool){
        if (bytes(s1).length != bytes(s2).length) {
            return false;
        }
        return keccak256(abi.encodePacked(s1)) == keccak256(abi.encodePacked(s2));
    }

字符串拼接

字符串拼接，官网上给出的方法是使用 abi.encodePacked 方法，自己实现则可以把 string 转换成 bytes，然后将 bytes 合并成一个大的 bytes，最后再将结果 bytes 转换成 string。

通过 bytes 实现。

    function test5(string memory s1,string memory s2) public pure returns(string memory){
        bytes memory s1b = bytes(s1);
        bytes memory s2b = bytes(s2);
        string memory ret = new string(s1b.length + s2b.length);
        bytes memory bret = bytes(ret);
        uint k = 0;
        for (uint i = 0; i < s1b.length; i++) bret[k++] = s1b[i];
        for (uint i = 0; i < s2b.length; i++) bret[k++] = s2b[i];
        return string(ret);
    }

通过 abi.encodePacked 实现更简洁，是官方推荐的方式。

    function test6(string memory s1,string memory s2) public pure returns(string memory){
        return string(abi.encodePacked(s1, s2));
    }

字符串转换

Solidity 不支持 string 与 int 的互相转换。工具类 oraclize 是把 string 首先转换成 bytes 类型，然后逐个遍历，进行数值累加。

    function uintToString(uint256 _i) public pure returns (string memory str){
        if (_i == 0){
            return "0";
        }
        uint256 j = _i;
        uint256 length;
        while (j != 0) {
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint256 k = length;
        j = _i;
        while (j != 0){
            bstr[--k] = bytes1(uint8(48 + j % 10));
            j /= 10;
        }
        str = string(bstr);
    }

    function stringToUint(string memory numString) public pure returns(uint) {
        uint  val=0;
        bytes   memory stringBytes = bytes(numString);
        for (uint  i =  0; i<stringBytes.length; i++) {
            uint exp = stringBytes.length - i;
            bytes1 ival = stringBytes[i];
            uint8 uval = uint8(ival);
           uint jval = uval - uint(0x30);
   
           val +=  (uint(jval) * (10**(exp-1))); 
        }
      return val;
    }