unterstützte Typen in Funktionen

Question

Lassen Sie sagen, wir haben diesen Code:

class MyEvent { 
    timestamp:number; 
} 
class AEvent extends MyEvent{ 
    x:number; 
    y:number; 
} 
class BEvent extends MyEvent{ 
    key:string; 
} 
var fn:(event:MyEvent)=>void; 
function AE(event:AEvent){ 
    let x = event.x; //Ok, but BEvent hasn't 'x' property. 
} 
fn = AE; 
fn(new BEvent()); 

Typoskript informiert nicht über Fehler. Für Typoskript ist es ein gültiger Code. Ich habe es in Typoskript Spielplatz versucht. (1.8 Version)

Wie erzwinge ich Typoskript, um es zu verbieten?

Zum Beispiel in C++

class Base { 
    public: 
     int timestamp; 
}; 

class B: public Base { 
    public: 
     char key; 
}; 
class A: public Base { 
    public: 
     int x; 
     int y; 
}; 


void fA(A *ptr) {} 

void (*fn)(Base *ptr); 


int main() 
{ 
    A *a = new A(); 
    B *b = new B(); 

    fn = fA; //error: invalid conversion from 'void (*)(A*)' to 'void (*)(Base*)' 
    fn(b); 
} 

Answer 1

Die Funktionsparameter sind bivariant gemeinsamen JavaScript-Muster zu erlauben, selbst wenn einige Laufzeitfehler in einigen seltenen Fall auftreten kann.

Nach Typ compatibility handbook:

Wenn die Typen der Funktionsparameter zu vergleichen, die Zuweisung erfolgreich ist wenn entweder die Quellparameter zuordenbar den Zielparameter ist, oder vice versa. Dies ist nicht sicher, da ein Aufrufer möglicherweise eine Funktion gegeben wird, die einen spezielleren Typ verwendet, aber ruft die -Funktion mit einem weniger spezialisierten Typ auf. In der Praxis ist diese Art von Fehler selten, und dies ermöglicht viele gängige JavaScript-Muster.

Why are function parameters bivariant?

Zusammengefasst im Typoskript Typ-System, die Frage, ob eine mehr spezifische-Typ-akzeptierende Funktion eine Funktion zuordenbar sein sollte weniger spezifischer Typ akzeptieren bietet eine vorausgesetzte Antwort , ob ein Array dieses spezifischeren Typs einem Array eines weniger spezifischen Typs zuweisbar sein soll. Wäre letzteres nicht der Fall wäre in den allermeisten Fällen kein akzeptables Typensystem, , so müssen wir einen Korrektheitskonflikt für den spezifischen Fall von Funktionsargumenttypen nehmen.