美文网首页罗韭菜的solidity学习笔记与踩过的坑
罗韭菜的solidity学习(八)solidity数组

罗韭菜的solidity学习(八)solidity数组

作者: 罗雪Melody | 来源:发表于2018-04-10 16:13 被阅读0次

    写在前面

    1.arrays的可变不可变的创建
    2.深度理解可变数组和不可变数组之间的区别
    3.二维数组
    4.memory arrays的创建
    5bytes0~bytes32、bytes与byte[]对比

    固定长度的数组(Arrays)

    • 如 uint [5] = [1,2,3,4,5];
    • 不能通过.length改变长度
    • 能通过索引改变某个值
    • 不能通过push插入值(从而改变长度)

    可变长度的数组(Arrays)

    • 如uint[] T =[1,2,3,4,5] 默认长度为5
    • 可通过.length修改可变数组的长度,因此可以通过改.length为0或者delete清空数组
    • 能通过索引改变某个值
    • 能通过push尾部插入值(在不需要设定长度的情况下)
    • 注意,当如unit[] t = new uint[5]; 其实默认了创了5个0,如果用push加入5个值,则增加为10个。

    二维数组

    • 注意与其他语言相反,如
    
    contract C {
        
        uint [2][3] T = [[1,2],[3,4],[5,6]];
        
        // 1 2
        // 3 4
        // 5 6
        
        // length is 3
        
    }
    
    • 数组里创建可变长度的数组(storage类型)


      image.png
    • memory 类型数组
      创建一个长度为length的memory类型的数组可以通过new关键字来创建。memory数组一旦创建,它不可通过length修改其长度。

    pragma solidity ^0.4.4;

    contract C {

    function f(uint len) {
        uint[] memory a = new uint[](7);
        bytes memory b = new bytes(len);
        // 在这段代码中 a.length == 7 、b.length == len
        a[6] = 8;
    }
    

    }

    数组字面量 Array Literals / 内联数组 Inline Arrays

    pragma solidity ^0.4.4;
    
    
    contract C {
        
        function f() public {
            g([1, 2, 3]);
        }
        
        function g(uint[3] _data) public {
            // ...
        }
    }
    

    在上面的代码中,[1, 2, 3]是 uint8[3] memory 类型,因为1、2、3都是uint8类型,他们的个数为3,所以[1, 2, 3]是 uint8[3] memory 类型。但是在g函数中,参数类型为uint[3]类型,显然我们传入的数组类型不匹配,所以会报错。

    正确写法如下

    pragma solidity ^0.4.4;
    
    contract C {
        
        function f() public {
            g([uint(1), 2, 3]);
        }
        
        function g(uint[3] _data) public {
            // ...
        }
    }
    
    
    • 默认uint[] t是storage类型(可变),加了memory关键字变成不可变
    • 在函数内部的时候,memory类型的固定长度的数组不可直接赋值给storage/memory类型的可变数组
      错误使用:
      memory
    pragma solidity ^0.4.4;
    
    contract C {
       function f() public {
           
           uint[] memory x = [uint(1), 3, 4];
       }
    }
    

    storage

    pragma solidity ^0.4.4;
    
    contract C {
        function f() public {
            
            uint[] storage x = [uint(1), 3, 4];
        }
    }
    

    正确使用

    pragma solidity ^0.4.4;
    
    
    contract C {
        function f() public {
            
            uint[3] memory x = [uint(1), 3, 4];
        }
    }
    

    创建固定大小/可变大小

    • bytes0 ~ bytes32创建的是固定字节大小的字节数组,长度不可变,内容不可修改

    • string是特殊的可变字节数组,它可以转换为bytes以通过length获取它的字节长度,亦可通过索引修改相对应的字节内容。

    • 创建可变字节数组除了可以通过bytes b = new bytes(len)来创建外,我们亦可以通过byte[] b来进行声明。

    • 而bytes0 ~ bytes32我们可以通过byte[len] b来创建,len 的范围为0 ~ 32。不过这两种方式创建的不可变字节数组有一小点区别,bytes0 ~ bytes32直接声明的不可变字节数组中,长度不可变,内容不可修改。而byte[len] b创建的字节数组中,长度不可变,但是内容可修改

    pragma solidity ^0.4.4;
    
    
    contract C {
        
        bytes9 a = 0x6c697975656368756e;
        // length and content can not be modified
        
        byte[9] aa = [byte(0x6c),0x69,0x79,0x75,0x65,0x63,0x68,0x75,0x6e];
        // length cannot, content can
        
       
        function setAIndex0Byte() public {
            // 错误,不可修改
            a[0] = 0x89;
        }
        
        function setAAIndex0Byte() public {
            
            aa[0] = 0x89;
        }
        
         // cc equals to ccc
        byte[] cc = new byte[](10);
        
        bytes ccc = new bytes(10);
        
        function setCC() public {
            
            for(uint i = 0; i < a.length; i++) {
                
                cc.push(a[i]);
            }
        }
           
    }
    

    相关文章

      网友评论

        本文标题:罗韭菜的solidity学习(八)solidity数组

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