TypeScript 学习记录

女爷i 2022-12-29 09:17 172阅读 0赞

### 文章目录 ###

*  1. TypeScript 是什么
 *   *  1.1 TypeScript 与 JavaScript 的区别
     *  1.2 安装 TypeScript
     *  1.3 编译 TypeScript 文件
 *  2. TypeScript 基础类型
 *   *  2.1 Boolean 类型
     *  2.2 Number 类型
     *  2.3 String 类型
     *  2.4 Array 类型
     *  2.5 Enum 类型
     *  2.6 Any 类型
     *  2.7 Unknown 类型
     *  2.8 Tuple 类型
     *  2.9 Void 类型
     *  2.10 Null 和 Undefined 类型
     *  2.11 Never 类型
 *  3. TypeScript 断言
 *   *  3.1 “尖括号” 语法
     *  3.2 as 语法
 *  4. 类型守卫
 *   *  4.1 in 关键字
     *  4.2 typeof 关键字
     *  4.3 instanceof 关键字
     *  4.4 自定义类型保护的类型谓词
 *  5. 联合类型和类型别名
 *   *  5.1 联合类型 \`|\`
     *  5.2 可辨识联合
     *  5.3 类型别名
 *  6. 交叉类型\`&\`
 *  7. TypeScript 函数
 *   *  7.1 TypeScript 函数与 JavaScript 函数的区别
     *  7.2 参数类型和返回类型
     *  7.3 函数类型
     *  7.4 可选参数及默认参数
     *  7.5 剩余参数
     *  7.6 函数重载
 *  8. TypeScript 数组
 *   *  8.1 数组解构
     *  8.2 数组展开运算符
 *  9. TypeScript 对象
 *   *  9.1 对象解构
     *  9.2 对象展开运算符
 *  10. TypeScript 接口
 *   *  10.1 对象的形状
     *  10.2 可选 | 只读属性
 *  11. TypeScript 类
 *   *  11.1 类的属性与方法
     *  11.2 访问器
     *  11.3 类的继承
     *  11.4 ECMAScript 私有字段
 *  12. TypeScript 泛型
 *   *  12.1 泛型接口
     *  12.2 泛型类
     *  12.3 泛型变量
     *  12.4 泛型工具类型
     *   *  12.4.1 typeof 操作符
         *  12.4.2 keyof 操作符
         *  12.4.3 in 操作符
         *  12.4.4 infer 操作符
         *  12.4.5 extends 操作符
         *  12.4.6 Partial 操作符
 *  13. TypeScript 装饰器
 *   *  13.1 装饰器是什么
     *  13.2 装饰器的分类
     *  13.3 类装饰器
     *  13.4 属性装饰器
     *  13.5 方法装饰器
     *  13.6 参数装饰器
 *  14. 编译上下文
 *   *  14.1 tsconfig.json 的作用
     *  14.2 tsconfig.json 重要字段
     *  14.3 compilerOptions 选项

# 1. TypeScript 是什么 #

`TypeScript` 是 `JavaScript` 的一个超集，它本质上其实是在 `JavaScript` 上添加了可选的静态类型和基于类的面向对象编程

中文手册：https://typescript.bootcss.com/

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm1rMTAyMw_size_20_color_FFFFFF_t_70_g_se_x_16]

## 1.1 TypeScript 与 JavaScript 的区别 ##

<table> 
 <thead> 
  <tr> 
   <th>TypeScript</th> 
   <th>JavaScript</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JavaScript 的超集用于解决大型项目的代码复杂性</td> 
   <td>一种脚本语言，用于创建动态网页</td> 
  </tr> 
  <tr> 
   <td>可以在编译期间发现并纠正错误</td> 
   <td>作为一种解释型语言，只能在运行时发现错误</td> 
  </tr> 
  <tr> 
   <td>强类型，支持静态和动态类型</td> 
   <td>弱类型，没有静态类型选项</td> 
  </tr> 
  <tr> 
   <td>最终被编译成 JavaScript 代码，使浏览器可以理解</td> 
   <td>可以直接在浏览器中使用</td> 
  </tr> 
  <tr> 
   <td>支持模块、泛型和接口</td> 
   <td>不支持模块，泛型或接口</td> 
  </tr> 
  <tr> 
   <td>支持 ES3，ES4，ES5 和 ES6 等</td> 
   <td>不支持编译其他 ES3，ES4，ES5 或 ES6 功能</td> 
  </tr> 
 </tbody> 
</table>

## 1.2 安装 TypeScript ##

$ npm install -g typescript

## 1.3 编译 TypeScript 文件 ##

$ tsc helloworld.ts
    # helloworld.ts => helloworld.js

# 2. TypeScript 基础类型 #

## 2.1 Boolean 类型 ##

let isDone: boolean = false;

## 2.2 Number 类型 ##

let count: number = 10;

## 2.3 String 类型 ##

let name: string = "Semliker";

## 2.4 Array 类型 ##

let list: number[] = [1, 2, 3];
    // ES5：var list = [1,2,3];
    
    let list: Array<number> = [1, 2, 3]; // Array<number>泛型语法
    // ES5：var list = [1,2,3];

## 2.5 Enum 类型 ##

使用枚举我们可以定义一些带名字的常量。 使用枚举可以清晰地表达意图或创建一组有区别的用例。 `TypeScript` 支持数字的和基于字符串的枚举。

1.数字枚举

enum Direction { 
      NORTH, // 默认情况下，从0开始，依次递增，也可以设置 NORTH 的初始值 NORTH=3
      SOUTH,  
      EAST,
      WEST,
    }
    
    let dir: Direction = Direction.NORTH;

2.字符串枚举

enum Direction { 
      NORTH = "NORTH",
      SOUTH = "SOUTH",
      EAST = "EAST",
      WEST = "WEST",
    }

## 2.6 Any 类型 ##

在 `TypeScript` 中，任何类型都可以被归为 any 类型。这让 `any` 类型成为了类型系统的`顶级类型`（也被称作全局超级类型）。

let notSure: any = 666;
    notSure = "Semlinker";
    notSure = false;

`any` 类型本质上是类型系统的一个逃逸舱。作为开发者，这给了我们很大的自由：`TypeScript` 允许我们对 `any` 类型的值执行任何操作，而无需事先执行任何形式的检查。比如：

let value: any;
    
    value.foo.bar; // OK
    value.trim(); // OK
    value(); // OK
    new value(); // OK
    value[0][1]; // OK

在许多场景下，这太宽松了。使用 `any` 类型，可以很容易地编写类型正确但在运行时有问题的代码。如果我们使用 any 类型，就无法使用 `TypeScript` 提供的大量的保护机制。为了解决 `any` 带来的问题，`TypeScript 3.0` 引入了 `unknown` 类型。

## 2.7 Unknown 类型 ##

就像所有类型都可以赋值给 `any`，所有类型也都可以赋值给 `unknown`。这使得 `unknown` 成为 `TypeScript` 类型系统的另一种顶级类型（另一种是 `any`）。

let value: unknown;
    
    value = true; // OK
    value = 42; // OK
    value = "Hello World"; // OK
    value = []; // OK
    value = { }; // OK
    value = Math.random; // OK
    value = null; // OK
    value = undefined; // OK
    value = new TypeError(); // OK
    value = Symbol("type"); // OK

`unknown` 类型只能被赋值给 `any` 类型和 `unknown` 类型本身。

let value: unknown;
    
    let value1: unknown = value; // OK
    let value2: any = value; // OK
    let value3: boolean = value; // Error
    let value4: number = value; // Error
    let value5: string = value; // Error
    let value6: object = value; // Error
    let value7: any[] = value; // Error
    let value8: Function = value; // Error

将 `value` 变量类型设置为 `unknown` 后，这些操作都不再被认为是类型正确的。通过将 `any` 类型改变为 `unknown` 类型，我们已将允许所有更改的默认设置，更改为禁止任何更改。

let value: unknown;
    
    value.foo.bar; // Error
    value.trim(); // Error
    value(); // Error
    new value(); // Error
    value[0][1]; // Error

## 2.8 Tuple 类型 ##

*  数组一般由同种类型的值组成，但有时我们需要`在单个变量中存储不同类型的值`，这时候我们就可以使用`元组`。
 *  在 `JavaScript` 中是没有元组的，元组是 `TypeScript` 中`特有`的类型，其工作方式类似于数组。
 *  元组初始化时，要正确匹配每一项的值。

let tupleType: [string, boolean]; // 定义一个元组类型
    tupleType = ["Semlinker", true]; // ok
    
    console.log(tupleType[0]); // Semlinker
    console.log(tupleType[1]); // true
    
    tupleType = [true, "Semlinker"]; // false
    tupleType = ["Semlinker"]; // false

## 2.9 Void 类型 ##

*  void 类型像是与 any 类型相反，它表示没有任何类型。
 *  当一个函数没有返回值时，你通常会见到其返回值类型是 void。
 *  声明一个 void 类型的变量没有什么作用，因为它的值只能为 undefined 或 null。

let unusable: void = undefined;

## 2.10 Null 和 Undefined 类型 ##

TypeScript 里，`undefined` 和 `null` 两者有各自的类型分别为 undefined 和 null。

let u: undefined = undefined;
    let n: null = null;

默认情况下 `null` 和 `undefined` 是所有类型的子类型。 就是说你可以把 `null` 和 `undefined` 赋值给 `number` 类型的变量。然而，如果你指定了`--strictNullChecks` 标记，`null` 和 `undefined` 只能赋值给 `void` 和它们各自的类型。

## 2.11 Never 类型 ##

`never` 类型表示的是那些永不存在的值的类型。 例如，`never` 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型。

// 返回never的函数必须存在无法达到的终点
    function error(message: string): never { 
      throw new Error(message);
    }
    
    function infiniteLoop(): never { 
      while (true) { }
    }

在 `TypeScript` 中，可以利用 `never` 类型的特性来实现全面性检查，具体示例如下：

type Foo = string | number;
    
    function controlFlowAnalysisWithNever(foo: Foo) { 
      if (typeof foo === "string") { 
        // 这里 foo 被收窄为 string 类型
      } else if (typeof foo === "number") { 
        // 这里 foo 被收窄为 number 类型
      } else { 
        // foo 在这里是 never
        const check: never = foo;
      }
    }
    
    controlFlowAnalysisWithNever(foo); // ok

假如修改Foo的类型，这时候 else 分支的 foo 类型会被收窄为 boolean 类型，导致无法赋值给 never 类型，这时就会产生一个编译错误。

type Foo = string | number | boolean;
    
    controlFlowAnalysisWithNever(foo); // 编译错误。

`controlFlowAnalysisWithNever` 方法总是穷尽了 Foo 的所有可能类型。 **使用 never 避免出现新增了联合类型没有对应的实现，目的就是写出类型绝对安全的代码。**

# 3. TypeScript 断言 #

有时候你会遇到这样的情况，你会比 TypeScript 更了解某个值的详细信息。通常这会发生在你清楚地知道一个实体具有比它现有类型更确切的类型。

通过类型断言这种方式可以告诉编译器，“相信我，我知道自己在干什么”。类型断言好比其他语言里的类型转换，但是不进行特殊的数据检查和解构。它没有运行时的影响，只是在编译阶段起作用。

## 3.1 “尖括号” 语法 ##

let someValue: any = "this is a string";
    let strLength: number = (<string>someValue).length;

## 3.2 as 语法 ##

let someValue: any = "this is a string";
    let strLength: number = (someValue as string).length;

# 4. 类型守卫 #

类型保护是可执行运行时检查的一种表达式，用于确保该类型在一定的范围内。类型保护与特性检测并不是完全不同，其主要思想是尝试检测属性、方法或原型，以确定如何处理值。目前主要有四种的方式来实现类型保护：

## 4.1 in 关键字 ##

interface Admin { 
      name: string;
      privileges: string[];
    }
    
    interface Employee { 
      name: string;
      startDate: Date;
    }
    
    type UnknownEmployee = Employee | Admin;
    
    function printEmployeeInformation(emp: UnknownEmployee) { 
      console.log("Name: " + emp.name);
      if ("privileges" in emp) { 
        console.log("Privileges: " + emp.privileges);
      }
      if ("startDate" in emp) { 
        console.log("Start Date: " + emp.startDate);
      }
    }

## 4.2 typeof 关键字 ##

## 4.3 instanceof 关键字 ##

interface Padder { 
      getPaddingString(): string;
    }
    
    class SpaceRepeatingPadder implements Padder { 
      constructor(private numSpaces: number) { }
      getPaddingString() { 
        return Array(this.numSpaces + 1).join(" ");
      }
    }
    
    class StringPadder implements Padder { 
      constructor(private value: string) { }
      getPaddingString() { 
        return this.value;
      }
    }
    
    let padder: Padder = new SpaceRepeatingPadder(6);
    
    if (padder instanceof SpaceRepeatingPadder) { 
      // padder的类型收窄为 'SpaceRepeatingPadder'
    }

## 4.4 自定义类型保护的类型谓词 ##

function isNumber(x: any): x is number { 
      return typeof x === "number";
    }
    
    function isString(x: any): x is string { 
      return typeof x === "string";
    }

# 5. 联合类型和类型别名 #

## 5.1 联合类型 `|` ##

const sayHello = (name: string | undefined) => { 
      /* ... */
    };

## 5.2 可辨识联合 ##

*  如果一个类型是多个类型的联合类型，且多个类型含有一个公共属性，那么就可以利用这个公共属性，来创建不同的类型保护区块。
 *  它包含 3 个要点：可辨识、联合类型和类型守卫

1.`可辨识`：要求联合类型中的每个元素都含有一个单例类型属性

enum CarTransmission { 
      Automatic = 200,
      Manual = 300
    }
    
    interface Motorcycle { 
      vType: "motorcycle"; // discriminant
      make: number; // year
    }
    
    interface Car { 
      vType: "car"; // discriminant
      transmission: CarTransmission
    }
    
    interface Truck { 
      vType: "truck"; // discriminant
      capacity: number; // in tons
    }

2.`联合类型`

type Vehicle = Motorcycle | Car | Truck;

3.`类型守卫`

function evaluatePrice(vehicle: Vehicle) { 
      switch(vehicle.vType) { 
        case "car":
          return vehicle.transmission * EVALUATION_FACTOR;
        case "truck":
          return vehicle.capacity * EVALUATION_FACTOR;
        case "motorcycle":
          return vehicle.make * EVALUATION_FACTOR;
      }
    }

## 5.3 类型别名 ##

type Message = string | string[];
    
    let greet = (message: Message) => { 
      // ...
    };

# 6. 交叉类型`&` #

`TypeScript` 交叉类型`&`是将多个类型合并为一个类型。 这让我们可以把现有的多种类型叠加到一起成为一种类型，它包含了所需的所有类型的特性。

interface IPerson { 
      id: string;
      age: number;
    }
    
    interface IWorker { 
      companyId: string;
    }
    
    type IStaff = IPerson & IWorker;
    
    const staff: IStaff = { 
      id: 'E1006',
      age: 33,
      companyId: 'EFT'
    };
    
    console.dir(staff)

# 7. TypeScript 函数 #

## 7.1 TypeScript 函数与 JavaScript 函数的区别 ##

<table> 
 <thead> 
  <tr> 
   <th>TypeScript</th> 
   <th>JavaScript</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>含有类型</td> 
   <td>无类型</td> 
  </tr> 
  <tr> 
   <td>必填和可选参数</td> 
   <td>所有参数都是可选的</td> 
  </tr> 
  <tr> 
   <td>函数重载</td> 
   <td>无函数重载</td> 
  </tr> 
 </tbody> 
</table>

## 7.2 参数类型和返回类型 ##

function createUserId(name: string, id: number): string { 
      return name + id;
    }

## 7.3 函数类型 ##

let IdGenerator: (chars: string, nums: number) => string;
    
    function createUserId(name: string, id: number): string { 
      return name + id;
    }
    
    IdGenerator = createUserId;

## 7.4 可选参数及默认参数 ##

// 可选参数
    function createUserId(name: string, id: number, age?: number): string { 
      return name + id;
    }
    
    // 默认参数
    function createUserId(
      name: string = "Semlinker",
      id: number,
      age?: number
    ): string { 
      return name + id;
    }

## 7.5 剩余参数 ##

function push(array, ...items) { 
      items.forEach(function (item) { 
        array.push(item);
      });
    }
    
    let a = [];
    push(a, 1, 2, 3);

## 7.6 函数重载 ##

`函数重载`或`方法重载`是`使用相同名称`和`不同参数数量或类型`创建多个方法的一种能力。

function add(a: number, b: number): number;
    function add(a: string, b: string): string;

# 8. TypeScript 数组 #

## 8.1 数组解构 ##

let x: number; let y: number; let z: number;
    let five_array = [0,1,2,3,4];
    [x,y,z] = five_array;

## 8.2 数组展开运算符 ##

let two_array = [0, 1];
    let five_array = [...two_array, 2, 3, 4];

# 9. TypeScript 对象 #

## 9.1 对象解构 ##

let person = { 
      name: "Semlinker",
      gender: "Male",
    };
    
    let {  name, gender } = person;

## 9.2 对象展开运算符 ##

# 10. TypeScript 接口 #

`TypeScript` 中的`接口`是一个非常灵活的概念，除了可用于对类的一部分行为进行`抽象`以外，也常用于对「`对象的形状`（Shape）」进行描述。

## 10.1 对象的形状 ##

interface Person { 
      name: string;
      age: number;
    }
    
    let Semlinker: Person = { 
      name: "Semlinker",
      age: 33,
    };

## 10.2 可选 | 只读属性 ##

interface Person { 
      readonly name: string;
      age?: number;
    }

只读属性用于限制只能在对象刚刚创建的时候修改其值。此外 `TypeScript` 还提供了 `ReadonlyArray<T>` 类型，它与 `Array<T>` 相似，只是把所有可变方法去掉了，因此可以确保数组创建后再也不能被修改。

let a: number[] = [1, 2, 3, 4];
    let ro: ReadonlyArray<number> = a;
    ro[0] = 12; // error!
    ro.push(5); // error!
    ro.length = 100; // error!
    a = ro; // error!

# 11. TypeScript 类 #

类是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法

## 11.1 类的属性与方法 ##

在 `TypeScript` 中，我们可以通过 `Class` 关键字来定义一个类：

class Greeter { 
      // 静态属性
      static cname: string = "Greeter";
      // 成员属性
      greeting: string;
    
      // 构造函数 - 执行初始化操作
      constructor(message: string) { 
        this.greeting = message;
      }
    
      // 静态方法
      static getClassName() { 
        return "Class name is Greeter";
      }
    
      // 成员方法
      greet() { 
        return "Hello, " + this.greeting;
      }
    }
    
    let greeter = new Greeter("world");

那么成员属性与静态属性，成员方法与静态方法有什么区别呢？看一下以下编译生成的 ES5 代码：

"use strict";
    var Greeter = /** @class */ (function () { 
        // 构造函数 - 执行初始化操作
        function Greeter(message) { 
            this.greeting = message;
        }
        // 静态方法
        Greeter.getClassName = function () { 
            return "Class name is Greeter";
        };
        // 成员方法
        Greeter.prototype.greet = function () { 
            return "Hello, " + this.greeting;
        };
        // 静态属性
        Greeter.cname = "Greeter";
        return Greeter;
    }());
    var greeter = new Greeter("world");

1.静态方法：在构造函数本身上定义的方法，只能通过构造函数本身调用，new出来的对象不能够调用  
2.动态方法：也叫做实例方法，它是通过prototype原型对象添加的，所有的实例对象都能够继承调用。

## 11.2 访问器 ##

在 `TypeScript` 中，我们可以通过 `getter` 和 `setter` 方法来实现数据的封装和有效性校验，防止出现异常数据。

## 11.3 类的继承 ##

继承 (Inheritance) 是一种联结类与类的层次模型。指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系。

在 `TypeScript` 中，我们可以通过 `extends` 关键字来实现继承：

class Animal { 
      name: string;
      
      constructor(theName: string) { 
        this.name = theName;
      }
      
      move(distanceInMeters: number = 0) { 
        console.log(`${ this.name} moved ${ distanceInMeters}m.`);
      }
    }
    
    class Snake extends Animal { 
      constructor(name: string) { 
        super(name);
      }
      
      move(distanceInMeters = 5) { 
        console.log("Slithering...");
        super.move(distanceInMeters);
      }
    }
    
    let sam = new Snake("Sammy the Python");
    sam.move();

## 11.4 ECMAScript 私有字段 ##

在 TypeScript 3.8 版本就开始支持`ECMAScript` 私有字段，使用方式如下：

class Person { 
      #name: string;
    
      constructor(name: string) { 
        this.#name = name;
      }
    
      greet() { 
        console.log(`Hello, my name is ${ this.#name}!`);
      }
    }
    
    let semlinker = new Person("Semlinker");
    
    semlinker.#name;
    // ~~~~~
    // Property '#name' is not accessible outside class 'Person'
    // because it has a private identifier.

与常规属性（甚至使用 private 修饰符声明的属性）不同，私有字段要牢记以下规则：

*  私有字段以 \# 字符开头，有时我们称之为私有名称；
 *  每个私有字段名称都唯一地限定于其包含的类；
 *  不能在私有字段上使用 TypeScript 可访问性修饰符（如 public 或 private）；
 *  私有字段不能在包含的类之外访问，甚至不能被检测到。

# 12. TypeScript 泛型 #

`泛型`（Generics）是允许同一个函数接受不同类型参数的一种模板。相比于使用 `any` 类型，使用泛型来创建可复用的组件要更好，因为泛型会保留参数类型。

## 12.1 泛型接口 ##

interface GenericIdentityFn<T> { 
      (arg: T): T;
    }

## 12.2 泛型类 ##

class GenericNumber<T> { 
      zeroValue: T;
      add: (x: T, y: T) => T;
    }
    
    let myGenericNumber = new GenericNumber<number>();
    myGenericNumber.zeroValue = 0;
    myGenericNumber.add = function (x, y) { 
      return x + y;
    };

## 12.3 泛型变量 ##

其实这些大写字母并没有什么本质的区别，只不过是一个约定好的规范而已。使用大写字母 A-Z 定义的类型变量都属于泛型，把 T 换成 A，也是一样的。

*  T（Type）：表示一个 TypeScript 类型
 *  K（Key）：表示对象中的键类型
 *  V（Value）：表示对象中的值类型
 *  E（Element）：表示元素类型

## 12.4 泛型工具类型 ##

### 12.4.1 typeof 操作符 ###

`typeof` 操作符可以用来获取一个变量声明或对象的类型

interface Person { 
      name: string;
      age: number;
    }
    
    const sem: Person = {  name: 'semlinker', age: 30 };
    type Sem= typeof sem; // -> Person
    
    function toArray(x: number): Array<number> { 
      return [x];
    }
    
    type Func = typeof toArray; // -> (x: number) => number[]

### 12.4.2 keyof 操作符 ###

`keyof` 操作符可以用来一个对象中的所有 key 值

interface Person { 
        name: string;
        age: number;
    }
    
    type K1 = keyof Person; // "name" | "age"
    type K2 = keyof Person[]; // "length" | "toString" | "pop" | "push" | "concat" | "join" 
    type K3 = keyof {  [x: string]: Person };  // string | number

### 12.4.3 in 操作符 ###

`in` 用来遍历枚举类型

type Keys = "a" | "b" | "c"
    
    type Obj =  { 
      [p in Keys]: any
    } // -> { a: any, b: any, c: any }

### 12.4.4 infer 操作符 ###

在条件类型语句中，可以用 infer 声明一个类型变量并且对它进行使用。

type ReturnType<T> = T extends (
      ...args: any[]
    ) => infer R ? R : any;

以上代码中 `infer R` 就是声明一个变量来承载传入函数签名的返回值类型，简单说就是用它取到函数返回值的类型方便之后使用。

### 12.4.5 extends 操作符 ###

有时候我们定义的泛型不想过于灵活或者说想继承某些类等，可以通过 `extends` 关键字添加泛型约束。

interface ILengthwise { 
      length: number;
    }
    
    function loggingIdentity<T extends ILengthwise>(arg: T): T { 
      console.log(arg.length);
      return arg;
    }

现在这个泛型函数被定义了约束，因此它不再是适用于任意类型：

loggingIdentity(3);  // Error, number doesn't have a .length property

这时我们需要传入符合约束类型的值，必须包含必须的属性：

loggingIdentity({ length: 10, value: 3});

### 12.4.6 Partial 操作符 ###

`Partial<T>` 的作用就是将某个类型里的属性全部变为可选项 `?`。

**定义：**

/** * node_modules/typescript/lib/lib.es5.d.ts * Make all properties in T optional */
    type Partial<T> = { 
      [P in keyof T]?: T[P];
    };

在以上代码中，首先通过 `keyof T` 拿到 `T` 的所有属性名，然后使用 `in` 进行遍历，将值赋给 `P`，最后通过 `T[P]` 取得相应的属性值。中间的 `?` 号，用于将所有属性变为可选。

**示例：**

interface Todo { 
      title: string;
      description: string;
    }
    
    function updateTodo(todo: Todo, fieldsToUpdate: Partial<Todo>) { 
      return {  ...todo, ...fieldsToUpdate };
    }
    
    const todo1 = { 
      title: "organize desk",
      description: "clear clutter",
    };
    
    const todo2 = updateTodo(todo1, { 
      description: "throw out trash",
    });

在上面的 updateTodo 方法中，我们利用 `Partial<T>` 工具类型，定义 fieldsToUpdate 的类型为 `Partial<Todo>`，即：

{ 
       title?: string | undefined;
       description?: string | undefined;
    }

# 13. TypeScript 装饰器 #

## 13.1 装饰器是什么 ##

*  它是一个表达式
 *  该表达式被执行后，返回一个函数
 *  函数的入参分别为 `target`、`name` 和 `descriptor`
 *  执行该函数后，可能返回 `descriptor` 对象，用于配置 `target` 对象

## 13.2 装饰器的分类 ##

*  类装饰器（Class decorators）
 *  属性装饰器（Property decorators）
 *  方法装饰器（Method decorators）
 *  参数装饰器（Parameter decorators）

## 13.3 类装饰器 ##

类装饰器声明：

declare type ClassDecorator = <TFunction extends Function>(
      target: TFunction
    ) => TFunction | void;

类装饰器顾名思义，就是用来装饰类的。它接收一个参数：

*  target: TFunction - 被装饰的类

示例：

上面的例子中，我们定义了 `Greeter` 类装饰器，同时我们使用了 `@Greeter` 语法糖，来使用装饰器。

例子中总是输出 `Hello Semlinker!` ，下一个例子能自定义输出的问候语：

## 13.4 属性装饰器 ##

属性装饰器声明：

declare type PropertyDecorator = (target:Object, propertyKey: string | symbol ) => void;

属性装饰器顾名思义，用来装饰类的属性。它接收两个参数：

*  target: Object - 被装饰的类
 *  propertyKey: string | symbol - 被装饰类的属性名

示例：

以上代码我们定义了一个 logProperty 函数，来跟踪用户对属性的操作，当代码成功运行后，在控制台会输出以下结果：

Set: name => semlinker
    Set: name => kakuqo

## 13.5 方法装饰器 ##

方法装饰器声明：

declare type MethodDecorator = <T>(target:Object, propertyKey: string | symbol, descriptor: TypePropertyDescript<T>) => TypedPropertyDescriptor<T> | void;

方法装饰器顾名思义，用来装饰类的方法。它接收三个参数：

*  target: Object - 被装饰的类
 *  propertyKey: string | symbol - 方法名
 *  descriptor: TypePropertyDescript - 属性描述符

示例：

## 13.6 参数装饰器 ##

参数装饰器声明：

declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number ) => void

参数装饰器顾名思义，是用来装饰函数参数，它接收三个参数：

*  target: Object - 被装饰的类
 *  propertyKey: string | symbol - 方法名
 *  parameterIndex: number - 方法中参数的索引值

# 14. 编译上下文 #

## 14.1 tsconfig.json 的作用 ##

*  用于标识 TypeScript 项目的根路径；
 *  用于配置 TypeScript 编译器；
 *  用于指定编译的文件。

## 14.2 tsconfig.json 重要字段 ##

`files` \- 设置要编译的文件的名称；  
`include` \- 设置需要进行编译的文件，支持路径模式匹配；

"include": ["src"],

`exclude` \- 设置无需进行编译的文件，支持路径模式匹配；

"extends": "./paths.json"

`compilerOptions` \- 设置与编译流程相关的选项。

"compilerOptions": { 
        "target": "es5",
        "lib": [
          "dom",
          "dom.iterable",
          "esnext"
        ],
        "experimentalDecorators": true,
        "allowJs": true,
        "skipLibCheck": true,
        "esModuleInterop": true,
        "allowSyntheticDefaultImports": true,
        "strict": true,
        "forceConsistentCasingInFileNames": true,
        "module": "esnext",
        "moduleResolution": "node",
        "resolveJsonModule": true,
        "isolatedModules": true,
        "noEmit": true,
        "jsx": "react",
        "suppressImplicitAnyIndexErrors": true,
        "downlevelIteration": true
      },

## 14.3 compilerOptions 选项 ##

`compilerOptions` 支持很多选项，常见的有 `baseUrl`、 `target`、`baseUrl`、 `moduleResolution` 和 `lib` 等。

{ 
      "compilerOptions": { 
    
        /* 基本选项 */
        "target": "es5",                       // 指定 ECMAScript 目标版本: 'ES3' (default), 'ES5', 'ES6'/'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'
        "module": "commonjs",                  // 指定使用模块: 'commonjs', 'amd', 'system', 'umd' or 'es2015'
        "lib": [],                             // 指定要包含在编译中的库文件
        "allowJs": true,                       // 允许编译 javascript 文件
        "checkJs": true,                       // 报告 javascript 文件中的错误
        "jsx": "preserve",                     // 指定 jsx 代码的生成: 'preserve', 'react-native', or 'react'
        "declaration": true,                   // 生成相应的 '.d.ts' 文件
        "sourceMap": true,                     // 生成相应的 '.map' 文件
        "outFile": "./",                       // 将输出文件合并为一个文件
        "outDir": "./",                        // 指定输出目录
        "rootDir": "./",                       // 用来控制输出目录结构 --outDir.
        "removeComments": true,                // 删除编译后的所有的注释
        "noEmit": true,                        // 不生成输出文件
        "importHelpers": true,                 // 从 tslib 导入辅助工具函数
        "isolatedModules": true,               // 将每个文件做为单独的模块 （与 'ts.transpileModule' 类似）.
    
        /* 严格的类型检查选项 */
        "strict": true,                        // 启用所有严格类型检查选项
        "noImplicitAny": true,                 // 在表达式和声明上有隐含的 any类型时报错
        "strictNullChecks": true,              // 启用严格的 null 检查
        "noImplicitThis": true,                // 当 this 表达式值为 any 类型的时候，生成一个错误
        "alwaysStrict": true,                  // 以严格模式检查每个模块，并在每个文件里加入 'use strict'
    
        /* 额外的检查 */
        "noUnusedLocals": true,                // 有未使用的变量时，抛出错误
        "noUnusedParameters": true,            // 有未使用的参数时，抛出错误
        "noImplicitReturns": true,             // 并不是所有函数里的代码都有返回值时，抛出错误
        "noFallthroughCasesInSwitch": true,    // 报告 switch 语句的 fallthrough 错误。（即，不允许 switch 的 case 语句贯穿）
    
        /* 模块解析选项 */
        "moduleResolution": "node",            // 选择模块解析策略： 'node' (Node.js) or 'classic' (TypeScript pre-1.6)
        "baseUrl": "./",                       // 用于解析非相对模块名称的基目录
        "paths": { },                           // 模块名到基于 baseUrl 的路径映射的列表
        "rootDirs": [],                        // 根文件夹列表，其组合内容表示项目运行时的结构内容
        "typeRoots": [],                       // 包含类型声明的文件列表
        "types": [],                           // 需要包含的类型声明文件名列表
        "allowSyntheticDefaultImports": true,  // 允许从没有设置默认导出的模块中默认导入。
    
        /* Source Map Options */
        "sourceRoot": "./",                    // 指定调试器应该找到 TypeScript 文件而不是源文件的位置
        "mapRoot": "./",                       // 指定调试器应该找到映射文件而不是生成文件的位置
        "inlineSourceMap": true,               // 生成单个 soucemaps 文件，而不是将 sourcemaps 生成不同的文件
        "inlineSources": true,                 // 将代码与 sourcemaps 生成到一个文件中，要求同时设置了 --inlineSourceMap 或 --sourceMap 属性
    
        /* 其他选项 */
        "experimentalDecorators": true,        // 启用装饰器
        "emitDecoratorMetadata": true          // 为装饰器提供元数据的支持
      }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm1rMTAyMw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221120/f0ab8a18074143b79ad64ca639b22c1e.png