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

逃离我推掉我的手 2021-05-16 20:36 345阅读 0赞

# 一、前言 #

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_36_color_FF36FF_t_70][]

# 二、 函数可见性 #

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_36_color_FF36FF_t_70]: /images/20210516/517741780b99423cb6bc8d1075646668.png