Hogyan dinamikusan hozzárendelni tulajdonságokat egy objektum géppel?

Vagy minden egy menetben:

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

Hajlok arra, hogy tegye anya másik oldalon, azaz var foo:IFoo = <any>{};Szóval valahogy így még 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; 

Másik lehetőség, hogy jelölje meg ezeket a tulajdonságokat, mint választható:

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

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

Próbáld meg online

Ez a megoldás akkor hasznos, ha a tárgy bizonyos típusú. Mint amikor megszerzése az objektum más forrásból.

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

Bár a fordító kifogásolja azt még kimenetet, amit igényelnek. Azonban ez működni fog.

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

Egy újabb lehetőség tenni, hogy elérni az ingatlan, mint egy gyűjtemény:

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

Annak biztosítására, hogy a típus egy Object(azaz kulcsértékpárokat ) használja:

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

A legcélszerűbb használni biztonságos gépelés, azt javasoljuk, hogy:

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

• 1. eset:

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

• 2. eset:

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

Megőrizni a korábbi típusú, ideiglenes öntött a tárgyat bármely

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

Az új, dinamikus tulajdonság csak akkor áll rendelkezésre, ha a szereplők:

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

Tárolja az új ingatlan bármilyen objektum typecasting hogy „bármilyen”:

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

Később megszerezheti azt öntéssel a kiterjedt tárgy vissza a „minden”:

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

Felveheti ezt a nyilatkozatot, hogy elhallgattassa a figyelmeztetéseket.

declare var obj: any;

Meglep, hogy sem a válaszok referencia Object.assign hiszen ez a technika, amit használni, amikor arra gondolok, „kompozíció” a JavaScript.

És ez a várt módon működik géppel:

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

Előnyök

• írja biztonsági egész, mert nem kell használni a anytípus egyáltalán
• használja géppel összesített típusát (ezt jelzi &, amikor kimondja a fajta objectWithAllProps), amely világosan kommunikálja, hogy mi alkotó új típusú on-the-fly (azaz dinamikusan)

A dolgok, hogy tisztában

1. Object.assign megvan a saját egyedi szempontjait (amelyek jól ismertek a legtapasztaltabb JS devs), hogy figyelembe kell venni az írás géppel.
   • Ezt fel lehet használni a változékony módon, vagy megváltoztathatatlan módon (I bizonyítani a megváltoztathatatlan fenti módon, ami azt jelenti, hogy existingObjectmarad érintetlen, és ezért nem rendelkezik emailtulajdon. A legtöbb funkcionális stílusú programozók, hogy ez egy jó dolog, mivel az eredmény az egyetlen új változás).
   • Object.assign működik a legjobban, ha van laposabb tárgyakat. Ha kombináljuk a két beágyazott objektumokat tartalmazó nullképes tulajdonságait, akkor a végén felülírása truthy értékeket definiált. Ha vigyázz a sorrendben a Object.assign érvek, akkor legyen finom.

Lehetőség van hozzá egy tagot egy meglévő objektum

1. szélesedő típus (értsd: meghosszabbítása / specializálódtak a felület)
2. öntött az eredeti objektumot a kiterjesztett típusú
3. hozzá a tag az objektum

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

Ha ön használ géppel, feltehetően a használni kívánt típusú biztonság; Ebben az esetben meztelen Object és a „minden” van counterindicated.

Jobb, hogy nem használja Object vagy {}, de néhány megnevezett típusú; vagy lehet, hogy egy API használatával konkrét típusokat, amelyben meg kell terjeszteni a saját területeken. Azt találtuk, hogy ez a munka:

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

dinamikusan hozzárendelni tulajdonságokat egy objektum géppel.

Ehhez meg csak meg kell használni géppel interfészek így:

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

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

akkor tudja használni, így

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

akkor használja ezt:

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

Hozhat létre új objektumot alapján a régi objektumot terjedésének operátor

interface MyObject {
    prop1: string;
}

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

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

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

Géppel fogja következtetni az összes mezőt az eredeti objektum és VSCode fog tenni az automatikus kiegészítés, stb

Legegyszerűbb lesz a következő

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

Javascript:

myObj.myProperty = 1;

Gépelt:

myObj['myProperty'] = 1;

Ha tudja használni ES6 JavaScript funkciókat használhatja Computer tulajdonságnevei kezelni ezt nagyon egyszerűen:

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

A [req.id] objektum kulcs tartalmaz egy dinamikus értéket