Typescript Funktion Schnittstelle überladen

Question

Ich habe den folgenden Code.

interface MySecondInterface<A>{ 
    type: A; 
} 

interface MyInterface { 
    (val1:string, val2:string): MySecondInterface<string>; 
    (): MySecondInterface<string>; 
} 

const myInterfaceFn: MyInterface = (value1: string, value2:string) => { 
    return { 
     type: value1 + value2 
    }; 
} 



const myInterfaceFn2: MyInterface =() => { 
    return { 
     type: "Text" 
    }; 
} 

Sie können den Code here finden. Ich erhalte Fehler

Type '(value: string) => { type: string; }' is not assignable to type 'MyInterface'. 

Wie werde ich schaffen die Schnittstelle beide Methodensignaturen zu unterstützen?

Grundsätzlich eine Schnittstelle für eine Funktion, die entweder 2 Argumente oder keine Argumente akzeptiert. Wie kann ich das machen?

Answer 1

Ich bin mir nicht ganz sicher, warum TypeScript mit Ihrer Interface-Deklaration in Ordnung ist, weil die beiden Signaturen nichts gemeinsam haben. Vielleicht liegt das daran, dass TypeScript Funktionssignaturen behandelt (siehe unten).

In Ihrem Fall würde ich

• vorschlagen die value optional oder
• eine Funktion und Verwendung Überlastung schaffen machen, z.B.

---

interface Result { 
    type: string; 
} 

function myFn(); 
function myFn(val?: string):Result { 
    if (!val) { return { type: 'foo' }; } 
    return { type: val }; 
} 

---

Nebenbei bemerkt: Typoskript ist ein bisschen komisch, wenn es darum geht, Unterschriften zu nennen. Ich denke, das liegt daran, dass es eine Obermenge von JavaScript sein möchte. Die folgenden Schnipsel verdeutlicht dies:

interface Fn { 
    (a: string): string; 
} 

const f1: Fn =() => 'hi'; 
const f2: Fn = (a: string) => a; 

f1();  // Supplied parameters do not match any signature of call target. 
f1('a'); // OK, even though `f1` has no explicit argument... 
f2('asd'); // OK 

Answer 2

Fokus in auf Fehler

Type '(value: string) => { type: string; }' is not assignable to type 'MyInterface'.

MyInterface Instanzen 0 Argumente nehmen dürfen, müssen. So können die folgenden Fehler:

const myInterfaceFn: MyInterface = (value1: string, value2:string) => { 
    return { 
     type: value1 + value2 
    }; 
} 

Aber wenn Sie beide als optional markieren (zum Beispiel unter Verwendung von Standard-Parameter) der Fehler geht weg:

const myInterfaceFn: MyInterface = (value1 = '', value2 = '') => { 
    return { 
     type: value1 + value2 
    }; 
} 

Answer 3

Was über die Verwendung von type statt interface?

interface MySecondInterface<A>{ 
    type: A; 
} 

type MyInterface = ((val1: string, val2: string) => MySecondInterface<string>) | (() => MySecondInterface<string>); 

const myInterfaceFn: MyInterface = (value1: string, value2:string) => { 
    return { 
    type: value1 + value2 
    }; 
} 

const myInterfaceFn2: MyInterface =() => { 
    return { 
    type: "Text" 
    }; 
} 

Answer 4

Ihre myInterfaceFn hat beide Funktionsdefinitionen in MyInterface gerecht zu werden.

Der folgende Code funktioniert einwandfrei!

interface MySecondInterface<A>{ 
    type: A; 
} 

interface MyInterface { 
    (val1:string, val2:string): MySecondInterface<string>; 
    (): MySecondInterface<string>; 
} 

const myInterfaceFn: MyInterface = (value1: string = undefined, value2:string = undefined) => { 
    return { 
     type: value1 !== undefined && value2 !== undefined 
      ? value1 + value2 
      : "Text" 
    }; 
} 



const myInterfaceFn3: MyInterface =() => { 
    return { 
     type: "Text" 
    }; 
}