The premise of the question is that interface should provide runtime identification of what objects implement a given interface. But that's not how Interface has been designed in TypeScript because, as both the OP and others have said, Interfaces simply do not exist at runtime. The implications of that design choice is that at runtime, interfaces are no more than a collection of JavaScript object properties.
To do a runtime check, you can do the hacky thing of checking for the individual members in the interface:
interface A{
member:string;
}
if(a.member) alert(a.member);
This is essentially what a lot of the proposed workarounds, including type guards, boil down to. This has obvious limitation when there are multiple members in the interface (should I check for them all? should I define an interface identifier/discriminator property?) and will in some cases require additional type checks on the members to pass the TS compiler's type checker. (E.g., another interface might implement member as number).
If the idea is to allow objects to exhibit behavior depending on what interfaces are present, then a better pattern is to use a base interface with a common method (or methods) to trigger behavior and then extend the base interface to add specialized properties and/or methods. Extending the OPs example:
interface A { //Base interface that all objects in the collection will implement
talk():string
}
interface B extends A { //Specialized interface
member: string
}
var a:A = {
talk() {return 'got no member'}
}
var b:B = {
member: 's',
talk() {return 'my member is '+this.member}
}
for(let item of [a,b]) { //We can now loop over both object types and get the relevant response
console.log(item, item.talk());
}
The point being that implementations of either interface are forced to implement a talk method with a common spec, which is enforced by the type checker. The compiler's type checking becomes increasingly valuable as the interfaces grow in complexity.
The biggest weakness of TypeScript's Interface is the lack of default implementations. You can fake it by defining a default object implementation of the interface and copying from it, like var defaultA = {talk() {'no member'}}; var a = {...defaultA}, but it would be much cleaner if it was possible to specify the defaults in the interface definition.
With many objects implementing the same interfaces, it is better to implement them as classes using the implements keyword in a class definition, which typically improves memory usage and performance. It also allows for multiple inheritance of interfaces and is another way to populate default behavior for objects.
