Kiterjesztése Array géppel

declare globalÚgy tűnik, hogy a jegy, mint a géppel 2.1. Megjegyzendő, hogy Array.prototypeez a típus any[], ezért ha azt szeretnénk, hogy a funkció végrehajtását ellenőrizni a következetesség, a legjobb, hogy adjunk egy általános típus paraméter magad.

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

Tól géppel 1.6, akkor „natívan” meghosszabbítja tetszőleges kifejezések, mint a beépített típusok.

Mi az új géppel :

Gépelt 1.6 már támogatja az osztályok kiterjesztése tetszőleges kifejezés, amely kiszámítja egy konstruktor függvényt. Ez azt jelenti, hogy a beépített típusok is meg kell hosszabbítani az osztályban nyilatkozatokat.

A kiterjeszti kikötés egy osztály korábban szükséges a típusszámot meg kell határozni. Ez most elfogadja egy expressziós majd adott esetben egy típusú argumentum lista. A típus a kifejezést úgy kell konstruktor függvény típusú legalább egy konstrukciót aláírás, amely azonos számú típusú paraméterek száma típusú érvek megadott kiterjeszti kikötés. A visszatérési típus a megfelelő konstrukció aláírás (ok) a bázis típusa, amelyből a osztály példányát típusú örökli. Valójában ez lehetővé teszi, hogy mind a valós osztályok és az „osztály-szerű” kifejezést meg kell határozni az húzódik záradékot.

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

ez nekem működik a géppel V2.2.1!

Hozzátéve, hogy Rikki Gibson választ,

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

Anélkül, hogy a kiviteli {} TS hiba „pontosságnöveléseket a globális hatókörű csak közvetlenül beágyazott külső modulok vagy a környezeti modul nyilatkozatokat.”