åsidosättande - Typescript: Överlagring med valfria parametrar: "Överlagringssignaturen är inte kompatibel med funktionsimplementeringen."

Jag har experimenterat med överlagringar (ursprungligen försökte jag implementera detta grundläggande proxyexempel i TypeScript utan fula knep som att stänga av typkontroll på en rad, om någon av er har löst det får ni gärna spoila för mig, jag har redan lärt mig mycket och det börjar bli irriterande att jag verkar inte kunna lösa det).

Jag har stött på ett problem medan jag experimenterar. Här är min kod:

// "Overload signature is not compatible with function implementation." on first (in code) declaration
function strOrObj (samePar:object, obj:object):object|undefined;
function strOrObj (samePar:object, num:number):number|undefined;
function strOrObj (samePar:object, num?:number, obj?:object):object|number|undefined{
    console.log("obj="+obj, "num="+num);
    return obj? obj: num;
}

Jag var tvungen att lägga till undefined i implementationen eftersom kompileraren, när den tittade på implementationen, trodde att det kunde behövas. Den bad mig inte att lägga till detta i överlagringarna, men jag gjorde det ändå för att experimentera. Men när jag lägger till typdeklarationer i implementationen får jag felet Overload signature is not compatible with function implementation..

Det enda sättet jag får detta att kompilera är att deklarera vilken parameter som helst i implementeringsdeklarationen som any, men på det sättet kommer det bara att stoppa varje given typ i den första valfria parametern (num i detta fall).

Så frågan är, vad är fel här? Är det ens möjligt att ha flera valfria parametrar om du inte är säker på att den första kommer att användas, eller är det kanske problemet (vilket kan vara en sak på grund av JS-implementeringen)?

Förlåt om detta är en duplikat, det enda jag kunde hitta som verkade gälla var ett problem på Github, men fixarna verkar ha blivit sammanfogade i release-koden.

Svar #1

Typescript låter dig definiera flera överlagringar men det är ditt jobb i implementeringen att skilja mellan dem, därför måste implementeringssignaturen vara kompatibel med alla överlagringar

function strOrObj (samePar:object, obj:object):object|undefined;
function strOrObj (samePar:object, num:number):number|undefined;
function strOrObj (samePar:object, numObj:number| object):object|number|undefined{
    if (typeof numObj === 'number') {
        return samePar
    } else {
        numObj
    }
}

Svar #2

@titian-cernicova-dragomir svarade på mitt faktiska svar i kommentarerna till hans svar. Här har jag skrivit ner vad jag drog för slutsats från hans svar och mina egna tester.

Typescript tillåter inte att man väljer namn på givna parametrar baserat på deras typ (utan att uttryckligen skriva typkontrollen själv). Den enda logiken som överlagringar implementerar i Typescript (åtminstone hittills) är en kontroll av om överlagringarna passar med implementeringen i indata- och returtyper, samt valet av den passande överlastningen för att bestämma returtypen.

De valfria variablerna fylls bara från höger till vänster, oavsett den angivna typen. Det är det som orsakar felet, eftersom även en sekundär objektparameter ("obj") kommer att hamna i num-variabeln i implementationen och kompilatorn klagar på att den andra parametern aldrig kommer att vara ett nummer, vilket gör att den överlagringssignaturen är ogiltig.

Du kan testa det genom att byta parametrarna; om du definierar obj först i implementationen kommer det att klaga på den andra överlagringssignaturen, eftersom den andra parametern alltid kommer att vara ett objekt.

Relaterade artiklar