Solidity語言學習筆記————12、陣列

固定長度的陣列

固定長度型別陣列的宣告

pragma solidity ^0.4.4;

contract test {

    // 陣列的長度為5，陣列裡面的儲存的值的型別為uint型別
    uint [6] T = [1,2,3,4,5,6];
}

通過length方法獲取陣列長度遍歷陣列求總和

pragma solidity ^0.4.4;


contract test {


    // 陣列的長度為5，陣列裡面的儲存的值的型別為uint型別
    uint [6] T = [1,2,3,4,5,6];


    // 通過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的長度

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;
    }

}

通過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 [3][2] 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[]對比分析。