Definição de tipo no literal do objeto no TypeScript

Nas classes TypeScript, é possível declarar tipos para propriedades, por exemplo:

class className {
  property: string;
};

Como declarar o tipo de uma propriedade em um objeto literal?

Eu tentei o seguinte código, mas ele não compila:

var obj = {
  property: string;
};

Estou recebendo o seguinte erro:

O nome 'string' não existe no escopo atual

Estou fazendo algo errado ou isso é um bug?

Você está bem perto, basta substituir o =com um :. Você pode usar um tipo de objeto literal (consulte a seção 3.5.3), ou uma interface. O uso de um literal de tipo de objeto é próximo ao que você possui:

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

Mas você também pode usar uma interface

interface MyObjLayout {
    property: string;
}

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

Atualizar 2019-05-15 (Padrão de código aprimorado como alternativa)

Depois de muitos anos usando conste se beneficiando de um código mais funcional, eu recomendaria não usar o abaixo na maioria dos casos. (Ao criar objetos, forçar o sistema de tipos a um tipo específico, em vez de permitir inferir tipos, geralmente indica que algo está errado).

Em vez disso, eu recomendaria usar as constvariáveis ​​o máximo possível e, em seguida, componha o objeto como a etapa final:

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

• Isso digitará tudo corretamente, sem a necessidade de digitar explicitamente.
• Não há necessidade de redigitar os nomes dos campos.
• Isso leva ao código mais limpo da minha experiência.
• Isso permite que o compilador forneça mais verificação de estado (por exemplo, se você retornar em vários locais, o compilador garantirá que o mesmo tipo de objeto seja sempre retornado - o que incentiva você a declarar todo o valor de retorno em cada posição - oferecendo uma visão perfeitamente clara intenção desse valor).

Adição 2020-02-26

Se você realmente precisa de um tipo que possa ser inicializado com preguiça: Marque como um tipo de união anulável (nulo ou Tipo). O sistema de tipos impedirá que você o use sem antes garantir que ele tenha um valor.

Em tsconfig.json, certifique-se de habilitar verificações nulas estritas:

"strictNullChecks": true

Em seguida, use esse padrão e permita que o sistema de tipos o proteja contra acesso nulo / indefinido acidental:

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
    }
}

Não faça o abaixo em 99% dos casos:

Atualização 10/02/2016 - Para lidar com o TSX (Obrigado @ Josh)

Use o asoperador para TSX.

var obj = {
    property: null as string
};

Um exemplo mais longo:

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

Resposta original

Use o operador de conversão para tornar isso sucinto (convertendo nulo para o tipo desejado).

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

Um exemplo mais longo:

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

Isso é muito melhor do que ter duas partes (uma para declarar tipos e a segunda para declarar padrões):

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

Estou surpreso que ninguém tenha mencionado isso, mas você pode simplesmente criar uma interface chamada ObjectLiteral, que aceita key: valuepares de tipos string: any:

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

Então você usaria, assim:

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

Um bônus adicional é que você pode reutilizar essa interface quantas vezes for necessário, em quantos objetos desejar.

Boa sorte.

Se você estiver tentando escrever uma anotação de tipo, a sintaxe é:

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

Se você estiver tentando escrever um objeto literal, a sintaxe é:

var x = { property: 'hello' };

Seu código está tentando usar um nome de tipo em uma posição de valor.

No TypeScript, se estamos declarando objeto, usaríamos a seguinte sintaxe:

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

Por exemplo:

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

Se você está tentando adicionar digitações a um objeto literal destruído , por exemplo, nos argumentos de uma função, a sintaxe é:

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

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

Se suas propriedades tiverem o mesmo tipo, você poderá usar o tipo de utilitário predefinido Record:

type Keys = "property" | "property2"

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

É claro que você pode ir além e definir um tipo personalizado para seus valores de propriedade:

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

No seu código:

var obj = {
  myProp: string;
};

Na verdade, você está criando um literal de objeto e atribuindo a sequência de variáveis ​​à propriedade myProp. Embora seja uma prática muito ruim, esse seria realmente um código TS válido (não use isso!):

var string = 'A string';

var obj = {
  property: string
};

No entanto, o que você deseja é que o literal do objeto seja digitado. Isso pode ser alcançado de várias maneiras:

Interface:

interface myObj {
    property: string;
}

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

Tipo personalizado:

type myObjType = {
    property: string
};

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

Operador de elenco:

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

Tipo de objeto literal:

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