Extinderea Array dactilografiat

declare globalpare a fi biletul ca dactilografiate 2.1. Rețineți că Array.prototypeeste de tip any[], așa că dacă doriți să aveți implementarea funcției verificate pentru consistență, cel mai bine pentru a adăuga un parametru de tip generic tine.

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 la typescript 1.6, puteți „nativ“, se extind expresii arbitrare, cum ar fi tipuri de încorporat.

Ce este nou dactilografiat :

Dactilografiat 1.6 adaugă suport pentru clasele extind expresie arbitrară, care calculează o funcție constructor. Acest lucru înseamnă că tipurile încorporate pot fi acum extinse în declarațiile de clasă.

Clauza se extinde dintr-o clasă necesară anterior o referință de tip să fie specificate. Se acceptă acum o expresie urmată opțional de o listă de tip argument. Tipul expresiei trebuie să fie un tip de funcție constructor cu cel puțin o semnătură construct care are același număr de parametri de tip ca numărul de argumente de tip specificate în clauza extends. Tipul de retur al semnăturii de potrivire construct (e) este tipul de bază de la care moștenește tipul de clasă instanță. Efectiv, aceasta permite ambele clase reale și expresii „clasă“ ca să fie specificate în clauza 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");

acest lucru funcționează pentru mine cu V2.2.1 dactilografiate!

Adăugarea la răspunsul 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);
  }
}

Fără export {} TS eroare „augmentations pentru domeniul de aplicare la nivel mondial pot fi imbricate numai direct în module externe sau declarații de module ambientale.“