本文对TS背景进行简单的介绍，用精简的语言和案例阐述了TS的常用类型，是TS入门学习很好的一篇文章。本文主要参考 [《ts入门教程》](https://ts.xcatliu.com/) 一书和 [《TS常见类型》](https://blog.csdn.net/zxl1990_ok/article/details/125205351)一文并加入了一些自己的思考和实践及整理了一些比较基础的面试题。



# 常见面试题
- TS有哪些基本类型
- `void`和`undefined`的区别
- `unknow`与`any`类型的区别
- `never`类型有了解吗？TS最底层的类型是什么？

带着问题开始本篇文章的阅读吧


# TypeScript介绍
- `TypeScript` 是由微软开发的一款开源的编程语言。
- `TypeScript` 是 `Javascript` 的超级，遵循最新的 `ES6+` 规范。`TypeScript` 扩展了 `JavaScript`的语法。
- TypeScript 更像后端 `Java`、`C#`这样的面向对象语言可以让 `JS` 开发大型企业项目。
- 谷歌也在大力支持 `Typescript` 的推广，谷歌的 `Angular2.x+`就是基于 `Typescript` 语法。
- 最新的 `Vue`、`React` 也可以集成 `TypeScript`。

![](https://blog.warmplace.cn:11443/static/img/f162343843c08008a75e82ef3bd6df20.image.webp)

## 设计理念
有过一定TS经验的同学可以了解一下TS的设计理念，这有助于我们更好的学习和理解TypeScript。

[官方TS设计理念介绍](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals)

## 安装使用
- `npm install -g typescript`
- `tsc --init` 生成配置文件 `tsconfig.json`
- `tsc helloworld.ts`  生成 `helloworld.js`
- [ts在线编译](https://c.runoob.com/compile/5577/)

- 运行和断点调试 要安装 `ts-node`
    - `npm install ts-node`
    - 运行TS `npx ts-node helloword.ts`
    - 调试只能在编辑器里调试，跟JS调试一样，
    - （VSCode点击右上角的 `运行和调试` --> `JavaScript调试终端`）

## 编辑器实时编译
### webstorm
- 打开`Preferences` > `Languages & Frameworks` > TypeScript配置如下
- ![image.png](https://blog.warmplace.cn:11443/static/img/8d6685aa8dde530a3097819b3830c96e.image.webp)
- 点击弹窗右下角 OK ，此时会生成 helloWorld.js, 选中它分屏 
- ![image.png](https://blog.warmplace.cn:11443/static/img/b620b720c667437dd30f2ae7690a624e.image.webp)
- ![预览效果](https://static.warmplace.cn:11443/blog-resources/ts/ty.gif)

### vscode配置
点击菜单 任务-运行任务 点击 `tsc:监视-tsconfig.json` 然后就可以自动生成代码了

![image.png](https://blog.warmplace.cn:11443/static/img/3bf68be902738243f37dcdf3cedd8853.image.webp)

## 为什么要使用TypeScript
1. **TypeScript 增加了代码的可读性和可维护性**
    - **类型系统实际上是最好的文档**，大部分的函数看看类型的定义就可以知道如何使用了
    - 可以**在编译阶段就发现大部分错误**，这总比在运行时候出错好
    - **增强了编辑器和 IDE 的功能**，包括代码补全、接口提示、跳转到定义、重构等
1. **TypeScript 非常包容**
    - `TypeScript` 是 `JavaScript` 的超集，`.js` 文件可以直接重命名为 `.ts` 即可
    - 即使不显式的定义类型，也能够自动做出类型推论
    - 可以定义从简单到复杂的几乎一切类型
    - 即使 `TypeScript` 编译报错，也可以生成 `JavaScript` 文件
    - 兼容第三方库，即使第三方库不是用 `TypeScript` 写的，也可以编写单独的类型文件供 `TypeScript` 读取
1. **TypeScript 拥有活跃的社区**
    - 大部分第三方库都有提供给 `TypeScript` 的类型定义文件
    - Google 开发的 `Angular2` 就是使用 `TypeScript` 编写的
    - `TypeScript` 拥抱了 `ES6` 规范，也支持部分 `ESNext` 草案的规范

## TypeScript 的缺点
任何事物都是有两面性的，我认为 `TypeScript` 的弊端在于：
1. 有一定的学习成本，需要理解接口（`Interfaces`）、泛型（`Generics`）、类（`Classes`）、枚举类型（`Enums`）等前端工程师可能不是很熟悉的概念
1. 短期可能会增加一些开发成本，毕竟要多写一些类型的定义，不过对于一个需要长期维护的项目，`TypeScript` 能够减少其维护成本
1. 集成到构建流程需要一些工作量
1. 可能和一些库结合的不是很完美

## TypeScrit 特性
- 静态类型（编译时还是运行时进行类型检查）
- 弱类型 （是否允许隐式类型转换）
- **IDE代码补全和接口提示**等功能
    - 一些第三方库原生支持了 `TypeScript`，在使用时就能获得代码补全了，比如 `Vue 3.0`
    - 如果三方库原生不支持 `TypeScript`，以通过安装社区维护的类型声明库 比如`npm install --save-dev @types/react`
- **完全兼容 JavaScript** 的，它不会修改 `JavaScript` 运行时的特性。
- 可以编译为 `JavaScript`
- 配置丰富，类型检查的严格程度由你决定
- `TypeScript`与标准同步发展

# TypeScript中的原始数据类型
- 与JS中的原始类型相对应`boolean`、`number`、`string`、`null`、`undefined`、`Symbol`、`BigInt`
- 包装类型也与JS对应（包装类型不是原始类型）
- `void`
- `any`
- `unknow`
- `never`

## boolean number string
- 即使不显式的定义类型，也能够自动做出类型推论
- 声明未赋值等价于 自动推断为`any`类型
```ts
// 不显式的定义类型，也能够自动做出类型推论 
let age = 1 // let age: number

age = 'zhangsan' // 报错 不能将类型“string”分配给类型“number”。ts(2322)

// 声明未赋值 自动推断为any类型
let person; // let person: any
```
补充知识点：**类型推论**

`TypeScript` 会在没有明确的指定类型的时候推测出一个类型，这就是类型推论。

例如 `let age = 1` 会自动推断为 `age: number`

## 包装对象
我们知道在 `JS` 中存在包装对象的概念。

当你使用原始类型（字符串、数字、boolean值）调用属性或方法是，`JS`会创建一个临时的包装对象，使你能够访问课操作原始数据类型的属性和方法。这个过程称为自动包装。

在`TS`中也存在包装对象
- 原始类型兼容对应的对象包装类型， 对象类型不兼容对应的原始类型。 （子类可以赋值给父类，反之不行，原始类型是父类）

```ts
var str = "Hello";
var strObject = new String(str); // 创建一个字符串包装对象
console.log(strObject.length); // 访问字符串的长度属性
console.log(str.length); // 访问字符串的长度属性

// 在TS中也存在包装对象
// 报错 Type 'Boolean' is not assignable to type 'boolean'.
let createdByNewBoolean: boolean = new Boolean(1); 
```
## null 和 undefined
- 与`void`的区别是 `undefined`和`null` 是所有类型的子类型
    - 也就是说 `undefined` 类型的变量，可以赋值给其他类型的变量(未指定`strictNullChecks`时)
```ts
// 这样不会报错
let num: number = undefined;

let u: void;
let num2: number = u; // 不能将类型“void”分配给类型“number”。ts(2322)
```

注意： 
`tsconfig.json`指定了`"strictNullChecks":true` , `null` 和 `undefined` 只能赋值给 `any`、 `unknown` 和它们各自的类型, `undefined`可以赋值给`void`类型。

## 空值 void
> - JS中`void`是一个运算符，表示忽略表达式的返回值， 或者或返回值是`undefined`
> - JS函数总是返回一些东西，没有返回值即返回`undefined`

- 在`TS`中可以用`void`表示没有任何返回值的函数， 它是`undfined`的父类型
- 未定义返回值自动推断为 `void` 类型
- 可以将`undefined`和`null` 赋值给`void`类型（未指定`strictNullChecks`时）
```ts
// 未定义返回值自动推断为 void 类型
function alertName() {
    alert('My name is Tom');
}
var showAlert = alertName(); // var showAlert: void
// null 和 undefined 可以赋值给 void
let unusable: void = undefined;
```
那么TS既然有了 `undefined` 为什么还需要 `void` 呢？区别是什么？

区别在于 **作为返回类型的void可以用不同的类型替换，以允许高级回调模式**
```ts
function doSomething (callback: () => void) {
    let c = callback();   // 此时c为void类型 
    // ...  
}
  
// 返回number类型 
function aNumberCallback (): number {
    return 2;  
}
  
doSomething(aNumberCallback); 
```

## any
TS新手超级喜欢这个类型
- 任意值（Any）用来表示允许赋值为任意类型。
- 它允许访问任意属性和调用任意方法
因此`any`成了系统的顶级类型
```ts
// 但如果是 any 类型，则允许被赋值为任意类型。
let myFavoriteNumber: any = 'seven';
myFavoriteNumber = 7;

// 在任意值上访问任何属性都是允许的：
console.log(myFavoriteNumber.logName);
// 也允许调用任何方法：
myFavoriteNumber.split('');

// 声明未赋值 推断为any
let any1; // any1: any
```

## unknow
- 与 `any`一样都是TypeScript的顶层类型，所有类型都可以分配给`unknow`
- 与 `any`不同的是
    - 不能对`unknow`类型执行任意操作,必须先缩小到具体类型才能使用其方法和属性
    - `unknow`类型只能被赋值给`any`类型和`unknow`类型本身

- 缩小未知类型的范围的三种方法
    - 类型断言
    - `typeof`
    - `is`关键字

```ts
let unknownVal: unknown = 'str';
unknownVal = true; // 所以所有类型都可以分配给unknown

// unknow类型只能赋值给any类型和unknow类型
let anyVal: any;
anyVal = unknownVal
let num: number = 12;
num = unknownVal; // 不能将类型“unknown”分配给类型“number”。ts(2322)

/* 缩小未知类型的范围的三种方法 */
// 类型断言
function toFixed(value: unknown) {
    return (value as number).toFixed(2);
}
// typeof 类型保护
function toFixed2(value: unknown) {
    if(typeof value === 'number') {
        return value.toFixed(2);
    }
}
// is 自定义类型保护
const isNumber = (val: unknown): val is number => typeof val === 'number';
function toFixed3(value: unknown) {
    if (isNumber(value)) {
        return value.toFixed(2);
    }
}
```

## never类型
- `never`类型表示的是那些永不存在的值的类型，这意味着，定义了一个`never`类型，只能被`never`类型的值所赋值
- `never` 是 `undefined` 和`null`的子类型， 是最底层的类型

什么情况下会出现`never`类型
- 一个从来不会有返回值的函数
    - `let ne = (() => { while(true) {} })();`
- 一个总是会抛出错误的函数
    - `let ne2 = (() => { throw new Error("异常"); })(); `


# 类型进阶
- 联合类型
- 对象的类型
- 数组的类型
- 函数的类型
- 元组类型

## 联合类型
- 联合类型（Union Types）表示取值可以为多种类型中的一种
- 只能访问此联合类型的所有类型里共有的属性或方法
```ts
let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;

function getLength(something: string | number): string {
    console.log(something.length) // 不可以 number类型没有length属性
    console.log(something.toFixed(2)) // 不可以， string类型没有toFixed方法
    return something.toString();
}
```

## 对象的类型
在 TypeScript 中，我们使用接口（Interfaces）来定义对象的类型。
- 何为接口？它是对行为的抽象。
- 接口一般首字母大写。有的编程语言中会建议接口的名称加上 `I` 前缀。
- 接口定义后 实例多一些属性或少一些属性都是不允许的
- 属性修饰 `?` 可选属性 `readonly` 只读属性
- 任意属性 `[propName: string]: any;`
    - 一旦定义了任意属性，那么确定属性和可选属性都必须是它的类型的子集
```ts
interface Person {
    name: string;
    age: number;
}
let tom: Person = { // 报错 缺少age属性
    name: 'Tom'
};
let tom2: Person = { // 报错 不需要 gender 属性
    name: 'Tom',
    age: 25,
    gender: 'male'
};


interface Person2 {
    readonly name: string;
    age?: number;
    // [propName: string]: string; // 报错，任意类型必须包含可选类型和确定类型
    [propName: string]: string | number | undefined; 
}
let jack: Person2 = {
    name: 'zs'
}
jack.name = 'ls' // 报错
jack.age = 12; // ok
jack.sex = 1 // ok

// 只读的约束存在于第一次给对象赋值的时候，而不是第一次给只读属性赋值的时候
interface Person3 {
    readonly id?: number;
    name: string;
    age?: number;
    [propName: string]: any;
}
let tom3: Person3 = {
    name: 'Tom',
    gender: 'male'
};
tom3.id = 89757; // 报错
```

## 数组的类型
###  数组的三种表示法
- 「类型 + 方括号」表示法 `let fibonacci: number[] = [1, 1, 2, 3, 5];`
- 泛型表示法 `let fibonacci: Array<number> = [1, 1, 2, 3, 5];`
- 接口表示法
```ts
interface NumberArray {
    [index: number]: number;
}
let fibonacci: NumberArray = [1, 1, 2, 3, 5];
```

### 类数组
```ts
function sum() {
    let args: number[] = arguments; // 报错
}

// Type 'IArguments' is missing the following properties from type 'number[]': pop, push, concat, join, and 24 more.

function sum() {
    let args: IArguments = arguments;
}
// IArguments 是TS内置对象
// 实际 IArguments 定义如下
interface IArguments {
    [index: number]: any;
    length: number;
    callee: Function;
}

// 用 any 表示数组中允许出现任意类型
let list: any[] = ['xcatliu', 25, { website: 'xcatliu.com' }];
```

## 函数的类型
- 可以约束函数参数类型、参数个数及返回值类型
- 函数声明语句的TS修饰
- 函数定义语句的TS修饰
- 使用interface修饰函数
- 对函数参数设置默认值， 同样会进行类型推断
- 可选修饰符: 
    - 仅最后一个参数可以用`?`
    - 设置了默认值就不能使用可选修饰符
- `readoly`修饰参数 只能在构造函数中使用
- 剩余参数， 准许JS语法 只能在最后一个参数定义
- 函数重载 （完整的函数重载将在下一篇进阶课中讲解）
```ts
// 函数声明语句
function sum(x: number, y: number): number {
    return x + y;
}
sum(1);  // 报错，不能少参数
sum(1, 2); // ok

// 函数定义表达式
let mySum = function (x: number, y: number): number {
    return x + y;
};
// 等同于如下代码
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
    return x + y;
};

// 使用interface修饰函数
interface SearchFunc {
    (source: string, subString: string): boolean;
}

let mySearch: SearchFunc;
mySearch = function(source: string, subString: string) {
    return source.search(subString) !== -1;
}
// 函数重载
function reverse(x: number): number; // 重载签名
function reverse(x: string): string; // 重载签名
// 实现签名
function reverse(x: number | string): number | string | void {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}
```
## 元组
数组合并了相同类型的对象，而元组（Tuple）合并了不同类型的对象
- 访问已知索引的元素会得到正确的类型
- 添加越界的元素时，他的类型会被限制为元组中每个类型的联合类型
```ts
// 元组的定义
let tom4: [string, number] = ['Tom', 25];
let tom5: [string, number];
// tom5 = [25, 'Tom'] // 报错
tom5 = ['Tom', 25]
tom5[0] = 'Tom'; // 可以只赋值其中一项：
// 当赋值或访问一个已知索引的元素时，会得到正确的类型：
tom4[0].slice(1);
tom4[1].toFixed(2);

// 当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型：
tom4.push('male'); // ok
tom4.push(true); // 报错
```


# 参考资料
- [《ts入门教程》](https://ts.xcatliu.com/)
- [《TS常见类型》](https://blog.csdn.net/zxl1990_ok/article/details/125205351)

TypeScript入门教程学习（一）

浏览器API

计算机网络（一）网络接口层与网际层

新概念英语1-语法

。。。。。。



# 被动语态
- 主动语态 强调动作的执行者
- 被动语态 强调动作的承受着

**主谓宾**
- The carrot was eaten by rabbit
- The rabbit was frightened by wolf

**主谓+间接宾语+直接宾语**
- The rabbit gave the carrot to the wolf
- The wolf was given the carrot by the rabbit
- The carrot was given to the wolf by the rabbit

**主语+谓语+宾语+宾补**
- The rabbit was invited to the party by the wolf
- The rabbit made the wolf (to) laugh
- The wolf was made to laugh (by the rabbit)



| 主动 | 被动  | 被动疑问  |
| --- | --- |--- |
| The rabbit has eaten the carrot | The carrot has been eaten by the rabbit | Has the carrot been eaten by the rabbit |
| The rabbit would have eaten the carrot | The carrot would have been eaten by the rabbit | Would the carrot have been eaten by the rabbit |
| The rabbit might eat the carrot | The carrot minght be eaten by the rabbit | Might the carrot be eaten by the rabbit |


# 倒装句

为了强调某种信息 而颠倒原有语序的顺序

倒装分三种
- 完全倒装 谓语动词完全在主语前
    - 副词/介词短语在句首的倒装
    - 表语的倒装
- 部分倒装 仅助动词提前
- 形式倒装 谓语动词不提前

地点副词在句首的倒装
- There goes the last bus

时间副词在句首的倒装
- Now comes the wolf's turn!

表运动方向的副词在句首的倒装
- In out up down away 
- Up went the carrot into air
- At the table sat a rabbit

英语中为了保持句子平衡，或者强调表语部分，将做表语的形容词、分词、介词短语、such, 置于句首时，需要完全倒装
- Seated on the ground is a group of rabbits
- Such were the wolf's tricks
- English you mush learn
- This video you like


部分倒桩句（将助动词和谓语动词分离，助动词提前）
- Never before have I eaten such a delicious carrot

独立主格结构
- Because he was invited by the wolf, the rabbit deside to go to party
- `Invited by the wolf, The rabbit deside to go to the party`
- Because the wolf invited him, the rabbit deside to go to the party
- The wolf Inviting him, the rabbit decided to go to the party
    - 这句话的主干是 `the rabbit ...`，但是invite这个动作是由`the wolf`发出的，而不是真正的主语 the rabbit 发出来的，所以语法上把`the wolf`称为动词invite的逻辑主语，而这就是"独立主格"中的"主格",因为`the wolf`是有利于真正主语the rabbit之外的呀，所以是独立，这个独立的主语（非真正的主语）叫逻辑主语

下面看一下独立主格对句子的简化

| 标题 |  |
| --- | --- |
| If the weather permits, the rabbit will go out | The weather permitting, the rabbit will go out  |
| After the work was finished, the rabbit went home | The work finished, the rabbit went home |
| The rabbit is lying in the bed and a carrot is still held in his hand | The rabbit is lying in the bed, a carrot still held in his hand |

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

- The rabbit to come, the wolf is overjoyed
- Many animals went to the party, some of them rabbits and wolves
- Many animals went to the party, some of them happy
- The rabbit sat on a chair, head down
- The rabbit came in, carrot in hand

名词/代词 + ~~being~~ + ...
- Many animals went to the party, some of them ~~being~~ rabbits and wolves
- Many animals went to the party, some of them ~~being~~ happy
- The rabbit sat on a chair, head ~~being~~ down
- The rabbit came in, carrot ~~being~~ in hand

- The work finished, the rabbit went home
- With the work finished, the rabbit went home
- The rabbit came in, with a carrot in his hand
    - The rabbit came in, carrot in hand


# 强调
- Rabbits like carrots
- Wow rabbits like carrots!
- Oh my god, rabbits like carrots

书面强调
- Rabbits like carrots!
- Rabbits like carrots!!!
- **Rabbits** like carrot!?
- *Rabbits* like carrots
- RABBITS like carrots

词汇强调 
- Rabbit really like carrots!
- I eat very very very fast!
- I missed the very beginning of the movie
- This is just unbelieveable!
- All I ever wanted is that carrot
- What the hell are you talking about


- He went on and on and on 
- He walked and walked and walked

Rabbits do like carrots

反身代词强调
- I can do it myself
- I myself went there! 
- I saw myself in the mirror 这个不是强调

- The carrot is big!  ---> How big the carrot is !
- You've grown a big carrot ---> What a big carrot you've grown!

- The rabbit will eat the carrot
    - It is the rabbit who/that will eat the carrot


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




# 省略
- 词法省略
- 句法省略
## 词法省略
表示独一无二的身份，可以省略冠词

chairman president head
- The rabbit was appointed (the) chairman of the carrotown Committee
- The wolf served as (the) head of our team


并列关系
- Both the rabbit and （the） wolf will be invited to the party
- Is this hunny a boy or (a) girl

有些情况下不能省略冠词
- a teacher and a wideo creator

某些独立主格结构可省略
- The rabbit came in, carrot in hand
- The rabbit came in, with a carrot in his hand

- I ate 10 carrots (on) that day
- I worked (for) 60 hours (in) last week

I am busy (in) making videos

裸不定式
- He wanted to stay here and (to) read
- The wolf helped me to eat the carrot


省略从句引导词
- This is the rabbit (that) we met yesterday.
- The rabbit said (that) the carrots were tasty

## 句法省略

祈使句
- Open the door please
- You open the door, please
- What a smart rabbit he is!
- How (fast) time flies!

在一些口语表达中力求简洁，可省略很多重复的部分
- The rabbit went home after work, and (the rabbit) ate a carrot
- The rabbit has eaten a carrot, but the wolf hasn't (eaten a carrot)
- The story made the rabbit happy, but (the story made) the wolf sad
- The rabbit likes carrots and the wolf (likes) apples

主从复合句中的省略
- The rabbit will eat the carrot , but I don't know when (he will eat it)
- When (the rabbit was) young, (he) went to school erery day
- If (it is) possible, I'll be there on time
- I can eat more carrots than you  (can eat carrtos)
- You are smarter than I am smart

# 主谓一致

中文是所谓**孤立语**，对次序的要求非常高，而词性变化很少或者没有变化。 比如咱们中文没有动词本身不存在于语法上的“变位”，（时态气）

而英文术语屈折语，通过丰富的词性变化表达语法意义。

如 `I am  a rabbit, you were a rabbit`
谓语动词和主语的人称一致，

英语语法 主谓一致，要求 语法一致、意义一致、就近一致

## 语法一致
句子中的谓语动词在形式上和主语的单复数保持一致
  
- Time is money
- Carrots are delicious

不可数名词后只能接单数谓语动词

比如
- A number of carrots have been eaten
- A lot of carrot juice has been sold
- To eat a carrot every day is good for the rabbit

非谓语动词做主语时，也相当于单数名词， 比如
- To eat a carrot every day is good for the rabbit
- Eating carrots is healthy

一般情况下用and连接不同的名词做主语，都会接复数谓语动词，比如：
- The rabbit and the wolf are at the party 

假象主语
一些词看起来像复数，但其实是单数
- `as well as` `expect` `but`

- `The rabbit` as well as other animals `gets` a rabbit
- `All the animals` except the wolf `get` the carrots

不定代词作主语
- Everyone gets a carrot
- Each of them gets a carrot
- Both of them like carrots
- Some of them are afraid of wolf


- None of them get/gets a carrot
- Neigher of them is/are afraid of the wolf

## 意义一致
主语意义位单数， 则谓语动词用单数， 主语意义为复数， 则谓语动词也需要用复数

同一个主语多种身份
- The teacher and video creator is a rabbit
- The teacher and the video creator are rabbits

意义一致
- Ten years is a long time
- Two coins isn't a lot
- A knift and fork is needed for eating the carrot
- Break and butter is also needed at dinner

3. 不定代词的单复数意义
- All is quiet --> All are quiet

4. 名词的行和意
- 行复意单 --->  用单数谓语动词
- 行单意复 ---> 用复数谓语动词  
- 单复数同形的名词 ---> 用单复数谓语动词都可
- 集合名词 ---> 用单复数谓语动词都可

有些名词，看起来是单数， 但是意义是单数， 比如：
- Physics is my favorite subject
- The cattle are on the hill
- A sheep is eating grass
- The sheep are eating grass

类似的名词还有 deer means series species 

集合名词
- The rabbit's family is huge.
- The rabbit's family are all at home

类似的集合名词还有
- army audience police  team  police  team 等

只能表示一个类别的事物， 只能用单复数谓语动词如
- All the funiture here is expensive

`the + 形容词`
可视作集合名词；表示单数意义/复数意义
- The young are expected to learn from the old
- The new is going to replace the old

## 就近一致
谓语动词的单复数由最近的主语决定，如`or`，`either... or...` 等

由 `or...` / `either... or...` / `neither...nor...`/ `not only... but alse` 等连接两个名词或代词作主语时， 谓语动词和和离的近的词一致
- Either you or I am going to party.
- Not only the rabbit but also many other animals like carrots
- There is a carrot and two apples on the table


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

# 缩写

| contraction | example sentence |
| --- | --- |
| I am ---> I'm | I'm 24 years old |
| You are ---> You're | You're such a sweetheart |
| He is ---> He's | He's so handsome |
| She is ---> She's | She's very beautiful  |
| They are ---> They're  | They're such cute kittens  |
| We are ---> We're | We're going to China next month |
| That is ---> That's | That's awesome |
| There is ---> There's | There's the hotel we were looking for |
| What is ---> What's | What's the matter? |
| Where is  ---> Where's | Where's my car? |
| Who is ---> Who's | Who's there? |
| Who are ---> Who're | Who're the people at next table? |
|  12  | 12 |
| Are not ---> Aren't | They aren't coming next week |
| Is not --->  Isn't | She isn't listening to you |
| Were not ---> **Weren't** | They weren't invited to the party |
| Was not ---> Wasn't |  I wasn't joking when I said that |
| Does not ---> Doesn't | He doesn't play tennis |
| Do not ---> Don't | I don't like cheese |
| Need not ---> **Needn't** | You needn't worry about that.  |
| Did not ---> Didn't |  I didn't know that |
| Can not ---> Can't | I can't understand you |
| Could not ---> Couldn't | He couldn't get his shoes on! |
| Will not ---> Won't | I won't be able to attend the conference |
| Would not ---> Wouldn't | I wouldn't ask her |
| Has not ---> Hasn't | She hasn't finished her homework yet |
| Have not ---> Haven't | I haven't finished my home work  |
| Had not ---> Hadn't | I hadn't thought of that |
| Might not ---> **Mightn't** | I almost wondered if he mightn't be right |
| Must not ---> **Mustn't** | You mustn't worry too much about this |
| Should not ---> Shouldn't | You shouldn't do things like that |
|  18  | 18 |
| I will ---> I'll | I'll be on vacation next week |
| You will ---> You'll | I think you'll pass the exam |
| He will ---> he'll | I'm sure he'll help you if he can |
| She will ---> She'll | She'll be there tommorrow, I'm sure. |
| They will ---> They'll | I hope they'll come to my party |
| I would ---> I'd | I'd like a cup of coffee |
| You would ---> You'd | I was afraid you'd ask me that |
| He would ---> He'd | He'd lick to go to the cinema tonight |
| She would ---> She'd | She'd be a great managing director.<br> don't you think? |
| They would ---> They'd | They'd love to see the film |
| We would ---> We'd | We'd be gratefull for an answer |
| 11 | 11 |
| I have ---> I've | I've been waiting an hour already |
| You have ---> You've | You've got to start working harder |
| They have ---> They've | They've got paint all over the carpet |
| We have ---> We've | It's been over a year since we're done that |
| Who have ---> Who've | Who've you asked so far? |
| He has ---> He's | He's worked here for 5 years |
| She has ---> She's | She's been to Japan twice |
| There has ---> There's | There's been entirely too much asid on the subject |
| That has ---> That's | That's got to be the most ridiculous thing I've ever seen |
| What has ---> What's | They want a list of what's been stolen |
| Who has ---> Who's | Who's been chosen, do you know? |
| I had ---> I'd | I'd just got in the bath when the phone rang |
| You had ---> You'd | It happened just after you'd left the room |
| He had ---> He'd | He'd been alone for a long time |
| She had ---> She'd | She'd already left |
| They had ---> They'd | They'd better be here on time |
| We had ---> We'd | We'd better be more careful in th fulture |
| Who had ---> Who'd | She wondered who'd sent her the mysterious email |
|  18  | 18 |
| Let us ---> Let's | Let's go out to dinner |

# 条件句
英语的条件句有时被称为“IF从句”， 分为真实条件句和非真实条件句，它描述了，可能发生（现在或将来）或可能发生但没有发生（过去）的事情的结果

由不同的时态组成，主要由四种条件句：
- 零条件句、
- 第一类条件句、
- 第二类条件句和
- 第三类条件句。

## 零条件句
格式： **If/When + ...一般现在时...**,

用法： **当结果总是发生时，或绝对真理时，使用零条件句**
- If water reaches 100 degrees, it boils
- If people eat too much, they get fat
- If you touch a fire, you get burned
- Snakes bite if they scared
- if babies are hungry, they cry
- If the weather is nice, she walks to work
- I read if there is noting on TV

If 和 when 

If 和 when都可以用于零条件句，但是 if表示某事发生频率较低， 而when表示有规律的发生，例如

- When I have a day off from work, I usually go to beach

## 第一类条件句
格式： **If/When + ...一般现在时...， ...一般将来时...**

用法： 当你用来描述你认为将来可能发生的事情时，使用第一类条件句。

- If it rains, I won't go to park
- If I study today, I'll go to the party tonight
- If I have enough money, I'll buy some new shoes
- She'll be late if the train is delayed
- If I see her, I'll tell her.

If 和 When
If 表示你不知道某事是否发生，而when表示某件事一定会在某个时刻发生，我们只是在等待它的发生。

- When you call me, I will give you the address

## 第二类条件句

格式： 
- **If+...一般过去时...，...would + 不带to不定式...**
- **...would + 不带to不定式...，If+...一般过去时...**

用法

用来表示与将来事实可能相反的事情，比如在幻想什么东西
- If I won the lottery, I would buy a big house.
- She would pass the exam if she ever studied
- She would travel all over the world if she were rich
- If I had his number, I would call him

3. 在第二类条件句中，虽然 was 经常出现在对话中，但是在语法上它是不正确的，在英语写作或考试中要用 were，例如：

- If he were French, he would live in Paris.
- I would play basketball if I were taller.

4. if 和 when：只有 if 可以用于第二类条件句，而 when 不可以。

更多条件句，[参考这篇文章](https://zhuanlan.zhihu.com/p/359713172)


# 不定式省略to的情况
1. 情态动词（除ought外）
2. 使役动词 make， let, have 后，感官动词see, watch,look at, noice, abserve, hear, listento, smell, feel, find 等后。
    - I saw him dance.
    - The boss made them work the whole night.
    - 注意被动语态中不能省去to. 例如:
    - He was seen to dance
    - The were made to work the whole night
    - 实义动词get(说服。。。)后的to不能省略
    - I'll get the wolf to wash my car for free
3. would rather, had better句型后
4. Why.../ Why no...句型后
5. help sb (to) do sth
    - The wolf helped the rabbit (to) grow carrots.
6. but和except后。but前时实义动词do时，后面出现的不定式不带to.
    - He wants to do nothing but go out
    - He wants to believe anything but to take the medicine
7. 由and, or和than连接的两个不定式，第二个to可以省去
8. 通常在discover, imagine, suppose, think等词后作宾语时，可以省去to



# 其它
- 其它使役动词
    - force（强迫）, 
    - leave（让，导致）, 
    - drive（驱使，使...变得）, 
    - see（看到）, 
    - find（发现）
    - watch 观看


# 翻译问题


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