मैं गतिशील रूप से टाइपप्रति में एक वस्तु के लिए गुण निर्दिष्ट करूं?

या फिर एक ही बार में सब:

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

मैं डाल करने के लिए करते हैं anyदूसरी तरफ यानी var foo:IFoo = <any>{};तो कुछ इस तरह अभी भी 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; 

वैकल्पिक रूप से आप वैकल्पिक के रूप में इन गुणों को चिह्नित कर सकते हैं:

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

• मामला एक:

  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

अपने पिछले प्रकार किसी भी करने के लिए, अस्थायी डाली अपने वस्तु की रक्षा करने के

  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;

'कोई भी' के लिए यह typecasting द्वारा वस्तु के किसी भी प्रकार पर किसी भी नए संपत्ति स्टोर:

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

बाद में आप इसे अपने विस्तारित वस्तु 'कोई भी' के लिए वापस कास्टिंग द्वारा प्राप्त कर सकते हैं:

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

आप चेतावनी चुप्पी को यह घोषणा जोड़ सकते हैं।

declare var obj: any;

मुझे आश्चर्य है कि जवाब में से कोई भी Object.assign संदर्भ के बाद से है कि तकनीक का उपयोग मैं है जब भी मैं "रचना" जावास्क्रिप्ट में के बारे में सोचना है।

और यह काम करता टाइपप्रति में अपेक्षा के अनुरूप:

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बिल्कुल प्रकार
• टाइपप्रति की कुल प्रकार (के रूप में से दर्शाया जाता है का उपयोग करता है &जब के प्रकार की घोषणा objectWithAllProps) है, जो स्पष्ट रूप से संपर्क करता है कि हम एक नए प्रकार के द्वारा लिखे जा रहे ऑन-द-मक्खी (यानी गतिशील)

हालात से अवगत होना

1. Object.assign यह अपने अद्वितीय पहलुओं (अच्छी तरह से सबसे अनुभवी जे एस devs के लिए जाना जाता है कि) कि जब टाइपप्रति लेखन विचार किया जाना चाहिए है है।
   • यह एक अस्थायी फैशन में इस्तेमाल किया जा सकता है, या एक अपरिवर्तनीय ढंग (मैं ऊपर अपरिवर्तनीय तरह से, जिसका अर्थ है कि प्रदर्शित existingObjectअछूता रहता है और इसलिए एक भी नहीं है emailसंपत्ति। सबसे कार्यात्मक शैली प्रोग्रामर के लिए, कि एक अच्छी बात है के बाद से परिणाम है केवल नए परिवर्तन)।
   • Object.assign सबसे अच्छा आप चापलूसी वस्तुओं है जब काम करता है। आप दो नेस्टेड वस्तुओं है कि नल प्रॉपर्टी हो के संयोजन कर रहे हैं, तो आप अपरिभाषित साथ truthy मूल्यों को अधिलेखित गए हों। यदि आप Object.assign तर्कों के आदेश के लिए बाहर देखने के लिए, आप ठीक होना चाहिए।

यह द्वारा किसी मौजूदा ऑब्जेक्ट के लिए एक सदस्य को शामिल करने के लिए संभव है

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

आप टाइपप्रति का उपयोग कर रहे हैं, तो शायद आप प्रकार सुरक्षा का उपयोग करना चाहते हैं; ऐसी स्थिति में नग्न वस्तु और 'कोई भी' counterindicated कर रहे हैं।

बेहतर वस्तु या {}, लेकिन कुछ नामित प्रकार का उपयोग नहीं करने के लिए; या आप जो आप अपने खुद के क्षेत्रों के साथ विस्तार की जरूरत विशिष्ट प्रकार के साथ एक एपीआई का उपयोग हो सकता है। मैं काम करने के लिए इस मिल गया है:

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

गतिशील टाइपप्रति में एक वस्तु के लिए गुण निर्दिष्ट करते हैं।

कि तुम सिर्फ इसलिए की तरह टाइपप्रति इंटरफेस उपयोग करने की आवश्यकता करने के लिए:

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

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

आप इसे इस तरह उपयोग कर सकते हैं

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

आप इस का उपयोग कर सकते हैं:

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

आप प्रसार ऑपरेटर के जरिए पुरानी वस्तु के आधार पर नई वस्तु बना सकते हैं

interface MyObject {
    prop1: string;
}

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

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

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

टाइपप्रति मूल वस्तु के सभी क्षेत्रों का अनुमान लगा होगा और VSCode स्वतः पूर्ण करना होगा, आदि

सरल निम्नलिखित हो जाएगा

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

जावास्क्रिप्ट:

myObj.myProperty = 1;

टाइपप्रति:

myObj['myProperty'] = 1;

आप ES6 JavaScript सुविधाओं का उपयोग करने में सक्षम हैं, तो आप उपयोग कर सकते हैं परिकलित प्रॉपर्टी नामों बहुत आसानी से इस संभाल करने के लिए:

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

[Req.id] वस्तु कुंजी एक गतिशील मान है