Jak mohu dynamicky přidělit vlastností k objektu na stroji?

Nebo všechny najednou:

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

Mám tendenci dát anyna druhou stranu, tj var foo:IFoo = <any>{};Takže něco takového ještě typesafe:

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; 

Případně můžete označit tyto vlastnosti jsou nepovinné:

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

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

Zkuste si to on-line

Toto řešení je užitečné, pokud váš objekt určitého typu. Stejně jako při získávání objektu na jiný zdroj.

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

Ačkoli kompilátor stěžuje, že by ještě výstup jako budete potřebovat. Bude to však fungovat.

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

A ještě jedna možnost udělat pro to, aby přístup k vlastnosti jako kolekce:

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

Aby bylo zaručeno, že typ je Object(tj páry klíč-hodnota ), použití:

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

Nejlepší je použít nouzový psaní, doporučuji vám:

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

• Případ 1:

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

• Případ 2:

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

Chcete-li zachovat předchozí typ, dočasné obsazení svůj objekt na kteroukoli

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

Nová dynamická vlastnost bude k dispozici pouze při použití obsazení:

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

Ukládat nové vlastnosti na jakémkoliv objektu typecasting to ‚každý‘:

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

Později jej můžete získat tím, že obsadí svou prodlouženou objekt zpět na ‚některý‘:

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

Můžete přidat toto prohlášení umlčet varování.

declare var obj: any;

Divím se, že žádná z odpovědí odkazovat Object.assign, protože to je ta technika mohu použít, když jsem přemýšlet o tom, „složení“ v JavaScriptu.

A funguje podle očekávání na stroji:

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

Výhody

• typ bezpečnosti celého protože nemusíte používat anytyp vůbec
• používá agregát typu strojopisem (jak je označováno &při deklarování typ objectWithAllProps), která jasně sděluje, že budeme skládat nový typ on-the-fly (tj dynamicky)

Věci mít na paměti

1. Object.assign má své vlastní jedinečné aspekty (které jsou dobře známo, že většina zkušených vývojářů JS), které by měly být považovány při psaní na psacím stroji.
   • Může být použit v měnitelného módě, nebo nezměnitelný způsobem (I demonstrovat neměnné výše popsaným způsobem, což znamená, že existingObjectzůstane nedotčen a tudíž nemá emailvlastnost. Pro většinu funkční stylu programátory, to je dobrá věc, protože je výsledkem jediná nová změna).
   • Object.assign funguje nejlépe, když máte plošší objekty. Pokud jste se kombinuje dvě vnořené objekty, které obsahují nullable vlastnosti, můžete skončit přepsání truthy hodnoty se nedefinovaná. Pokud si dávat pozor na pořadí Object.assign argumenty, měli byste být v pořádku.

Je možné přidat člena do existujícího objektu

1. rozšíření typ (čti: rozšířit / specializují na rozhraní)
2. cast původní objekt na rozšířený typ
3. přidání člena do objektu

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

Pokud používáte strojopisu, pravděpodobně budete chtít použít bezpečnostní typu; v takovém případě nahý objekt a ‚každý‘ jsou counterindicated.

Lepší nepoužívat objekt nebo {}, ale někteří s názvem typu; nebo byste mohli být pomocí rozhraní API se specifickými typy, které budete potřebovat rozšířit pomocí vlastních polí. Zjistil jsem, že se to práce:

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

dynamicky přidělit vlastnosti objektu na psacím stroji.

k tomu, že stačí použít strojopisem rozhraní jako tak:

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

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

můžete ji použít takhle

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

můžete použít toto:

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

Můžete vytvořit nový objekt založený na starém objektu pomocí operátoru spread

interface MyObject {
    prop1: string;
}

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

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

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

Strojopisem bude odvozovat všechna pole původního objektu a VSCode udělá automatické doplňování, atd.

Nejjednodušší bude sledovat

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

javascript:

myObj.myProperty = 1;

strojopisem:

myObj['myProperty'] = 1;

Pokud jste schopni používat funkce ES6 JavaScript, můžete použít počítán názvy vlastností zvládnout velmi snadno:

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

Objekt klíč [req.id] má dynamickou hodnotu