首页 > 其他分享 >『0016』 - Solidity Types - 玩转 Solidity 数组 （Arrays）

『0016』 - Solidity Types - 玩转 Solidity 数组 （Arrays）

时间：2023-04-08 17:02:32浏览次数：33  
标签：function 0016 Arrays Solidity length uint 数组 memory public

作者：黎跃春，

学习目标

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

固定长度的数组（Arrays）

固定长度类型数组的声明

pragma solidity ^0.4.4;

contract C {

    // 数组的长度为5，数组里面的存储的值的类型为uint类型
    uint [5] T = [1,2,3,4,5];
}

通过length方法获取数组长度遍历数组求总和

pragma solidity ^0.4.4;

contract C {

    // 数组的长度为5，数组里面的存储的值的类型为uint类型
    uint [5] T = [1,2,3,4,5];


    // 通过for循环计算数组内部的值的总和
    function numbers() constant public returns (uint) {
        uint num = 0;
        for(uint i = 0; i < T.length; i++) {
            num = num + T[i];
        }
        return num;
    }

}

尝试修改T数组的长度

pragma solidity ^0.4.4;

contract C {

    uint [5] T = [1,2,3,4,5];


    function setTLength(uint len) public {

        T.length = len;
    }


}

PS:声明数组时，一旦长度固定，将不能再修改数组的长度。

尝试修改T数组内部值

pragma solidity ^0.4.4;

contract C {

    uint [5] T = [1,2,3,4,5];


    function setTIndex0Value() public {

        T[0] = 10;
    }

    // 通过for循环计算数组内部的值的总和
    function numbers() constant public returns (uint) {
        uint num = 0;
        for(uint i = 0; i < T.length; i++) {
            num = num + T[i];
        }
        return num;
    }

}

T数组初始的内容为[1,2,3,4,5]，总和为15 ，当我点击setTIndex0Value方法将第0个索引的1修改为10时，总和为24。

PS：通过一个简单的试验可证明固定长度的数组只是不可修改它的长度，不过可以修改它内部的值，而bytes0 ~ bytes32固定大小字节数组中，大小固定，内容固定，长度和字节均不可修改。

尝试通过push往T数组中添加值

pragma solidity ^0.4.4;

contract C {

    uint [5] T = [1,2,3,4,5];


    function pushUintToT() public {

        T.push(6);
    }
}

PS:固定大小的数组不能调用push方法向里面添加存储内容，声明一个固定长度的数组，比如：uint [5] T，数组里面的默认值为[0,0,0,0,0]，我们可以通过索引修改里面的值，但是不可修改数组长度以及不可通过push添加存储内容。

可变长度的Arrays

可变长度类型数组的声明

pragma solidity ^0.4.4;

contract C {

    uint [] T = [1,2,3,4,5];

    function T_Length() constant returns (uint) {

        return T.length;
    }

}

uint [] T = [1,2,3,4,5]，这句代码表示声明了一个可变长度的T数组，因为我们给它初始化了5个无符号整数，所以它的长度默认为5。

通过length方法获取数组长度遍历数组求总和

pragma solidity ^0.4.4;

contract C {

    uint [] T = [1,2,3,4,5];

    // 通过for循环计算数组内部的值的总和
    function numbers() constant public returns (uint) {
        uint num = 0;
        for(uint i = 0; i < T.length; i++) {
            num = num + T[i];
        }
        return num;
    }

}

尝试修改T数组的长度

pragma solidity ^0.4.4;

contract C {

    uint [] T = [1,2,3,4,5];

    function setTLength(uint len) public {

        T.length = len;
    }

    function TLength() constant returns (uint) {

        return T.length;
    }
}

PS：对可变长度的数组而言，可随时通过length修改它的长度。

尝试通过push往T数组中添加值

pragma solidity ^0.4.4;

contract C {

    uint [] T = [1,2,3,4,5];

    function T_Length() constant public returns (uint) {

        return T.length;
    }

    function pushUintToT() public {

        T.push(6);
    }

    function numbers() constant public returns (uint) {
        uint num = 0;
        for(uint i = 0; i < T.length; i++) {
            num = num + T[i];
        }
        return num;
    }
}

PS：当往里面增加一个值，数组的个数就会加1，当求和时也会将新增的数字加起来。

二维数组 - 数组里面放数组

pragma solidity ^0.4.4;

contract C {

    uint [2][3] T = [[1,2],[3,4],[5,6]];

    function T_len() constant public returns (uint) {

        return T.length; // 3
    }
}

uint [2][3] T = [[1,2],[3,4],[5,6]]这是一个三行两列的数组，你会发现和Java、C语言等的其它语言中二位数组里面的列和行之间的顺序刚好相反。在其它语言中，上面的内容应该是这么存储uint [2][3] T = [[1,2,3],[4,5,6]]。

上面的数组T是storage类型的数组，对于storage类型的数组，数组里面可以存放任意类型的值（比如：其它数组，结构体，字典／映射等等）。对于memory类型的数组，如果它是一个public类型的函数的参数，那么它里面的内容不能是一个mapping(映射／字典)，并且它必须是一个ABI类型。

创建 Memory Arrays

创建一个长度为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 {
        // ...
    }
}

在这段代码中，我们将[1, 2, 3]里面的第0个参数的类型强制转换为uint类型，所以整个[uint(1), 2, 3]的类型就匹配了g函数中的uint[3]类型。

memory类型的固定长度的数组不可直接赋值给storage/memory类型的可变数组

  • TypeError: Type uint256[3] memory is not implicitly convertible to expected type uint256[] memory.
pragma solidity ^0.4.4;

contract C {
    function f() public {

        uint[] memory x = [uint(1), 3, 4];
    }
}
browser/ballot.sol:8:9: TypeError: Type uint256[3] memory is not implicitly convertible to expected type uint256[] memory.
        uint[] memory x = [uint(1), 3, 4];
        ^-------------------------------^
  • TypeError: Type uint256[3] memory is not implicitly convertible to expected type uint256[] storage pointer
pragma solidity ^0.4.4;

contract C {
    function f() public {

        uint[] storage x = [uint(1), 3, 4];
    }
}
browser/ballot.sol:8:9: TypeError: Type uint256[3] memory is not implicitly convertible to expected type uint256[] storage pointer.
        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、bytes以及string的使用。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;
    byte[9] aa = [byte(0x6c),0x69,0x79,0x75,0x65,0x63,0x68,0x75,0x6e];

    byte[] cc = new byte[](10);

    function setAIndex0Byte() public {
        // 错误，不可修改
        a[0] = 0x89;
    }

    function setAAIndex0Byte() public {

        aa[0] = 0x89;
    }

    function setCC() public {

        for(uint i = 0; i < a.length; i++) {

            cc.push(a[i]);
        }
    }

}

总结

本篇文章系统讲解了可变与不可变数组的创建、以及二位数组与其它语言中二位数组的区别，同时讲解了如何创建memory类型的数组以及对bytes0 ～ bytes32、bytes与byte[]对比分析。

技术交流

  • 区块链技术交流QQ群：348924182


标签：function,0016,Arrays,Solidity,length,uint,数组,memory,public
From： https://blog.51cto.com/u_10981011/6177808

相关文章

  • 『0012』 - Solidity Types - 字符串(String Literals)
    作者：黎跃春，案例字符串可以通过""或者''来表示字符串的值，Solidity中的string字符串不像C语言一样以\0结束，比如我的微信号liyc1215这个字符串的长度就为我们所看见的字母的个数，它的长度为8。pragmasolidity^0.4.4;contractStringLiterals{string_name;//状态变量......
  • 『0009』 - Solidity Types - 布尔(Booleans)
    作者：黎跃春，布尔(Booleans)bool:可能的取值为常量值true和false。支持的运算符：!逻辑非&&逻辑与||逻辑或==等于!=不等于备注：运算符&&和||是短路运算符，如f(x)||g(y)，当f(x)为真时，则不会继续执行g(y)在f(x)&&g(y)表达式中，当f(x)为false时，则不会执行g(y)。boola=true;boolb=......
  • 『0013』 - Solidity Types - 固定大小字节数组(Fixed-size byte arrays)
    作者：黎跃春，固定大小字节数组(Fixed-sizebytearrays)固定大小字节数组可以通过bytes1,bytes2,bytes3,…,bytes32来进行声明。PS：byte的别名就是byte1。bytes1只能存储一个字节，也就是二进制8位的内容。bytes2只能存储两个字节，也就是二进制16位的内容。bytes3只能存储三个字......
  • 『0015』 - Solidity Types - （Dynamically-sized byte array）、（Fixed-size byte arrays
    作者：黎跃春，大纲固定大小字节数组（Fixed-sizebytearrays）之间的转换固定大小字节数组(Fixed-sizebytearrays)转动态大小字节数组(Dynamically-sizedbytearray)固定大小字节数组（Fixed-sizebytearrays）不能直接转换为string动态大小字节数组(Dynamically-sizedbytearray)转stri......
  • 『0008』- Solidity中public、internal、private在状态变量和函数中的使用以及Solidit
    作者：黎跃春，在上一小节中我们在函数参数中使用storage这个关键字时，当前的函数必须是internal或者private类型。在本小节中，我（微信：liyc1215）将重点为大家介绍属性和函数的使用权限。状态变量、函数的权限一、public备注：为了演示方便，我直接通过https://remix.ethereum.org/来进行演示。p......
  • 『0004』- 基于Ethereum Wallet的Solidity HelloWorld智能合约(Smart Contract)
    作者：黎跃春，相信大家都有学习各种开发语言的经历，一般学习任何一门语言都会先从最简单的HelloWorld开始，所以本篇文章，我们将编写一个最基本的合约代码，并且一步步讲解如何通过EthereumWallet将合约部署到区块链，同时我们将通过本demo的演示如何通过发送数据和接收数据和合约进行交互。S......
  • 『0014』 - Solidity Types - 动态大小字节数组(Dynamically-sized byte array)
    作者：黎跃春，一、Dynamically-sizedbytearraystring是一个动态尺寸的UTF-8编码字符串，它其实是一个特殊的可变字节数组，string是引用类型，而非值类型。bytes动态字节数组，引用类型。根据经验，在我们不确定字节数据大小的情况下，我们可以使用string或者bytes，而如果我们清楚的知道或者......
  • 『0018』 - Solidity Types - Solidity 结构体（Structs）
    作者：黎跃春，自定义结构体pragmasolidity^0.4.4;contractStudents{structPerson{uintage;uintstuID;stringname;}}Person就是我们自定义的一个新的结构体类型，结构体里面可以存放任意类型的值。初始化一个结构体初始化一个storage......
  • Arrays.stream().boxed()的使用
    Arrays.stream().boxed()的使用0.写在前面1.Arrays.stream()的使用算法：代码：输出结果：2.boxed()的使用boxed()方法实现在原始类型「primitives」和盒式类型「boxed」之间转换数组3.参考0.写在前面文章翻译自以下本文的最后链接1.Arrays.stream()的使用算法：获取要转换的数组。使......
  • 如何在Solidity中建立DAO（去中心化自治组织）？
    本文将帮助您理解DAO的概念，并帮助您构建一个基本的DAO。什么是DAO？您可以将DAO视为基于互联网的实体（比如企业），由其股东（拥有代币和比例投票权的成员）共同拥有和管理。在DAO中，决策是通过提案做出的，DAO的成员可以对这些提案进行投票，然后执行它们。DAO完全由可公开查看/可验......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99