Bauen Sie ein Funktionsobjekt mit Eigenschaften in Typoskript

Update: Diese Antwort war die beste Lösung in früheren Versionen von Typoskript, aber es gibt bessere Optionen in neueren Versionen (siehe andere Antworten).

Die akzeptierte Antwort funktioniert und könnte in einigen Situationen erforderlich sein, hat aber den Nachteil keine Typsicherheit geschaffen wird, das Objekt aufzubauen. Diese Technik wird mindestens eine Art Fehler auslösen, wenn Sie eine nicht definierte Eigenschaft hinzuzufügen versuchen.

interface F { (): any; someValue: number; }

var f = <F>function () { }
f.someValue = 3

// type error
f.notDeclard = 3

Maschinenschrift soll durch diesen Fall behandeln Erklärung Verschmelzen :

Sie können auch mit JavaScript Praxis der Schaffung einer Funktion und dann zur Verlängerung der Funktion weiter durch Hinzufügen von Eigenschaften auf die Funktion vertraut sein. Typoskript verwendet Erklärung Verschmelzung wie diese aufzubauen Definitionen in einer typsichere Weise.

Erklärung Verschmelzung lässt uns sagen, dass etwas ist sowohl eine Funktion und ein Namensraum (internes Modul):

function f() { }
namespace f {
    export var someValue = 3;
}

Auf diese Weise bleibt die Eingabe und lässt uns beide schreiben f()und f.someValue. Wenn eine .d.tsSchreibdatei für bestehende JavaScript - Code verwenden declare:

declare function f(): void;
declare namespace f {
    export var someValue: number;
}

Hinzufügen von Eigenschaften zu Funktionen ist oft ein verwirrendes oder unerwartete Muster in Typoskript, so versuchen Sie es zu vermeiden, aber es kann notwendig sein, bei der Verwendung oder Umwandlung von älterem JS-Code. Dies ist eines der wenigen Male, es wäre angebracht interne Module (Namespaces) mit externem zu mischen.

Dies ist leicht erreichbar jetzt (Typoskript 2.x) mit Object.assign(target, source)

Beispiel:

Die Magie ist hier, dass Object.assign<T, U>(...)typisiert ist eine Rückkehr Kreuzung Typ T & U.

Erzwingen, dass dies zu einer bekannten Schnittstelle löst auch straight-forward:

interface Foo {
  (a: number, b: string): string[];
  foo: string;
}

let method: Foo = Object.assign(
  (a: number, b: string) => { return a * a; },
  { foo: 10 }
); 

Fehler: foo: Zahl nicht zuordenbar foo: string
Fehler: Anzahl nicht zuordenbar string [] (Rückgabetyp)

Nachteil: Sie müssen möglicherweise POLYfill wenn Targeting älteren Browser Object.assign.

Ich kann nicht sagen, dass es sehr einfach ist, aber es ist auf jeden Fall möglich:

interface Optional {
  <T>(value?: T): OptionalMonad<T>;
  empty(): OptionalMonad<any>;
}

const Optional = (<T>(value?: T) => OptionalCreator(value)) as Optional;
Optional.empty = () => OptionalCreator();

Wenn Sie neugierig geworden ist dies aus einem Kern von mir mit dem Typoskript / JavaScript - VersionOptional

Eine aktualisierte Antwort: da die Zugabe von Kreuzungstypen über &, ist es möglich, zwei abgeleitete Typen on the fly „verschmelzen“.

Hier ist ein allgemeiner Helfer, die die Eigenschaften eines Objekts liest fromund kopiert sie auf ein Objekt onto. Es gibt das gleiche Objekt , ontoaber mit einer neuen Art , die beiden Arten von Eigenschaften enthalten, so richtig das Laufzeitverhalten beschreiben:

function merge<T1, T2>(onto: T1, from: T2): T1 & T2 {
    Object.keys(from).forEach(key => onto[key] = from[key]);
    return onto as T1 & T2;
}

Diese Low-Level-Helfer nicht durchführt noch eine Art Behauptung, aber es ist typsicher durch Design. Mit diesem Helfer an Ort und Stelle haben wir einen Operator, dass wir die OP das Problem zu lösen, mit voller Typsicherheit verwenden:

interface Foo {
    (message: string): void;
    bar(count: number): void;
}

const foo: Foo = merge(
    (message: string) => console.log(`message is ${message}`), {
        bar(count: number) {
            console.log(`bar was passed ${count}`)
        }
    }
);

Klicken Sie hier , um es auszuprobieren im Typoskript Spielplatz . Beachten Sie, dass wir gezwungen foovom Typ zu sein Foo, so das Ergebnis mergehat eine vollständig zu sein Foo. Also , wenn Sie umbenennen , barum baddann erhalten Sie einen Typfehler.

NB Es gibt immer noch eine Art Loch hier jedoch. Typoskript bietet keine Möglichkeit , einen Typ - Parameter zu beschränken „keine Funktion“ zu sein. So könnten Sie verwirren und Ihre Funktion als zweites Argument übergeben zu merge, und das würde nicht funktionieren. Also , bis diese deklariert werden können, müssen wir es zur Laufzeit fangen:

function merge<T1, T2>(onto: T1, from: T2): T1 & T2 {
    if (typeof from !== "object" || from instanceof Array) {
        throw new Error("merge: 'from' must be an ordinary object");
    }
    Object.keys(from).forEach(key => onto[key] = from[key]);
    return onto as T1 & T2;
}

Als Abkürzung können Sie dynamisch den Objektwert mit dem [ ‚Eigentum‘] Accessor zuordnen:

var f = function() { }
f['someValue'] = 3;

Dies umgeht die Typprüfung. Es ist jedoch ziemlich sicher, weil Sie absichtlich haben, um die Eigenschaft Zugriff auf die gleiche Art und Weise:

var val = f.someValue; // This won't work
var val = f['someValue']; // Yeah, I meant to do that

Wenn Sie jedoch wirklich die Art Prüfung für den Eigenschaftswert wollen, wird dies nicht funktionieren.

Alte Frage, aber für die Versionen von Typoskript mit 3.1 starten, können Sie einfach tun , um die Eigenschaftszuweisung , wie Sie es im Klar JS, solange Sie eine Funktionsdeklaration oder die Verwendung constSchlüsselwort für die Variable:

function f () {}
f.someValue = 3; // fine
const g = function () {};
g.someValue = 3; // also fine
var h = function () {};
h.someValue = 3; // Error: "Property 'someValue' does not exist on type '() => void'"

Referenz und Online - Beispiel .

Dies weicht von der starken Typisierung, aber Sie tun können,

var f: any = function() { }
f.someValue = 3;

wenn Sie versuchen, um drückend starke Typisierung zu bekommen wie ich war, als ich diese Frage gefunden. Leider ist dies ein Fall, Typoskript auf absolut gültige JavaScript versagt, so dass Sie müssen Sie Typoskript sagen sich zurückzuziehen.

„Du JavaScript ist absolut gültige Typoskript“ das Ergebnis falsch. (Anmerkung: Die Verwendung 0,95)