Rozšíření Array na stroji

declare globalZdá se, že vstupenka k strojopisem 2.1. Všimněte si, že Array.prototypeje typu any[], takže pokud chcete, aby vaše implementace funkce kontrolována konzistence, nejlépe přidat parametr obecný typ sami.

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

Od strojopisem 1.6, můžete „nativně“ rozšířit libovolné výrazy jako vestavěné typy.

Co je nového na stroji :

Psacím stroji 1.6 přidává podporu pro výuku vystupujících libovolný výraz, který vypočítá funkci konstruktoru. To znamená, že vestavěné typy mohou být nyní rozšířen v prohlášení třídy.

Extends klauzule třídy dříve vyžadovaly typové označení, které budou specifikovány. Nyní přijímá výraz popřípadě následuje seznam typ argumentu. Typ výrazu musí být typu funkce konstruktoru s alespoň jedním konstruktem podpisu, který má stejný počet parametrů typu jako počet argumentů typu uvedených v rozšiřuje platnosti. Návratový typ podpisu (y) odpovídající konstruktu je typ základnou typ instance třídy dědí. Efektivně, což umožňuje jak skutečné třídy a výrazy „class-like“, které mají být uvedeny v extends klauzule.

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

to funguje pro mě strojopisem v2.2.1!

Přidání do Rikki Gibsona odpověď,

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

Bez exportu {} TS chyba „rozšiřující systémy pro globální rozsah může být přímo vnořené pouze v externích modulů nebo prohlášení okolních modulů.“