Estendentesi Array a macchina

declare globalsembra essere il biglietto a partire dal dattiloscritto 2.1. Si noti che Array.prototypeè di tipo any[], quindi se si vuole avere la funzione di implementazione controlli sulla consistenza, meglio aggiungere un parametro di tipo generico da soli.

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

Da dattiloscritto 1.6, è possibile "nativamente" estendere espressioni arbitrarie come tipi incorporati.

Cosa c'è di nuovo a macchina :

Tipografico 1.6 aggiunge il supporto per le classi estendono espressione arbitraria che calcola una funzione di costruzione. Ciò significa che i tipi built-in possono ora essere estesi in dichiarazioni di classe.

La clausola estende di una classe precedentemente richiesto un riferimento di tipo da specificare. Ora accetta un'espressione opzionalmente seguito da una lista tipo di argomento. Il tipo di espressione deve essere un tipo di funzione costruttore con almeno una firma costrutto che ha lo stesso numero di parametri di tipo come il numero di argomenti di tipo specificate nella clausola estende. Il tipo di ritorno della firma corrispondente costrutto (s) è il tipo di base da cui il tipo di istanza classe riceve. In effetti, questo permette entrambe le classi reali e le espressioni "class-like" da specificare nella clausola estende.

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

questo funziona per me con v2.2.1 dattiloscritto!

L'aggiunta alla risposta di 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);
  }
}

Senza l'esportazione {} TS errore "potenziamenti per scope globale possono essere nidificati solo direttamente in moduli esterni o dichiarazioni di modulo ambientali."