理解solidity中访问控制符

Maic

发布于 2025-11-13 19:15:58

800

在solidity中大量的访问控制符，因此理解这些访问控制符就像java中的类修饰变量和方法一样，合适的修饰符，合约代码会更省gas,诸如，public,exteral，internal，private这类修饰符是控制函数或者变量在合约中的可见性以及可调用范围,通俗理解就是谁能访问这段代码的权限。

public

在合约内部或者外部都能访问

定义了一个 A 合约，申明了变量name与getName都是 public,公有的name在getName中可以被访问，他们在外部也可以被访问

contract A {
    // 申明name变量为public,且为string类型
     string public name = "Tom";
     // 申明getName为public
     function getName() public view returns(string memory) {
        return name;
     }
}

在外部可以被访问

private

只能在当前合约中访问，子合约不能访问。
使用 private 申明的变量或者方法无法在合约外部访问
在合约内部无法通过 this 访问
适用场景：写合约内部专用的辅助函数或状态变量。

    // SPDX-License-Identifier: UNLICENSED
    pragma solidity ^0.8.28;
    contract A {
    // 申明name变量为public
     string public name = "Tom";
     uint private age = 18;
     // 申明getName为public
     function getName() public view returns(string memory) {
        return name;
     }

     function setAge (uint _age) public {
      age = _age;
     }

     function getAge() private  view returns(uint) {
       return age;
     }

     function getPrivateAge () public view returns(uint) {
        return getAge();
     }
}

private example

contract Example {
    uint private secret = 123;
    function getSecret() private view returns(uint) {
        return secret;
    }
    function reveal() public view returns(uint) {
        return getSecret(); // OK
    }
}

访问不了私有方法

父类 private 方法无法访问

internal

只能在当前合约中访问，不能在外部访问
继承的子类可以调用访问

contract A {
    // 申明name变量为public

     string public hobby = "basketball";
     ...
     function setHobby(string memory _hobby) internal {
         hobby = _hobby;
     }

     function getHobby() public view returns(string memory) {
       return hobby;
     }

}
contract B is A {
   function getViewParent() public view {
      // 子类访问父类public方法
      this.getName();
      this.getHobby();
   }
   // 能直接调用父类的setHobby方法
   function setParentHobby(string memory _hoddy) public {
      setHobby(_hoddy);
   }
}

internal example

contract Base {
    function _add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }
}
contract Derived is Base {
    function sum(uint x, uint y) public pure returns (uint) {
        return _add(x, y); // 子合约可以用
    }
}

external

只能从合约外部调用（或通过 this.f() 调用），不能直接在内部调用。
在合约外部调用
在合约内部通过this访问
应用：节省 gas，用于对外提供接口。

external example

contract Example {
    function foo(uint x) external pure returns(uint) {
        return x * 2;
    }
    function bar(uint y) public view returns(uint) {
        // return foo(y); // ❌ 错误
        return this.foo(y); // ✅ 只能这样调用
    }
}

在外部可以访问

view

我们发现我们的方法里也有 view 这样的关键字，这是读取合约的状态变量，只能读取，不能修改

contract Example {
    uint public x = 10;

    // view: 可以读取状态，但不能修改
    function getX() public view returns (uint) {
        return x; // ✅ 可以读取状态
    }
}

pure

完全与合约无关，只能通过形参数计算结果
不能访问全局 this 中的变量，this.balance、block.timestam
不能读取合约中的变量

pragma solidity ^0.8.0;

contract Math {
    // 纯函数：不会读写状态，只做运算
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }
}

没有 pure/view 的普通函数

 contract A {
       function sum (uint a, uint b) internal pure returns(uint) {
            return a + b;
       }
       uint public num = 0;
       function callSum(uint a, uint b) public {
          num = sum(a, b);
       }
}