'tout' vs 'Objet'

Peu vieux, mais ne fait pas de mal à ajouter quelques notes.

Lorsque vous écrivez quelque chose comme ceci

var a: any;
var b: Object;
var c: {};

• un a pas d'interface, il peut être n'importe quoi, le compilateur ne sait rien de ses membres, de manière minimale type de vérification est effectuée lors de l'accès/l'affectation à la fois pour lui-même et de ses membres. Fondamentalement, vous avez dit au compilateur "de retour de congé, je sais ce que je suis en train de faire, alors fais-moi confiance";
• b a l'interface d'un Objet, de sorte que SEULS les membres définis dans cette interface sont disponibles pour b. C'est encore le JavaScript, donc tout ce qui s'étend de l'Objet;
• c s'étend de l'Objet, comme toute autre chose dans la Machine, mais de ne pas ajouter de membres. Etant donné que le type de compatibilité dans le Tapuscrit est basé sur des structures de sous-typage, pas de sous-typage nominal, c finit par être le même que b parce qu'ils ont la même interface: l'interface d'un Objet.

Et c'est pourquoi

a.doSomething(); //Ok: the compiler trusts you on that
b.doSomething(); //Error: Object has no doSomething member
c.doSomething(); //Error: c neither has doSomething nor inherits it from Object

et pourquoi

a.toString(); //Ok: whatever, dude, have it your way
b.toString(); //Ok: toString is defined in Object
c.toString(); //Ok: c inherits toString from Object

De sorte que les deux Object et {} sont l'équivalent pour les caractères d'imprimerie. Je ne vois pas quelqu'un de vraiment l'utiliser. Trop restrictives.

Si vous déclarez ces fonctions

function fa(param: any): void {}
function fb(param: Object): void {}

avec l'intention d'accepter quoi que ce soit pour les param (vous allez peut-être vérifier les types à l'exécution, le temps de décider quoi faire avec elle), n'oubliez pas que

• à l'intérieur de fa, le compilateur va vous laisser faire ce que vous voulez avec param;
• à l'intérieur de fb, le compilateur ne vous permettent d'accéder à l'Objet de membres, et vous finirez par avoir à faire beaucoup de typecasting là...

Donc, fondamentalement, lorsque vous ne connaissez pas le type, aller avec tout et faire de type à l'exécution de la vérification.

Évidemment, OO héritage règles continuent de s'appliquer, donc, si vous voulez accepter les instances de classes dérivées et les traiter en fonction de leur type de base, comme dans

interface IPerson {
    gender: string;
}

class Person implements IPerson {
    gender: string;
}

class Teacher extends Person {}

function func(person: IPerson): void {
    console.log(person.gender);
}

func(new Person());     //Ok
func(new Teacher());    //Ok
func({gender: 'male'}); //Ok
func({name: 'male'});   //Error: no gender..

le type de base est la façon de le faire, pas tout. Mais c'est OO, hors de portée, je voulais juste préciser que tout ne doit être utilisé lorsque vous ne savez pas ce qui est à venir, et pour tout ce que vous devez annoter le type correct.

Mise à JOUR:

Tapuscrit 2.2 ajouté une object type, qui indique qu'une valeur est un non-primitive: (c'est à dire pas un number, string, boolean, symbol, undefined, ou null).

Considérer que les fonctions définies comme suit:

function b(x: Object) {}
function c(x: {}) {}
function d(x: object) {}

x aura les mêmes propriétés disponibles au sein de l'ensemble de ces fonctions, mais c'est une erreur de type à l'appel d avec quelque chose de non-primitive:

b("foo"); //Okay
c("foo"); //Okay
d("foo"); //Error: "foo" is a primitive

Contrairement à .NET où tous les types de dériver à partir d'un "objet", en caractères d'imprimerie, tous les types de dériver de "tout". Je voulais juste ajouter cette comparaison que je pense que ça va être une commune fait aussi plus .NET développeurs de donner à la Machine un essai.

L'ajout d'Alex réponse et de simplification:

Objets sont plus sévères avec leur utilisation et leur donne donc le programmeur en plus de la compilation "évaluation" puissance et, par conséquent, dans beaucoup de cas, fournir plus de "capacités de vérification" et coould empêcher toute fuite, alors que tout est un terme plus générique et beaucoup de temps de compilation chèques peuvent donc être ignorés.