Solidity學習記錄

第一章 創建生產僵尸的工廠
第二章 設定僵尸的攻擊功能

前言

本人平時比較忙，只能在周末自學Solidity，盡量在周日更新學習記錄，這份學習記錄不僅僅是記錄我的學習程序，也是我繼續按時學習的監督，

一、本章主要目的

我們在之前的課程建立了僵尸工廠，可以生成僵尸，但只有僵尸這個類，沒有為僵尸添加任何動作和功能（就類似于之前只是做了一個手辦一樣的僵尸），這節課是對僵尸建立起動作相關的功能（讓手辦一樣的僵尸變成可以吃東西，可以感染其他生物的僵尸），這里要添加僵尸的食物來源和如何生成新僵尸，同時注意僵尸要有進食間隔，不能不停地吃東西，同時，由于這個教程的目的是撰寫一個游戲，要支持多玩家模式，所以要記錄好僵尸的所屬，不能讓一個用戶可以隨意的使用他人的僵尸，

二、學習程序

1.本節課程知識點

1、Solidity中，一個十分重要的資料型別：Addresses （地址），
以太坊區塊鏈由 _ account _ (賬戶)組成，你可以把它想象成銀行賬戶，一個帳戶的余額是 Ether （以太）（在以太坊區塊鏈上使用的幣種），你可以和其他帳戶之間支付和接受以太幣，就像你的銀行帳戶可以電匯資金到其他銀行帳戶一樣，
每個帳戶都有一個“地址”，你可以把它想象成銀行賬號，這是賬戶唯一的識別符號，它看起來長這樣：

0x5B38Da6a701c568545dCfcB03FcB875f56beddC4 （這是一個隨機生成的虛擬地址）
注意：地址屬于特定用戶（或智能合約）的，
所以我們可以指定“地址”作為僵尸主人的 ID----因為地址具有唯一表示，當用戶通過與我們的應用程式互動來創建新的僵尸時，新僵尸的所有權被設定到呼叫者的以太坊地址下，

2、我們看到了 _ struct _ 和 _ array _ ， _ mapping _ 是另一種在 Solidity 中存盤有組織資料的方法，mapping是這樣定義的：

//對于金融應用程式，將用戶的余額保存在一個 uint型別的變數中：
mapping (address => uint) public accountBalance;
//或者可以用來通過userId 存盤/查找的用戶名
mapping (uint => string) userIdToName;

mapping本質上是存盤和查找資料所用的key–value（鍵-值對），在第一個例子中，鍵是一個 address，值是一個 uint，在第二個例子中，鍵是一個uint，值是一個 string，

3、我們在設定mapping的時候，有兩個問題要考慮到：
（1）僵尸和擁有者是多對一的關系，即一個僵尸只能有一個擁有者，但一個擁有者可以擁有多個僵尸；

（2）鍵-值對是一對一關系，多個值組成的一個集合可以看成一個值，但想要查找僵尸的擁有者的時間則未定，（如果一個用戶擁有大量的僵尸，用擁有者作為鍵，在修改僵尸的所有權時會花費大量資源或者打亂僵尸的順序，前者會花費gas，這是需要真金白銀的；后者會改變僵尸軍團的秩序，）

4、在 Solidity 中，有一些全域變數可以被所有函式呼叫， 其中一個就是 msg.sender，它指的是當前呼叫者（或智能合約）的 address，使用 msg.sender 很安全，因為它具有以太坊區塊鏈的安全保障 —— 除非竊取與以太坊地址相關聯的私鑰，否則是沒有辦法修改其他人的資料的，
注意：在 Solidity 中，功能執行始終需要從外部呼叫者開始， 一個合約只會在區塊鏈上什么也不做，除非有人呼叫其中的函式，所以 msg.sender總是存在的，（在智能合約的眾籌專案中，msg.sender是十分重要的，它代表著參加眾籌專案的支持者的地址和支付賬戶（因為涉及到從哪個賬戶轉賬、扣錢，所以這個最為關鍵！！！））

5、require使得函式在執行程序中，當不滿足某些條件時拋出錯誤，并停止執行，在呼叫一個函式之前，用 require 驗證前置條件是非常有必要的，（注意：在 Solidity 中，關鍵詞放置的順序并不重要，引數的兩個位置是等效的，）
例如：我們設定每個用戶只能呼叫一次 createRandomZombie函式來生成一個僵尸，則可以在createRandomZombie中首先添加：
require(ownerZombieCount[msg.sender] == 0); // 只有用戶沒有僵尸時才能呼叫

6、Solidity同樣有繼承功能，支持合約之間的繼承，現有一個合約A、合約B，合約B想要繼承合約A，則要寫為contract B is A，由于 B 是從 A 那里 inherits （繼承)過來的， 這意味著當你編譯和部署了 B，它將可以訪問我們定義在B和A中定義的所有公共函式，這可以用于邏輯繼承（比如表達子類的時候，Cat 是一種 Animal）， 但也可以簡單地將類似的邏輯組合到不同的合約中以組織代碼，

7、在 Solidity 中，當你有多個檔案并且想把一個檔案匯入另一個檔案時，可以使用 import 陳述句，若兩個檔案在同一個檔案夾中，可以用如下的代碼：
例如想要將同檔案夾的sol檔案A匯入，則應該寫為：import “./A.sol”;
這樣當我們在這個合約目錄下有一個名為 A.sol 的檔案（ ./ 就是同一目錄的意思），它就會被編譯器匯入，

8、在 Solidity 中，有兩個地方可以存盤變數 —— storage 或 memory，
Storage 變數是指永久存盤在區塊鏈中的變數， Memory 變數則是臨時的，當外部函式對某合約呼叫完成時，記憶體型變數即被移除， 你可以把它想象成存盤在你電腦的硬碟或是RAM中資料的關系，
大多數時候你都用不到這些關鍵字，默認情況下 Solidity 會自動處理它們， 狀態變數（在函式之外宣告的變數）默認為“存盤”形式，并永久寫入區塊鏈；而在函式內部宣告的變數是“記憶體”型的，它們函式呼叫結束后消失，
然而也有一些情況下，你需要手動宣告存盤型別，主要用于處理函式內的 _ struct _ 和 _ array _ 時，
（注：當不得不使用到這些關鍵字的時候，即使用錯了，Solidity 編譯器也發警示提醒你該用什么的，）

9、除 public 和 private 屬性之外，Solidity 還使用了另外兩個描述函式可見性的修飾詞：internal（內部） 和 external（外部），internal 和 private 類似，不過， 如果某個合約繼承自其父合約，這個合約即可以訪問父合約中定義的“內部”函式，external 與public 類似，只不過這些函式只能在合約之外呼叫 - 它們不能被合約內的其他函式呼叫，宣告函式 internal 或 external 型別的語法，與宣告 private 和 public類 型相同，

10、如果我們的合約需要和區塊鏈上的其他的合約會話，則需先定義一個 interface (介面)，先舉一個簡單的例子， 假設在區塊鏈上有這么一個合約：

contract LuckyNumber {
  mapping(address => uint) numbers;

  function setNum(uint _num) public {
    numbers[msg.sender] = _num;
  }

  function getNum(address _myAddress) public view returns (uint) {
    return numbers[_myAddress];
  }
}

這是個很簡單的合約，您可以用它存盤自己的幸運號碼，并將其與您的以太坊地址關聯， 這樣其他人就可以通過您的地址查找您的幸運號碼了，現在假設我們有一個外部合約，使用 getNum 函式可讀取其中的資料，
首先，我們定義 LuckyNumber 合約的 interface ：

contract NumberInterface {
  function getNum(address _myAddress) public view returns (uint);
}

請注意，這個程序雖然看起來像在定義一個合約，但其實內里不同：
首先，我們只宣告了要與之互動的函式 —— 在本例中為 getNum —— 在其中我們沒有使用到任何其他的函式或狀態變數，
其次，我們并沒有使用大括號（{ 和 }）定義函式體，我們單單用分號（;）結束了函式宣告，這使它看起來像一個合約框架，
編譯器就是靠這些特征認出它是一個介面的，
在我們的 app 代碼中使用這個介面，合約就知道其他合約的函式是怎樣的，應該如何呼叫，以及可期待什么型別的回傳值，

11、在 Solidity中，可以讓一個函式回傳多個值，

12、創建一個介面：（1）定義一個名為 XXX 的介面， 請注意，因為我們使用了 contract 關鍵字， 這程序看起來就像創建一個新的合約一樣，（2）在interface里定義了 YYY 函式（不過是復制/粘貼上面的函式，但在 returns 陳述句之后用分號，而不是大括號內的所有內容），

13、回傳多個值的函式可以這樣處理：

function multipleReturns() internal returns(uint a, uint b, uint c) {
  return (1, 2, 3);
}

function processMultipleReturns() external {
  uint a;
  uint b;
  uint c;
  // 這樣來做批量賦值:
  (a, b, c) = multipleReturns();   //按回傳值的順序依次給a、b、c賦值
}

// 或者如果我們只想回傳其中一個變數:
function getLastReturnValue() external {
  uint c;
  // 可以對其他欄位留空:
  (,,c) = multipleReturns();  //只對c賦值，將c賦值為回傳的眾多值中的最后一個回傳值
}

2.最終代碼

代碼如下：

zombiefeeding.sol

//this is zombiefeeding.sol

pragma solidity ^0.4.19;

import "./zombiefactory.sol";

contract KittyInterface {
  function getKitty(uint256 _id) external view returns (
    bool isGestating,
    bool isReady,
    uint256 cooldownIndex,
    uint256 nextActionAt,
    uint256 siringWithId,
    uint256 birthTime,
    uint256 matronId,
    uint256 sireId,
    uint256 generation,
    uint256 genes
  );
}

contract ZombieFeeding is ZombieFactory {

  // 1. 移除這一行:
  address ckAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
  // 2. 只宣告變數:
  KittyInterface kittyContract = KittyInterface(ckAddress);

  // 3. 增加 setKittyContractAddress 方法

  function feedAndMultiply(uint _zombieId, uint _targetDna, string species) public {
    require(msg.sender == zombieToOwner[_zombieId]);
    Zombie storage myZombie = zombies[_zombieId];
    _targetDna = _targetDna % dnaModulus;
    uint newDna = (myZombie.dna + _targetDna) / 2;
    if (keccak256(species) == keccak256("kitty")) {
      newDna = newDna - newDna % 100 + 99;
    }
    _createZombie("NoName", newDna);
  }

  function feedOnKitty(uint _zombieId, uint _kittyId) public {
    uint kittyDna;
    (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);
    feedAndMultiply(_zombieId, kittyDna, "kitty");
  }

}

zombiefactory.sol

//this is zombiefactory.sol

pragma solidity ^0.4.19;

contract ZombieFactory {

    event NewZombie(uint zombieId, string name, uint dna);

    uint dnaDigits = 16;
    uint dnaModulus = 10 ** dnaDigits;

    struct Zombie {
        string name;
        uint dna;
    }

    Zombie[] public zombies;

    mapping (uint => address) public zombieToOwner;
    mapping (address => uint) ownerZombieCount;

    function _createZombie(string _name, uint _dna) internal {
        uint id = zombies.push(Zombie(_name, _dna)) - 1;
        zombieToOwner[id] = msg.sender;
        ownerZombieCount[msg.sender]++;
        NewZombie(id, _name, _dna);
    }

    function _generateRandomDna(string _str) private view returns (uint) {
        uint rand = uint(keccak256(_str));
        return rand % dnaModulus;
    }

    function createRandomZombie(string _name) public {
        require(ownerZombieCount[msg.sender] == 0);
        uint randDna = _generateRandomDna(_name);
        randDna = randDna - randDna % 100;
        _createZombie(_name, randDna);
    }

}

總結

這個章節重點內容為：

1. 每個人的地址address是獨一無二的，可以通過msg.sender獲得呼叫者的地址，
2. mapping在Solidity語言中有著重要作用，是類似于字典類的、獨屬于Solidity的函式，
3. require有著十分便利的功能，如果在撰寫眾籌智能合約時，可以用來檢測眾籌資金是否達到目標金額等一系列問題，
4. 繼承和匯入方法使得代碼不再過于冗長，讓代碼撰寫更加規范，更加易于檢查，internal則使得函式可以在同一合約的不同檔案之間可以互相使用，而不能被外部使用，
5. storage指全域變數，多為指標型別；memory指區域變數，不限型別，在編譯器remix中可以自動檢查，若將memory錯用為storage，會反饋錯誤，同時寫明此處應該為memory，
6. interface讓我們的合約可以和其他合約會話，也方便我們獲得其他合約的回傳值，