高级类型
2019-10-16 本文已影响0人
竹林_
交叉类型
是将多个类型合并为一个类型，包含了所需要的所有类型的特性
使用场景：大多是在混入（mixins）或其他不适合典型面向对象模型的地方看到交叉类型的使用
// 同时满足T跟U两种类型
function extend<T, U>(first: T, second: U): T & U {
let result = <T & U>{};
for(let id in first){
(<any>result)[id] = (<any>first)[id];
}
for(let id in second){
if(!result.hasOwnProperty(id)){
(<any>result)[id] = (<any>second)[id];
}
}
return result;
}
class Person {
constructor(public name: string){}
}
interface Loggable {
log(): void;
}
class ConsoleLogger implements Loggable {
log() {
console.log('this is log')
}
}
var jim = extend(new Person('Jim'), new ConsoleLogger());
var n = jim.name;
jim.log();
联合类型
联合类型跟交叉类型很有关联，但使用上完全不同：
- 联合类型表示一个值可以是集中类型之一，用竖线（|）分割每个类型
- 如果一个值是联合类型，我们只能访问此联合类型的所有类型里共有的成员
// 这种方式padding传入的是any类型，也就是说可以传入number跟string以外的类型
function padLeft(value: string, padding: any){
if(typeof padding === 'number'){
return Array(padding + 1).join(' ') + value;
}
if(typeof padding === 'string'){
return padding + value;
}
throw new Error(`Expected string or number, got '${padding}'.`)
}
// 通过联合类型实现：控制只能传入两种指定类型
function padLeft1(value: string, padding: string | number){
// ...
}
interface Bird{
fly();
layEggs();
}
interface Fish{
swim();
layEggs();
}
function getSmallPet(): Fish | Bird {}
let pet = getSmallPet();
pet.layEggs(); // okay
pet.swim(); // errors
// 类型保护与类型区分：上面例子通过这种方式判断会报错
let pet = getSmallPet();
// 每一个成员访问都会报错
if (pet.swim) {
pet.swim();
}
else if (pet.fly) {
pet.fly();
}
// 想判断类型需要使用类型断言
let pet = getSmallPet();
if ((<Fish>pet).swim) {
(<Fish>pet).swim();
}
else {
(<Bird>pet).fly();
}
用户自定义的类型保护
pet is Fish 类型谓词：parameterName is Type 形式
// 每当使用一些变量调用isFish时，TS会将变量缩减为那个具体的类型，只要这个类型与变量的原始类型是兼容的
function isFish(pet: Fish | Bird): pet is Fish{
return (<Fish>pet).swim !== undefined;
}
let pet = getSmallPet();
if (isFish(pet)) {
pet.swim();
}else {
pet.fly();
}
typeof 类型保护
function isNumber(x: any): x is number {
return typeof x === 'number';
}
function isString(x: any): x is string{
return typeof x === 'string';
}
function padL(value: string, padding: string | number) {
if(isNumber(padding)){
return Array(padding + 1).join(' ') + value;
}
if(isString(padding)){
return padding + value;
}
// 两种方式：typeof v === 'typename' 其中typename必须是：number，string，boolean，symbol
if(typeof padding === 'number'){
return Array(padding + 1).join(' ') + value;
}
if(typeof padding === 'string'){
return padding + value;
}
throw new Error(`Expected string or number, got '${padding}'.`);
}
instanceof 类型保护
是通过构造函数来细化类型的一种方式
// instanceof 右侧要求是一个构造函数，TS将其细化为：此构造函数的prototype属性的类型，如果他的类型不为any的话，构造签名所返回的类型的联合
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;
}
}
function getRandomPadder(){
return Math.random() < 0.5 ? new SpaceRepeatingPadder(4) : new StringPadder(' ');
}
let padder: Padder = getRandomPadder();
if(padder instanceof SpaceRepeatingPadder){
padder;
}
if(padder instanceof StringPadder){
padder;
}
类型别名
类型别名会给一个类型起个新名字。 类型别名有时和接口很像，但是可以作用于原始值，联合类型，元组以及其它任何你需要手写的类型
- 类型别名也可以是泛型
- 也可以使用类型别名来在属性里引用自己
- 与交叉类型一起使用
注：起别名不会新建一个类型 - 它创建了一个新 名字来引用那个类型
注：类型别名不能出现在声明右侧的任何地方
type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
if (typeof n === 'string') {
return n;
}
else {
return n();
}
}
// 泛型
type Container<T> = { value: T };
// 用类型别名来在属性里引用自己
type Tree<T> = {
value: T;
left: Tree<T>;
right: Tree<T>;
}
// 与交叉类型一起使用，可以创建出一些十分稀奇古怪的类型
type LinkedList<T> = T & { next: LinkedList<T> };
interface Person {
name: string;
}
var people: LinkedList<Person>;
var s = people.name;
var s = people.next.name;
var s = people.next.next.name;
var s = people.next.next.next.name;
// 类型别名不能出现在声明右侧的任何地方
type Yikes = Array<Yikes>; // error
接口 vs. 类型别名
类型别名可以像接口一样，但仍然有一些区别：
- 接口创建了名字，可以在其他任何地方使用，类型并不创建新名字：如，错误信息就不会使用别名
- 类型不能被extends和implements（自己也不能extends和implements其他类型）
注：因为软件中对象应该对于扩展是开放的，但对于修改是封闭的，应该尽量使用接口代替类型别名
type Alias = { num: number };
interface Interface { num: number };
// 在编译器中将鼠标悬停在 interfaced上，显示它返回的是 Interface
declare function aliased(arg: Alias): Alias;
// 悬停在 aliased上时，显示的却是对象字面量类型
declare function interfaced(arg: Interface): Interface;
字符串字面量类型
允许指定字符串必须的固定值
注：在实际应用中，字符串字面量类型可以与联合类型，类型保护和类型别名很好的配合，通过结合使用这些特性，可以实现类似枚举类型的字符串
数字字面量类型：很少使用可以缩小范围调试bug
type Easing = "ease-in" | "ease-out" | "ease-in-out";
class UIElement {
animate(dx: number, dy: number, easing: Easing){
if(easing === "ease-in"){
console.log('this is ease-in');
}else if (easing === "ease-out"){
console.log('this is ease-out');
}else if (easing === "ease-in-out"){
console.log('this is ease-in-out');
}else {
console.log('no animate');
}
}
}
let button = new UIElement();
button.animate(0,0,'ease-in');
button.animate(0, 0, "uneasy"); // error no animate
// 数字字面量类型
function rollDie(x: number) : 1 | 2 | 3 | 4 {
// 当 x与 2进行比较的时候，它的值必须为 1，这就意味着下面的比较检查是非法的
if(x !== 1 || x !== 2) {}
return 1;
}
可辨识联合
可以合并单例类型，联合类型，类型保护和类型别名来创建一个叫做可辨识联合的高级模式，也称作：标签联合或代数数据类型
TS基于已有的JS模式有三个要素：
- 具有普通的单例类型属性---可辨识的特征
- 一个类型别名包含了那些类型的联合---联合
- 此属性上的类型保护
// 声明了联合的接口，每个接口都有kind属性但有不同的字符串字面量类型
// kind属性：称作可辨识的特征或标签，其他属性则特定于各自接口
// 注：目前各个接口时没有联系的
interface Square {
kind: 'square';
size: number;
}
interface Rectangle {
kind: 'rectangle';
width: number;
height: number;
}
interface Circle {
kind: 'circle';
radius: number;
}
// 把接口联合到一起
type Shape = Square | Rectangle | Circle;
// 使用可辨识联合
function area(s: Shape) {
switch(s.kind){
case 'square': return s.size * s.size;
case 'rectangle': return s.height * s.width;
case 'circle': return Math.PI * s.radius ** 2;
}
}
完整性检查
当没有涵盖所有可辨识联合的变化时，我们想让编译器可以通知我们
比如，如果添加了Triangle到 Shape，同时还需要更新area
有两种方式可以实现：
- 首先是启用 --strictNullChecks并且指定一个返回值类型
- 使用never类型，编译器用它来进行完整性检查
// 因为 switch没有包涵所有情况，所以TypeScript认为这个函数有时候会返回 undefined。
// 如果你明确地指定了返回值类型为 number，那么你会看到一个错误，因为实际上返回值的类型为 number | undefined
function area1(s: Shape): number {
switch(s.kind){
case 'square': return s.size * s.size;
case 'rectangle': return s.height * s.width;
case 'circle': return Math.PI * s.radius ** 2;
}
}
// 第二种方法使用 never类型
function assertNever(x: never): never{
throw new Error("Unexpected object: " + x);
}
// assertNever检查 s是否为 never类型—即为除去所有可能情况后剩下的类型
// 如果忘记了某个case，那么 s将具有一个真实的类型并且你会得到一个错误
function area2(s: Shape): number {
switch(s.kind){
case 'square': return s.size * s.size;
case 'rectangle': return s.height * s.width;
case 'circle': return Math.PI * s.radius ** 2;
default: return assertNever(s);
}
}
多态的this类型
表示某个包含类或接口的子类型，这被称作 F-bounded多态性
应用：他能很容易的表现连贯接口间的继承
class BasicCalculator {
public constructor(protected value: number = 0){}
public currentValue(): number {
return this.value;
}
public add(operand: number): this {
this.value == operand;
return this;
}
public multiply(operand: number): this {
this.value *= operand;
return this;
}
}
let val = new BasicCalculator(2).multiply(5).add(1).currentValue();
// 由于这个类使用了 this类型，你可以继承它，新的类可以直接使用之前的方法，不需要做任何的改变
class ScientificCalculator extends BasicCalculator {
public constructor(value = 0){
super(value);
}
public sin(){
this.value = Math.sin(this.value);
return this;
}
}
let scientVal = new ScientificCalculator(2).multiply(5).sin().add(1).currentValue();
索引类型
使用索引类型，编译器就能够检查使用了动态属性名的代码
keyof T：索引类型查询操作符，对于任何类型T，keyof T的结果为T上已知的公共属性名的联合
T[K]：索引访问操作符
索引类型和字符串索引签名：keyof和 T[K]与字符串索引签名进行交互
注： 如果你有一个带有字符串索引签名的类型，那么 keyof T会是 string。 并且 T[string]为索引签名的类型
// JS模式从对象中选取属性的子集
function pluck(o, names){
return names.map(n => o[n]);
}
// 在TS中通过索引类型检查和索引访问操作符
function pluck1<T, K extends keyof T>(o: T, names: K[]): T[K][] {
return names.map(n => o[n]);
}
interface Person {
name: string;
age: number;
}
let person: Person = {
name: 'Jarid',
age: 20
}
let strings: string[] = pluck1(person, ['name']);
// 索引类型和字符串索引签名
interface Maps<T> {
[key: string]: T;
}
let keys: keyof Maps<number>; // string
let value: Maps<number>['foo']; // number
console.log('keys: ' + keys, + ' value: ' + value)
映射类型
TS提供了从旧类型中创建新类型的一种方式 — 映射类型
定义：在映射类型里，新类型以相同的形式去转换旧类型里每个属性
语法与索引签名的语法类型，内部使用了for...in具有三个部分：
- 类型变量K，他会依次绑定到每个属性
- 字符串字面量联合的keys，包含了要迭代的属性名的集合
- 属性的结果类型
// 一个常见的任务是将一个已知的类型每个属性都变为可选的:
interface PersonPartial1 {
name?: string;
age?: number;
}
// 或者只想要一个只读版本：
interface PersonReadonly1 {
readonly name: string;
readonly age: number;
}
// 映射类型
type Readonlyp<T> = {
readonly [P in keyof T]: T[P];
}
type Partials<T> = {
[P in keyof T]?: T[P];
}
// 使用
type PersonPartial = Partials<Person>;
type ReadonlyPerson = Readonlyp<Person>;
type Keys = 'option1' | 'option2';
type Flags = { [K in Keys]: boolean };
预定义的有条件类型
TS2.8中增加了一些预定义的有条件类型：
- Exclude<T, U> -- 从T中剔除可以赋值给U的类型
- Extract<T, U> -- 提取T中可以赋值给U的类型
- NonNullable<T> -- 从T中剔除null和undefined
- ReturnType<T> -- 获取函数返回值类型
- InstanceType<T> -- 获取构造函数类型的实例类型
type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d"
type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "a" | "c"
type T02 = Exclude<string | number | (() => void), Function>; // string | number
type T03 = Extract<string | number | (() => void), Function>; // () => void
type T04 = NonNullable<string | number | undefined>; // string | number
type T05 = NonNullable<(() => string) | string[] | null | undefined>; // (() => string) | string[]
function f1(s: string) {
return { a: 1, b: s };
}
class C {
x = 0;
y = 0;
}
type T10 = ReturnType<() => string>; // string
type T11 = ReturnType<(s: string) => void>; // void
type T12 = ReturnType<(<T>() => T)>; // {}
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
type T15 = ReturnType<any>; // any
type T16 = ReturnType<never>; // any
// type T17 = ReturnType<string>; // Error
// type T18 = ReturnType<Function>; // Error
type T20 = InstanceType<typeof C>; // C
type T21 = InstanceType<any>; // any
type T22 = InstanceType<never>; // any
// type T23 = InstanceType<string>; // Error
// type T24 = InstanceType<Function>; // Error
