为什么 TypeScript 使用Like类型

如果你看一下定义文件(让我们看lib.es6.d.ts个)，那么它是非常直接的.

例如，ArrayLike接口:

interface ArrayLike<T> {
    readonly length: number;
    readonly [n: number]: T;
}

比Array个更有限:

interface Array<T> {
    length: number;
    toString(): string;
    toLocaleString(): string;
    push(...items: T[]): number;
    pop(): T | undefined;
    concat(...items: T[][]): T[];
    concat(...items: (T | T[])[]): T[];
    join(separator?: string): string;
    reverse(): T[];
    shift(): T | undefined;
    slice(start?: number, end?: number): T[];
    sort(compareFn?: (a: T, b: T) => number): this;
    splice(start: number, deleteCount?: number): T[];
    splice(start: number, deleteCount: number, ...items: T[]): T[];
    unshift(...items: T[]): number;
    indexOf(searchElement: T, fromIndex?: number): number;
    lastIndexOf(searchElement: T, fromIndex?: number): number;
    
    // lots of other methods such as every, forEach, map, etc

    [n: number]: T;
}

将两者分开是件好事，因为我可能希望有这样一个函数:

function getSize(arr: Array<any>): number {
    return arr.length;
}

console.log(getSize([1, 2, 3])); // works

但这不起作用:

function fn() {
    console.log(getSize(arguments)); // error
}

它会导致以下错误:

Argument of type 'IArguments' is not assignable to parameter of type 'any[]'.
Property 'push' is missing in type 'IArguments'.

但如果我这样做，两者都会起作用:

function getSize(arr: ArrayLike<any>): number {
    return arr.length;
}

(更多关于ArrayLike in MDN)

与Promise和PromiseLike一样，如果我正在构建一个对Promise的实现没有意见的库，那么与其这样做，不如:

function doSomething(promise: Promise<any>) { ... }

我会这样做:

function doSomething(promise: PromiseLike<any>) { ... }

然后，即使我的库的用户正在使用不同的实现(bluebird)，它也可以正常工作.

如果你注意到Promise的定义是:

declare var Promise: PromiseConstructor;

这使得它非常具体，其他实现可能具有不同的属性，例如不同的原型:

interface PromiseConstructor {
    readonly prototype: Promise<any>;

    ...
}

I guess that the main reason that we have PromiseLike is that several implementations were available before the native one was supported (such as bluebird, Promises/A+, jQuery, and more).
In order for typescript to work with code bases that are using those implementations there must be a type other than Promise, otherwise there would be a lot of contradictions.