Erweitern von Array in Typoskript

declare globalscheint das Ticket als Schreibmaschinen 2.1 zu sein. Beachten Sie, dass Array.prototypeist der Typ any[], also , wenn Sie Ihre Funktion Implementierung auf Konsistenz geprüft haben wollen, am besten ein generischer Typ Parameter selbst hinzufügen.

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);
  }
}

Von Typoskript 1.6 können Sie „nativ“ beliebige Ausdrücke wie eingebaute Typen erweitern.

Was ist neu in Typoskript :

Maschinenschrift 1.6 fügt für Klassen Unterstützung beliebiger Ausdruck erstreckt, die eine Konstruktionsfunktion berechnet. Das bedeutet, dass eingebaute Typen können nun in Klassendeklarationen erweitert werden.

Die Klausel erstreckt sich von einer Klasse erforderlich zuvor eine Typenbezeichnung angegeben werden. Er nimmt nun einen Ausdruck gegebenenfalls durch eine Art Argumentliste gefolgt. Die Art des Ausdrucks muß ein -Konstruktorfunktion Typ mit mindestens einem Konstrukt Signatur sein, die die gleiche Anzahl von Typ-Parametern wie die Anzahl der Typargumente haben angegeben in der Klausel erstreckt. Der Rückgabetyp des Anpassungs Konstrukt Signatur (en) ist der Basistyp, aus dem der Klasseninstanztyp erbt. Effektiv ermöglicht dies sowohl reale Klassen und „Klasse-like“ Ausdrücke angegeben werden, in der Klausel erstreckt.

// 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());
    }
}

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");

Dies funktioniert für mich mit Typoskript v2.2.1!

Hinzufügen zu Rikki Gibsons Antwort,

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);
  }
}

Ohne den Export {} TS error „Augmentationen für den globalen Bereich können nur direkt in externen Modulen oder Umgebungs Modul Deklarationen verschachtelt werden.“