给闺女讲讲种地的故事<br>
给她讲一下为什么要上学？<br>
为什么要逼着她学习？<br>
为什么不给她玩手机？<br>
为什么种地不挣钱了？为什么来到外地上学，还要租人家房子？




**收集了一些关于种地的图片**

手工耕种： 古代农民通常使用简单的手工农具，如锄头、镰刀和耙子。他们会用这些工具开垦土地、翻土、除草和收割庄稼。

# 古代种地
1. 牛犁地
![aaa.jpeg](/static/img/146b02e0fda77dfcdfb27c67c8bdd818.aaa.webp)

2. 扫牛粪
![image.png](/static/img/23ad98248f40ee12f058d92c0959fbb7.image.webp)


3. 牛耕播种


![bbbb.jpeg](/static/img/abd3432ad4f9064d0e22e3766e509ddf.bbbb.webp)


4. 人工除草

![image.png](/static/img/20a22952ce6ba141802e3952f7774ac1.image.webp)
畜力助农： 一些文明开始使用动物的力量来辅助农耕，如牛、驴、马等。这些动物被用于拉犁，帮助犁地和耕田。

5. 人工收割


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


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



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

6. 打场：


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

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



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


7. 磨出面粉

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


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


古代的时候种地是一个很费事费力的过程。<br>
牛耕翻地--> 
撒牛粪洒种子-->
除草除虫浇水（经历多次）-->
镰刀收割-->
打场地、牛拉石磨分离秸秆和种子-->
扬场、晒干种子，储藏。

**吃面的过程**

洗麦子，晒干-->驴子抹面粉、储藏

有了面粉可以做馒头、包子、面条等。

# 爸爸小时候如何种地


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


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


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



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



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



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


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


# 现在种地

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



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

现在种地<br>
只需三四天时间即可<br>
1. 耕种过程（一天）
    1. 提前撒化肥
    2. 翻土机翻地
    3. 播种机播种
2. 喷洒农药、灌溉（农作物成长季节只需少量几次）

3. 收割过程
    1. 收割机直接分离秸秆和种子



# 一些思考
## 为什么现在种地不挣钱了？

假设一个国家有10个人，以前是5个人种地，另外5个人做其他事情（做衣服、做生意、小买卖、医生老师）。<br>

这5个人种地每人可收获2袋粮食，总共就是10袋粮食够养活10个人。那些没有种地的人通过做生意可以换取一袋粮食，同样种地的人同样需要一袋粮食换取其他（衣服、鞋子、学费等）

假设一袋粮食 1000元那么种地的收益是$1000*2-1000=1000元$

假设有一天，有人发明了联合播种机、联合收割机，这5个人中有一个买了机器，那么他可以种5份地，那么他收入是 `5*2=10`袋粮食, `10*1000=1万元`，假设买机器花费2000元，他自己花1000元，还赚$10000 - 2000 - 1000=7000元$，

但实际他赚不了那么多钱，因为粮食多了，粮食价格就会下降（因为东西多了，谁卖的便宜我就买谁的，物以稀为贵）假设粮食价格下降一半，一袋粮食500元，那么他还赚
$500*10 - 2000 - 1000=2000元$，相比之前的1000元还是赚的，

但是其他人呢，还是生产2袋粮食  但是只赚500块钱了。

但是其他人也会抢着买机器也就是机器可能还要涨价
粮食更多了可能还要降价，

而生产和发明机器的人呢，大家都争着抢着买他的机器，谁不卖谁吃亏，是不是要发财了呢？

爸爸希望你是发明机器的人而不是种地的人。

## 为什了来到外地生活？在这里上学，还要给人房租。

前面已经说了，挣钱不挣钱了，在这里工作去掉学费生活费房租还是比在老家种地强，这里的教育能给你更好的未来。

## 为什么要逼着你学习？
只有你学到更多的知识，才会更聪明才会最先发明那个机器，成为大赢家。<br>
假设你是第二名，有个同学比你聪明，先发明了机器，那么,别人已经买了他的机器，还会买你的机器吗？<br>
这就是逼着你学习的原因

## 老了在学可以吗？
人老了，大脑会衰老，会变笨，那时候的记忆里远不如现在，而且随着社会的发展，挣钱所需要的知识越来越多，所以现在学知识是挣钱最容易的路。

## 为什么不让你玩手机？
玩手机会上瘾， 一直玩下去不学习，你会被社会淘汰了，沦为 “牛马” 日夜劳作，没有选择的机会。

## 不学习会怎样
看看[白羽鸡的一生](https://www.youtube.com/watch?v=WgpSSY5WN40)

![baiyuji.webp](/static/img/bea2c4c14ad4fcab17e439f2566820cb.baiyuji.webp)

工人轻轻的把他们放到笼子里<br>
送到外面停靠的卡车<br>
这是白羽鸡第一次看到外面的世界<br>
也是唯一一次接受阳光的洗礼<br>
然而幸福总是短暂的<br>
几个小时后，他们来到生命的最后一站-屠宰场<br>

种地

最近工作中遇到了mobx的坑，与Vue2数据劫持一样的坑，没错东家项目中的mobx版本比较旧`mobx@4.8`，今天总结一下Mobx老版本及遇到的问题，再探索下mobx中的性能优化。




# mobx@4 用法
mobx@4 与用法与我前面一篇文章对mobx的总结用法基本一致，只是有一些细微的区别
1. 异步变更 不需要用`runInAction`包裹，没有警告。
2. store 构造函数不需要用`makeObservable`包裹



# mobx@4 的问题

官方有这么[一段话](https://cn.mobx.js.org/#%E6%B5%8F%E8%A7%88%E5%99%A8%E6%94%AF%E6%8C%81)，

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

`mobx<5` 的实现 与 `Vue2` 一样，都是基于`Object.defineProperty`+覆盖数组的7个方法。所有Vue2响应式存在的问题 ，在mobx中同样存在。
1. 对象劫持的问题--新加或删除属性无法监听

- 无法监听删除属性

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

- 无法监听新增的属性

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

当然也有解决方式 就是对变量 直接赋值新对象，代价是会有重复的渲染（一些组件引用了obj的属性，但值没有变化，也会渲染）。


2. 数组的问题
```js
import { action, observable} from 'mobx';

class AppState {
  @observable list = [];
  @action push = () => {
    this.list.push({id: Math.random()});
  }
}

export default window.bb = new AppState()
```
如果我们对`list`进行操作，修改`length`,对数组元素进行赋值`list[x]=xxx`都没呕问题。但是不能修改数组元素属性`list[x].name='xx'`（失去了响应式）

**然而这些问题在`mobx>=5`的版本中都没有问题**

proxy 数据劫持，除了解决了上述问题，还有更好的性能提升
- `Object.defineProperty`本质是对对象进行遍历，收集依赖进行递归便利不仅耗时，也产生了大量闭包造成内存占用，
- 而`Proxy`是惰性执行，按需对数据劫持，有更好的性能

然而Proxy也并非完美，代理对象与原对象是不同的对象，对代理对象进行解构，会得到原始对象，对原始对象的操作没有响应性。

# mobx@4 升级到5
对于react项目 mobx从4升到5，react也要配套升级

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

此外由于Proxy独特特性 babel不提供补丁，也就好说`android>=7`、`ios>=10`的手机才能运行

# mobx@4性能优化

前面提到 通过`Object.assign` 或`deepMerge`的方式可以减少不必要的渲染，但是要注意前面的坑，也就是说必须事先声明好对象的完整keys。

Mobx踩坑&性能优化

react和mobx虽然诞生很久很久了，但是网上依旧没有很好的入门学习案例，官方给的一个 十分钟交互式教程 就是扯蛋(后半段内容有跳跃了)，网上其他一些文章就是展示，不能直接运行， 我还看了一个Mobx todomvc的案例 竟然是用express + webpack写，给入门开发者的心智负担太重了。

另外跑个demo 不等于会了，mobx可以用普通与语法也可以装饰器语法（虽然我知道用推荐用装饰器语法），但是装饰器分新旧两个版本（虽然我知道使用的是旧的装饰器语法），React 又有class组件和函数组件两种。所以mobx学习如果没有好的教程学起来比较折腾，作为专业的前端，这篇文章带你熟练使用mobx.



# 核心概念

照例先贴一下官网 [Mobx官方文档](https://cn.mobx.js.org/)

官网开头的核心概念多看几遍，，

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

- `state`
- `computed`   -- `derivations`
- `reactions`
- `actions`

# 入门案例

## 接入准备
- `npx create-react-app  XXX`
- `cd XXX && npm i && npm eject`
- `npm i mobx mobx-react`
- 修改`package.json` babel增加`plugins`
```json
[
  "@babel/plugin-proposal-decorators",
  {
    "legacy": true
  }
]
```

补充还有一种环境搭建方式 [使用`react-app-rewired`](https://juejin.cn/post/6873794258743066632)

下面以一个最简单的计时器功能为案例， 看一看mobx的玩法

<img src="/static/img/bbd666feeffa175478802af90962defa.image.webp" width=60>

## 无装饰器写法

```js
import {makeObservable, observable, action} from "mobx";
import {observer} from 'mobx-react'

class AppState  {
    timer = 0;
    constructor() {
        makeObservable(this, {
            timer: observable,
            reset: action,
            add: action
        });
        setInterval(() => {
            this.add();
        }, 1000)
    }
    add = () => {
        this.timer += 1;
    }
    reset = () => {
        this.timer = 0;
    }
}
const store = new AppState();


const TimerComp = observer(({store}) => {
    return <div>
        <p>{store.timer}</p>
        <button onClick={store.reset}>reset</button>
    </div>
})

export default function TimerView() {
    return <div>
        <TimerComp store={store}></TimerComp>
    </div>
}
```

## 装饰器语法

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

当然 store也可以改为装饰器语法

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

## 装饰器语法（跨层级）

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

## store和组件一体式写法
```js
import React from 'react';
import {makeObservable, observable, action} from 'mobx';
import { Observer } from 'mobx-react';
class App extends React.Component {
    constructor(props) {
        super(props);
        makeObservable(this);
    }
    componentDidMount() {
        this.timer = setInterval(() => {
            this.add();
        }, 1000)
    }
    componentWillUnmount() {
        clearInterval(this.timer)
    }
    @observable
    count = 0;

    @action
    add = () => {
        ++this.count;
    }
    @action
    reset = () => {
        this.count = 0;
    }
    render() {
        return <Observer>
            {
                () => <div>
                    <p>{this.count}</p>
                    <button onClick={this.reset}>reset</button>
                </div>
            }
        </Observer>
    }
}

export default App;
```

## 函数组件用法

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

## hook用法

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



本段落完整代码 [点这里](https://github.com/guojingwen/frontend-project/tree/main/react_study/5.mobx)

# 进阶教程
## 如果想用多个store

- `Provider` 可以注入多个属性
- class组件  `@inject('store1');@inject('store2')`
- 函数组件 `const Comp = inject('store1', 'store2')(ImplComp)`

## inject
inject的参数可以是一个function 类似JS array.map 或 react-redux的mapState的作用

```js
@inject((store) => ({
    count: store.counterStore.count,
    doubleCount: store.counterStore.doubleCount
}))
```

[mobx vs redux](https://tech.youzan.com/mobx_vs_redux/)

[十分钟交互式的 MobX + React 教程](https://mobx.js.org/getting-started.html)  可以看，但个人觉得不是很好，尤其后半段内容有跳跃，需要看看其他示例。

`@action.bound`  与 `@action` 的区别是， 前者相当于JS的bind绑定this的作用

## runInAction
- 在mobx中要求变更必须使用`@action`
- `@action`中异步的变更推荐用`runInAction` 包裹

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

<img src='/static/img/78b97252905e4fc731fa52752780827b.image.webp' width=300>

Mobx学习

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: 被导入文件中的全局符号想要被其他合约单独导入，应该怎么编写？<br>
A:  与合约并列在文件结构中

Q: `import`导入文件中的全局符号可以单独指定其中的：<br>
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的安全隐患问题 <br>
> 当前合约和目标合约的状态变量存储结构相同，并且目标合约安全

原文的案例说明`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`代表什么?<br>
A: 当前合约发送给新创建合约的`Token`


Q: `Pair`合约创建时的`msg.sender`是?<br>
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执行成功，返回变量必须声明，并且与返回的变量类型相同。