阅读 183

TS类型系统相关内容详解

名义上的类型别名,类型结构兼容的预防,函数参数的双向协变、及赋值

1. 什么是名义上的类型别名? (名义上的类型别名不兼容)

使用Type 来为类型创建一个别名从而使用一个间断的名字引用该类型

类型别名实质上与原来的类型一样,它仅仅是一个替代的名字,别名只是对类型的一个引用,并创建一个新的类型。类型别名可以让代码的可读性更高

let a: string = 'a'
type aaa = string
let b: aaa = 'b'
 // type bbb extends aaa error  
 console.log(b)

 // 类型别名不能被 extends 和implements
复制代码

类型结构兼容的预防

基本类型

let str: string = 'Hello'

str = 123 // error TS2322: Type '123' is not assignable to type 'string'.
复制代码

TS的结构类型兼容

TypeScript里的类型兼容性是基于结构子类型的,这是有别于传统的JAVA、C#基于名义类型的语言。

interface Named {
    name: string
}

class Person {
    name: string
}

let p: Named
p = new Person()
复制代码

x要兼容y,那么y至少具有与x相同的属性

interface Named {
    name: string
}

let x: Named
// y's inferred type is { name: string; location: string; }
let y = { name: 'Alice', location: 'Seattle' }
x = y
复制代码

如何避免

添加差异性,如添加一个私有属性

interface ScreenCoordinate {
  _screenCoordBrand: any
  x: number
  y: number
}
interface PrintCoordinate {
  _printCoordBrand: any
  x: number
  y: number
}

function sendToPrinter(pt: PrintCoordinate) {
}

function getCursorPos(): ScreenCoordinate {
  return <ScreenCoordinate>{ x: 0, y: 0 }
}

// getCursorPos的return值继承了ScreenCoordinate类的私有变量

sendToPrinter(getCursorPos())
复制代码

PrintCoordinate要兼容ScreenCoordinate,那至少ScreenCoordinate要具有与PrintCoordinate相同的属性

显然,以上案列是错误的

// 正确写法
function sendToPrinter(pt: PrintCoordinate | ScreenCoordinate) {
}

function getCursorPos(): ScreenCoordinate {
  return <ScreenCoordinate>{ x: 0, y: 0 }
}

sendToPrinter(getCursorPos())
复制代码

如何将更少参数的函数能够赋值给具有更多参数的函数?(函数参数的类型结构兼容)

function handler(arg: string) {
  // ....
}

function doSomething(callback: (arg1: string, arg2: number) => void) {
  callback('hello', 42);
}

// Expected error because 'doSomething' wants a callback of
// 2 parameters, but 'handler' only accepts 1
doSomething(handler);
复制代码

doSomething的回调函数,必需两个参数 handler只有一个参数

那如何让有更少参数的函数赋值给具有更多参数的函数

function handler(arg: string) {
  // ....
}

function doSomething(callback: (arg1: string, arg2?: number) => void) {
  callback('hello', 42);
}

doSomething(handler);
复制代码

此时,arg2是一个可有可没有的参数,不会强制执行

跟forEach(callback(element, index, array))中的回调函数可选参数含义的区别

let items = [1, 2, 3];
items.forEach(arg => console.log(arg));
复制代码

forEach循环数组,必定会产生三个参数传入callback,只是callback接受参数的个数是可选的

mozilla的forEach源码

function ArrayForEach(callbackfn/*, thisArg*/) {
  var O = ToObject(this);
  var len = ToLength(O.length);
 if (arguments.length === 0)
   ThrowTypeError(JSMSG_MISSING_FUN_ARG, 0, "Array.prototype.forEach");
  if (!IsCallable(callbackfn))
   ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, callbackfn));
  var T = arguments.length > 1 ? arguments[1] : void 0;

  for (var k = 0; k < len; k++) {
   if (k in O) {
   callContentFunction(callbackfn, T, O[k], k, O);
   }
  }
  return void 0;
}
复制代码

从源码可以看出,callContentFunction(callbackfn, T, O[k], k, O); 并没有对forEach内的回调函数callback的参数做必需使用做判断, 但确实是给回调函数提供了三个参数

因此

[1, 2, 3].forEach(() => console.log('just counting'));
[1, 2, 3].forEach(x => console.log('just counting'));
复制代码

以上两行代码没有本质区别

为什么函数参数是双向协变?(函数参数的类型)

  • 换个角度说,协变保持了类型参数的继承关系

  • TypeScript 2.6新增了编译器选项--strictFunctionTypes,对函数参数进行严格逆变比较。

  • 首先考虑数组类型构造器: 从Animal类型,可以得到Animal[](“animal数组”)。 是否可以把它当作

协变:一个Cat[] 也是一个Animal[] 逆变:一个Animal[] 也是一个Cat[] 以上二者均不是(不变)? 如果要避免类型错误,且数组支持对其元素的读、写操作,那么只有第3个选择是安全的。 Animal[] 并不是总能当作Cat[], 因为当一个客户读取数组并期望得到一个Cat,但Animal[]中包含的可能是个Dog。所以逆变规则是不安全的。

反之,一个Cat[] 也不能被当作一个Animal[]。 因为总是可以把一个Dog放到Animal[]中。 在协变数组,这就不能保证是安全的,因为背后的存储可以实际是Cat[]。因此协变规则也不是安全的—数组构造器应该是不变。

举个🌰

class Animal {
  public shout() {
    console.log('animal can shout')
  }
}

class Dog implements Animal {
  public eat() {
    console.log('dog eat bone bone')
  }

  public shout() {
    console.log('dog shout wang wang')
  }
}

let animalShout = (animal: Animal) => { console.log(animal.shout()) }

let dogShout = (dog: Dog) => { console.log(dog.shout()) }

dogShout = animalShout
animalShout = dogShout

let funA = (arg: number | string): void => {}
let funB = (arg: number): void => {}
funA = funB
funB = funA
复制代码

编译结果

$ tsc --strictFunctionTypes Bivariance.ts

Bivariance.ts:26:1 - error TS2322: Type '(dog: Dog) => void' is not assignable to type '(animal: Animal) => void'.
  Types of parameters 'dog' and 'animal' are incompatible.
    Property 'eat' is missing in type 'Animal' but required in type 'Dog'.

26 animalShout = dogShout
   ~~~~~~~~~~~

  Bivariance.ts:12:10
    12   public eat() {
                ~~~
    'eat' is declared here.

Bivariance.ts:30:1 - error TS2322: Type '(arg: number) => void' is not assignable to type '(arg: string | number) => void'.
  Types of parameters 'arg' and 'arg' are incompatible.
    Type 'string | number' is not assignable to type 'number'.
      Type 'string' is not assignable to type 'number'.

30 funA = funB
   ~~~~


Found 2 errors.
复制代码