Angular学习笔记

solidity入门学习课程2，推荐去官方学习



# 函数重载
- solidity中允许函数进行重载（overloading），即名字相同但输入参数类型不同的函数可以同时存在，他们被视为不同的函数。注意，**solidity不允许修饰器（modifier）重载**。
- 最终重载函数在经过编译器编译后，由于不同的参数类型，都变成了不同的函数选择器（selector）
- 如果出现多个匹配的重载函数，则会报错。

# 库函数
库函数是一种特殊的合约，为了提升solidity代码的复用性和减少gas而存在。库合约一般都是好用的函数合集（库函数），由大神或者项目方创作。

它和普通合约的区别
1. 不能存在状态变量
2. 不能够继承或者被继承
3. 不能接受以太币
4. 不可以被销毁

使用示例
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
using Strings for uint256;

contract UseLib {
 function getString1(uint256 _number) public pure returns(string memory) {
 return _number.toHexString();
 }
 // 直接通过库合约名调用
 function getString2(uint256 _number) public pure returns(string memory){
 return Strings.toHexString(_number);
 }
}

library Strings {
 function toHexString(uint256 value) public pure returns (string memory) {
 // todo something
 return "0x00";
 }
}
```

一些常见的库合约
1. [String](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/4a9cc8b4918ef3736229a5cc5a310bdc17bf759f/contracts/utils/Strings.sol): 将uint256转换为String
2. [Address](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/4a9cc8b4918ef3736229a5cc5a310bdc17bf759f/contracts/utils/Address.sol): 判断某个地址是否为合约地址
3. [Create2](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/4a9cc8b4918ef3736229a5cc5a310bdc17bf759f/contracts/utils/Create2.sol): 更安全的使用`Create2 EVM opcode`
4. [Arrays](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/4a9cc8b4918ef3736229a5cc5a310bdc17bf759f/contracts/utils/Arrays.sol)：跟数组相关的库函数

# Import 

import用法
1. 通过源文件相对位置导入`import './Yeye.sol';`
2. 通过源文件网址导入智能合约 `import 'https://github.com/xxx/../Address.sol';`
3. 通过npm的目录导入 `import '@xx/../Ownable.sol';`
4. 通过全局符号导入特定的合约 `import {Yeye} from './Yeye.sol';`
5. 引用(`import`)在代码中的位置为：在声明版本号之后，在其余代码之前。

`import` 可以用 `as` 可以用 `*`

```solidity
import {Yeye as Wowo} from "./Yeye.sol";
import * as Wowo from "./Yeye.sol";
```

Q: 被导入文件中的全局符号想要被其他合约单独导入，应该怎么编写？ 
A: 与合约并列在文件结构中

Q: `import`导入文件中的全局符号可以单独指定其中的： 
A: 合约、纯函数、结构体类型

# 接收ETH
`Solidity`支持两种特殊的回调函数，`receive()`和`fallback()`，他们主要在两种情况下被使用：
1. 接收`ETH`
2. 处理合约中不存在的函数调用（代理合约proxy contract）

注意： 在`solidity`0.6.x版本之前只有`fallback()`

## receive函数
`receive()`函数的规则
- receive()只用于处理接收ETH。
- 一个合约最多只有一个receive函数
- 声明：不需要`function`关键字: `receive() external payable{ ... }` 
- `receive()` 函数不能有任何的参数，不返回任何值，
- 必须包含`external`和`payable`。

当合约接收ETH时receive函数被触发。

`receive()`函数的注意事项：
- 最好不要执行太多的逻辑，因为如果别人用send和transfer方法发送ETH的话，gas会限制在`2300`, `receive()`太负载的话可能会触发`Out of Gas`报错；如果用`call`就可以自定义`gas`执行更复杂的逻辑。

由于receive函数没有返回值，可以通过事件的形式通知

```solidity
// 定义事件
event Received(address Sender, uint Value);
// 接收ETH时释放Received事件
receive() external payable {
 emit Received(msg.sender, msg.value);
}
```

有些恶意合约，会在`receive()` 函数（老版本的话，就是 `fallback()`函数）嵌入恶意消耗`gas`的内容或者使得执行故意失败的代码，导致一些包含退款和转账逻辑的合约不能正常工作，因此写包含退款等逻辑的合约时候，一定要注意这种情况。

## 回退函数fallback
- `fallback()`函数会在调用合约不存在的函数时被触发。可用于接收ETH，也可用于代理合约`proxy contract`。
- `fallback()`函数的声明规则和`receive()`函数一致

`fallback()`也是使用事件的形式通知
```solidity
event fallbackCalled(address Sender, uint Value, bytes Data);
fallback() external payable{
 emit fallbackCalled(msg.sender, msg.value, msg.data);
}
```
## receive和fallback的区别
```txt
触发fallback() 还是 receive()?
 接收ETH
 |
 msg.data是空？
 / \
 是 否
 / \
receive()存在? fallback()
 / \
 是 否
 / \
receive() fallback()

receive()和payable fallback()均不存在的时候，向合约直接发送ETH将会报错（你仍可以通过带有payable的函数向合约发送ETH）
```

# 发送ETH
`Solidity` 有三种方法向其它合约发送`ETH`，他们是：`transfer()`，`send()`和`call()`，其中`call()`是推荐用法。


## 接收ETH合约
```solidity
contract ReceiveETH {
 // 收到eth事件，记录amount和gas
 event Log(uint amount, uint gas);
 
 // receive方法，接收eth时被触发
 receive() external payable{
 emit Log(msg.value, gasleft());
 }
 
 // 返回合约ETH余额
 function getBalance() view public returns(uint) {
 return address(this).balance;
 }
}
```
## 发送ETH合约
有三种方式向ReceiveETH合约发送ETH。首先先在发送ETH合约SendETH中实现payable和构造函数receive()，让我们能够在部署时和部署后向合约转账

```solidity
contract SendETH {
 constructor() payable {}
 receive() external payable {}
}
```

`transfer`
- `接收方地址.transfer(发送ETH数额)`。
- `transfer()`的gas限额时2300，足够用于转账，但对方合约的`fallbak()`或`receive()`函数不能实现太复杂的逻辑。
- `transfer()` 如果转账失败，会自动`revert`(回滚交易)

```solidity
function transferETH(address payable _to, uint256 amount) external payable {
 _to.transfer(amount);
}
```

`send`
- 用法`接收方地址.send(发送ETH数额)`
- gas限制也是2300，但对方合约的fallback()或receive()函数不能实现太复杂的逻辑
- `send()` 如果转账失败，不会revert
- `send()` 的返回值时bool ，代表转账成功或失败，需要额外代码处理一下

`call`
- `call` 用法是`接收方地址.call{value: 发送ETH数额}("")`。
- `call()`没有`gas`限制，可以支持对方合约`fallback() 或`receive()`函数实现复杂逻辑。
- `call()`如果转账失败，不会`revert`。
- `call()`的返回值是`(bool, data)`，其中`bool`代表着转账成功或失败，需要额外代码处理一下

总结:

`solidity`三种发送ETH的方法：`transfer`，`send`和`call`。
- `call`没有`gas`限制，最为灵活，是最提倡的方法；
- `transfer`有2300 gas限制，但是发送失败会自动`revert`交易，是次优选择；
- `send`有2300 gas限制，而且发送失败不会自动`revert`交易，几乎没有人用它。

# 调用其他合约
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract OtherContract {
 uint256 private _x = 0; // 状态变量x
 // 收到eth事件，记录amount和gas
 event Log(uint amount, uint gas);
 
 // 返回合约ETH余额
 function getBalance() view public returns(uint) {
 return address(this).balance;
 }

 // 可以调整状态变量_x的函数，并且可以往合约转ETH (payable)
 function setX(uint256 x) external payable{
 _x = x;
 // 如果转入ETH，则释放Log事件
 if(msg.value > 0){
 emit Log(msg.value, gasleft());
 }
 }

 // 读取x
 function getX() external view returns(uint x){
 x = _x;
 }
}

contract CallContract{
 function callSetX(address _Address, uint256 x) external{
 OtherContract(_Address).setX(x);
 }

 // 调用合约方法1
 function callGetX(OtherContract _Address) external view returns(uint x){
 x = _Address.getX();
 }

 // 调用合约方法2
 function callGetX2(address _Address) external view returns(uint x){
 OtherContract oc = OtherContract(_Address);
 x = oc.getX();
 }

 // 调用合约方法 同时转账
 function setXTransferETH(address otherContract, uint256 x) payable external{
 OtherContract(otherContract).setX{value: msg.value}(x);
 }
}
```

# call()函数

call函数除了前面说的可以发送ETH，可以可以调用合约的任意方法

`目标合约地址.call(二进制编码);`

`二进制编码`利用结构化编码函数 `abi.encodeWithSignature`获得：
`abi.encodeWithSignature('函数签名', "逗号分割的具体参数")`

call还可以调用不存在的函数，会触发合约的`fallback`函数

总结：

`call`这一低级函数可以用来调用其他合约。`call`不是调用合约的推荐方法，因为不安全。但他能让我们在不知道源代码和`ABI`的情况下调用目标合约，很有用。


call函数是address类型的函数。

# delegatecall

`delegatecall`与`call`类似，是`solidity`中地址类型的低级成员函数。`delegate`是委托/代表的意思。

`delegatecall`语法和`call`类似也是`目标合约地址.delegatecall(二进制编码)`。其中`二进制编码`利用结构化编码函数`abi.encodeWithSignature`获得

`abi.encodeWithSignature("函数签名", 逗号分隔的具体参数)`。

和`call`不同的是，`delegatecall`在调用合约时可以指定交易发送的gas，但不能指定发送的ETH数额
 
什么情况下会用到`delegatecall` ?

1. 代理合约 **将智能合约的存储合约和逻辑合约分开**：代理合约存储所有相关的变量，并且保存逻辑合约的地址；所有函数存在逻辑合约中，通过delegatecall执行。当升级时，只需要将代理合约指向新的逻辑合约即可。
2. 砖石： 钻石是一个支持构建**可在生产中扩展的模块化智能合约系统的标准**。钻石是具有多个实施合同的代理合同。 更多信息请查看：[钻石标准简介](https://eip2535diamonds.substack.com/p/introduction-to-the-diamond-standard)。

> delegatecall的安全隐患问题 
> 当前合约和目标合约的状态变量存储结构相同，并且目标合约安全

原文的案例说明`delegatecall`和`call`的另一个区别 **语境不同**
**前者修改的本合约的状态变量，而后者修改的是代理的目标合约的对象**

使用delegatecall时，要求 变量类型可以不同，变量名、声明顺序必须相同

```solidity
function delegatecallMint(address _addr, uint _num) external payable{
 (bool success, bytes memory data) = _addr.delegatecall(abi.encodeWithSignature("mint(uint256)", _num));
}
```

在代理合约中，存储所有相关的变量是 **代理合约** 存储所有函数的是 **逻辑合约**，同时 **代理合约delegatecall逻辑合约**

# 在合约中创建新合约
在以太坊上，用户（外部账户，EOA）可以创建智能合约，智能合约同样也可以创建新的智能和鱼。 去中心化交易所 `uniswap`就是利用工厂合约创造了无数的币对合约（`Pair`）。

## 创建新合约方式1 new
有两种方式可以在合约中创建新合约，`new`和`create2`


Q: `Contract x = new Contract{value: _value}(params)`，表达式中`value`代表什么? 
A: 当前合约发送给新创建合约的`Token`


Q: `Pair`合约创建时的`msg.sender`是? 
A: 工厂合约`PairFactory`

## 创建新合约方式2

create2 操作码

`新地址 = hash("0xFF",创建者地址, salt, bytecode)`

使用create2方式创建合约，我们可以在部署合约前确定合约地址，这也是一些layer2项目的基础

create2的实际应用场景
1. 交易所为新用户预留创建钱包合约地址。
2. 由create2驱动的factory合约，可以得到一个确定的pair地址，不需要在执行一次跨合约调用

## 删除合约 selfdestruct
- `selfdestruct`命令可以用来删除智能合约，并将该合约剩余ETH转向指定地址
- `selfdestruct` 是为应对合约出错的极端情况而设计的。

:::warning{title=注意事项}
1. 对外提供合约销毁接口时，最好设置为只有合约所有者可以调用，可以使用函数修饰符`onlyOwner进行函数声明。
2. 当合约被销毁后与智能合约的交互也能成功，并且返回0。
3. 当合约中有selfdestruct功能时，常常会带来安全问题和信任问题
:::


# ABI编码解码
- ABI是与以太坊智能合约交互的标准。数据基于他们的类型编码；并且由于编码后不包含类型信息，解码时需要注明它们的类型。

在`solidity`中，ABI编码有4个函数
- `abi.encode` 每个数据都填充32个字节
- `abi.encodePacked` 给定参数根据所需最低空间编码
- `abi.encodeWithSignature` 与`abi.encode` 功能类似，只是第一个参数为函数签名
- `abi.encodeWithSelector` 与`abi.encodeWithSignature`类似，只不过第一个参数为函数选择器

ABI解码有一个函数 `abi.decode`,用于解码`abi.encode`的数据

[编码规则](https://learnblockchain.cn/docs/solidity/abi-spec.html)

ABI的使用场景
1. ABI常配合call来实现对合约的底层调用
2. ethers.js中常用ABI实现合约的导入和函数调用
3. 对不开开源合约进行反编译后，某些函数无法查到函数签名，可以通过ABI进行调用

Q： 如果对于某个哈希函数，我们统计大量不同字符串对应的哈希值（二进制串），发现其前 n 位全部为 0 的频率恰好约为 1/2^n，则我们认为该哈希函数具有良好的

A 均一性： 每个哈希值被取到的概率应该基本相等。


# 选择器

当我们调用智能合约时，本质上是向目标合约发送了一段`calldata`，在remix中发送一次交易后，可以在详细信息中，看见input 即为此次交易的calldata。

- 发送`calldata`中前4个字节是`selector`(函数选择器)
- `calldata`的后面32个字节是`msg.data`，`msg.data`是`solidity`中的一个全局变量，值为完整的calldata(调用函数时传入的数据)


`method id`、`selector` 和 `函数签名`之间的关系

- `method id` 定义为 `函数签名` 的 `Keccak`哈希后的前四个字节。即`bytes4(keccak256("mint(address)"))`
- 当`selector`与`method id`相匹配时，即表示调用该函数。
- 函数签名 `函数名(逗号分隔的参数类型)`。对于不同的函数及函数重载问题，通过调用不同的函数签名，确定具体调用哪一个函数。

:::warning{title=注意}
在函数签名中，`uint`和`int`要写成`uint256`和`int256`
:::


# try catch

solidity0.6版本添加了`try catch`捕捉智能合约的异常

try catch 只能被用于 external函数或 创建合约时 constructor的调用。基本语法如下

```solidity
try externalContract.f() {
 // call成功的情况下，运行一些代码
} catch {
 // call失败的情况下，运行一些代码
}
```

如果调用的函数有返回值

```solidity
try externalContract.f() returns( returnType val){
 // 在try模块中可以使用返回的变量
 // 如果是创建合约，那么返回值是新创建的合约变量
} catch { }
```

另外合约支持捕获特殊的异常原因

```solidity
try externalContract.f() returns(returnType) {
 // call成功的情况下 运行一些代码
} catch Error(string memory reason) {
 // 捕获失败的revert()和require()
} catch (bytes memory reason) {
 // 捕获失败的assert()
}
```

总结
- `try catch` 只能用于处理外部合约调用和创建
- 如果try执行成功，返回变量必须声明，并且与返回的变量类型相同。

solidity入门学习2

为什么学英语语法？

我认为学习英语语法是学英语的捷径！语法是对一门语言的句子结构归纳总结，对语法的学习可以让我们能举一反三，快速造句。



# 汉语语法基础
学英语前，先大致梳理下汉语语法的核心，原因是我们是以汉语语句来学习英语句子的。通过对比汉语语法可以快速掌握英语语法。

## 词类
**按照词在结构中能起的作用，即词的句法功能分的类**
- 划分词类的目的在于说明**语句的结构规律**和**各类词的用法**。
- 词类的分类标准有多种，**汉语是根据语法功能来划分的**
- 一般将汉语的词类分为 **`名词`**、**`动词`**、**`形容词`**、`数词`、`量词`、**`代词`**、`区别词`、**`副词`**、`介词`、`连词`、`助词`、`叹词`、`语气词`、`拟声词`共十四类

两个大类14个小类
- 实词 （名词、动词、形容词、数词、量词、代词、区别词）
- 虚词 （副词、介词、连词、助词、叹词、语气词、拟声词）

1. **名词** 表示人和事物的名称的实词。
 - 专用名词
 - 抽象名词
2. **动词** 表示人或事物的动作、行为、发展、变化
 - 能愿动词 表示能够愿意这些意思，叫做“能愿动词” 如“能” “要” “应” “敢” “可能” “必须” 。这些能源动词长城用在一般的动词前面，如“得去” “可能会” “应该说明”
 - 趋向动词 表示趋向， 如 “来” “往” “上” “进” “过去”。他们往往用在一般动词的后面，表示趋势 如 “跳起来” “走下去” “抬上来” “跑过去”。
 - 判断动词 “是” “有”
3. **形容词** 形容词表示事物的形状、样式、性质等。
4. 代词 代替实词和短句。
 - 人称代词 
 - 疑问代词 谁 什么 哪里 多少 怎样
 - 指示代词 这 那 这些 这里 各自 某
5. 副词 副词总是用在动词形容词的前面做状语。 如 “很” “极” “马上” “曾经” “不断”
6. 助词 
 - 结构助词 如 “的” “地” “得” “所” “似的”
 - 动态助词 如 “着” “了” “”
 - 语气助词 如 “啊” “吗” “呢” “呀” “吧” “哇”
7. 区别词 表示任何事物的属性，有区分事物的分类作用。 如“慢性” “急性” “欧式” “色彩” “上等” “野生” “人造” “冒牌”
8. 连词
9. 介词 “把” “从” “朝” “为了” “比” “被”
10. 数词
11. 量词
12. 感叹词
13. 拟声词
14. 语气词

## 汉语句子的结构

[定] 主 + [状] 谓 [补] + [定] 宾

[定] 主 + [状] 谓 [补] + [定] 宾

例如：[我们]学生[一定][要]学[好][专业]课程。

[状（修饰全句的）] + [定] 主 + [状] 谓 [动补]+ [定] 宾[宾补]

例如：[每当有外地人来]，[好客的]天津人[总是][眉飞色舞地]谈[起][天津的]小吃[有多么地道]。

主语也可能有补语，主语的补语也叫做表语

# 英语语法

## 简单句
我们写文章，有时用短句子，也有时用长句子，不同的短句又可以组成新的长句

需要把长句子拆开，拆到不能再拆了为止（否则句意不完整）--即**简单句**，才好研究语法。把基本句子研究透了，长句子就是它们的组合嘛。

而这样的简单句，除去哪些 “嗯”、“哦”、“啊”这样的感叹句 或者省略句，或者向整句提问的问句，全部都是在说 **什么怎么样**，两个最基础的句子成分是**主语+谓语**

<img src='/static/img/38567fae1c27042162ffb6e3a027289b.image.webp' width=150>

几乎所有的英语句子都是 **主语+谓语**

<img src='/static/img/b71a5ee0fbcbca990d23a950f6bce3d4.image.webp' width=200>

那么有哪些“动作”（动词）呢？

1. 可以独立完成的动作 **不及物动词**

**主语 + 不及物动词**

`PaPa Rabbit sleeps` 兔老爹睡觉
这样没有承受者的动词 叫做 **不及物动词**

2. 有一个动作的承受者 **及物动词**

**主语 + 单及物动词 + 宾语**

`PaPa Rabbit likes you` 兔老爹喜欢你

3. 有两个承受者 **双及物动词**

**主语 + 双及物动词 + 间接宾语 + 直接宾语**

`PaPa Rabbit teaches you English` 兔老爹教你英语

4. 只有一个承受者（不同于2） **复杂及物等词**（需要宾语补语）

**主语 + 复杂及物动词 + 宾语 + 宾语补语**
`PaPa Rabbit considers you smart` 兔老爹认为你很聪明

5. （不是个“动作”）

`PaPa Rabbit is tall` 兔老爹很高
`PaPa Rabbit is in the room` 兔老爹在房间里
`PaPa Rabbit looks tall` 兔老爹看上去高

`is` 代表的一类词，作用就是把后面的信息赋值给前面的值。 划🟰号

这类动词被 **(连)系动词 系动词**

**主语 + 系动词 + 主语补语**

主语补语在汉语中还有另一个称谓 **“表语”**


| - | - | - |
| --- | --- | --- |
| 可独立完成的动作 |主语 + （**不及物）动词** | PaPa Rabbit sleeps |
| 有一个动作的承受者 |主语 + （**及物）动词** + 间接宾语 + 直接宾语 | PaPa Rabbit likes you |
| 有两个动作的承受者 |主语 + （**双及物）动词** + 间接宾语 + 直接宾语 | PaPa Rabbit teaches you English |
| 只有一个动作的承受者( 不同于2) |主语 + （**复杂及物）动词** + 宾语 + 宾语补语 | PaPa Rabbit considers you smart |
| 把这个词后面的信息赋予给前者 |主语 + **（系）动词** +主语补语 | PaPa Rabbit is tall|


“主谓宾： 主语+谓语动词+宾语” 只不过是以上的一个类别（类别2），而严格说来谓语和谓语动词是有区别的，英语中句子主语后面余下的句子就是谓语，谓语包含谓语动词+后续，在平时为了方便，很多人会称呼谓语动词为谓语，所以 “主谓宾”变成了 “主语+谓语+宾语”

## 句子成分
<img src='/static/img/7519619b55241ef0452bdf012db7feaa.image.webp' width='300'>


**定语** 修饰主语或宾语

<img src='/static/img/72bb56afff57c5edee62fd10d65917a6.image.webp' width='300'> 


**状语** 修饰谓语动词，汉语在谓语前面，英语在谓语动词后面

<img src='/static/img/8e8849e406012dad32f8633bdd06e516.image.webp' width='240'> 

**同谓语** 再把主语或宾语说一遍

<img src='/static/img/581a624af1af6df63f79c0b693ee1191.image.webp' width='360'> 

前面说的都是简单句，可是我们说话、写文章并不全是简单句。

- `Compound Sentence` 复合句 简单句的叠加，是并列关系（有些语法书上成为并列句）
- `Complex Sentence` 复杂句简单说就是把一个句子套在另一个句子中，可以无限套娃，这是一种从属关系，（有些语法书却用复合句，造成了很多人的混乱）

一个句子套另一个句子，在英语语法上分别叫做主句和从句。
从句说白了就是把一个句子简单修改下来充当另一个句子的成分。
- 比如我们修改一个简单句，它就可以充当另一个句子的主语， 就是主语从句
- 比如我们修改一个简单句，它就可以充当另一个句子的宾语， 就是宾语从句
- 比如我们修改一个简单句，它就可以充当另一个句子的主语补语， 就是表语从句
- 比如我们修改一个简单句，它就可以充当另一个句子的同位语， 就是同位语从句

以上四个句子都具有名词的性质，所以又合称为名词性从句。

同理还有定语从句、状语从句。

## 词类的划分

英语中的类词
1. 名词 表示人或物，氛围不同名词和专有名词

<img src='/static/img/87a81378e3dc1b4fcc1c312949aee6a1.image.webp' width=200>

2. 冠词 `a` `the` 说明人或事物
3. 代词 替代人和物
4. 形容词 同中文，修饰人或事物的形状、性质、状态等
5. 数词
6. 副词 修饰动词、形容词，等等

I ate two carrots quickly. `quickly`就是副词

7. 介词 表示和其他词之间的关系

I ate two carrots with chopsticks。 `with`就是介词

8. 叹词 `Ah`
9. 连词 连接词或句 `and` `because`
10. 动词 

以上这些便是英语的10大词类

与汉语词类相比较
1. 英语中同样有量词、助词， 只是不常用
2. 英语中没有 区别词、拟声词、语气词
3. 英语中有冠词一说
4. 英语中的疑问词可类比汉语的疑问代词
5. **名词没有格的变化，也没有性和数的区别**。
6. **动词有时态气一说**。

## 汉语与英语的差异
英语中分12个词类 基本与汉语相同区别如下
- 没有 区别词， 个人理解被形容词包含
- 没有 助词
- 没有 拟声词 语气词
- 新增 疑问词（汉语中的疑问代词） 
- 新增 冠词 `a` `the`

## 句子成分VS词类
句词成分和词类是完全不同的概念

![image.png](/static/img/5cfef812b937d104f868734af540d779.image.webp)

一只会说话的兔子，叫兔爸爸，正在教你如何快速学习困难的语法规则，这是第一课，概述。



## 谓语动词三大本领
1. 表示动作的时间 **现在**、**过去**、**将来**、**过去将来**（从过去的某个时间点算将来）
2. 表示动作的状态 **一般**（未说明）、**完成**、**进行**，**完成进行** （不但完成而且继续）

两者合在一起被称为英语的 **时态**

动词的时间和状态可以任意排列组合，共计16中可能的时态

![image.png](/static/img/d25a72c4cb749d654d806730e0e8f2d4.image.webp)

3. 表示动作的假设，情感等。

这个也称作动词的语气，但这个语气不是说话的语气，而是语法的语气！

比如

<img src='/static/img/7f1c914d6aa430babbd39a0727697749.image.webp' width=200>


虚拟语气 表示意愿和事实相反的假设等。

总结：
![image.png](/static/img/b49b9dabd9802a2a97ff171e5bb9fc5a.image.webp)

## 助动词
英语的谓语动词本身往往是不能独立完成刚才所说的那些本领，以及另外一些其它的本领，而且谓语动词也无法独立完成表示否定、可能型、必要性等意思。

想让谓语动词充分发挥，我们必须用到另一类经常和动词一起用的词，**帮助完成任务**，他们就是**助动词**

<img src='/static/img/3c84ab2658e2d1132de279404c349e57.image.webp' width=400>

但是比较麻烦的一点是，很多助动词喜欢伪装，他们除了做助动词，还可以做实义动词，甚至其他词性。比如
- `hava` 可以是 拥有
- `be` 可以是存在
- `can` 可以是 易拉罐
- `might` 可以是 力量
- `must` 可以是 发霉
- `do` 可以是 做某事

千万别把这些助动词和它的实义动词弄混淆

## 非谓语动词
动词 不全是谓语动词， 不然也就没有非谓语动词什么事情了。

为什么要叫非谓语动词呢？因为动词除了充当谓语， 还有可能充当主语、宾语、宾语补语、表语、定语、状语、同位语

<img src='/static/img/c73d4f1bd7511a317200d3abccffa4df.image.webp' width=400> 

不仅如此，**非谓语动词可以取代所有的从句，从而可以简化句子**，只不过这样的动词就不再具有表示动作的时间、状态、语态、语气的功能。

它们是以不同的形式出现在句中，包括
- 动词原形 e.g. `eat`
- 动词不定式 e.g. `to eat`
- 动名词/现在分词 e.g. `eating`
- 过去分词 e.g. `eaten`
- 过去式 e.g. `ate`

但是这里也有麻烦事，不定式长得跟谓语动词原形一样

<img src='/static/img/a2f0dfabe6c2c912827432e8628e305b.image.webp' width=200> 
我告诉你句中有`eat`，你并不能确定是 谓语动词还是不定式，除非我告诉你其他还有什么词

现在分词和动名词长得和谓语动词的进行状态一样

<img src='/static/img/5cd154186124f30f01cccfb37de5cfa7.image.webp' width=200> 

过去分词长得跟谓语动词的完成状态一样

<img src='/static/img/f170a5eec07b95a7f57b954f427aa595.image.webp' width=200> 


**英语语法的核心就是动词**，动词可以串起几乎所有的语法概念。
- 动词分 谓语动词(动词充当谓语) 和非谓语动词(主语、宾语、宾语补语、表语、定语、状语、同位语)
- 谓语动词分5种，组成了简单句
 - 不及物动词 
 - 及物动词
 - 双及物动词
 - 复杂及物动词
 - 系动词
- 非谓语动词用于复合句（并列关系）、复杂句（主从关系）
- 复杂句 分 名词性从句 定语从句 状语从句
 - 名词性从句 有 主语从句 宾语从句 同位语从句 表语从句
- 谓语动词可以表达动作的时态气 但是需要用到助动词
 - 助动词可以帮助否定动词，
 - 和表达动词的被动、可能性、义务性等
- 非谓语动词可以视作改动后的谓语动词，可以充当除谓语动词外的所有句子成分，取代几乎所有从句，简化句子

![image.png](/static/img/cb308f49f46ca0f4aa2ee12f9aec96ea.image.webp)

这就是英语语法的简化后的主体框架，绝大多数语法规则都逃脱不了这个框架，而无数的规则和特例也只不过是让这个核心体系更加丰富而已。

英语语法学习

本文是基于WTF学院的Solidity学习笔记, 推荐还是去[官网学习](https://www.wtf.academy/docs/solidity-101/)， 教程写的很友好，章节划分很有节奏，学完一节还可以做题检测，我这里只是摘抄一部分内容，仅为了个人学习与掌握，不推荐阅读。



# HelloWorld

- `Solidity`是以太坊虚拟机（`EVM`）智能合约的语言。
- `Solidity`语言的开发工具是`remix`,`remix`是以太坊官方推荐的智能合约开发IDE，你也可以使用[在线IDE](https://remix.ethereum.org/)
- 安装了`remix`IDE后有三个教程 Remix的基础使用 Solidity入门介绍 在Remix中部署，建议新手体验一下。


HelloWorld
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract HelloWeb3 {
 string public _string = "Hello Web3!";
}
```
从helloWorld中可以看出
- 注释 单行注释 `//` 多行注释 `/* */`
- 通过注释声明软件协议
- `pragma solidity ^0.8.4;` 声明软件版本，采用语意版本号
- `cantract` 定义一个智能合约, 采用面向对象的编程范式
- `string public _string = 'Hello Web3';` 定义成员变量，与java语法很像，分号结束一条语句。

# 变量类型
Solidity中的变量类型有四大分类：数值类型、函数类型、引用类型、映射类型
1. 数值类型`Value Type` 包括布尔型、整数型、无符号整型、地址类型
2. 引用类型`Reference Type` 包含数组和结构体，这类变量占空间大，赋值的时候直接传递地址（类似指针）
3. 映射类型`MappingType` `Solidity`里的哈希表
4. 函数类型`Function Type` `Solidity`文档里把函数归到数值类型，但实际区别比较大

运算符与JavaScript一致，区别是Solidity是强类型语言，所有没有 `===`、`!==`运算符

# 数值类型
包括布尔型、整数型、无符号整型、地址类型

## 地址类型`address`

地址类型存储一个20字节的值。地址类型也有成员变量，并作为所有合约的基础。有普通的地址和可转账ETH的地址`payable`。其中payable修饰的地址相对普通地址多了`transfer`和`send`两个成员。

在`payable`修饰的地址中，send执行失败不会影响当前合约的执行，但是返回false值需要开发人员检查send的返回值

## 定长字节数组
字节数组bytes分两种，一种定长（byte、bytes8、bytes32），另一种不定长。定长的属于数值类型，不定长的是引用类型。定长字节数组消耗的gas比较少

```solidity
bytes32 public _byte32 = "MiniSolidity"; // 0x4d....0000
bytes1 public _byte = _byte32[0]; // 0x4d
```

## 枚举类型

枚举 是solidity中用户定义的数据类型，它主要用于为`unit`分配名称，使程序易于阅读和维护。它与`TypeScript`中的`enum`类似
```solidity
enum ActionSet { Buy, Hold, Sell } // 不能加;
ActionSet action = ActionSet.Buy;
```
它可以显示的转换为 `unit`类型 示例 `unit(action)`

## 函数类型
形式： `function <functionName>(<parameter types>) {internal|external|public|private [pure|view|payable] [returns (<returnTypes>)]}`
- `{internal|external|public|private}` 函数的可见性，一共有4种，默认是public
 - `public` 内部外部均可见
 - `private` 只能从合约内部访问，继承的合约也不能用
 - `external` 只能从合约外部访问
 - `internal` 只能从合约内部访问，继承的合约可以用
- `[pure|view|payable]` 决定函数权限/功能的关键字。
 - `payable` 可支付的，可以给合约转入ETH. 默认值
 - `pure`和`view`与汽油费有关
 - `pure` 不能读不能写
 - `view` 能读取但不能写入状态变量
- `[returns ()]` 函数返回的变量类型和名称。

函数输出
```solidity
// 命名式返回
function returnNamed() public pure returns(
 uint256 _number,
 bool _bool,
 uint256[3] memory _array
) {
 _number = 2;
 _bool = false; 
 _array = [uint256(3),2,1];
}
// 命名式返回，依然支持return
function returnNamed2() public pure returns(
 uint256 _number, bool _bool
) {
 return (1, true);
}
```

解构式赋值
```solidity
function getVal() public payable {
 uint256 _number;
 bool _bool;
 uint256[3] memory _array;
 (_number, _bool, _array) = returnNamed();
}
```

# 引用类型
引用类型，包括数组、结构体和映射，这三类变量占空间大，赋值的时候直接传递地址（类似指针）。由于这类变量比较复杂，占用存储空间大，我们在使用时必须声明数据存储的位置。

## 数据位置
solidity数据存储的位置有三类： `storage`、`memory`、`calldata`。不同的存储位置的`gas`成本不同。
- `storage` 数据存储在链上，类似计算机硬盘，消耗`gas`多; 合约中的状态变量默认都是`storage`。
- `memory` 函数里的参数和临时变量一般用`memory`，存储在内存中，消耗`gas`少
- `calldata` 和`memory`类似，存储在内存中，区别是`calldata` 变量不能修改 `immutable`，一般用于函数的参数。


## 数据位置与赋值规则
在不同存储类型相互赋值时，有时产生独立的副本，有时产生引用。规则如下
1. `storage` (合约的状态变量) 赋值给本地`storage`（函数里）的时候，会创建引用，改变新变量会影响原变量。
```solidity
uint[] x = [1,2,3]; // 状态变量：数组 x
function fStorage() public{
 //声明一个storage的变量 xStorage，指向x。修改xStorage也会影响x
 uint[] storage xStorage = x;
 xStorage[0] = 100;
}
```

2. `storage` 赋值给`memory`，会创建独立的副本，修改其中一个不会影响另一个，反之亦然。
3. `memory`赋值给`memory`，会创建引用，改变新变量会影响原变量
4. 其它情况，变量赋值给`storage`， 会创建独立的副本，求改其中一个不会影响另一个

总结， `storage`与`memory`相互赋值会创建副本，其它情况时引用类型赋值

## 变量的作用域
1. 状态变量
 - 在合约内函数外声明，`gas`消耗高
2. 局部变量
 - 仅在函数执行过程中有效的变量，函数退出后，变量无效。局部变量的数据存储在内存里，不上链，`gas`低。局部变量在函数内声明
3. 全局变量
 - 全局变量时全局范围工作的变量，都是`solidity`预留的关键字。
 - 他们可以在函数内不声明直接使用
```solidity
function global() external view returns(
 address, uint, bytes memory
) {
 address sender = msg.sender;
 uint blockNum = block.number;
 bytes memory data = msg.data;
 return(sender, blockNum, data);
}
```

下面是一些常用的全局变量，更完整的列表请看[这个](https://learnblockchain.cn/docs/solidity/units-and-global-variables.html#special-variables-and-functions)

- `blockhash(uint blockNumber): (bytes32)`给定区块的哈希值只适用于256最近区块, 不包含当前区块。
- `block.coinbase: (address payable)` 当前区块矿工的地址
- `block.gaslimit: (uint)` 当前区块的gaslimit
- `block.number: (uint)` 当前区块的number
- `block.timestamp: (uint)` 当前区块的时间戳，为unix纪元以来的秒
- `gasleft(): (uint256)` 剩余 gas
- `msg.data: (bytes calldata)` 完整call data
- `msg.sender: (address payable)` 消息发送者 (当前 caller)
- `msg.sig: (bytes4)` calldata的前四个字节 (function identifier)
- `msg.value: (uint)` 当前交易发送的wei值

## 数组Array
数组是Solidity常用的一种变量类型，用来存储一组数据（整数、字节、地址等等）。数组分为固定长度数组和可变长度数组两种

1. 固定长度数组

用`T[K]`的格式声明，其中`T`是元素的类型，`k`是长度。
```solidity
// 固定长度 Array
uint[8] array1;
bytes1[5] array2;
address[100] array3;
```
2. 可变长度数组（动态数组）

在声明时不指定数组长度。用`T[]`的格式声明
```solidity
// 可变长度 Array
uint[] array4;
bytes1[] array5;
address[] array6;
bytes array7; // 特殊情况
```

注意：`bytes`比较特殊，是数组，但不用加`[]`。另外，不能用`byte[]`声明单字节数组，可以使用`bytes`或`bytes1[]`。在gas上，`bytes`比`bytes1[]`便宜。因为`bytes1[]`在`memory`中要增加31个字节进行填充，会产生额外的`gas`。但是在`storage`中，由于内存紧密打包，不存在字节填充。

创建数组的规则
1. 对于memory修饰的动态数组，可以用new操作符来创建，但是必须声明长度，并且声明后的长度不能改变
2. 数组字面常数
 - 例如`[1,2,3]`里面所有的元素都是`uint8`类型，因为在`solidity`中如果一个值没有指定`type`的话，默认就是最小单位的该`type`，这里`int`的默认最小单位类型就是`uint8`
 - 而`[uint(1),2,3]`里面的元素都是`uint`类型，因为第一个元素指定了是`uint`类型了，我们都以第一个元素为准。 
 - 如果创建的是动态数组，你需要一个一个元素的赋值
```solidity
uint[] memory x = new uint[](2);
x[0] = 1;
x[1] = 3;
```

数组成员属性和方法
- `length` `memory`数组的长度在创建后是固定的
- `push()`
- `push(x)`
- `pop()`


## 结构体struct
```solidity
// 结构体
struct Student{
 uint256 id;
 uint256 score; 
}
Student student; // 初始一个student结构体
```

给结构体赋值有两种方式
```solidity
function initStudent1() external{
 Student storage _student = student; // 引用
 _student.id = 11;
 _student.score = 100;
}

// 2 直接赋值
function initStudent2() external{
 student.id = 11;
 student.score = 100;
}
```

# 映射类型
声明映射类型的格式`mapping(_KeyType => _ValueType)`
```solidity
mapping(uint => address) public idToAddress; // id映射到地址
mapping(address => address) public swapPair; // 币对的映射，地址到地址
```

映射的规则：
1. `_KeyType` 只能是`solidity`默认的类型，`_ValueType`类型可以是任意类型，比如结构体
2. 映射的存储位置必须是`storage`，因此可以用于合约的状态变量，函数中的`storage`变量，和`library`函数的参数。不能用于public函数的参数或返回结果中，因为`mapping`记录到的是一种关系（key - value pair）
3. 如果映射类型声明为`public`，那么`solidity`会自动给你创建一个`getter`函数，可以通过`Key`来查询对应的`Value`
4. 给映射新增的键值对语法为 `_Var[_Key] = _Value`


映射的原理
1. 映射不储存任何键（Key）的资讯，也没有length的资讯。
2. 映射使用keccak256(key)当成offset存取value。
3. 因为Ethereum会定义所有未使用的空间为0，所以未赋值（Value）的键（Key）初始值都是各个type的默认值，如uint的默认值是0。


# 变量的初始值
```solidity
contract InitialVal {
 /* 值类型的初始值 */
 bool public _bool; // false
 string public _string; // ""
 int public _int; // 0
 uint public _uint; // 0
 address public _address; // 0x0000000000000000000000000000000000000000 (或 address(0))

 enum ActionSet { Buy, Hold, Sell}
 ActionSet public _enum; // 枚举中的第一个元素

 function fi() internal{} // internal空白方程 
 function fe() external{} // external空白方程 


 /* 引用类型的初始值 */
 uint[8] public _staticArray; // 所有成员设为其默认值的静态数组[0,0,0,0,0,0,0,0]
 uint[] public _dynamicArray; // `[]`
 mapping(uint => address) public _mapping; // 所有元素都为其默认值的mapping
 // 所有成员设为其默认值的结构体 0, 0
 struct Student{
 uint256 id;
 uint256 score; 
 }
 Student public student;
}
```
`delete`操作符 会让变量变为初始值

# 常数
- `constant`变量必须在声明的时候初始化，之后再也不能改变。否则编译不通过
- `immutable` 变量可以在声明时或构造函数中初始化，因此更加灵活

```solidity
// 报错
string immutable x7 = "hello world";
```

# 控制流
solidity的控制流和其它语言比较类似
- `if else`
- `for`循环 `continue` `break`
- `while`循环
- `do while`循环
- 三元运算符

写一个冒泡排序
```solidity
function bubbleSort(uint[] memory a) public pure returns(uint[] memory) {
 for(uint i = a.length-1; i>=0;i--) {
 bool hasChange = false;
 for(uint j = 0; j<i; j++) {
 if(a[j] > a[j+1]) {
 uint temp = a[j+1];
 a[j+1] = a[j];
 a[j] = temp;
 hasChange = true;
 }
 }
 // 冒泡排序剪枝优化
 if(!hasChange) {
 break;
 }
 }
 return (a);
}
```

# 构造函数和装饰器

构造函数
- 构造函数（constructor）是一种特殊的函数，每个合约可以定义一个，并在部署合约的时候自动运行一次
- 它可以用来初始化合约的一些参数，例如初始化合约的owner地址
- 在Solidity 0.4.22之前使用与合约名同名的函数作为构造函数而使用


装饰器

- 修饰器（`modifier`）是`solidity`特有的语法，类似于面向对象编程中的`decorator`。
- 作用 **运行函数前的检查**， **声明函数拥有的特性**，**并减少代码冗余**。

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Owner {
 address public owner; // 定义Owner变量

 constructor() {
 owner = msg.sender; // 在部署合约的时候将owner设置为部署者的地址
 }

 modifier onlyOwner {
 require(msg.sender == owner); // 检查调用者是否为owner地址
 _; // 如果是，继续运行函数主体，否则报错并revert交易
 }

 function changeOwner(address _newOwner) external onlyOwner {
 owner = _newOwner;
 }
}
```

# 事件
Solidity中的事件是EVM上日志的抽象，它具有两个特点
- 响应：应用程序`ethers.js`可以通过RPC接口订阅和监听这些事件，并在前端做响应
- 经济：事件是EVM 上比较经济的存储数据的方式，每个大概消耗2000gas；相比之下链上存储一个新变量至少需要20000gas

声明事件

`event Transfer(address indexed from, address indexed to, uint256 value);`

触发事件

`emit Transfer(from, to, amount)`

EVM日志： 每条日志都包含`Topics` 和`Data`两部分

事件可以在`etherscan`上查询

# 继承
可以把合约看成对象，solidity也是面向对象的编程，也支持继承。

规则
- 合约之间通过`is`继承
- `virtual` 父合约中的函数，如何希望子合约重写，需要加上`virtual`关键字。
- `override` 子合约重写父合约中的函数，需要加上override关键字。
 - 注意： 用`override`修饰`public`变量，会重写与变量同名的`getter`函数
- 支持多重继承
 - 继承时要按辈分从高到低排
 - 如果一个函数在多个继承的合约里都存在，则在子合约里必须重写，不然报错。
 - 重写父合约中的函数时，override关键字要加上所有父合约的名字
- 支持修饰器的继承
- 构造函数的继承
 - 子合约在继承时声明父合约构造函数参数
 - 子合约构造函数声明父合约构造函数参数
- 调用父合约中的函数
 - 直接调用`父合约名.函数名()`
 - `super`关键字 `super.函数名()`
 - 多继承按照从右到左的顺序调用
- 砖石继承

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Yeye {
 event Log(string msg);
 function hip() public virtual {
 emit Log("Yeye");
 }

 function pop() public virtual{
 emit Log("Yeye");
 }

 function yeye() public virtual {
 emit Log("Yeye");
 }
}

// 合约通过 is继承
contract Baba is Yeye {
 function hip() public virtual override {
 emit Log("Baba");
 }
 function pop() public virtual override {
 emit Log("Baba");
 }

 function baba() public virtual { 
 emit Log("Baba");
 }
}

// 多继承的顺序是按照辈分从高到低
contract Erzi is Yeye, Baba {
 function hip() public virtual override(Yeye, Baba) {
 emit Log("Erzi");
 }
 function pop() public virtual override(Yeye, Baba) {
 emit Log("Erzi");
 }
}

/*
 验证多重继承
 父函数的方法必须加 virtual
 子合约函数必须继承所有父类同一重名的方法
*/
contract P1 {
 function test() public virtual {}
}
contract P2 {
 function test() public virtual{}
}
contract C is P1, P2 {
 function test() public override(P1, P2){}
}

// 修饰器的继承
contract Base1 {
 modifier exactDividedBy2And3(uint _a) virtual {
 require(_a % 2 == 0 && _a % 3 == 0);
 _;
 }
}
contract Identifier is Base1 {
 modifier exactDividedBy2And3(uint _a) virtual override {
 _;
 require(_a % 2 == 0 && _a % 3 == 0);
 }
 function test(uint a) public exactDividedBy2And3(a) {}
}

// 构造函数的继承
abstract contract A {
 constructor(uint a) {}
}
// 1. 在继承时声明父构造函数的参数
contract B is A(1) {}
// 2. 在子合约的构造函数中声明构造函数的参数
contract C1 is A {
 constructor(uint a) A(a * a){}
}

// 砖石继承
/* 继承树：
 God
 / \
Adam Eve
 \ /
people
*/
contract God {
 event Log(string message);
 function bar() public virtual {
 emit Log("God.bar called");
 }
}

contract Adam is God {
 function bar() public virtual override {
 emit Log("Adam.bar called");
 super.bar();
 }
}
contract Eve is God {
 function bar() public virtual override {
 emit Log("Eve.bar called");
 super.bar();
 }
}

contract people is Adam, Eve {
 function bar() public override(Adam, Eve) {
 super.bar();
 }
}
// 调用合约people中的super.bar()会依次调用Eve、Adam，最后是God合约
```

# 抽象合约和接口
抽象合约
- 与`TypeScript`类似，`Solidity`语言使用`abstract`关键字定义抽象合约
- 如果一个智能合约里至少有一个未实现的函数，则必须将该合约标记为`abstract`

接口

接口类似于抽象合约，但是它不能实现任何功能，接口的规则如下
1. 不能包含状态变量
2. 不能包含构造函数
3. 不能继承除接口外的其它合约
4. 所有函数都必须是`enternal`且不能有函数体
5. 继承接口的合约必须实现接口定义的所有功能

虽然接口不实现任何功能，但它非常重要。它是智能合约的骨架，定义了合约的功能以及如何触发它们：如果智能合约实现了某种接口，其它Dapps和智能合约就知道如何与它交互。因为接口提供了两个重要的信息：
- 合约里每个函数的`bytes4`选择器，以及函数签名`函数名（每个参数类型）`。
- 接口id

另外，接口与合约`ABI`登记，可以相互转换： 编译接口可与得到合约的ABI, 利用 [abi-to-sol工具](https://gnidan.github.io/abi-to-sol/)也可以将`ABIjson` 文件转换为`接口sol`文件

# 异常
智能合约经常会出`bug` `solidity`中的异常命令帮助我们`debug`

- `Error` ^0.8.4 
 - `error`必须搭配`revert`使用
 - 支持携带参数
- `require` ^0.8.0 `require(检查条件, "异常的描述")`
 - 缺点是gas随着描述一场的字符串长度增加， 比error要高
- `assert` 
 - 缺点是不能解释异常的原因

gas费用消耗 error < assert < require