Digitare la definizione nell'oggetto letterale in TypeScript

Nelle classi TypeScript è possibile dichiarare i tipi per le proprietà, ad esempio:

class className {
  property: string;
};

Come dichiarare il tipo di una proprietà in un oggetto letterale?

Ho provato il seguente codice ma non viene compilato:

var obj = {
  property: string;
};

Ricevo il seguente errore:

Il nome 'stringa' non esiste nell'ambito corrente

Sto facendo qualcosa di sbagliato o è un bug?

Sei abbastanza vicino, devi solo sostituire il =con un :. È possibile utilizzare un tipo di oggetto letterale (vedere la sezione 3.5.3 delle specifiche) o un'interfaccia. L'uso di un tipo di oggetto letterale è simile a quello che hai:

var obj: { property: string; } = { property: "foo" };

Ma puoi anche usare un'interfaccia

interface MyObjLayout {
    property: string;
}

var obj: MyObjLayout = { property: "foo" };

Aggiornamento 15/05/2019 (modello di codice migliorato come alternativa)

Dopo molti anni di utilizzo conste di utilizzo di un codice più funzionale, nella maggior parte dei casi consiglierei di non utilizzare quanto segue. (Quando si costruiscono oggetti, forzare il sistema di tipi in un tipo specifico invece di lasciarne dedurre i tipi è spesso un'indicazione che qualcosa non va).

Invece, consiglierei di utilizzare le constvariabili il più possibile e quindi comporre l'oggetto come passaggio finale:

const id = GetId();
const hasStarted = true;
...
const hasFinished = false;
...
return {hasStarted, hasFinished, id};

• Questo scriverà correttamente tutto senza la necessità di digitare esplicitamente.
• Non è necessario digitare nuovamente i nomi dei campi.
• Questo porta al codice più pulito dalla mia esperienza.
• Ciò consente al compilatore di fornire una maggiore verifica dello stato (ad esempio, se si ritorna in più posizioni, il compilatore assicurerà che venga sempre restituito lo stesso tipo di oggetto, il che ti incoraggia a dichiarare l'intero valore di ritorno in ciascuna posizione) fornendo un risultato perfettamente chiaro intenzione di quel valore).

Aggiunta 2020-02-26

Se in realtà hai bisogno di un tipo che puoi inizializzare pigramente: Segna come un tipo di unione nullable (null o Type). Il sistema dei tipi ti impedirà di usarlo senza prima assicurarti che abbia un valore.

In tsconfig.json, assicurati di abilitare controlli null rigorosi:

"strictNullChecks": true

Quindi utilizzare questo modello e consentire al sistema di tipi di proteggerti da accessi nulli / indefiniti accidentali:

const state = {
    instance: null as null | ApiService,
    // OR
    // instance: undefined as undefined | ApiService,

};

const useApi = () => {
    // If I try to use it here, the type system requires a safe way to access it

    // Simple lazy-initialization 
    const api = state?.instance ?? (state.instance = new ApiService());
    api.fun();

    // Also here are some ways to only access it if it has value:

    // The 'right' way: Typescript 3.7 required
    state.instance?.fun();

    // Or the old way: If you are stuck before Typescript 3.7
    state.instance && state.instance.fun();

    // Or the long winded way because the above just feels weird
    if (state.instance) { state.instance.fun(); }

    // Or the I came from C and can't check for nulls like they are booleans way
    if (state.instance != null) { state.instance.fun(); }

    // Or the I came from C and can't check for nulls like they are booleans 
    // AND I was told to always use triple === in javascript even with null checks way
    if (state.instance !== null && state.instance !== undefined) { state.instance.fun(); }
};

class ApiService {
    fun() {
        // Do something useful here
    }
}

Non eseguire le operazioni seguenti nel 99% dei casi:

Aggiornamento 10-02-2016 - Per gestire TSX (Grazie @Josh)

Utilizzare l' asoperatore per TSX.

var obj = {
    property: null as string
};

Un esempio più lungo:

var call = {
    hasStarted: null as boolean,
    hasFinished: null as boolean,
    id: null as number,
};

Risposta originale

Usa l'operatore cast per rendere questo succinto (lanciando null al tipo desiderato).

var obj = {
    property: <string> null
};

Un esempio più lungo:

var call = {
    hasStarted: <boolean> null,
    hasFinished: <boolean> null,
    id: <number> null,
};

È molto meglio che avere due parti (una per dichiarare i tipi, la seconda per dichiarare i valori predefiniti):

var callVerbose: {
    hasStarted: boolean;
    hasFinished: boolean;
    id: number;
} = {
    hasStarted: null,
    hasFinished: null,
    id: null,
};

Sono sorpreso che nessuno abbia menzionato questo, ma potresti semplicemente creare un'interfaccia chiamata ObjectLiteral, che accetta key: valuecoppie di tipo string: any:

interface ObjectLiteral {
  [key: string]: any;
}

Quindi lo useresti, in questo modo:

let data: ObjectLiteral = {
  hello: "world",
  goodbye: 1,
  // ...
};

Un ulteriore vantaggio è che puoi riutilizzare questa interfaccia tutte le volte che vuoi, su tutti gli oggetti che desideri.

In bocca al lupo.

Se stai cercando di scrivere un'annotazione di tipo, la sintassi è:

var x: { property: string; } = ...;

Se stai provando a scrivere un oggetto letterale, la sintassi è:

var x = { property: 'hello' };

Il codice sta tentando di utilizzare un nome di tipo in una posizione di valore.

In TypeScript se dichiariamo un oggetto, utilizziamo la sintassi seguente:

[access modifier] variable name : { /* structure of object */ }

Per esempio:

private Object:{ Key1: string, Key2: number }

Se si sta tentando di aggiungere letteralmente un oggetto destrutturato , ad esempio negli argomenti di una funzione, la sintassi è:

function foo({ bar, baz }: { bar: boolean, baz: string }) {
  // ...
}

foo({ bar: true, baz: 'lorem ipsum' });

Se le proprietà hanno lo stesso tipo, è possibile utilizzare un tipo di utilità predefinito Record :

type Keys = "property" | "property2"

var obj: Record<Keys, string> = {
  property: "my first prop",
  property2: "my second prop",
};

Ovviamente puoi andare oltre e definire un tipo personalizzato per i tuoi valori di proprietà:

type Keys = "property" | "property2"
type Value = "my prop" | "my other allowed prop"

var obj: Record<Keys, Value> = {
  property: "my prop",
  property2: "my second prop", // TS Error: Type '"my second prop"' is not assignable to type 'Value'.
};

// 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());

Nel tuo codice:

var obj = {
  myProp: string;
};

In realtà stai creando un oggetto letterale e assegnando la stringa variabile alla proprietà myProp. Anche se una cattiva pratica sarebbe effettivamente un codice TS valido (non usarlo!):

var string = 'A string';

var obj = {
  property: string
};

Tuttavia, ciò che vuoi è che l'oggetto letterale sia digitato. Ciò può essere ottenuto in vari modi:

Interfaccia:

interface myObj {
    property: string;
}

var obj: myObj = { property: "My string" };

Tipo personalizzato:

type myObjType = {
    property: string
};

var obj: myObjType = { property: "My string" };

Operatore cast:

var obj = {
    myString: <string> 'hi',
    myNumber: <number> 132,
};

Tipo di oggetto letterale:

var obj: { property: string; } = { property: "Mystring" };