Dactylographiée en classe, il est possible de déclarer le type de propriété, par exemple:
class className{
property : string;
};
Comment dois-je écrire du code pour déclarer le type de propriété dans l'objet littéral? Ce code ne compile pas:
var obj = {
property: string;
};
(J'obtiens l'erreur - Le nom « string » n'existe pas dans le champ d'application actuel).
Ce que je fais mal ou il est un bug?
Vous êtes assez proche, il vous suffit de remplacer le =avec :. Vous pouvez utiliser un type d'objet littéral (voir section 3.5.3 spec) ou une interface. L' utilisation d' un type d'objet littéral est proche de ce que vous avez:
var obj: { property: string; } = { property: "foo" };
Mais vous pouvez aussi utiliser une interface
interface MyObjLayout {
property: string;
}
var obj: MyObjLayout = { property: "foo" };
Utiliser l'opérateur de distribution pour rendre cette brève (par coulée nulle au type désiré).
var obj = {
property: <string> null
};
Un exemple plus:
var call = {
hasStarted: <boolean> null,
hasFinished: <boolean> null,
id: <number> null,
};
Cela est beaucoup mieux que d'avoir deux parties (une pour déclarer des types, la seconde à déclarer par défaut):
var callVerbose: {
hasStarted: boolean;
hasFinished: boolean;
id: number;
} = {
hasStarted: null,
hasFinished: null,
id: null,
};
Utilisez le comme opérateur pour TSX.
var obj = {
property: null as string
};
Un exemple plus:
var call = {
hasStarted: null as boolean,
hasFinished: null as boolean,
id: null as number,
};
Si vous essayez d'écrire une annotation de type, la syntaxe est:
var x: { property: string; } = ...;
Si vous essayez d'écrire un objet littéral, la syntaxe est:
var x = { property: 'hello' };
Votre code tente d'utiliser un nom de type dans une position de valeur.
Dactylographiée si nous proclamons objet alors
[Modificateur d'accès] nom de la variable: {// structure objet}
private Object:{Key1:string , Key2:number }
// Use ..
const Per = {
name: 'HAMZA',
age: 20,
coords: {
tele: '09',
lan: '190'
},
setAge(age: Number): void {
this.age = age;
},
getAge(): Number {
return age;
}
};
const { age, name }: { age: Number; name: String } = Per;
const {
coords: { tele, lan }
}: { coords: { tele: String; lan: String } } = Per;
console.log(Per.getAge());
Dans votre code:
var obj = {
myProp: string;
};
Vous créez en fait un objet littéral et en attribuant la chaîne variable à la myProp propriété. Bien que très mauvaise pratique ce serait en fait un code valide TS (ne pas utiliser cela!):
var string = 'A string';
var obj = {
property: string
};
Cependant, ce que vous voulez que le littéral d'objet est tapé. Ceci peut être réalisé de différentes façons:
Interface:
interface myObj {
property: string;
}
var obj: myObj = { property: "My string" };
Type de mesure:
type myObjType = {
property: string
};
var obj: myObjType = { property: "My string" };
opérateur Cast:
var obj = {
myString: <string> 'hi',
myNumber: <number> 132,
};
Type d'objet littéral:
var obj: { property: string; } = { property: "Mystring" };
Je suis surpris que personne ne est mentionné cela , mais vous pouvez simplement créer une interface unique appelée ObjectLiteral, comme ceci:
interface ObjectLiteral {
[key: string]: any;
}
Ensuite, vous voulez l'utiliser, comme ceci:
let data: ObjectLiteral = {
hello: "world",
goodbye: 1,
// ...
};
Vous pouvez réutiliser cette interface unique autant de fois que vous le souhaitez.
Bonne chance.
Si vous essayez d'ajouter typages à un déstructuré littéral d' objet, par exemple dans des arguments à une fonction, la syntaxe est:
function foo({ bar, baz }: { bar: boolean, baz: string }) {
// ...
}
foo({ bar: true, baz: 'lorem ipsum' });