assign property to object

Advisory boards aren’t only for executives. Join the LogRocket Content Advisory Board today →

• Product Management
• Solve User-Reported Issues
• Find Issues Faster
• Optimize Conversion and Adoption
• Start Monitoring for Free

How to dynamically assign properties to an object in TypeScript

Editor’s note: This article was updated on 6 October 2023, introducing solutions like type assertions and the Partial utility type to address the TypeScript error highlighted.

JavaScript is a dynamically typed language, meaning that a variable’s type is determined at runtime and by what it holds at the time of execution. This makes it flexible but also unreliable and prone to errors because a variable’s value might be unexpected.

TypeScript, on the other hand, is a statically typed version of JavaScript — unlike JavaScript, where a variable can change types randomly, TypeScript defines the type of a variable at its declaration or initialization.

Dynamic property assignment is the ability to add properties to an object only when they are needed. This can occur when an object has certain properties set in different parts of our code that are often conditional.

In this article, we will explore some ways to enjoy the dynamic benefits of JavaScript alongside the security of TypeScript’s typing in dynamic property assignment.

Consider the following example of TypeScript code:

This seemingly harmless piece of code throws a TypeScript error when dynamically assigning name to the organization object:

See this example in the TypeScript Playground .

The source of confusion, perhaps rightly justified if you’re a TypeScript beginner, is: how could something that seems so simple be such a problem in TypeScript?

The TL;DR of it all is that if you can’t define the variable type at declaration time, you can use the Record utility type or an object index signature to solve this. But in this article, we’ll go through the problem itself and work toward a solution that should work in most cases.

The problem with dynamically assigning properties to objects

Generally speaking, TypeScript determines the type of a variable when it is declared. This determined type stays the same throughout your application. There are exceptions to this rule, such as when considering type narrowing or working with the any type, but otherwise, this is a general rule to remember.

In the earlier example, the organization object is declared as follows:

There is no explicit type assigned to this variable, so TypeScript infers a type of organization based on the declaration to be {} , i.e., the literal empty object.

If you add a type alias, you can explore the type of organization :

See this in the TypeScript Playground .

When you then try to reference the name prop on this empty object literal:

You receive the following error:

There are many ways to solve the TypeScript error here. Let’s consider the following:

Solution 1: Explicitly type the object at declaration time

This is the easiest solution to reason through. At the time you declare the object, go ahead and type it, and assign all the relevant values:

This eliminates any surprises. You’re clearly stating what this object type is and rightly declaring all relevant properties when you create the object.

However, this is not always feasible if the object properties must be added dynamically, which is why we’re here.

Solution 2: Use an object index signature

Occasionally, the properties of the object truly need to be added at a time after they’ve been declared. In this case, you can use the object index signature, as follows:

When the organization variable is declared, you can explicitly type it to the following: {[key: string] : string} .

You might be used to object types having fixed property types:

However, you can also substitute name for a “variable type.” For example, if you want to define any string property on obj :

Note that the syntax is similar to how you’d use a variable object property in standard JavaScript:

The TypeScript equivalent is called an object index signature.

Over 200k developers use LogRocket to create better digital experiences

Moreover, note that you could type key with other primitives:

Solution 3: Use the Record Utility Type

The Record utility type allows you to constrict an object type whose properties are Keys and property values are Type . It has the following signature: Record<Keys, Type> .

In our example, Keys represents string and Type . The solution here is shown below:

Instead of using a type alias, you can also inline the type:

Solution 4: Use the Map data type

A Map object is a fundamentally different data structure from an object , but for completeness, you could eliminate this problem if you were using Map .

Consider the starting example rewritten to use a Map object:

With Map objects, you’ll have no errors when dynamically assigning properties to the object:

This seems like a great solution at first, but the caveat is your Map object is weakly typed. You can access a nonexisting property and get no warnings at all:

See the TypeScript Playground .

This is unlike the standard object. By default, the initialized Map has the key and value types as any — i.e., new () => Map<any, any> . Consequently, the return type of the s variable will be any :

When using Map , at the very least, I strongly suggest passing some type information upon creation. For example:

s will still be undefined, but you won’t be surprised by its code usage. You’ll now receive the appropriate type for it:

If you truly don’t know what the keys of the Map will be, you can go ahead and represent this at the type level:

And if you’re not sure what the keys or values are, be safe by representing this at the type level:

Solution 5: Consider an optional object property

This solution won’t always be possible, but if you know the name of the property to be dynamically assigned, you can optionally provide this when initializing the object as shown below:

If you don’t like the idea of using optional properties, you can be more explicit with your typing as shown below:

Solution 6: Leveraging type assertions

TypeScript type assertion is a mechanism that tells the compiler the variable’s type and overrides what it infers from the declaration or assignment. With this, we are telling the compiler to trust our understanding of the type because there will be no type verification.

We can perform a type assertion by either using the <> brackets or the as keyword. This is particularly helpful with the dynamic property assignment because it allows the properties we want for our object to be dynamically set because TypeScript won’t enforce them.

Let’s take a look at applying type assertions to our problem case:

Note that with type assertions, the compiler is trusting that we will enforce the type we have asserted. This means if we don’t, for example, set a value for organization.name , it will throw an error at runtime that we will have to handle ourselves.

Solution 7: Use the Partial utility type

TypeScript provides several utility types that can be used to manipulate types. Some of these utility types are Partial , Omit , Required , and Pick .

For dynamic property assignments, we will focus specifically on the Partial utility type. This takes a defined type and makes all its properties optional. Thus, we can initialize our object with any combination of its properties, from none to all, as each one is optional:

In our example with the Partial utility type, we defined our organization object as the type partial Org , which means we can choose not to set a phoneNumber property:

Grouping and comparing the options for adding properties in TypeScript

In this article, we explored the different options for setting properties dynamically in TypeScript. These options can be grouped together by their similarities.

Index/Key signatures

This group of options allows you to define the type of keys allowed without limiting what possible keys can exist. The options in this group include:

• Using an object index signature
• Using the Record utility type
• Using the Map data type (with key/value typing)

With these, we can define that our object will take string indexes and decide what types to support as values, like String , Number , Boolean , or Any :

See in TypeScript Playground .

Pro: The main benefit of these methods is the ability to dynamically add properties to an object while still setting expectations for the potential types of keys and values.

Con: The main disadvantage of this way of defining objects is that you can’t predict what keys our objects will have and so some references may or may not be defined. An additional disadvantage is that if we decide to define our key signature with type Any , then the object becomes even more unpredictable.

Conditional/Optional properties

This set of object assignment methods shares a common feature: the definition of optional properties. This means that the range of possible properties are known but some may or may not be set. The options in this group include:

• Using optional object properties
• Using the Partial utility type
• Using type assertions

See this example in the TypeScript Playground , or in the code block below:

Note: While these options mean that the possible keys are known and may not be set, TypeScript’s compiler won’t validate undefined states when using type assertions. This can lead to unhandled exceptions during runtime. For example, with optional properties and the Partial utility type, name has type string or undefined . Meanwhile, with type assertions, name has type string .

Pro: The advantage of this group of options is that all possible object keys and values are known.

Con: The disadvantage is that while the possible keys are known, we don’t know if those keys have been set and will have to handle the possibility that they are undefined.

Apart from primitives, the most common types you’ll have to deal with are likely object types. In cases where you need to build an object dynamically, take advantage of the Record utility type or use the object index signature to define the allowed properties on the object.

If you’d like to read more on this subject, feel free to check out my cheatsheet on the seven most-asked TypeScript questions on Stack Overflow, or tweet me any questions . Cheers!

LogRocket : Full visibility into your web and mobile apps

LogRocket is a frontend application monitoring solution that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.

In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page and mobile apps.

Try it for free .

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on Facebook (Opens in new window)
• #typescript

Would you be interested in joining LogRocket's developer community?

Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.

Stop guessing about your digital experience with LogRocket

Recent posts:.

Exploring the React Compiler: A detailed introduction

The new React Compiler promises to streamline frontend development with React by eliminating the need for manual memoization and optimization.

Leveraging Perplexity AI for frontend development

Perplexity AI is a powerful tool that can transform how you approach development tasks, research information, and more.

User agent detection and the ua-parser-js license change

Explore the recent license change for ua-parser-js, a library for user agent detection.

Ant Design adoption guide: Overview, examples, and alternatives

In this adoption guide, we’ll explore Ant Design’s key features of Ant Design, see how to get started using it in a React project, and more.

3 Replies to "How to dynamically assign properties to an object in TypeScript"

I know this is explicitly for TypeScript, and I think type declarations should always be first. But in general, you can also use a Map object. If it’s really meant to by dynamic, might as well utilize the power of Map.

Great suggestion (updated the article). It’s worth mentioning the weak typing you get by default i.e., with respect to Typescript.

Hi, thanks for your valuable article please consider ‘keyof type’ in TypeScript, and add this useful solution if you are happy have nice time

Leave a Reply Cancel reply

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

Working with objects

JavaScript is designed on a simple object-based paradigm. An object is a collection of properties , and a property is an association between a name (or key ) and a value. A property's value can be a function, in which case the property is known as a method .

Objects in JavaScript, just as in many other programming languages, can be compared to objects in real life. In JavaScript, an object is a standalone entity, with properties and type. Compare it with a cup, for example. A cup is an object, with properties. A cup has a color, a design, weight, a material it is made of, etc. The same way, JavaScript objects can have properties, which define their characteristics.

In addition to objects that are predefined in the browser, you can define your own objects. This chapter describes how to use objects, properties, and methods, and how to create your own objects.

Creating new objects

You can create an object using an object initializer . Alternatively, you can first create a constructor function and then instantiate an object by invoking that function with the new operator.

Using object initializers

Object initializers are also called object literals . "Object initializer" is consistent with the terminology used by C++.

The syntax for an object using an object initializer is:

Each property name before colons is an identifier (either a name, a number, or a string literal), and each valueN is an expression whose value is assigned to the property name. The property name can also be an expression; computed keys need to be wrapped in square brackets. The object initializer reference contains a more detailed explanation of the syntax.

In this example, the newly created object is assigned to a variable obj — this is optional. If you do not need to refer to this object elsewhere, you do not need to assign it to a variable. (Note that you may need to wrap the object literal in parentheses if the object appears where a statement is expected, so as not to have the literal be confused with a block statement.)

Object initializers are expressions, and each object initializer results in a new object being created whenever the statement in which it appears is executed. Identical object initializers create distinct objects that do not compare to each other as equal.

The following statement creates an object and assigns it to the variable x if and only if the expression cond is true:

The following example creates myHonda with three properties. Note that the engine property is also an object with its own properties.

Objects created with initializers are called plain objects , because they are instances of Object , but not any other object type. Some object types have special initializer syntaxes — for example, array initializers and regex literals .

Using a constructor function

Alternatively, you can create an object with these two steps:

• Define the object type by writing a constructor function. There is a strong convention, with good reason, to use a capital initial letter.
• Create an instance of the object with new .

To define an object type, create a function for the object type that specifies its name, properties, and methods. For example, suppose you want to create an object type for cars. You want this type of object to be called Car , and you want it to have properties for make, model, and year. To do this, you would write the following function:

Notice the use of this to assign values to the object's properties based on the values passed to the function.

Now you can create an object called myCar as follows:

This statement creates myCar and assigns it the specified values for its properties. Then the value of myCar.make is the string "Eagle" , myCar.model is the string "Talon TSi" , myCar.year is the integer 1993 , and so on. The order of arguments and parameters should be the same.

You can create any number of Car objects by calls to new . For example,

An object can have a property that is itself another object. For example, suppose you define an object called Person as follows:

and then instantiate two new Person objects as follows:

Then, you can rewrite the definition of Car to include an owner property that takes a Person object, as follows:

To instantiate the new objects, you then use the following:

Notice that instead of passing a literal string or integer value when creating the new objects, the above statements pass the objects rand and ken as the arguments for the owners. Then if you want to find out the name of the owner of car2 , you can access the following property:

You can always add a property to a previously defined object. For example, the statement

adds a property color to car1 , and assigns it a value of "black" . However, this does not affect any other objects. To add the new property to all objects of the same type, you have to add the property to the definition of the Car object type.

You can also use the class syntax instead of the function syntax to define a constructor function. For more information, see the class guide .

Using the Object.create() method

Objects can also be created using the Object.create() method. This method can be very useful, because it allows you to choose the prototype object for the object you want to create, without having to define a constructor function.

Objects and properties

A JavaScript object has properties associated with it. Object properties are basically the same as variables, except that they are associated with objects, not scopes . The properties of an object define the characteristics of the object.

For example, this example creates an object named myCar , with properties named make , model , and year , with their values set to "Ford" , "Mustang" , and 1969 :

Like JavaScript variables, property names are case sensitive. Property names can only be strings or Symbols — all keys are converted to strings unless they are Symbols. Array indices are, in fact, properties with string keys that contain integers.

Accessing properties

You can access a property of an object by its property name. Property accessors come in two syntaxes: dot notation and bracket notation . For example, you could access the properties of the myCar object as follows:

An object property name can be any JavaScript string or symbol , including an empty string. However, you cannot use dot notation to access a property whose name is not a valid JavaScript identifier. For example, a property name that has a space or a hyphen, that starts with a number, or that is held inside a variable can only be accessed using the bracket notation. This notation is also very useful when property names are to be dynamically determined, i.e. not determinable until runtime. Examples are as follows:

In the above code, the key anotherObj is an object, which is neither a string nor a symbol. When it is added to the myObj , JavaScript calls the toString() method of anotherObj , and use the resulting string as the new key.

You can also access properties with a string value stored in a variable. The variable must be passed in bracket notation. In the example above, the variable str held "myString" and it is "myString" that is the property name. Therefore, myObj.str will return as undefined.

This allows accessing any property as determined at runtime:

However, beware of using square brackets to access properties whose names are given by external input. This may make your code susceptible to object injection attacks .

Nonexistent properties of an object have value undefined (and not null ).

Enumerating properties

There are three native ways to list/traverse object properties:

• for...in loops. This method traverses all of the enumerable string properties of an object as well as its prototype chain.
• Object.keys() . This method returns an array with only the enumerable own string property names ("keys") in the object myObj , but not those in the prototype chain.
• Object.getOwnPropertyNames() . This method returns an array containing all the own string property names in the object myObj , regardless of if they are enumerable or not.

You can use the bracket notation with for...in to iterate over all the enumerable properties of an object. To illustrate how this works, the following function displays the properties of the object when you pass the object and the object's name as arguments to the function:

The term "own property" refers to the properties of the object, but excluding those of the prototype chain. So, the function call showProps(myCar, 'myCar') would print the following:

The above is equivalent to:

There is no native way to list inherited non-enumerable properties. However, this can be achieved with the following function:

For more information, see Enumerability and ownership of properties .

Deleting properties

You can remove a non-inherited property using the delete operator. The following code shows how to remove a property.

Inheritance

All objects in JavaScript inherit from at least one other object. The object being inherited from is known as the prototype, and the inherited properties can be found in the prototype object of the constructor. See Inheritance and the prototype chain for more information.

Defining properties for all objects of one type

You can add a property to all objects created through a certain constructor using the prototype property. This defines a property that is shared by all objects of the specified type, rather than by just one instance of the object. The following code adds a color property to all objects of type Car , and then reads the property's value from an instance car1 .

Defining methods

A method is a function associated with an object, or, put differently, a method is a property of an object that is a function. Methods are defined the way normal functions are defined, except that they have to be assigned as the property of an object. See also method definitions for more details. An example is:

where objectName is an existing object, methodName is the name you are assigning to the method, and functionName is the name of the function.

You can then call the method in the context of the object as follows:

Methods are typically defined on the prototype object of the constructor, so that all objects of the same type share the same method. For example, you can define a function that formats and displays the properties of the previously-defined Car objects.

Notice the use of this to refer to the object to which the method belongs. Then you can call the displayCar method for each of the objects as follows:

Using this for object references

JavaScript has a special keyword, this , that you can use within a method to refer to the current object. For example, suppose you have 2 objects, Manager and Intern . Each object has its own name , age and job . In the function sayHi() , notice the use of this.name . When added to the 2 objects, the same function will print the message with the name of the respective object it's attached to.

this is a "hidden parameter" of a function call that's passed in by specifying the object before the function that was called. For example, in Manager.sayHi() , this is the Manager object, because Manager comes before the function sayHi() . If you access the same function from another object, this will change as well. If you use other methods to call the function, like Function.prototype.call() or Reflect.apply() , you can explicitly pass the value of this as an argument.

Defining getters and setters

A getter is a function associated with a property that gets the value of a specific property. A setter is a function associated with a property that sets the value of a specific property. Together, they can indirectly represent the value of a property.

Getters and setters can be either

• defined within object initializers , or
• added later to any existing object.

Within object initializers , getters and setters are defined like regular methods , but prefixed with the keywords get or set . The getter method must not expect a parameter, while the setter method expects exactly one parameter (the new value to set). For instance:

The myObj object's properties are:

• myObj.a — a number
• myObj.b — a getter that returns myObj.a plus 1
• myObj.c — a setter that sets the value of myObj.a to half of the value myObj.c is being set to

Getters and setters can also be added to an object at any time after creation using the Object.defineProperties() method. This method's first parameter is the object on which you want to define the getter or setter. The second parameter is an object whose property names are the getter or setter names, and whose property values are objects for defining the getter or setter functions. Here's an example that defines the same getter and setter used in the previous example:

Which of the two forms to choose depends on your programming style and task at hand. If you can change the definition of the original object, you will probably define getters and setters through the original initializer. This form is more compact and natural. However, if you need to add getters and setters later — maybe because you did not write the particular object — then the second form is the only possible form. The second form better represents the dynamic nature of JavaScript, but it can make the code hard to read and understand.

Comparing objects

In JavaScript, objects are a reference type. Two distinct objects are never equal, even if they have the same properties. Only comparing the same object reference with itself yields true.

For more information about comparison operators, see equality operators .

• Inheritance and the prototype chain

How to Add a property to an Object in TypeScript

Last updated: Feb 27, 2024 Reading time · 10 min

# Table of Contents

• Add a property to an Object in TypeScript
• Dynamically add Properties to an Object in TypeScript
• Set an Object's property name from a Variable in TypeScript
• Constructing the object's property name from multiple variables
• Using Object.assign() in TypeScript

# Add a property to an Object in TypeScript

To add a property to an object in TypeScript:

• Mark the property on the interface or type as optional.
• Use the interface to type the object.
• Add the property to the object.

We set the age property on the Person interface to optional .

Now you can initialize the object without the property and set it later on.

If you try to assign a non-numeric value to the age property, you'd get an error.

If you need to make all properties of an object optional, use the Partial utility type.

# Add any property to an object in TypeScript

You can use the Record utility type to add any property of any type to an object.

The Record utility type allows us to enforce the type of an object's values in TypeScript, e.g. type Animal = Record<string, string> .

We used a type of any for the values and a type of string for the keys in the object.

This is very broad and allows us to add any property of any type to the object.

# Add any property but type key-value pairs you know in advance

You can specify the properties and the types in an object that you know about and use the Record utility type to allow the user to add other properties.

The interface we created requires the name and age properties but also extends a type that allows any string properties with values of any type.

This is better than just using the Record utility type with string keys and any values because we get type safety when it comes to the properties we explicitly specified.

Setting a property to the incorrect type causes an error because we've already declared the name property to be of type string in the Animal interface.

I've also written an article on how to get an object's key by value in TS .

# Dynamically add Properties to an Object in TypeScript

Use an index signature to dynamically add properties to an object.

Index signatures are used when we don't know all of the names of a type's properties and the type of their values ahead of time.

The {[key: string]: any} syntax is an index signature in TypeScript and is used when we don't know all the names of a type's properties and the shape of the values ahead of time.

You might also see the index signature {[key: string]: string} in examples. It represents a key-value structure that when indexed with a string returns a value of type string .

I've also written an article on how to dynamically access an object's property .

# Explicitly typing specific properties

If the value of the string keys were set to any in the index signature, you could add properties to the object of any type, since anything is more specific than any .

This is a good way to narrow down the type of some of the properties that you know ahead of time.

For example, if I try to set the age property to a string , the type checker would throw an error because it expects a number .

We've set the age property to have a type of number , so the type checker helps us spot an error in our application.

# Using a union to dynamically add properties to an object

You can also use a union type to dynamically add properties to an object.

The keys in the object can either have a type of string or number .

Both types are allowed and you can use the union | syntax to include as many types as necessary.

If we try to set a property with a different value on the object, we'd get an error.

# Dynamically adding properties to an object with the Record type

The Record utility type constructs an object type whose keys and values are of a specified type.

We typed the object above to have keys of type string and values of type any .

If you know the type of some of the values ahead of time, specify them in an interface for better type safety.

The interface EmployeeData extends from the Record constructed type with string keys and any type values.

If we try to set the role , salary or color properties to an incompatible type, we'd get an error.

# Set an Object's property name from a Variable in TypeScript

Use computed property names to set an object's property name from a variable in TypeScript.

We set an object's property name from a variable using computed properties.

Here is an example that uses a function.

# Constructing the object's property name from multiple variables

The expression between the square brackets gets evaluated, so you could construct the object's property name by using multiple variables or concatenating strings.

You can also use a template literal .

However, notice that TypeScript was not able to type the property in the object as name and instead typed it as a more generic index signature of [x: string] (any string property).

If you are sure about the value the expression will evaluate to, use a type assertion .

Now the object is typed correctly and we can still use the dynamic nature of the computed property names feature.

# Using Object.assign() in TypeScript

To use the Object.assign() method in TypeScript, pass a target object as the first parameter to the method and one or more source objects.

The method will copy the properties from the source objects to the target object.

We used the Object.assign method to merge two source objects into a target object.

The next parameters are source objects - objects containing the properties you want to apply to the target .

# Caveats around using an existing object as the target

In the example, we passed an empty object as the target because you should generally avoid mutating objects as it introduces confusion.

For example, we could've passed obj1 as the target and obj2 as the source.

Note that the target object is changed in place.

This is especially problematic when using TypeScript because obj1 was changed in place but its type is still {name: string} , even though the object contains a country property as well.

# The return type of Object.assign in TypeScript

TypeScript uses an intersection type to type the return value of the Object.assign() method.

In other words, the return value has a type that has all of the members of all of the objects you passed to the Object.assign() method.

# The latter object wins

When you use the Object.assign() method with objects that have the same properties, the properties are overwritten by objects that come later in the parameter list.

Both of the objects in the example have a name property, so the object that is passed later in the parameters order wins.

I've also written an article on how to initialize a typed empty object in TypeScript .

# An alternative to using Object.assign

You should also consider using the spread syntax (...) as a replacement for Object.assign() .

The spread syntax (...) unpacks the properties of the objects into a new object.

This is generally a better approach because you can't shoot yourself in the foot by forgetting to provide an empty object as the first parameter of the Object.assign() method.

You can unpack as many objects as necessary into a new object and if two objects have the same property, the object that comes later wins.

Both of the objects have a name property, so the latter object wins.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• Dynamically access an Object's Property in TypeScript
• Check if a Property exists in an Object in TypeScript
• Check if Value with Unknown Type contains Property in TS
• How to Remove a Property from an Object in TypeScript
• Property is incompatible with index signature in TypeScript
• A spread argument must either have a tuple type or be passed to a rest parameter
• 'this' implicitly has type 'any' error in TypeScript [Fixed]
• Type 'string or null' is not assignable to type string (TS)
• Type Object must have a Symbol.iterator method that returns an iterator
• Type 'string' is not assignable to type in TypeScript

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

Home » JavaScript Object Methods » JavaScript Object.assign()

JavaScript Object.assign()

Summary : in this tutorial, you will learn how to use the JavaScript Object.assign() method in ES6.

The following shows the syntax of the Object.assign() method:

The Object.assign() copies all enumerable and own properties from the source objects to the target object. It returns the target object.

The Object.assign() invokes the getters on the source objects and setters on the target. It assigns properties only, not copying or defining new properties.

Using JavaScript Object.assign() to clone an object

The following example uses the Object.assign() method to clone an object .

Note that the Object.assign() only carries a shallow clone, not a deep clone.

Using JavaScript Object.assign() to merge objects

The Object.assign() can merge source objects into a target object which has properties consisting of all the properties of the source objects. For example:

If the source objects have the same property, the property of the later object overwrites the earlier one:

• Object.assign() assigns enumerable and own properties from a source object to a target object.
• Object.assign() can be used to clone an object or merge objects .

Object.assign() in JavaScript

In JavaScript, the Object.assign() function copies properties from one or more source objects to a target object. It returns the target object.

Object.assign() is commonly used to shallow copy objects, although the spread operator is generally faster than Object.assign() for shallow copying . Shallow copying is most commonly used in Redux reducers .

Multiple Sources

You can pass multiple source objects to Object.assign() . If there's multiple sources with the same property, the last one in the parameter list wins out.

More Fundamentals Tutorials

• JavaScript Array flatMap()
• How to Get Distinct Values in a JavaScript Array
• Check if a Date is Valid in JavaScript
• Encode base64 in JavaScript
• Check if URL Contains a String
• JavaScript Add Month to Date
• JavaScript Add Days to Date

Understanding Object.assign() Method in JavaScript

Cloning an object, merging objects, converting an array to an object, browser compatibility.

The Object.assign() method was introduced in ES6 that copies all enumerable own properties from one or more source objects to a target object, and returns the target object .

The Object.assign() method invokes the getters on the source objects and setters on the target object. It assigns properties only, not copying or defining new properties.

The properties in the target object are overwritten by the properties in source objects if they have the same key. Similarly, the later source objects' properties are overwritten by the earlier ones.

The Object.assign() method handles null and undefined source values gracefully, and doesn't throw any exception.

Here is how the syntax of Object.assign() looks like:

• target — The target object that is modified and returned after applying the sources' properties.
• sources — The source object(s) containing the properties you want to apply to the target object.

The Object.assign() method is one of the four ways, I explained earlier, to clone an object in JavaScript.

The following example demonstrates how you can use Object.assign() to clone an object:

Remember that Object.assign() only creates a shallow clone of the object and not a deep clone.

To create a deep clone, you can either use JSON methods or a 3rd-party library like Lodash .

The Object.assign() method can also merge multiple source objects into a target object. If you do not want to modify the target object, just pass an empty ( {} ) object as target as shown below:

If the source objects have same properties , they are overwritten by the properties of the objects later in the parameters order:

Lastly, you could also use the Object.assign() method to convert an array to an object in JavaScript. The array indexes are converted to object keys, and array values are converted to object values:

As Object.assign() is part of ES6, it only works in modern browsers. To support older browsers like IE, you can use a polyfill available on MDN.

To learn more about JavaScript objects, prototypes, and classes, take a look at this guide .

Read Next: Understanding Array.from() Method in JavaScript

✌️ Like this article? Follow me on Twitter and LinkedIn . You can also subscribe to RSS Feed .

You might also like...

• Get the length of a Map in JavaScript
• Delete an element from a Map in JavaScript
• Get the first element of a Map in JavaScript
• Get an element from a Map using JavaScript
• Update an element in a Map using JavaScript
• Add an element to a Map in JavaScript

The simplest cloud platform for developers & teams. Start with a $200 free credit.

Buy me a coffee ☕

If you enjoy reading my articles and want to help me out paying bills, please consider buying me a coffee ($5) or two ($10). I will be highly grateful to you ✌️

Enter the number of coffees below:

✨ Learn to build modern web applications using JavaScript and Spring Boot

I started this blog as a place to share everything I have learned in the last decade. I write about modern JavaScript, Node.js, Spring Boot, core Java, RESTful APIs, and all things web development.

The newsletter is sent every week and includes early access to clear, concise, and easy-to-follow tutorials, and other stuff I think you'd enjoy! No spam ever, unsubscribe at any time.

• JavaScript, Node.js & Spring Boot
• In-depth tutorials
• Super-handy protips
• Cool stuff around the web
• 1-click unsubscribe
• No spam, free-forever!

5 ways to Add a Property to object in JavaScript

To demonstrate adding new properties to JavaScript object, we will consider the following example of an employee object:

1. “object.property_name” syntax

The dot notation is the simplest way to access/modify the properties of a JavaScript object. A new property can be initialized by the following syntax:

In the below example, we are creating an “id” property with the value 130 for the employee object.

Below, the “country” property is added to a nested object which is the value of the “location” parent property in the employee object.

This approach is most ideal for the following instances:

2. Access property though “object[‘property_name’]”

The syntax based on the square brackets is an alternative approach with similar capabilities and avoids most of the disadvantages of the dot operator. The syntax for adding new property using square brackets is as follows:

In the below example, the “Last name” property cannot be directly added using dot operator syntax due to the presence of space characters . Hence, we are able to accomplish the creation of “Last name” property using square bracket syntax.

3. Create new property using Object.defineProperty()

JavaScript Object class also provides native “ defineProperty() ” method to define new properties for an object. In addition to specifying the value of the new property, “ defineProperty() ” also allow configuring the behavior for the property .

The generic syntax for “defineProperty()” is as follows:

In the below example, we define “id” property for the employee object with a value of 130 and writable as false . Hence, subsequent changes in the value of the id property are discarded. Read more about Object.defineProperty from developer.mozilla.org/Object/defineProperty .

4. Spread operator syntax “{ …object, property_name: property_value } “

In the below example, we create a copy of the employee object combined with location and id properties. Next line, “id” object is added to employee object using the spread operator .

5. Assign properties using Object.assign()

The “Object.assign()” method allows properties of the source object to be added to the target object . By defining all the new properties which need to be added to the source object, we achieve the addition of properties to a target object.

In the below example, we add the “id” property with value 670 to the employee object using Object.assign.

Related Articles

• DSA with JS - Self Paced
• JS Tutorial
• JS Exercise
• JS Interview Questions
• JS Operator
• JS Projects
• JS Examples
• JS Free JS Course
• JS A to Z Guide
• JS Formatter
• JavaScript Object.prototype.constructor Property

JavaScript Object assign() Method

• JavaScript Object create() Method
• JavaScript Object defineProperty() Method
• JavaScript Object defineProperties() Method
• JavaScript Object entries() Method
• JavaScript Object freeze() Method
• JavaScript Object getOwnPropertyDescriptor() Method
• JavaScript Object getOwnPropertyNames() Method
• JavaScript Object getOwnPropertySymbols() Method
• JavaScript Object getPrototypeOf() Method
• JavaScript Object hasOwn() Method
• JavaScript Object is() Method
• JavaScript Object isExtensible() Method
• JavaScript Object isFrozen() Method
• JavaScript Object isSealed() Method
• JavaScript Object keys() Method
• JavaScript Object preventExtensions() Method
• JavaScript Object seal() Method
• JavaScript Object setPrototypeOf() Method
• JavaScript Object toLocaleString() Method
• JavaScript Object values() Method
• JavaScript Object __defineGetter__() Method
• JavaScript hasOwnProperty() Method
• JavaScript Object isPrototypeOf() Method
• JavaScript Object propertyIsEnumerable() Method

The Object.assign() method is used to copy the values and properties from one or more source objects to a target object. It invokes getters and setters since it uses both [[Get]] on the source and [[Set]] on the target.

Parameters:  

• target : It is the target object to which values and properties have to be copied.
• sources : It is the source object from which values and properties have to be copied.

Return Value:  

Object.assign() returns the target object.

Example 1:  In this example, the properties of the object “obj1” i.e. { a: 10 } is copied to the target object “new_obj”.

Output:  

Example 2: In this example, the properties of three source objects “obj1, obj2, obj3” are copied to the target object “new_obj”. The value of any pre-existing key-value pair that existed in the previous object will be over-written. For example, obj1.b which has a value of 10 will now be overwritten with obj2.b which has a value of 20

Output :  

Example 3: In this example, the properties of three source objects “obj1, obj2, obj3” are copied to the target object “new_obj” and the target object gets the overwritten values.

Explanation:

In the above code the properties are overwritten by other objects that have the same properties later in the same order of parameters.

Applications:  

• Object.assign() is used for cloning an object, to merge objects with the same properties.

Errors and Exceptions :

• A TypeError is raised if the property is non-writable.
• The target object can be changed only if the properties are added before the error is raised.
• Object.assign() does not throw on null or undefined source values

We have a complete list of JavaScript Object methods, to check those please go through this JavaScript Object Complete Reference article.

Supported Browsers:

• Google Chrome 6.0 and above
• Internet Explorer 9.0 and above
• Mozilla 4.0 and above
• Opera 11.1 and above
• Safari 5.0 and above

Please Login to comment...

Similar reads.

• JavaScript-Methods
• javascript-object
• Web Technologies

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

JavaScript: 5 ways to add new properties to an existing object

This succinct, straightforward article will walk you through 5 different ways to add new properties to an existing object in JavaScript. We’ll write code with the modern feature of the language, such as arrow functions, spread operator syntax, etc. Without any further ado, let’s get started.

Dot Notation

Using dot notation is the simplest way to add new properties to an object. You just write the object name, followed by a dot (.), followed by the property name.

Bracket Notation

Just write the object name, followed by a pair of square brackets [] , and inside the brackets, you write the property name as a string. This is useful when the property name is not a valid identifier or when it is stored in a variable.

Object.defineProperty()

This is a static method that allows you to add a property to an object with more options, such as making it read-only, enumerable, or configurable. You pass 3 arguments to this method: the object, the property name, and an object with some descriptors for the property.

If you try to modify the new property hobby , you will end up with an error:

Spread Operator

This is an operator that allows you to create a copy of an object and add or modify some properties at the same time. You write three dots … followed by the object name, and then you write any additional properties inside curly braces {} .

Object.assign()

This is another static method that allows you to copy the properties of one or more objects into another object. You pass at least 2 arguments to this method: the target object and one or more source objects. The properties of the source objects will be copied to the target object.

This tutorial ends here. Happy coding & have a nice day!

Next Article: JavaScript: 3 Ways to Check if an Object is Empty

Previous Article: The Modern JavaScript Objects Cheat Sheet

Series: Working with Objects in JavaScript

Related Articles

• JavaScript: Press ESC to exit fullscreen mode (2 examples)
• Can JavaScript programmatically bookmark a page? (If not, what are alternatives)
• Dynamic Import in JavaScript: Tutorial & Examples (ES2020+)
• JavaScript: How to implement auto-save form
• JavaScript: Disable a Button After a Click for N Seconds
• JavaScript: Detect when a Div goes into viewport
• JavaScript Promise.any() method (basic and advanced examples)
• Using logical nullish assignment in JavaScript (with examples)
• Understanding WeakRef in JavaScript (with examples)
• JavaScript Numeric Separators: Basic and Advanced Examples
• JavaScript: How to Identify Mode(s) of an Array (3 Approaches)
• JavaScript: Using AggregateError to Handle Exceptions

Search tutorials, examples, and resources

• PHP programming
• Symfony & Doctrine
• Laravel & Eloquent
• Tailwind CSS
• Sequelize.js
• Mongoose.js

JavaScript Standard Objects: assign, values, hasOwnProperty, and getOwnPropertyNames Methods Explained

In JavaScript, the Object data type is used to store key value pairs, and like the Array data type, contain many useful methods. These are some useful methods you'll use while working with objects.

Object Assign Method

The Object.assign() method is used to

• add properties and values to an existing object
• make a new copy of an existing object, or
• combine multiple existing objects into a single object.

The Object.assign() method requires one targetObject as a parameter and can accept an unlimited number of sourceObjects as additional parameters.

It's important to note here is that the targetObject parameter will always be modified. If that parameter points to an existing object, then that object will be both modified and copied.

If, you wish to create a copy of an object without modifying that original object, you can pass an empty object {} as the first ( targetObject ) parameter and the object to be copied as the second ( sourceObject ) parameter.

If objects passed as parameters into Object.assign() share the same properties (or keys), property values that come later in the parameters list will overwrite those which came earlier.

Return Value

Object.assign() returns the targetObject .

Modifying and copying targetObject :

Copying targetObject without modification:

Objects with the same properties :

Object Values Method

The Object.values() method takes an object as a parameter and returns an array of its values. This makes it useful for chaining with common Array methods like .map() , .forEach() , and .reduce() .

Return value

An array of the passed object's ( targetObject ) values.

If the object you're passing has numbers as keys, then Object.value() will return the values according to the numerical order of the keys:

If something other than an object is passed to Object.values() , it will be coerced into an object before being returned as an array:

Object hasOwnProperty Method

The Object.hasOwnProperty() method returns a boolean indicating if the object owns the specified property.

This is a convenient method to check if an object has the specified property or not since it returns true/false accordingly.

Object.hasOwnProperty(prop)

Using Object.hasOwnProperty() to test if a property exist or not in a given object:

Object getOwnPropertyNames Method

The Object.getOwnPropertyNames() method takes an object as a parameter and returns and array of all its properties.

An array of strings of the passed object's properties.

If something other than an object is passed to Object.getOwnPropertyNames() , it will be coerced into an object before being returned as an array:

Promise.prototype.then

A Promise.prototype.then function accepts two arguments and returns a Promise.

The first argument is a required function that accepts one argument. Successful fulfillment of a Promise will trigger this function.

The second argument is an optional function that also accepts one argument of its own. A thrown Error or Rejection of a Promise will trigger this function.

Promise.prototype.then allows you to perform many asynchronous activities in sequence. You do this by attaching one then function to another separated by a dot operator.

Map.prototype.entries

Returns a new Iterator object that contains the [key, value] pairs for each element in the Map object in insertion order.

More info on objects in JavaScript:

• How to create objects in JavaScript
• How to loop through objects in JavaScript

More info about booleans:

• Booleans in JavaScript

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

JS Tutorial

Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript object properties, property management methods, javascript object.defineproperty().

The Object.defineProperty() method can be used to:

• Adding a new property to an object
• Changing property values
• Changing property metadata
• Changing object getters and setters

Adding a new Property

This example adds a new property to an object:

Changing a Property Value

This example changes a property value:

Property Attributes

All properties have a name. In addition they also have a value.

The value is one of the property's attributes.

Other attributes are: enumerable, configurable, and writable.

These attributes define how the property can be accessed (is it readable?, is it writable?)

In JavaScript, all attributes can be read, but only the value attribute can be changed (and only if the property is writable).

( ECMAScript 5 has methods for both getting and setting all property attributes)

Changing Meta Data

The following property meta data can be changed:

Getters and setters can also be changed:

This example makes language read-only:

This example makes language not enumerable:

Advertisement

JavaScript getOwnPropertyNames()

The Object.getOwnPropertyNames() method can:

• List object properties

List all Object Properties

This example gets all properties of an object:

Object.getOwnPropertyNames() will also list properties that is not enumerable:

JavaScript Object.keys()

The Object.keys() method can:

• List enumerable object properties

List Enumerable Object Properties

This example uses Object.keys() insted of Object.getOwnPropertyNames() :

The getOwnPropertyNames() method returns all properties.

The Object.keys() method returns all enumerable properties.

If you define object properties without enumerable:false , the two methods will return the same.

Adding Getters and Setters

The Object.defineProperty() method can also be used to add Getters and Setters:

A Counter Example

Prototype properties.

JavaScript objects inherit the properties of their prototype.

The delete keyword does not delete inherited properties, but if you delete a prototype property, it will affect all objects inherited from the prototype.

Complete Object Reference

For a complete reference, go to our:

Complete JavaScript Object Reference .

The reference contains descriptions and examples of all Object Properties and Methods.

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Popular Tutorials

Popular examples, reference materials, learn python interactively, javascript object methods.

• JavaScript assign()
• JavaScript create()
• JavaScript defineProperties()
• JavaScript defineProperty()
• JavaScript entries()
• JavaScript freeze()
• JavaScript fromEntries()
• JavaScript getOwnPropertyDescriptor()
• JavaScript getOwnPropertyDescriptors()
• JavaScript getOwnPropertyNames()
• JavaScript getOwnPropertySymbols()
• JavaScript getPrototypeOf()
• JavaScript hasOwnProperty()
• JavaScript is()
• JavaScript isExtensible()
• JavaScript isFrozen()
• JavaScript isPrototypeOf()
• JavaScript isSealed()
• JavaScript keys()
• JavaScript preventExtensions()
• JavaScript propertyIsEnumerable()
• JavaScript seal()
• JavaScript setPrototypeOf()
• JavaScript toLocaleString()
• JavaScript toString()
• JavaScript valueOf()
• JavaScript values()

JavaScript Tutorials

JavaScript Object.keys()

JavaScript Object.values()

JavaScript Object.getOwnPropertyNames()

JavaScript Object.is()

• Javascript Object.defineProperties()
• JavaScript Object.entries()

JavaScript Object.assign()

The Object.assign() method copies all the enumerable properties of the given objects to a single object and returns it.

assign() Syntax

The syntax of the assign() method is:

Here, assign() is a static method. Hence, we need to access the method using the class name, Object .

assign() Parameters

The assign() method takes in:

• target - the target object to which we will copy all the properties of the sources .
• sources - the source object(s) whose properties we want to copy.

assign() Return Value

The assign() method returns the target object.

Note: Properties in the target object are overwritten by properties in the sources if they have the same key.

Example 1: Javascript Object.assign() to Clone Objects

In the above example, we have used the assign() method to assign the contents of obj to newObject .

Since assign() modifies the target object and returns the same object, both copy and newObject are clones of one another. As a result, we get identical outputs when we print them both.

Example 2: assign() to Merge Objects

In the above example, we have used assign() to merge the objects o1 , o2 , and o3 into a new object o4 .

Using the empty object {} as a target object ensures that the properties of the other objects are copied to a new object without modifying any of the source objects.

As can be seen from the output, properties of later objects overwrite that of earlier ones. For example,

• the b key from o1 is overwritten by its counterpart in o2 .
• the c keys from o1 and o2 are overwritten by their counterpart in o3 .

Note: If the source value is a reference to an object, it only copies the reference value.

Sorry about that.

Related Functions

JavaScript Library

Unreal Engine 5 Documentation has been moved to the Epic Developer Community

Property Specifiers

Keywords used when declaring uproperties to specify how the property behaves with various aspects of the engine and editor..

Choose your operating system:

Metadata Specifiers

When declaring properties, Property Specifiers can be added to the declaration to control how the property behaves with various aspects of the Engine and Editor.

When declaring classes, interfaces, structs, enums, enum values, functions, or properties, you can add Metadata Specifiers to control how they interact with various aspects of the engine and editor. Each type of data structure or member has its own list of Metadata Specifiers.

Metadata only exists in the editor; do not write game logic that accesses metadata.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How can I create an object and add attributes to it?

I want to create a dynamic object in Python and then add attributes to it. This didn't work:

AttributeError: 'object' object has no attribute 'somefield'

For details on why it doesn't work, see Can't set attributes on instance of "object" class .

• 9 Why are you doing this? A generic "object" has no actual meaning . What is the meaning of the thing you are creating? Why is it not a proper class or namedtuple? –  S.Lott Commented May 13, 2010 at 14:45
• 3 The example is not minimal and confusing for me or I just don't see why you don't work with some a = object() and you need obj.a = object() . Again I am talking about the example, in your actual code an object inside an object might be useful. –  kon psych Commented Jul 25, 2017 at 2:51

18 Answers 18

The built-in object can be instantiated but can't have any attributes set on it. (I wish it could, for this exact purpose.) This is because it doesn't have a __dict__ to hold the attributes.

I generally just do this:

But consider giving the Object class a more meaningful name, depending on what data it holds.

Another possibility is to use a sub-class of dict that allows attribute access to get at the keys:

To instantiate the object attributes using a dictionary:

• 11 it can be instantiated, just not used for anything useful once it has been done. foo = object() works, but you just can't do much of anything with it –  Daniel DiPaolo Commented May 13, 2010 at 14:43
• 2 great answer, the only thing I changed was to use Struct as the name of the class to make it more obvious. Saved me a ton of typing [" and "] , Cheers! –  pragman Commented Oct 22, 2016 at 14:16

You could use my ancient Bunch recipe, but if you don't want to make a "bunch class", a very simple one already exists in Python -- all functions can have arbitrary attributes (including lambda functions). So, the following works:

Whether the loss of clarity compared to the venerable Bunch recipe is OK, is a style decision I will of course leave up to you.

• 5 @naught101, a function is an object, in Python, so your objection is unfathomable. –  Alex Martelli Commented Jan 26, 2015 at 6:02
• 8 @naught101, avoiding the creation of a new type (reusing an existing one) does not complicate, it simplifies. Nowadays on might actually prefer from argparse import Namespace though I wish it lived elsewhere *e.g, collection ) -- again reusing a now-existing type, just a better one, and still avoiding new-type creation. But, it wasn't there then:-). –  Alex Martelli Commented Jan 26, 2015 at 14:58
• 1 I was looking for exactly this functionality, but from argparse import Namespace is so counter intuitive. Has it ever been suggested to move it, indeed, to collections ? –  schatten Commented Jan 30, 2015 at 8:22
• 1 See answer below from "J F Sebastian" regarding SimpleNamespace from the types module. If your version of python supports it, this is the best solution (and exactly what SimpleNamespace is designed for) –  Tim Richardson Commented Feb 4, 2016 at 23:40
• 1 @AlexMartelli Except that dynamically slapping more attributes onto some object that happens to be a callable has nothing to do with lambda calculus and is by all means "hacky" - abusing some random object that had no intention of being a dictionary for you, but just so happens to work. Not that I don't like lambda calculus. I really do. –  Elliot Cameron Commented Jan 24, 2019 at 6:35

There is types.SimpleNamespace class in Python 3.3+ :

collections.namedtuple , typing.NamedTuple could be used for immutable objects. PEP 557 -- Data Classes suggests a mutable alternative.

For a richer functionality, you could try attrs package . See an example usage . pydantic may be worth a look too .

• 4 If you need something that works with Python 2.7, you can also try the argparse.Namespace class –  RolKau Commented Aug 26, 2016 at 20:09
• @Roel attrs package supports Python 2.7 –  jfs Commented Sep 11, 2018 at 17:27
• This seems a better solution to me than unittest.mock; the latter is a bit too heavy-weight and a bit more malleable. With a mock object, simply assigning to an attribute will cause it to spring into existence; SimpleNamespace will resist that. –  jdzions Commented Feb 4, 2020 at 0:14

You can also use a class object directly; it creates a namespace:

• 6 I don't understand why this is not the top answer? –  confiq Commented May 4, 2021 at 15:03
• @confiq it doesn't say anything that the top answer is missing. –  Karl Knechtel Commented Aug 13, 2022 at 9:40
• 1 @KarlKnechtel This answer uses a custom class directly, while the top answer instantiates a custom class. –  Ernesto Commented Aug 7, 2023 at 7:30
• Easy to make mistakes with this (e.g. reusing the class). Instantiating an object is much more robust. –  Mateen Ulhaq Commented Nov 6, 2023 at 12:12

The mock module is basically made for that.

• 6 Disadvantge is that's an external dependency –  Kangur Commented Mar 16, 2017 at 17:17
• 14 unittest.Mock is a part of the standard library since Python 3.3 ( docs.python.org/3/library/unittest.mock.html ) –  illagrenan Commented Dec 18, 2017 at 13:03
• 3 Depends on the usage of your code I think. If it is production code, I would not want some mock in it. Just feels weird to me. –  Mike de Klerk Commented Feb 28, 2019 at 19:18

There are a few ways to reach this goal. Basically you need an object which is extendable.

• 20 obj.a = type('', (), {}) –  iman Commented Jan 30, 2014 at 15:37

Now you can do (not sure if it's the same answer as evilpie):

• @evilpie's answer sets attributes directly on MyObject (the class), not its instance like yours. –  jfs Commented Nov 30, 2015 at 15:04

Try the code below:

• 1 Can you explain more of what this does? while the code may be useful for solving this problem, having it explained can go a lot further than just one problem. –  DeadChex Commented Jul 23, 2015 at 20:52
• 2 @DeadChex Clearly it creates a new Class(object) which is a empty class with object properties, and stores the attributes inside the class. This is even better than install more modules, or rely in lambdas. –  m3nda Commented May 15, 2017 at 23:08
• 2 Not sure why this does not have more upvotes. Is there a reason not to use this for a basic container class? Seems to work fine in Python 2.7, 2.6, and 3.4 –  user5359531 Commented Jun 14, 2017 at 17:21
• So how does this set the value of an attribute whose name is contained in a separate variable? –  GLRoman Commented Aug 31, 2021 at 4:41

as docs say :

Note : object does not have a __dict__ , so you can’t assign arbitrary attributes to an instance of the object class.

You could just use dummy-class instance.

These solutions are very helpful during testing. Building on everyone else's answers I do this in Python 2.7.9 (without staticmethod I get a TypeError (unbound method...):

If we can determine and aggregate all the attributes and values together before creating the nested object, then we could create a new class that takes a dictionary argument on creation.

We can also allow keyword arguments. See this post .

To create an object from a dictionary:

• 1 Another way is types.SimpleNamespace(**d) . –  Mateen Ulhaq Commented Nov 6, 2023 at 12:36
• Thanks for sharing! This is why I always scroll down. –  Bruno Bronosky Commented Dec 8, 2023 at 15:20

Which objects are you using? Just tried that with a sample class and it worked fine:

And I got 123 as the answer.

The only situation where I see this failing is if you're trying a setattr on a builtin object.

Update: From the comment this is a repetition of: Why can't you add attributes to object in python?

• b.c is set to object() not a defined class –  John Commented May 13, 2010 at 15:08

I think the easiest way is through the collections module.

if you are looking for chain assignment, to do things such as django model template abstract attribute assigning:

which allows you to pass model as a target , and assign end attribute to it.

Coming to this late in the day but here is my pennyworth with an object that just happens to hold some useful paths in an app but you can adapt it for anything where you want a sorta dict of information that you can access with getattr and dot notation (which is what I think this question is really about):

This is cool because now:

So this uses the function object like the above answers but uses the function to get the values (you can still use (getattr, x_path, 'repository') rather than x_path('repository') if you prefer).

Other way i see, this way:

• you can add in append the name attr this di[name].append([at,cmds.getAttr(name+'.'+at)[0]]) –  Pablo Emmanuel De Leo Commented May 13, 2016 at 18:08
• 1 This is adding a very big non-standard dependency while a simple class a: pass gives all the power required. –  Alexis Paques Commented Jun 28, 2018 at 13:43

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python class object attributes or ask your own question .

• The Overflow Blog
• Community Products Roadmap Update, July 2024
• Featured on Meta
• We spent a sprint addressing your requests — here’s how it went
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• Policy: Generative AI (e.g., ChatGPT) is banned
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• Plane to train in Copenhagen
• Who first promoted the idea that the primary purpose of government is to protect its citizens?
• Segments of a string, doubling in length
• Why does `p` not put all yanked lines when copying across files?
• Why danach instead of darüber?
• Orange marks on ceiling underneath bathroom
• As an advisor, how can I help students with time management and procrastination?
• Questions about mail-in ballot
• Sort Number Array
• Spec sheet on Shimano FC-C201 seemingly does not match my bike
• My previously healthy avocado plant was pruned bare and has since been turning brown on top
• When Canadian citizen residing abroad comes to visit Canada
• Are there any parts of the US Constitution that state that the laws apply universally to all citizens?
• Can the U. S. Supreme Court decide on agencies, laws, etc., that are not in front of them for a decision?
• Sci-fi book series about a teenage detective, possibly named Diamond, with a floating AI assistant
• TWR of near-term NTR engines
• How much damage does my Hexblade Warlock deal with their Bonus Action attack?
• Why does independent research from people without formal academic qualifications generally turn out to be a complete waste of time?
• What is the answer to this problem? What should be applied here? PRA? RS? RV?
• GDPR Data Processor
• Rear disc brakes work intermittently
• How would we write code for a smile with a dot underneathe it?
• Major church father / reformer who thought Paul is one of the 24 elders in Rev 4:4 and/or one of the 12 apostles of the Lamb in Rev 21:14
• Should "as a ..." and "unlike ..." clauses refer to the subject?