Wie kann ich eine Klasse aus einem Typoskript Funktion?

Ich bin mit Typoskript mit dependency injection library und die funktioniert sehr ähnlich Eckig 1 - grundsätzlich: registrieren eine Fabrik mit Ihren Abhängigkeiten als Argumente.

Dies ist, wie ich würde die Registrierung einer Klasse in ES6

export let factory = () => {
    return class Foo {}
};

Wenn ich das gleiche schreiben in Maschinenschrift:

export let factory = () => {
    return class Foo {}
};

Es nicht kompiliert werden kann mit dem Fehler

Fehler TS4025: Exportierte variable 'Fabrik' hat oder mit eigenem Namen 'Foo'.

Gibt es eine Möglichkeit, Typoskript, um wieder eine Klasse aus einer factory-Funktion?

InformationsquelleAutor RiggerTheGeek | 2016-02-10

6

Schnelle Antwort

ändern:
```
export let factory = () => {
    return class Foo {}
};
```
zu diesem:
```
export let factory = () : any => {
    return class Foo {}
};
```
Mehr beantworten

Dieser Fehler ausgelöst werden könnte, - /forced-by - tsconfig.json Einstellung:
```
{
    "compilerOptions": {
        ...
        "declaration": true //this should be false or omitted
```
Aber das ist nicht der Grund, es ist nur ein trigger. Der wahre Grund (wie hier beschrieben Fehler beim exportieren-Funktion, die zurückgibt, Klasse: Exportierte variable oder mit eigenem Namen) kommt aus dem Typescript-compiler

wenn TS compiler gründet Aussage wie diese
```
let factory = () => { ...
```
muss es beginnen, zu erraten, was ist der return-Typ, weil diese information fehlt (überprüfen Sie die : <returnType> Platzhalter):
```
let factory = () : <returnType> => { ...
```
in unserem Fall, TS wird schnell feststellen, dass das zurückgegebene type ist leicht zu erraten:
```
return class Foo {} //this is returned value, 
                    //that could be treated as a return type of the factory method
```
so, in Fall würden wir haben, die ähnliche Anweisung (dies ist nicht das gleiche, wie die ursprüngliche Aussage an alle, aber lasst uns einfach versuchen, es zu benutzen als ein Beispiel, um zu verdeutlichen, was passiert) können wir richtig erklären Rückgabetyp:
```
export class Foo {} //Foo is exported
export let factory = () : Foo => { //it could be return type of export function
    return Foo
};
```
diesem Ansatz arbeiten würden, weil die Foo Klasse exportiert wird, d.h. sichtbar für die Außenwelt.

Zurück zu unserem Fall. Wir wollen zu Rückgabetyp die nicht exportiert. Und dann MÜSSEN wir helfen TS-compiler, um zu entscheiden, was ist der return-Typ.

Könnte es werden explizit alle:
```
export let factory = () : any => {
    return class Foo {}
};
```
Aber noch besser wäre es, einige öffentliche Schnittstelle
```
export interface IFoo {}
```
Und verwenden Sie dann eine solche Schnittstelle als Rückgabetyp:
```
export let factory = () : IFoo => {
    return class Foo implements IFoo {}
};
```
- gute Antwort! Und nun klappt es auch mit Erklärung: wahr! 🙂 Allerdings, Ihre endgültige Vorschlag ist genau das, was ich wollte versuchen, in der Anfang - das funktioniert nicht: der Typ 'typeof Foo' ist nicht belegbar zu geben '"ifoo") vom'.
- Ich würde sagen, dass dies ist ein anderes Thema. Überprüfen Sie für diesen Spielplatz Beispiel ... zeigt, wie Problem.. in-Fall wenn IFoo als Schnittstelle erfordert etwas.. die Foo nicht implementiert... in diesem Beispiel IFoo {x:boolean} erfordert x, aber die Klasse hat es nicht class Foo implements IFoo {} hoffe, es hilft ein bisschen
- Ich denke, das ist wahr, aber in meinem Fall hinzufügen public x: boolean = false; zu class Foo führt immer noch in die gleichen Fehler. Check dieser
InformationsquelleAutor Radim Köhler
2

Müssen Sie zum exportieren der Klasse als gut, so dass die Verbraucher von der Methode kann der Zugriff auf Typ.

In der Regel eine factory Instanz zurück, anstatt eine Klasse oder ein Konstruktor.
- Nicht sehr hilfreich, da bei der Rückkehr eine dynamisch generierte Klasse (z.B. Reagieren HOC).
- Die ursprüngliche Frage ist über die Implementierung des Factory-Musters in Maschinenschrift (mit AngularJS), und die Lösung zu einem compiler-Fehler. Es sagt nichts darüber aus, generieren eine dynamisch generierte Klasse.
InformationsquelleAutor Martin
1

Ich war kämpfen mit dem gleichen Fehler. Die Lösung für mich war das entfernen der
```
"declaration": true
```
vom tsconfig.json oder, um es zu false.

InformationsquelleAutor MiB

Ich denke, das ist eine richtige Weg, es zu tun:

export let factory = () => {
     class Foo {/* ... */}
     return Foo as (new () => { [key in keyof Foo]: Foo[key] })
};

Check it out auf Spielplatz

InformationsquelleAutor Joseph Buchma

-3

Sind Sie auf der Suche nach der Rückgabe-Typ der Klasse, aus der Funktion? Unten ist ein code-snippet, wie wir das umsetzen können-Fabrik in Maschinenschrift, ähnlich wie in anderen Sprachen.

    class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}
class Factory{
    getObject(msg:string): Greeter {
        return new Greeter(msg);
    }
}
var greeter = new Factory().getObject("Hi");
console.log(greeter.greet());

InformationsquelleAutor Joy George Kunjikkuru

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Schnelle Antwort

Mehr beantworten