Uitbreiding van Array schrijfmachine

declare globallijkt het ticket als getypte 2.1 zijn. Merk op dat Array.prototypeis van het type any[], dus als u wilt dat uw functie implementatie gecontroleerd op consistentie, het beste om een algemeen type parameter zelf toevoegen.

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

Vanaf Typescript 1.6, kunt u "native" uit te breiden willekeurige uitdrukkingen als ingebouwde types.

Wat is nieuw in typoscript :

Typescript 1.6 voegt ondersteuning van klassen verlenging willekeurige expressie die een constructorfunctie berekent. Dit betekent dat de ingebouwde types nu kan worden uitgebreid in de klas declaraties.

Extends Bepalingen van klasse eerder vereiste een typeaanduiding aan te geven. Het accepteert nu een uitdrukking eventueel gevolgd door een soort lijst met argumenten. Het type van de expressie moet constructorfunctie soort met tenminste één signatuur construct dat hetzelfde aantal systeemparameters als typenummer argumenten opgegeven in de clausule uitstrekt. De terugkeer type handtekening (en) overeenkomende constructie is het basistype waaruit de klasse subsysteemtype erft. Effectief, dit maakt het mogelijk zowel echte klassen en "class-achtige" uitdrukkingen te worden gespecificeerd in de uitstrekt clausule.

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

dit werkt voor mij met typoscript v2.2.1!

Het toevoegen van het antwoord van Rikki Gibson's,

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

Zonder de uitvoer {} TS error "augmentations voor het globale bereik kan alleen direct genest externe modules of module ambient verklaringen."