玩轉 Solidity 陣列 (Arrays)
學習目標
- 掌握Arragys的可變不可變的建立
- 深度理解可變陣列和不可變陣列之間的區別
- 二維陣列
- menory arrays的建立
- bytes 0-bytes32,bytes與bytes[]對比
固定長度的陣列(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;
}
}
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;
}
}
```js
PS:對可變長度的陣列而言,可隨時通過length修改它的長度。
#### 嘗試通過push往下T陣列中新增值
```js
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;
}
二維陣列-數組裡面放陣列
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];
}
}
正確使用
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;
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[]對比分析