Tout" vs "Objet

Question

Je regarde le code TypeScript et j'ai remarqué qu'ils utilisent :

interface Blablabla {

   field: Object;

}

Quel est l'intérêt d'utiliser Object vs any , comme dans :

interface Blablabla {

  field: any;

}

Answer 1

Un peu vieux, mais ça ne fait pas de mal d'ajouter quelques notes.

Lorsque vous écrivez quelque chose comme ceci

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

• a n'a pas d'interface, il peut être n'importe quoi, le compilateur ne sait rien de ses membres et aucune vérification de type n'est effectuée lors de l'accès ou de l'affectation à lui et à ses membres. En fait, vous dites au compilateur de " Je sais ce que je fais, alors faites-moi confiance. " ;
• b possède l'interface Object, de sorte que SEULS les membres définis dans cette interface sont disponibles pour les b . Il s'agit toujours de JavaScript, donc tout s'étend à Object ;
• c étend Object, comme tout ce qui existe en TypeScript, mais n'ajoute aucun membre. La compatibilité des types en TypeScript est basée sur le sous-typage structurel et non sur le sous-typage nominal, c est identique à b car ils ont la même interface : l'interface Objet.

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

Donc Object y {} sont équivalents en TypeScript.

Si vous déclarez des fonctions comme celles-ci

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

avec l'intention d'accepter n'importe quoi pour param (peut-être allez-vous vérifier les types à l'exécution pour décider de ce qu'il faut faire avec), rappelez-vous que

• à l'intérieur fa le compilateur vous laissera faire ce que vous voulez avec paramètre ;
• à l'intérieur fb le compilateur ne vous laissera faire référence qu'à Objet Les membres de l'Union européenne.

Il convient toutefois de noter que si les paramètre est censé accepter plusieurs types connus, une meilleure approche consiste à le déclarer en utilisant des types d'union, comme dans

function fc(param: string|number): void {}

Bien entendu, les règles d'héritage OO s'appliquent toujours, donc si vous souhaitez accepter des instances de classes dérivées et les traiter sur la base de leur type de base, comme dans l'exemple suivant

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 meilleure façon de procéder, et non le type de base. tous . Mais c'est OO, hors du champ d'application, je voulais juste le préciser tous ne doit être utilisé que lorsque vous ne savez pas ce qui va arriver, et pour toute autre chose, vous devez annoter le type correct.

UPDATE :

Typescript 2.2 a ajouté un object qui spécifie qu'une valeur est un : non primitif (c'est-à-dire qui n'est pas un number , string , boolean , symbol , undefined ou null ).

Considérons 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 dans toutes ces fonctions, mais c'est une erreur de type d'appeler d avec un primitif :

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

Answer 2

Object est plus restrictif que le any . Par exemple :

let a: any;
let b: Object;

a.nomethod(); // Transpiles just fine
b.nomethod(); // Error: Property 'nomethod' does not exist on type 'Object'.

En Object n'a pas d'élément nomethod() le transpondeur génèrera donc une erreur qui vous le signalera. Si vous utilisez any au lieu de cela, vous dites au transpileur que tout est permis, vous ne fournissez aucune information sur ce qui est stocké dans le fichier a - tout est possible ! Par conséquent, le transpondeur vous permettra de faire ce que vous voulez avec quelque chose défini comme any .

En résumé

• any peut être n'importe quoi (vous pouvez appeler n'importe quelle méthode, etc. sans erreur de compilation)
• Object expose les fonctions et les propriétés définies dans le Object classe.

Answer 3

any est quelque chose de spécifique à TypeScript est assez bien expliqué par la réponse d'Alex.

Object se réfère au code JavaScript object type. Couramment utilisé comme {} ou parfois new Object . La plupart des choses en javascript sont compatibles avec le type de données de l'objet car ils en héritent. Mais les any es TypeScript spécifique et compatible avec tout dans les deux sens (non basé sur l'héritage), par exemple :

var foo:Object; 
var bar:any;
var num:number;

foo = num; // Not an error
num = foo; // ERROR 

// Any is compatible both ways 
bar = num;
num = bar;

Answer 4

Contrairement à .NET où tous les types dérivent d'un "objet", en TypeScript, tous les types dérivent de "any". Je voulais simplement ajouter cette comparaison, car je pense qu'elle sera couramment faite à mesure que les développeurs .NET essaieront TypeScript.

Answer 5

L'objet semble être une déclaration plus spécifique que toutes les autres. Extrait de la spécification TypeScript (section 3) :

A Tout type. Le mot-clé any fait référence à ce type. Le type Any est le seul type qui peut représenter n'importe quelle valeur JavaScript sans aucune contrainte. Tous les autres types sont classés comme des types primitifs, des types objets ou des paramètres de type. Ces types introduisent diverses contraintes statiques sur leurs valeurs.

En outre :

Le type Any est utilisé pour représenter n'importe quelle valeur JavaScript. Une valeur de type Any supporte les mêmes opérations qu'une valeur en JavaScript et une vérification statique minimale du type est effectuée pour les opérations sur les valeurs Any. une vérification statique minimale des types est effectuée pour les opérations sur les valeurs de type Any sont soumises à une vérification statique minimale. Plus précisément, il est possible d'accéder à des propriétés de n'importe quel nom par l'intermédiaire de par l'intermédiaire d'une valeur Any et les valeurs Any peuvent être appelées en tant que fonctions ou avec n'importe quelle liste d'arguments.

Les objets ne permettent pas la même flexibilité.

Par exemple :

var myAny : any;

myAny.Something(); // no problemo

var myObject : Object;

myObject.Something(); // Error: The property 'Something' does not exist on value of type 'Object'.