Rozszerzanie Array w maszynopisie

declare globalWydaje się, że bilet jak maszynopisu 2.1. Zauważ, że Array.prototypejest typu any[], więc jeśli chcesz mieć swoją implementacją funkcji sprawdzane pod kątem spójności, najlepiej dodać parametr typu rodzajowego siebie.

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 maszynopis 1.6, można „natywnie” przedłużyć dowolnych wyrażeń takich jak wbudowanych typów.

Co nowego w maszynopisie :

Maszynopis 1.6 dodaje wsparcie dla zajęć rozciągających dowolny wyraz, który oblicza funkcję konstruktora. Oznacza to, że wbudowane typy mogą być teraz rozszerzone w deklaracji klasy.

Rozciąga punkt klasy wcześniej konieczne odwołanie Do określenia. Obecnie przyjmuje wyrażenie po czym ewentualnie liście typu argumentu. Typ ekspresji musi być typu konstruktor z co najmniej jedną sygnaturą konstrukt, który ma taką samą liczbę parametrów typu jako liczbę argumentów typu wyspecyfikowanego w części rozciąga punktu. Typ powrót Podpis (y) Dalsze konstruktu rodzaju, z których typ przykład klasa dziedziczy. Skutecznie, pozwala zarówno prawdziwe zajęcia i wyrażenia „klasa-like”, które zostaną określone w klauzuli rozszerza.

// 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 działa na mnie z maszynopis v2.2.1!

Dodając do odpowiedzi Rikki Gibsona,

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 eksportu {} TS błędach „rozszerzonych o zasięgu globalnym mogą być zagnieżdżone bezpośrednio tylko w modułach zewnętrznych lub deklaracji składanych otoczenia.”