Если бы я хотел программно назначить свойство для объекта в Javascript, я бы сделал это так:

var obj = {};
obj.prop = "value";

Но в TypeScript это вызывает ошибку:

Свойство 'prop' не существует для значения типа '{}'

Как я должен назначить любое новое свойство для объекта в TypeScript?

Это можно обозначить objкак any, но это противоречит цели использования машинописи. obj = {}подразумевает objэто Object. Отмечать это как anyне имеет смысла. Для достижения желаемой согласованности интерфейс может быть определен следующим образом.

interface LooseObject {
    [key: string]: any
}

var obj: LooseObject = {};

ИЛИ сделать его компактным:

var obj: {[k: string]: any} = {};

LooseObjectможет принимать поля с любой строкой в ​​качестве ключа и anyвводить в качестве значения.

obj.prop = "value";
obj.prop2 = 88;

Настоящая элегантность этого решения заключается в том, что вы можете включить в интерфейс типобезопасные поля.

interface MyType {
    typesafeProp1?: number,
    requiredProp1: string,
    [key: string]: any
}

var obj: MyType ;
obj = { requiredProp1: "foo"}; // valid
obj = {} // error. 'requiredProp1' is missing
obj.typesafeProp1 = "bar" // error. typesafeProp1 should be a number

obj.prop = "value";
obj.prop2 = 88;

Хотя это отвечает на оригинальный вопрос, ответ здесь @GreeneCreations может дать другую точку зрения на то, как подойти к проблеме.

Или все за один раз:

  var obj:any = {}
  obj.prop = 5;

Я склонен ставить anyна другую сторону, т.е. var foo:IFoo = <any>{};что-то вроде этого все еще безопасное:

interface IFoo{
    bar:string;
    baz:string;
    boo:string;     
}

// How I tend to intialize 
var foo:IFoo = <any>{};

foo.bar = "asdf";
foo.baz = "boo";
foo.boo = "boo";

// the following is an error, 
// so you haven't lost type safety
foo.bar = 123; 

В качестве альтернативы вы можете пометить эти свойства как необязательные:

interface IFoo{
    bar?:string;
    baz?:string;
    boo?:string;    
}

// Now your simple initialization works
var foo:IFoo = {};

Попробуйте онлайн

Это решение полезно, когда ваш объект имеет определенный тип. Как при получении объекта в другой источник.

let user: User = new User();
(user as any).otherProperty = 'hello';
//user did not lose its type here.

Хотя компилятор жалуется, он все равно должен выводить его так, как вам нужно. Тем не менее, это будет работать.

var s = {};
s['prop'] = true;

Еще один способ сделать это - получить доступ к свойству как к коллекции:

var obj = {};
obj['prop'] = "value";

Я удивлен, что ни один из ответов не ссылается на Object.assign, поскольку именно эту технику я использую всякий раз, когда думаю о «композиции» в JavaScript.

И это работает как положено в TypeScript:

interface IExisting {
    userName: string
}

interface INewStuff {
    email: string
}

const existingObject: IExisting = {
    userName: "jsmith"
}

const objectWithAllProps: IExisting & INewStuff = Object.assign({}, existingObject, {
    email: "jsmith@someplace.com"
})

console.log(objectWithAllProps.email); // jsmith@someplace.com

преимущества

• Тип безопасности во всем, потому что вам не нужно использовать anyтип вообще
• использует агрегатный тип TypeScript (как обозначено &при объявлении типа objectWithAllProps), который четко сообщает, что мы создаем новый тип на лету (то есть динамически)

Что нужно знать

1. Object.assign имеет свои уникальные аспекты (которые хорошо известны большинству опытных разработчиков JS), которые следует учитывать при написании TypeScript.
   • Он может быть изменяемым или неизменным (я демонстрирую неизменный способ выше, что означает, что он existingObjectостается неизменным и, следовательно, не имеет emailсвойства. Для большинства программистов в функциональном стиле это хорошо, так как результат единственное новое изменение).
   • Object.assign работает лучше всего, когда у вас есть более плоские объекты. Если вы объединяете два вложенных объекта, которые содержат обнуляемые свойства, вы можете перезаписать истинные значения неопределенными. Если вы следите за порядком аргументов Object.assign, все будет в порядке.

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

interface MyObject {
    prop1: string;
}

const myObj: MyObject = {
    prop1: 'foo',
}

const newObj = {
    ...myObj,
    prop2: 'bar',
}

console.log(newObj.prop2); // 'bar'

TypeScript выведет все поля исходного объекта, а VSCode сделает автозаполнение и т. Д.

Самое простое будет следующее

const obj = <any>{};
obj.prop1 = "value";
obj.prop2 = "another value"

Можно добавить члена к существующему объекту

1. расширение типа (читай: расширять / специализировать интерфейс)
2. приведите исходный объект к расширенному типу
3. добавить член к объекту

interface IEnhancedPromise<T> extends Promise<T> {
    sayHello(): void;
}

const p = Promise.resolve("Peter");

const enhancedPromise = p as IEnhancedPromise<string>;

enhancedPromise.sayHello = () => enhancedPromise.then(value => console.info("Hello " + value));

// eventually prints "Hello Peter"
enhancedPromise.sayHello();

Поскольку вы не можете сделать это:

obj.prop = 'value';

Если ваш компилятор TS и ваш линтер не строгие к вам, вы можете написать это:

obj['prop'] = 'value';

Если ваш компилятор TS или линтер строгий, другой ответ был бы для typecast:

var obj = {};
obj = obj as unknown as { prop: string };
obj.prop = "value";

Сохраните любое новое свойство на объекте любого типа, указав его тип «any»:

var extend = <any>myObject;
extend.NewProperty = anotherObject;

Позже вы можете получить его, переведя расширенный объект обратно в 'any':

var extendedObject = <any>myObject;
var anotherObject = <AnotherObjectType>extendedObject.NewProperty;

Чтобы гарантировать, что тип является Object(т.е. пары ключ-значение ), используйте:

const obj: {[x: string]: any} = {}
obj.prop = 'cool beans'

• Дело 1:

  var car = {type: "BMW", model: "i8", color: "white"}; car['owner'] = "ibrahim"; // You can add a property:

• Случай 2:

  var car:any = {type: "BMW", model: "i8", color: "white"}; car.owner = "ibrahim"; // You can set a property: use any type

Вы можете использовать это:

this.model = Object.assign(this.model, { newProp: 0 });

Вы можете добавить эту декларацию, чтобы заставить замолчать предупреждения.

declare var obj: any;

Лучше всего использовать безопасную печать, я рекомендую вам:

interface customObject extends MyObject {
   newProp: string;
   newProp2: number;
}

Чтобы сохранить ваш предыдущий тип, временно приведите ваш объект к любому

  var obj = {}
  (<any>obj).prop = 5;

Новое динамическое свойство будет доступно только при использовании приведения:

  var a = obj.prop; ==> Will generate a compiler error
  var b = (<any>obj).prop; ==> Will assign 5 to b with no error;

Вот специальная версия Object.assign, которая автоматически корректирует тип переменной при каждом изменении свойства. Нет необходимости в дополнительных переменных, утверждениях типа, явных типах или копиях объектов:

function assign<T, U>(target: T, source: U): asserts target is T & U {
    Object.assign(target, source)
}

const obj = {};
assign(obj, { prop1: "foo" })
//  const obj now has type { prop1: string; }
obj.prop1 // string
assign(obj, { prop2: 42 })
//  const obj now has type { prop1: string; prop2: number; }
obj.prop2 // number

//  const obj: { prop1: "foo", prop2: 42 }

Примечание. В примере используются функции утверждений TS 3.7 . Возвращаемый тип assignявляется void, в отличие от Object.assign.

Если вы используете Typescript, вероятно, вы хотите использовать безопасность типов; в этом случае голый объект и «любой» противопоказаны.

Лучше не использовать Object или {}, а какой-нибудь именованный тип; или вы можете использовать API с определенными типами, которые вам необходимо расширить с помощью собственных полей. Я нашел это, чтобы работать:

class Given { ... }  // API specified fields; or maybe it's just Object {}

interface PropAble extends Given {
    props?: string;  // you can cast any Given to this and set .props
    // '?' indicates that the field is optional
}
let g:Given = getTheGivenObject();
(g as PropAble).props = "value for my new field";

// to avoid constantly casting: 
let k:PropAble = getTheGivenObject();
k.props = "value for props";

динамически назначать свойства объекту в TypeScript.

Для этого вам просто нужно использовать машинописные интерфейсы, например:

interface IValue {
    prop1: string;
    prop2: string;
}

interface IType {
    [code: string]: IValue;
}

Вы можете использовать это так

var obj: IType = {};
obj['code1'] = { 
    prop1: 'prop 1 value', 
    prop2: 'prop 2 value' 
};

Попробуй это:

export interface QueryParams {
    page?: number,
    limit?: number,
    name?: string,
    sort?: string,
    direction?: string
}

Тогда используйте это

const query = {
    name: 'abc'
}
query.page = 1

Единственное решение , которое полностью типобезопасный является это один , но немного многословным и сила создавать несколько объектов.

Если вам необходимо сначала создать пустой объект, выберите одно из этих двух решений. Имейте в виду, что каждый раз, когда вы используете as, вы теряете безопасность.

Более безопасное решение

Тип objectявляется безопасным внутри getObject, что средства object.aбудут иметь типstring | undefined

interface Example {
  a: string;
  b: number;
}

function getObject() {
  const object: Partial<Example> = {};
  object.a = 'one';
  object.b = 1;
  return object as Example;
}

Краткое решение

Тип внутри неobject является безопаснымgetObject , что означает, что он object.aбудет иметь тип stringеще до его назначения.

interface Example {
  a: string;
  b: number;
}

function getObject() {
  const object = {} as Example;
  object.a = 'one';
  object.b = 1;
  return object;
}