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

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

  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 (то есть пары ключ-значение), используйте:

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

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

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

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

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

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

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

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

declare var obj: any;

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

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

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

  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;

• Случай 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

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

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

class Given { ... }  // API specified fields; or maybe it 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' 
};

Я удивлен, что ни один из ответов не ссылается на 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: "[email protected]"
})

console.log(objectWithAllProps.email); // [email protected]

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

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

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

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

Если вы можете использовать функции ES6 JavaScript, вы можете использовать Имена вычисляемых свойств, чтобы справиться с этим очень легко:

var req = {id : 0123456};    
var response = {responses: {[req.id]: 'The 0123456 response message'}};

Ключ объекта [req.id] имеет динамическое значение