Funktion Eigenschaft vs Methode

Question

Welche praktischen Unterschiede gibt es ein Schnittstellenverfahren zwischen der Definition:

interface Foo { 
    bar(): void; 
} 

ist und eine Eigenschaft mit einem Funktionstyp:

interface Foo { 
    bar:() => void; 
} 

?

Answer 1

Wenn dies die einzigen Deklarationen sind, sind diese identisch.

Der einzige Unterschied ist, dass Sie die erste Form in einer zweiten Erklärung neue Signaturen hinzuzufügen erweitern können:

// Somewhere 
interface Foo { 
    bar(): void; 
} 

// Somewhere else 
interface Foo { 
    bar(s: number): void; 
} 

// Elsewhere 
let x: Foo = ... 
x.bar(32); // OK 

Answer 2

Es scheint, dass der Compiler nicht zu kümmern scheint, wie alle diese gültig:

interface Foo1 { 
    bar(): void; 
} 

class Foo1Class1 implements Foo1 { 
    bar =() => { } 
} 

class Foo1Class2 implements Foo1 { 
    bar() { } 
} 

interface Foo2 { 
    bar:() => void; 
} 

class Foo2Class1 implements Foo2 { 
    bar =() => { } 
} 

class Foo2Class2 implements Foo2 { 
    bar() { } 
} 

(code in playground)

Der Grund dafür wahrscheinlich mit, wie das compil zu tun ist, es in javascript:

var Foo1Class1 = (function() { 
    function Foo1Class1() { 
     this.bar = function() { }; 
    } 
    return Foo1Class1; 
}()); 
var Foo1Class2 = (function() { 
    function Foo1Class2() { 
    } 
    Foo1Class2.prototype.bar = function() { }; 
    return Foo1Class2; 
}()); 

In beiden Fällen wird eine Instanz eines dieser Klassen wird eine Eigenschaft mit dem Namen bar, die eine aufrufbare Funktion ist.
Der Unterschied ist nur, dass in Foo1Class2 die bar Methode Teil des Prototyps ist, die dann von einer erweiterten Klasse überschrieben werden kann.

Answer 3

Es gibt einen weiteren Unterschied darin, dass der Modifikator readonly nicht auf Methoden angewendet werden kann. Daher kann die folgende Zuordnung nicht verhindert werden:

interface Foo { 
    bar(): void; 
} 

declare var x: Foo; 
x.bar = function() { }; 

Wenn bar als Eigenschaft definiert ist, dann wird der readonly Modifikator auf sie angewendet werden können:

interface Foo { 
    readonly bar:() => void; 
} 

verhindert Neuzuordnung.

(Playground)