美文网首页Blockchain区块链研习社区块链实践专题
Solidity的数组特性深入详解(十)| 入门系列

Solidity的数组特性深入详解(十)| 入门系列

作者: TryBlockchain | 来源:发表于2017-04-08 18:49 被阅读1658次

    数组在所有的语言当中都是一种常见类型。在Solidity中,可以支持编译期定长数组和变长数组。一个类型为T,长度为k的数组,可以声明为T[k],而一个变长的数组则声明为T[]

    1. 创建一个数组

    1.1 字面量

    创建数组时,我们可以使用字面量,隐式创建一个定长数组。

    pragma solidity ^0.4.0;
    
    contract ArrayLiteral{
      function arrayLiteral(){
        uint[3] memory a = [uint(1), 2, 3];
    
        //长度必须匹配
        //Type string memory[1] memory is not implicitly convertible to expected type string memory[2] memory.
        //string[2] memory b = ["a"];
      }
    }
    
    

    通过上面的代码,我们可以发现。

    首先元素类型是刚好能存储的元素的类型,比如代码里的[1, 2, 3],只需要uint8即可存储。但由于我们声明的变量是uint(默认的uint表示的其实是uint256),所以要使用uint(1)来进行显式的类型转换。

    其次,字面量方式声明的数组是定长的,且实际长度要与声明的相匹配,否则编译器会报错Type string memory[1] memory is not implicitly convertible to expected type string memory[2] memory

    1.2 new关键字

    对于变长数组,在初始化分配空间前不可使用,可以通过new关键字来初始化一个数组。

    pragma solidity ^0.4.0;
    
    contract NewArray{
      uint[] stateVar;
    
      function f(){
       //定义一个变长数组
        uint[] memory memVar;
    
        //不能在使用new初始化以前使用
        //VM Exception: invalid opcode
        //memVar [0] = 100;
    
        //通过new初始化一个memory的变长数组
        memVar = new uint[](2);
        
        //不能在使用new初始化以前使用
        //VM Exception: invalid opcode
        //stateVar[0] = 1;
        
        //通过new初始化一个storage的变长数组
        stateVar = new uint[](2);
        stateVar[0] = 1;
      }
    }
    

    在上面的例子中,我们声明了一个storagestateVar,和一个memorymemVar。它们不能在使用new关键字初始化前使用下标方式访问,会报错VM Exception: invalid opcode。可以根据情况使用如例子中的new uint[](2);来进行初始化。

    2. 数据的属性和方法

    2.1 length属性

    数组有一个length属性,表示当前的数组长度。对于storage的变长数组,可以通过给length赋值调整数组长度。

    2.1.1 storage

    我们来看一个自增长数组的例子。

    pragma solidity ^0.4.0;
    
    contract AutoExtendArray{
      uint[] stateVar = new uint[](1);
    
      function autoExendArray(uint a) returns (uint){
        //stateVar.length++语句会修改数组的长度加1
        stateVar[stateVar.length++] = a;
        return stateVar[stateVar.length - 1];
      }
    }
    

    在上面这个例子中,我们可以看到,通过stateVar.length++语句对数组长度进行自增,我们就得到了一个不断变长的数组。

    还可以使用后面提到的push()方法,来隐式的调整数组长度。

    不能通过对超出当前数组的长度序号元素赋值的方式,来实现数组长度的自动扩展。

    2.1.2 memory

    对于memory的变长数组,不支持修改length属性,来调整数组大小。memory的变长数组虽然可以通过参数灵活指定大小,但一旦创建,大小不可调整。

    2.2 push方法

    变长的storage数组和bytes(不包括string)有一个push()方法。可以将一个新元素附加到数组末端,返回值为当前长度。

    pragma solidity ^0.4.0;
    
    contract NewArray{
      uint[] stateVar;
    
      function f() returns (uint){
        //在元素初始化前使用
        stateVar.push(1);
    
        stateVar = new uint[](1);
        stateVar[0] = 0;
        //自动扩充长度
         uint len = stateVar.push(1);
    
        //不支持memory
        //Member "push" is not available in uint256[] memory outside of storage.
        //uint[] memory memVar = new uint[](1);
        //memVar.push(1);
    
        return len;
      }
    }
    

    在上面的代码中,我们声明了一个storagestateVar,在未显式初始化的情况下,通过push()附加了一个新值,方法内进行了初始化。后面的代码中,我们通过stateVar = new uint[](1);显示分配了存储空间为1,使用push()能实现存储空间的自动扩展。另外,我们发现,memory的变长数组不支持push()

    2.3 下标

    与大多数语言一样,数组可以通过数字下标访问,从0开始。对于大小为2的数组T[2],要访问第二个元素,要使用下标值1

    如果状态变量的类型为数组,也可以标记为public类型,从而让Solidity创建一个访问器。

    pragma solidity ^0.4.0;
    
    contract ArrayPublic{
      uint[] public stateVar = [uint(1)];
    }
    

    如上面的合约在Remix运行后,需要我们填入的是一个要访问序号的数字,来访问具体某个元素。

    3. 多维数组

    多维数据的定义与非区块链语言类似。如,我们要创建一个长度为5uint数组,每个元素又是一个变长数组。将被声明为uint[][5](注意,定义方式对比大多数语言来说是反的,使用下标访问元素时与其它语言一致)。

    pragma solidity ^0.4.6;
    
    contract ArrayMD{
    
        //一个变长的数组,里面的每个元素是一个长度为2的数组。
        //定义方式与常规语言相反
        bool[2][] flags;
    
        function appendFlag() returns(uint length) {
           //添加一个新元素到二维数组中
           return flags.push([true,true]);
        }
    
        function getFlag(uint dynamicIndex, uint lengthTwoIndex) constant returns(bool flag) {
          //访问数组,第一个为变长数组的序号,第二个为长度为2的数组序号
          return flags[dynamicIndex][lengthTwoIndex];
        }
    }
    

    在上面的代码中,我们声明了一个二维数组,它是一个变长的数组,里面的每个元素是一个长度为2的数组。要访问这个数组flags,第一个下标为变长数组的序号,第二个下标为长度为2的数组序号。

    4. bytes与String

    bytesstring是一种特殊的数组。bytes类似byte[],但在外部函数作为参数调用中,会进行压缩打包,更省空间,所以应该尽量使用bytes[1]string类似bytes,但不提供长度和按序号的访问方式。

    由于bytesstring,可以自由转换,你可以将字符串s通过bytes(s)转为一个bytes。但需要注意的是通过这种方式访问到的是UTF-8编码的码流,并不是独立的一个个字符。比如中文编码是多字节,变长的,所以你访问到的很有可能只是其中的一个代码点。

    另外bytes支持push()方法,参考2.2节说明。

    5. 限制

    当前在外部函数中,不能使用多维数组。另外,因为EVM的限制,不能通过外部函数返回变长的数据。

    pragma solidity ^0.4.0;
    
    contract ArrayWarming {
        function f() returns (uint[]) {
            return new uint[](1);
        }
    
        //Return argument type inaccessible dynamic type is not implicitly convertible to expected type (type of first return variable) uint256[] memory.
        /*
        function g() returns (uint[]){
            return this.f();
        }
    }
    */
    

    在上面的例子中,f()返回的是uint[]的变长数组。使用web3.js的方式可以访问得到结果,但使用Solidity的外部函数的访问方式,将编译不通过,提示Return argument type inaccessible dynamic type is not implicitly convertible to expected type

    对于这样的问题的一种临时的解决办法,是使用一个非常大的定长数组。

    pragma solidity ^0.4.0;
    
    contract ArrayBig {
        function f() returns (uint[1]) {
          //构造一个超级大数组,来拼装你想返回的结果
          return [uint(1)];
        }
    
        function g() returns (uint[1]){
            return this.f();
        }
    }
    

    关于作者

    专注基于以太坊的相关区块链技术,了解以太坊,Solidity,Truffle。
    博客:http://me.tryblockchain.org

    参考资料


    1. 因为字节数组在使用时会padding,所以不节省空间。https://github.com/chriseth/solidity/blob/48588b5c4f21c8bb7c5d4319b05a93ee995b457d/_docs/faq_basic.md#what-is-the-difference-between-bytes-and-byte

    相关文章

      网友评论

      • string2020:solidity 里面,字符串拼接怎么做?

      本文标题:Solidity的数组特性深入详解(十)| 入门系列

      本文链接:https://www.haomeiwen.com/subject/uoxrattx.html