javascript - one - ¿Por qué mecanografia utiliza tipos "Me gusta"?

driver acer para windows 7

Question

¿Por qué mecanografia tiene un tipo y luego un "tipo similar"? Un ejemplo de esto es Promise<T> y PromiseLike<T> . ¿Cuáles son las diferencias entre estos dos tipos? ¿Cuándo debo usarlos? En este caso, ¿por qué no tener un solo tipo de Promise ?

Answer 1

Si nos fijamos en los archivos de definición (tomemos lib.es6.d.ts ), es bastante sencillo.

Por ejemplo, la interfaz ArrayLike :

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

es más limitado que el 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;
}

Es bueno tener los dos separados porque podría querer tener una función como esta:

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

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

Pero no funcionará con esto:

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

Resulta con este error:

El argumento del tipo ''IArguments'' no se puede asignar al parámetro de tipo ''any []''.
Falta la propiedad ''push'' en el tipo ''IArguments''.

Pero ambos funcionarán si hago esto:

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

(más sobre ArrayLike en MDN )

Lo mismo PromiseLike con Promise y PromiseLike , si estoy construyendo una biblioteca que no tiene opiniones acerca de la implementación de Promise , en lugar de hacer esto:

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

Haré esto

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

Entonces, incluso si el usuario de mi biblioteca está utilizando una implementación diferente (bluebird), funcionará bien.

Si te das cuenta la definición de Promise es esta:

declare var Promise: PromiseConstructor;

Lo que lo hace muy específico, otras implementaciones pueden tener diferentes propiedades, por ejemplo, un prototipo diferente:

interface PromiseConstructor {
    readonly prototype: Promise<any>;

    ...
}

Supongo que la razón principal por la que tenemos PromiseLike es que varias implementaciones estaban disponibles antes de que se PromiseLike nativa (como bluebird , Promises/A+ , jQuery , y más).
Para que mecanografíe para trabajar con las bases de código que están utilizando esas implementaciones, debe haber un tipo que no sea Promise , de lo contrario habría muchas contradicciones.