number - Ampliación de matriz en TypeScript

typescript undefined

Question

¿Cómo agregar un método a un tipo base, por ejemplo Array? En el módulo global esto será reconocido

interface Array {
   remove(o): Array;
}

pero dónde poner la implementación real?

Answer 1

Añadiendo a la respuesta de Rikki Gibson,

export{}
declare global {
    interface Array<T> {
        remove(elem: T): Array<T>;
    }
}

if (!Array.prototype.remove) {
  Array.prototype.remove = function<T>(elem: T): T[] {
      return this.filter(e => e !== elem);
  }
}

Sin la exportación {} Error TS "Las ampliaciones para el alcance global solo pueden anidarse directamente en módulos externos o declaraciones de módulos ambientales".

Answer 2

Desde TypeScript 1.6, puede "extender" de forma nativa expresiones arbitrarias como tipos incorporados.

¿Qué hay de nuevo en TypeScript ?

TypeScript 1.6 agrega soporte para las clases que extienden expresiones arbitrarias que calculan una función constructora. Esto significa que los tipos incorporados ahora se pueden extender en las declaraciones de clase.

La cláusula extends de una clase requería previamente una referencia de tipo para ser especificada. Ahora acepta una expresión opcionalmente seguida de una lista de argumentos de tipo. El tipo de expresión debe ser un tipo de función de constructor con al menos una firma de construcción que tenga la misma cantidad de parámetros de tipo que la cantidad de argumentos de tipo especificados en la cláusula extends. El tipo de devolución de las firmas de constructo coincidentes es el tipo de base del que hereda el tipo de instancia de clase. Efectivamente, esto permite que tanto las clases reales como las expresiones "de clase" se especifiquen en la cláusula extends.

// Extend built-in types

class MyArray extends Array<number> { }
class MyError extends Error { }

// Extend computed base class

class ThingA {
    getGreeting() { return "Hello from A"; }
}

class ThingB {
    getGreeting() { return "Hello from B"; }
}

interface Greeter {
    getGreeting(): string;
}

interface GreeterConstructor {
    new (): Greeter;
}

function getGreeterBase(): GreeterConstructor {
    return Math.random() >= 0.5 ? ThingA : ThingB;
}

class Test extends getGreeterBase() {
    sayHello() {
        console.log(this.getGreeting());
    }
}

Answer 3

Puedes usar el prototipo para extender Array:

interface Array<T> {
   remove(o: T): Array<T>;
}

Array.prototype.remove = function (o) {
    // code to remove "o"
    return this;
}

Answer 4

declare global parece ser el boleto a partir de TypeScript 2.1. Tenga en cuenta que Array.prototype es de tipo any[] , por lo tanto, si desea que se compruebe la coherencia de la implementación de su función, lo mejor es agregar usted mismo un parámetro de tipo genérico.

declare global {
  interface Array<T> {
    remove(elem: T): Array<T>;
  }
}

if (!Array.prototype.remove) {
  Array.prototype.remove = function<T>(elem: T): T[] {
    return this.filter(e => e !== elem);
  }
}

Answer 5

class MyArray<T> extends Array<T> {
    remove: (elem: T) => Array<T> = function(elem: T) {
        return this.filter(e => e !== elem);
    }
}
let myArr = new MyArray<string>();
myArr.remove("some");

esto funciona para mí con el v2.2.1 mecanografiado!