Определение типа в литерале объекта в TypeScript

В классах TypeScript можно объявлять типы для свойств, например:

class className {
  property: string;
};

Как объявить тип свойства в литерале объекта?

Я пробовал следующий код, но он не компилируется:

var obj = {
  property: string;
};

Я получаю следующую ошибку:

Имя 'строка' не существует в текущей области

Я делаю что-то не так или это ошибка?

Вы довольно близко, вам просто нужно заменить =с :. Вы можете использовать литерал типа объекта (см. Раздел 3.5.3 спецификации) или интерфейс. Использование литерала типа объекта близко к тому, что у вас есть:

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

Но вы также можете использовать интерфейс

interface MyObjLayout {
    property: string;
}

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

Обновление 2019-05-15 (улучшенный шаблон кода в качестве альтернативы)

После многих лет использования constи использования более функционального кода я рекомендовал бы в большинстве случаев не использовать приведенное ниже. (При построении объектов принудительное использование системы типов в конкретном типе вместо того, чтобы позволять выводить типы, часто является признаком того, что что-то не так).

Вместо этого я бы рекомендовал использовать constпеременные в максимально возможной степени, а затем составить объект как последний шаг:

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

• Это будет правильно печатать все без необходимости явной печати.
• Нет необходимости перепечатывать имена полей.
• Это приводит к чистому коду из моего опыта.
• Это позволяет компилятору обеспечить больше проверки состояния (например, если вы вернетесь в нескольких местах, компилятор будет гарантировать, что всегда возвращается один и тот же тип объекта - что побуждает вас объявлять все возвращаемое значение в каждой позиции - давая совершенно ясную информацию). намерение этой ценности).

Дополнение 2020-02-26

Если вам действительно нужен тип, который можно лениво инициализировать: отметьте, что это объединяемый тип, допускающий значение NULL (нуль или тип). Система типов не позволит вам использовать ее, не убедившись, что она имеет значение.

В tsconfig.json, убедитесь, что вы включаете строгие проверки нуля:

"strictNullChecks": true

Затем используйте этот шаблон и позвольте системе типов защитить вас от случайного нулевого / неопределенного доступа:

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

Не делайте ниже в 99% случаев:

Обновление 2016-02-10 - для обработки TSX (спасибо @ Джош)

Используйте asоператор для TSX.

var obj = {
    property: null as string
};

Более длинный пример:

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

Оригинальный ответ

Используйте оператор приведения, чтобы сделать это кратким (приведя значение null к нужному типу).

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

Более длинный пример:

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

Это намного лучше, чем две части (одна для объявления типов, вторая для объявления значений по умолчанию):

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

Я удивлен, что никто не упомянул об этом, но вы могли бы просто создать интерфейс ObjectLiteral, который принимает key: valueпары типа string: any:

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

Тогда вы бы использовали его, вот так:

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

Дополнительным бонусом является то, что вы можете повторно использовать этот интерфейс столько раз, сколько вам нужно, на любом количестве объектов.

Удачи.

Если вы пытаетесь написать аннотацию типа, синтаксис:

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

Если вы пытаетесь написать литерал объекта, синтаксис:

var x = { property: 'hello' };

Ваш код пытается использовать имя типа в позиции значения.

В TypeScript, если мы объявляем объект, мы бы использовали следующий синтаксис:

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

Например:

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

Если вы пытаетесь добавить типизацию к литералу деструктурированного объекта, например, в аргументах функции, синтаксис:

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

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

Если ваши свойства имеют одинаковый тип, вы можете использовать предопределенный тип утилиты Record:

type Keys = "property" | "property2"

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

Конечно, вы можете пойти дальше и определить пользовательский тип для значений вашего свойства:

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

В вашем коде:

var obj = {
  myProp: string;
};

Вы фактически создаете литерал объекта и присваиваете строку переменной свойству myProp. Хотя это очень плохая практика, на самом деле это будет действительный код TS (не используйте это!):

var string = 'A string';

var obj = {
  property: string
};

Однако вы хотите, чтобы литерал объекта был напечатан. Это может быть достигнуто различными способами:

Интерфейс:

interface myObj {
    property: string;
}

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

Пользовательский тип:

type myObjType = {
    property: string
};

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

Оператор приведения:

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

Тип объекта литерал:

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