最近工作中遇到了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>
 {store.timer}
 <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>
 {this.count}
 <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: 被导入文件中的全局符号想要被其他合约单独导入，应该怎么编写？ 
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` 代表的一类词，作用就是把后面的信息赋值给前面的值。 划🟰号

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

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

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

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


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

“主谓宾： 主语+谓语动词+宾语” 只不过是以上的一个类别（类别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. `to eat`
- 现在分词 e.g. `eating`
- 动名词 e.g. `eating`
- 过去分词 e.g. `eaten`

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

<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> 


英语语法的核心就是动词，动词可以串起几乎所有的语法概念。

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

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