【CryptoZombies - 1 Solidity 教程】014 函数可见性

一、前言

看了一些区块链的教程，论文，在网上刚刚找到了一个项目实战，CryptoZombies。

如果你想了解更多有关于机器学习、深度学习、区块链、计算机视觉等相关技术的内容，想与更多大佬一起沟通，那就扫描下方二维码加入我们吧！

二、 函数可见性

1、回顾

我们之前讲函数权限，讲到函数可以设置公有和私有，当初设置私有是因为：不是任何时候，其他合约都可以调用某个合约中的函数，而且容易受到攻击。所以一般情况下，将函数定义为私有，只有外部调用时，才设置为公有。

设置私有函数方式如下：

uint[] numbers;

function _addToArray(uint _number) private {
  numbers.push(_number);
}

在这个代码中，我们定义一个无符号整数数组，并通过函数为其添加元素。

1.添加private意味着：只有合约中的其它函数才能够调用这个函数。

2.和函数的参数类似，私有函数的名字用(_)起始

 

2、内部internal和外部external

1.引入

当我们讲到继承的时候，因为子合约不能继承使用父合约的私有函数，这显然和我们的想法是违背的，一旦继承，有些合约只不过不能让外部合约进行访问而已，但是子合约应该允许访问。所以通过private已经不能满足我们的需求了。所以我们引入外部和内部两个描述函数可见性的修饰词。

2.internal和external

除 public 和 private 属性之外，Solidity 还使用了另外两个描述函数可见性的修饰词：

1.internal（内部） ：internal 和 private 类似，不过， 如果某个合约继承自其父合约，这个合约即可以访问父合约中定义的“internal”函数。

2.external（外部）：external 与public 类似，只不过这些函数只能在合约之外调用 - 它们不能被合约内的其他函数调用。

 声明函数 internal 或 external 类型的语法，与声明 private 和 public类 型相同：

contract Sandwich {
  uint private sandwichesEaten = 0;

  function eat() internal {
    sandwichesEaten++;
  }
}

contract BLT is Sandwich {
  uint private baconSandwichesEaten = 0;

  function eatWithBacon() public returns (string) {
    baconSandwichesEaten++;
    // 因为eat() 是internal 的，所以我们能在这里调用
    eat();
  }
}

3、实战

1.要求

将 _createZombie() 函数的属性从 private 改为 internal ， 使得其他的合约也能访问到它。

pragma solidity >=0.5.0 <0.6.0;

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;

    // edit function definition below
    function _createZombie(string memory _name, uint _dna) private {
        uint id = zombies.push(Zombie(_name, _dna)) - 1;
        zombieToOwner[id] = msg.sender;
        ownerZombieCount[msg.sender]++;
        emit NewZombie(id, _name, _dna);
    }

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

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

}

2.代码

pragma solidity >=0.5.0 <0.6.0;

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;

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

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

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

}