我报名参加金石计划1期挑战——瓜分10万奖池，这是我的第9篇文章，点击查看活动详情

关于区块链和智能合约开发者的区别解释

我发现很多人都表述不清楚区块链和智能合约。我认识几位程序员朋友，他们都自称是在做区块链开发，但实际上是在做智能合约的开发。大多数外行分不清楚区块链和智能合约我能理解，但是很多从事智能合约开发的程序员竟然也分不清楚，我不知道是不是表述问题还是理解问题。

区块链是区块链，智能合约是智能合约，两者的关系就像是微信和微信小程序一样，一个是 App 开发，一个是小程序开发，根本不一样，不能混为一谈。

据我了解，区块链的需求没那么多，特别是中国这个环境下。大多数区块链相关的程序员都是在做智能合约开发，而不是真的在开发区块链。

区块链是可以用很多后端语言去开发的，比如用 Go、Node.js、Rust、Java 等。

但是智能合约不可以随便选择编程语言，我这里讲的智能合约是指以太坊智能合约。目前它只能选择 Solidity、Vyper、YUL、YUL+ 和 Fe 这 5 种语言。其中 solidity 最受欢迎，大多数项目和开发者都是选择了 solidity。我们几乎可以说 solidity 是智能合约的首选编程语言。

这篇文章会讲什么？

这篇文章将会介绍我认为使用 Solidity 编写智能合约时 90% 以上的场景中能够用到的语法和特性。

但是 Solidity 是一门完整的编程语言，想要把它彻底学明白，一篇文章肯定是不够的。因为很多语言都被写成了一厚厚地本书。不过通常写编程语言的书都会非常全体、体系化地介绍语言的全部，包括那些平时压根用不到的知识，或者一些已经落伍，语言设计上糟粕的部分。总体来说，通过一本厚厚的书来讲一门编程语言，多少是从研究的角度出发的，如果你只想快速用 Solidity 开发智能合约，不想把这门语言研究的这么透彻，那么本文很适合你。

同时本文会拿 solidity 和一些面向对象的语言做对比，如果你完全不懂其他编程语言，那么本文不适合你。

面向合约

Solidity 的设计理念和面向对象编程语言很相似，不过 Solidity 是面相合约的编程语言，如果你有面向对象编程语言的开发经验，那么学习 Solidity 就没有那么难。

Solidity 语言被设计为编写合约的语言，目前来说也只能写合约，所以它不像其他语言那样可以做很多事情。

合约构成解读

我们先来看一个最简单的合约构成，做一个整体的感受。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract HelloWorld {
	address private owner;
  unit public state;

  modifier onlyOwner() {
  	require(msg.sender == owner, "only owner");
    _;
  }

  event StateChanged(unit state);

  constructor() public {
  	owner = msg.sender;
  }

  function setState(uint _state) external onlyOwner {
  	state = state;
    emit StateChanged(_state)
  }
}

我简单解释下这个合约的代码，不会详细介绍。

第 1 行是指定版本许可。

第 2 行是指定使用的语言版本。

第 4 行是声明一个名为 HelloWorld 的合约。

第 5-6 行是状态变量，它们会永久存储在合约中。

第 8 -11 行是函数修改器，它可以用在函数修饰符上，可以改变函数的行为。

第 13 行是声明一个事件，事件可以被触发和监听。

第 15-17 行是构造函数，在部署时会被调用。

第 19-22 行是声明了一个名为 setState 的函数。

版本

solidity 有很多种版本，目前最新的版本是 8.x。

但是在早期比较流行的是 5.x、6.x 这两个版本。

solidity 的版本命名规范采用 。

和其他大多数编程语言不同的是，solidity 的版本是直接写在源代码里的。

在任意一个 sol 文件的最开始，都应该是版本代码。

语法为：

pragma solidity 0.8.0;

如果你用过 npm 的话，那这个版本语言一定不会陌生，因为 solidity 同样使用了 semver 版本规范。

合约

合约的概念有点像面向对象编程语言的类，属于一等公民。

通过关键字 contract 创建。

语法：

contract MyContract {
  
}

可以通过 new 关键字创建合约。

new MyContract();

继承

面向对象的语言通常会使用 extends 关键字来继承，但是 solidity 没有这样做，它使用 is 来继承合约。

contract MyContract1 {
  uint256 num = 2022;
}

contract MyContract2 is MyContract1 {
  
}

子合约被部署时，会把所有父合约的代码一起打包，所以对父合约中函数的调用都属于内部调用。

子合约可以隐式转换父合约，合约也可以显式转换为地址。

address addr = address(c);

重写函数使用 override 关键字。父合约中支持重写的函数必须是 virtual 的。

contract Parent {
    function fn() public virtual {}
}

contract Child is Parent {
    function fn() public override {}
}

调用父合约中的方法，使用 super 关键字。

contract Parent {
    function fn() public {}
}

contract Child is Parent {
    function fn2() public {
        super.fn();
    }
}

支持多重继承。

contract Parent1 {
    function fn() public virtual {}
}

contract Parent2 {
    function fn() public virtual {}
}

contract Child is Parent1, Parent2 {
    function fn() public override(Parent1, Parent2) {}
}

变量与基础类型

变量是永久存储在合约中的值，通常用来记录业务信息。

每个变量都需要声明类型，solidity 中的类型有如下几种：

• string：字符串类型
• bool：布尔值，true/false。
• uint：无符号整型，有 uint 和 uint8/16/32/64/128/256 几个类型。uint 是 uint256 的别名。
• int：有符号整型，规则和 uint 一样。
• bytes：定长字节数组。从 bytes1 到 bytes32，byte 是 bytes1 的别名。它和数组类似，通过下标获取元素，通过 length 获取成员数量。
• address：地址类型。保存一个 20 字节的地址。
• address payable：可支付的地址，有成员函数 transfer 和 send。

contract MyContract {
  string name = ""
}

uint

对于整型变量，我们可以通过 type(x).min 和 type(x).max 来获取某个类型的最大值和最小值。

address

address payable 可以隐式转换到 address，但是 address 必须通过 payable(address) 这种方式显示转换。

address 还可以显示转换为 uint160 和 bytes20。

bytes 和 string

bytes 和 string 都是数组，而不是普通的值类型。

bytes 和 byte[] 非常像，但是它在 calldata 和 memory 中会紧打包。紧打包的意思是将元素连续存储在一起，不会按照每 32 字节为一个单元进行存储。

string 是变长 utf-8 编码的字节数组，和 bytes 不同的是它不可以用索引来访问。

字符串没有操作函数，一般都是通过第三方 string 库来操作字符串。

string 可以转换为 bytes，转换时是创建引用而不是创建拷贝。

function stringToBytes() public pure returns (bytes memory) {
  string memory str = "hello";
  bytes memory bts = bytes(str);
  return bts;
}

由于 bytes 和 string 很相似，所以我们在使用它们时应该有对应的原则。

• 对于任意长度的原始字节使用 bytes。
• 对于任意长度的 UTF-8 字符串使用 string。
• 当需要对字节数组长度进行限制时，应该使用 byte1-byte32 之间的具体类型。

合理使用 bytes 可以节省 Gas 费。

变量修饰符

我们也可以为变量指定访问修饰符。

语法是 类型 访问修饰符（可选） 字段名。

访问修饰符有三种：

• public：公开，外部可以访问，声明为 public 的话会自动生成 getter 函数。
• internal：默认，只有合约自身和派生的合约可以访问。
• private：只有合约自身可以访问。

solidity 中的变量与传统语言的变量有些不同。

1. 字符串的值默认不可以包含中文。如果要使用除了英文外的其他语言，必须加 unicode 前缀。

string name = unicode"小明";

结构体

使用关键字 struct 创建结构，有点类似 Go/C 的 struct，或者类似 TypeScript 中的 type/interface。

struct User {
	string name;
  string password;
  uint8 age;
  bool state;
}

初始化结构体和调用函数类似，参数的顺序和结构体的顺序保持一致。

User user = User("章三", "123", 12, false);

访问某一个属性使用点号。

user.name;

属性也可以直接赋值。

user.name = "里斯";

数组

和 TypeScript 中的数组语法一致，语法是 type[]。

User[] users;

访问数组元素，使用 array[index] 的方式。

users[0];

访问不存在的下标，会直接报错。

在创建数组时可以声明长度，如果不声明，那就是可以动态调整大小的数组。

uint256[10] nums;

数组具有 pop 和 push 方法，分别用于弹出一个元素和添加一个元素。但是它们不可以用在定长数组中。

push 方法可以不传递参数，这时表示它添加一个该元素类型的零值。

strs.push("1");
strs.pop();

映射

类似于很多语言中的 Map 结构。语法是 mapping(keyType => valueType)。

mapping(address => User) userMapping;

key 的类型只允许是基本类型，不可以是复杂类型，比如合约、枚举、映射和结构体。

value 的类型没有限制。

访问 mapping 元素，使用 mapping[key] 的方式。

userMapping[0x021221]

访问不存在的 key，会返回 value 类型的默认值。

mapping 不可以作为公有函数的参数和返回值，只可以作为变量或者函数内的存储或者库函数的参数。

声明为 public 的 mapping，会自动创建 getter 函数。KeyType 作为参数，ValueType 作为返回值。

mapping 无法被遍历。不过有一些开源库用一种结构来实现了可遍历的 mapping。可以直接拿过来用。

枚举

枚举是创建用户自定义类型的一种方式。

enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
ActionChoices choice;

枚举可以和所有的整型显示相互转换，但是不能隐式转换。

uint num = uint(choice);

从整型显示转换到枚举类型，会在运行时检查整数是否在枚举范围内，超过的话会导致异常。

choice = ActionChoices(num);

枚举最少包含 1 个成员，最多可以包含 256 个成员。

枚举默认值是第一个成员。

枚举的数据表示和 C 语言是一样的，从 0 开始的无符号整数开始递增。

构造函数

部署合约时会由 EVM 自动调用构造函数，和常规的编程语言语法一致。

contract MyContract {
  constructor () {
  }
}

如果在构造函数中设置参数的话，那么在部署时需要传入对应参数的值。

contract MyContract {
  constructor (uint256 initNum) {
  }
}

构造函数不支持重载。

如果一个合约没有构造函数，那么会采用默认构造函数，将所有变量初始化为类型对应的默认值。

函数

语法是 function(type param) {internal|external} [pure|view|payable] [returns(paramType)]

可访问性标识符、状态标识符、函数修改器

函数可以定义在合约之外，但是只能通过 internal 的形式访问。

函数可以接受多个参数，也可以返回多个返回值。

函数修改器

可以放在函数声明中，具有修改函数行为的能力。

modifier onlyOwner() {
  require(msg.sender == owner, "only owner");
  _;
}

常用的关键字有 require 和 _。

require 有两个参数，第一个参数是一个 bool 值，如果为 false，那么就会触发错误，终止函数运行。第二个参数是当发生错误时的消息。

_ 表示函数运行。

使用函数修改器只需要在函数的修饰符部分添加修改器的名字即可，如果要添加多个修改器，使用空格隔开。

function setState(uint _state) external onlyOwner m2 m3 {
  state = state;
  emit StateChanged(_state)
}

函数修改器可以被继承。

函数修饰符

修饰符可以用在成员属性或者函数上，它决定了成员属性/函数的访问权限，共有 4 种：

• public：最大访问权限，任何人都可以调用。
• private：只有合约内部可以调用，不可以被继承。
• internal：子合约可以继承和调用。
• external：外部可以调用，子合约可以继承和调用，当前合约不可以调用。

external 和 public 的函数是合约的成员变量，可以通过 fn.address 来获取地址，通过 .selector 来获取标识符，这也被称作函数选择器。

函数调用

函数分为内部函数与外部函数。

内部函数

只有在同一个合约内的函数可以内部调用，内部调用可以递归调用。函数调用在 EVM 中会被解释为简单地跳转，内存不会被清除。

比如可以做斐波那契数列。

contract MyContract {
    function fibonacci(uint256 n) public returns (uint256) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return fibonacci(n - 2) + fibonacci(n - 1);
    }
}

外部调用

调用父合约的 external 方法和调用其他合约中的 external/public 方法，都属于外部调用。

调用父合约的方法使用 this.fn();，调用外部合约的方法使用 contract.fn();。

进行外部调用会通过消息调用，而不是简单跳转。

接口

与传统语言一样，使用关键字 interface。

接口可以被合约继承。

interface Token {
    function transfer(address recipient, uint amount) external;
}

contract MyToken is Token {
    function transfer(address recipient, uint amount) external override {}
}

事件

定义事件：

event eventName(paramsType paramsName)

触发事件。

emit eventName(params)

事件会被记录到区块链的 Log 中，区块链的 Log 分为索引和数据。我们可以指定最多 3 个参数为 indexed，表示它们可以被索引。

前端可以通过 web3.js 来订阅和监听事件。

事件也可以被继承。

控制结构

solidity 支持大多数传统编程语言的流程控制语句。比如 if、else、while、do、for、break、continue、return。但是不支持 goto 和 switch。

solidity 支持 try/catch 做异常处理，但是只支持外部函数调用和合约创建调用。

数据存储位置

所有引用类型的数据（包括数组、结构体、mapping、合约等）都有三种存储位置。分别是：

• 内存 memory：合约执行时的内存。
• 存储 storage：合约的永久存储。
• 调用数据 calldata：不可修改，函数的参数。和 memory 有些像，但和内存不在同一个位置。

直接声明在合约中的变量都会存储在 storage 中。

声明为 external 的函数，参数必须存储在 calldata。

在 storage 和 memory/calldata 之间进行复制，会创建独立的拷贝。

memory 和 calldata 之间相互赋值不会创建拷贝，而是创建引用。

storage 与本地 storage 之间的赋值也只会创建引用。

contract MyContract {
  uint256[] arr1; // arr1 存储在 storage 中

  // arr2 存储在 memory 中
  function fn1(uint256[] memory arr2) public {
      // memory 赋值到 storage 中，创建拷贝
      arr1 = arr2;
      // stoarge 赋值到 本地 storage 中，创建引用
      uint256[] storage arr4 = arr1;
      // pop 会同时影响 arr1
      arr4.pop();
      // 清空 arr1，同时会影响 arr4
      delete arr1;
      // storage 是静态分配内存，所以不可以直接从 memory 赋值到本地 storage 中
      // arr4 = arr2;
      // 因为没有指向存储位置，所以无法重置指针
      // delete arr4;

      // storage 之间传递引用
      fn3(arr1);
      // storage 到 memory 会拷贝
      fn4(arr1);
  }

  // arr3 存储在 calldata 中
  function fn2(uint256[] calldata arr3) external {}

  function fn3(uint256[] storage arr5) internal pure {}

  function fn4(uint256[] memory arr6) public pure {}

}

在使用数据时，要优先考虑放在 memory 和 calldata 中。

因为 EVM 的执行空间有限。而且如果 storage 的占用很高，Gas 费也会很贵。

单位

solidity 中有两种单位。以太单位和时间单位。

以太单位

以太单位是以太坊独有的单位，在其他编程语言中没有这种单位。

1 wei 等于 1。

1 gwei 等于 1e9。

1 ether = 1e18。

用代码表示如下：

assert(1 wei == 1);
assert(1 gwei == 1e9);
assert(1 ether == 1e18);

时间单位

默认 1 等于 1 秒。

solidity 支持以下时间单位：

• seconds：秒
• minutes：分
• hours：时
• days：天
• weeks：周
• years：年，不推荐使用。

用代码表示如下：

assert(1 seconds == 1);
assert(1 minutes == 60 seconds);
assert(1 hours == 60 minutes);
assert(1 days == 24 hours);
assert(1 weeks == 7 days);

错误处理与异常

Solidity 使用状态恢复异常来处理错误。这种异常会撤销当前调用以及子调用中的状态变更，并且会向调用者标记错误。

外部调用的异常可以被 try/catch 捕获。

assert

assert 用在我们认为不会出现错误的地方，它返回 Panic(uint256) 类型的错误。

function buy(address payable addr) public {
    addr.transfer(1 ether);
    assert(addr.balance > 1 ether);
}

require

require 通常用来条件判断，它会创建一个 Error(string) 类型的错误，或者是没有错误数据的错误。

function buy(uint amount) public {
    require(amount < 1, "amount must be greater than 1");
}

revert

可以用来标记错误并且退回当前调用。

require 本身也会去调用 revert。

function buy(uint amount) public {
  if(amount < 1) {
    revert(amount > 1, "amount must be greater than 1"); 
  }
}

区块和交易属性

区块和交易属性都是以全局变量或者全局函数的形式存在的。我们可以直接访问它们。常见的属性如下：

• blockhash(uint blockNumber) returns (bytes32)：获取指定区块的区块哈希，可用于最新的 256 个区块，不包含当前区块。
• block.chainid：uint 类型，当前链的 id。
• block.coinbase：address 类型，当前区块的矿工地址。
• block.diffculty：uint 类型，当前区块的难度。
• block.gaslimit：uint 类型，当前区块的 gas 限额。
• block.number：uint 类型，当前区块号。
• block.timestamp：uint 类型，从 unix epoch 到当前区块以秒计的时间戳。
• gasleft() returns (uint256)：剩余的 gas。
• msg.data：bytes 类型，完整的 calldata。
• msg.sender：address 类型，消息发送者（当前调用者）。
• msg.sig：bytes4 类型，calldata 的前 4 个字节，也就是函数标识符。
• msg.value：uint 类型，消息发送的 wei 数量。
• tx.gasprice：uint 类型，当前交易的 gas 价格。
• tx.origin：address payable 类型，交易发起者。

receive 和 fallback

receive 是一个特殊的函数，一个合约可以包含最多一个 receive 函数。

receive 没有 function 关键字，必须是 external payable 的。可以是 virtual 的，可以被重载，可以添加 modifier。

我们给合约转账时，会去执行 receive 函数。如果转账时 receive 函数不存在，会去调用 fallback 函数。如果 fallback 函数也不存在，那么合约不可以通过正常转账来接受 ether。

fallback 函数和 receive 类似，只能最多有一个 fallback 函数，必须是 external 的，可以是 virtual 的，可以被重载，可以添加 modifier。但 payable 是可选的。

fallback 方法可以接受参数，也可以返回数据。

如果调用某个合约的函数，但是这个函数不存在，会调用 fallback。

contract MyContract {
  receive() external payable {}

  fallback() external {}
}

我是代码与野兽，一位长期专注于 Web3 的探索者，同时也非常擅长 Web2.0 中的前后端技术。

如果你对 Web3 感兴趣，可以关注我和我的专栏。我会持续更新更多 Web3 相关的高质量文章。