L'extension de tableau dactylographié

declare globalsemble être le ticket au tapuscrit 2.1. Notez que Array.prototypeest de type any[], donc si vous voulez avoir votre implémentation de la fonction contrôlée par souci de cohérence, préférable d'ajouter un paramètre de type générique vous - même.

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

De tapuscrit 1.6, vous pouvez « nativement » étendre les expressions arbitraires comme types intégrés.

Quoi de neuf dans tapuscrit :

Tapuscrit 1.6 ajoute le support pour les classes étendant expression arbitraire qui calcule une fonction de constructeur. Cela signifie que les types intégrés peuvent désormais être étendus dans les déclarations de classe.

La clause EXTENDS d'une classe requise au préalable une référence de type à préciser. Il accepte maintenant une expression éventuellement suivie d'une liste d'arguments de type. Le type de l'expression doit être un type de fonction de construction avec au moins une signature de construction qui a le même nombre de paramètres de type que le nombre d'arguments de type spécifié dans la clause se prolonge. Le type de retour de la signature de l'assemblage correspondant (s) est le type de base à partir duquel le type d'instance de la classe hérite. En effet, cela permet à la fois de vraies classes et « classe » comme expressions à préciser dans la clause 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());
    }
}

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

cela fonctionne pour moi avec tapuscrit v2.2.1!

Ajout à la réponse 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);
  }
}

Sans l'exportation {} erreur TS « Augmentations pour la portée globale ne peuvent être directement imbriqués dans des modules externes ou des déclarations du module ambiant. »