Se eu quisesse atribuir programaticamente uma propriedade a um objeto em Javascript, faria assim:

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

Mas no TypeScript, isso gera um erro:

A propriedade 'prop' não existe no valor do tipo '{}'

Como devo atribuir qualquer nova propriedade a um objeto no TypeScript?

É possível denotar objcomo any, mas isso anula todo o objetivo do uso de texto datilografado. obj = {}implica objé um Object. Marcá-lo como anynão faz sentido. Para obter a consistência desejada, uma interface pode ser definida da seguinte maneira.

interface LooseObject {
    [key: string]: any
}

var obj: LooseObject = {};

OU para torná-lo compacto:

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

LooseObjectpode aceitar campos com qualquer sequência como chave e anydigitar como valor.

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

A verdadeira elegância dessa solução é que você pode incluir campos de segurança tipográfica na interface.

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;

Enquanto isso responde à pergunta original, a resposta aqui de @GreeneCreations pode dar outra perspectiva de como abordar o problema.

Ou tudo de uma só vez:

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

Eu costumo colocar anydo outro lado, ou seja, var foo:IFoo = <any>{};algo assim ainda é seguro:

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; 

Como alternativa, você pode marcar essas propriedades como opcionais:

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

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

Experimente online

Esta solução é útil quando seu objeto possui um tipo específico. Como ao obter o objeto para outra fonte.

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

Embora o compilador reclame, ele ainda deve gerá-lo conforme necessário. No entanto, isso vai funcionar.

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

Mais uma opção a fazer é acessar a propriedade como uma coleção:

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

Estou surpreso que nenhuma das respostas faça referência a Object.assign, pois essa é a técnica que uso sempre que penso em "composição" em JavaScript.

E funciona como esperado no 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

Vantagens

• digite segurança por toda parte, porque você não precisa usar o anytipo
• usa o tipo agregado do TypeScript (como indicado pelo &ao declarar o tipo de objectWithAllProps), que comunica claramente que estamos compondo um novo tipo on-the-fly (ou seja, dinamicamente)

Coisas para estar ciente

1. O Object.assign possui seus próprios aspectos exclusivos (que são bem conhecidos pelos desenvolvedores JS mais experientes) que devem ser considerados ao escrever o TypeScript.
   • Ele pode ser usado de maneira mutável ou imutável (eu demonstro a maneira imutável acima, o que significa que existingObjectpermanece intocado e, portanto, não possui uma emailpropriedade. Para a maioria dos programadores de estilo funcional, isso é bom, pois o resultado é a única nova mudança).
   • Object.assign funciona melhor quando você tem objetos mais planos. Se você estiver combinando dois objetos aninhados que contêm propriedades anuláveis, poderá substituir os valores de verdade por indefinidos. Se você observar a ordem dos argumentos Object.assign, deverá ficar bem.

Você pode criar um novo objeto com base no objeto antigo usando o operador de propagação

interface MyObject {
    prop1: string;
}

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

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

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

O TypeScript inferirá todos os campos do objeto original e o VSCode executará o preenchimento automático, etc.

Mais simples seguirá

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

É possível adicionar um membro a um objeto existente,

1. ampliando o tipo (leia: estenda / especialize a interface)
2. converter o objeto original no tipo estendido
3. adicione o membro ao objeto

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

Como você não pode fazer isso:

obj.prop = 'value';

Se o seu compilador TS e seu linter não o restringem, você pode escrever o seguinte:

obj['prop'] = 'value';

Se o seu compilador ou ponteiro TS for rigoroso, outra resposta seria digitar:

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

Armazene qualquer nova propriedade em qualquer tipo de objeto digitando-a como 'any':

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

Posteriormente, você pode recuperá-lo lançando seu objeto estendido de volta para 'any':

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

Para garantir que o tipo seja um Object(ou seja , pares de valores-chave ), use:

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

• Caso 1:

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

• Caso 2:

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

você pode usar isso:

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

Você pode adicionar esta declaração para silenciar os avisos.

declare var obj: any;

A melhor prática é usar a digitação segura, eu recomendo que você:

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

Para preservar seu tipo anterior, projete temporariamente seu objeto em qualquer

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

A nova propriedade dinâmica estará disponível apenas quando você usar o elenco:

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

Aqui está uma versão especial de Object.assign, que ajusta automaticamente o tipo de variável a cada alteração de propriedade. Não há necessidade de variáveis ​​adicionais, asserções de tipo, tipos explícitos ou cópias de objetos:

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 }

Nota: A amostra utiliza as funções de asserção TS 3.7 . O tipo de retorno de assigné voiddiferente Object.assign.

Se você estiver usando o Typecript, provavelmente você deseja usar o tipo safety; nesse caso, Objeto nu e 'qualquer' são contra-indicados.

Melhor não usar Object ou {}, mas algum tipo nomeado; ou você pode estar usando uma API com tipos específicos, que você precisa estender com seus próprios campos. Descobri que isso funciona:

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";

atribuir dinamicamente propriedades a um objeto no TypeScript.

para fazer isso Você só precisa usar interfaces de texto datilografado da seguinte maneira:

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

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

você pode usá-lo assim

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

Tente o seguinte:

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

Então use

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

A única solução totalmente segura para o tipo é essa , mas é um pouco prolixo e obriga a criar vários objetos.

Se você deve criar um objeto vazio primeiro, escolha uma dessas duas soluções. Lembre-se de que toda vez que você usa as, perde a segurança.

Solução mais segura

O tipo de objecté seguro por dentro getObject, o que significa que object.aserá do tipostring | undefined

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

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

Solução curta

O tipo de nãoobject é seguro por dentro getObject, o que significa que object.aserá do tipo stringmesmo antes de sua atribuição.

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

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