In zijn blogpost over typoscript, Mark Rendle zegt, dat één van de dingen die hij graag over het is:
Structurele typering voor interfaces. Ik wou echt C # zou kunnen doen
Wat bedoelde hij daarmee?
In zijn blogpost over typoscript, Mark Rendle zegt, dat één van de dingen die hij graag over het is:
Structurele typering voor interfaces. Ik wou echt C # zou kunnen doen
Wat bedoelde hij daarmee?
In principe betekent dit dat interfaces worden vergeleken op een "duck-typing" basis in plaats van op identiteitstype basis.
Beschouw de volgende C # -code:
interface X1 { string Name { get; } }
interface X2 { string Name { get; } }
// ... later
X1 a = null;
X2 b = a; // Compile error! X1 and X2 are not compatible
En het equivalent typoscript code:
interface X1 { name: string; }
interface X2 { name: string; }
var a: X1 = null;
var b: X2 = a; // OK: X1 and X2 have the same members, so they are compatible
De specificatie dit niet dekken gedetailleerd, maar klassen "merken" die dezelfde code geschreven met klassen plaats van interfaces verstaan, zou een fout hebben. C # interfaces hebben wel merken, en kan dus niet impliciet worden geconverteerd.
De eenvoudigste manier om na te denken over het is dat als je probeert een conversie van interface-X te gebruiken interface Y, als X heeft alle leden van Y, de conversie slaagt, hoewel X en Y is misschien niet dezelfde naam hebben.
Denk er eens over.
class Employee { fire: = ..., otherMethod: = ...}
class Missile { fire: = ..., yetMoreMethod: = ...}
interface ICanFire { fire: = ...}
val e = new Employee
val m = new Missile
ICanFire bigGuy = if(util.Random.nextBoolean) e else m
bigGuy.fire
Wat als we zeiden:
interface IButtonEvent { fire: = ...}
interface IMouseButtonEvent { fire: = ...}
...
Typescript zal dit toe te staan, C # niet.
Zoals Typescript bedoeld om goed te werken met de DOM dat “los” te typen gebruikt, het is de enige verstandige kiezen voor typoscript.
Ik laat het aan de lezer om te beslissen of ze willen “Structural typen” ... ..