JavaScript Objects | Complete Guide
JavaScript Objects
Similar to other programming languages javascript objects is a collection of key-value pairs, where each key is a string and each value can be of any data type.
Ways to create JavaScript Object
Object liternal Notation The simplests way that you will use 98% of time.
const scorcism = { name: "Abhishek", age:21 }
The key-value pairs are enclosed within curly braces
{}
Using the
new
Keyword Creating objects with constructor functions and thenew
keyword. You will use this only 1.8% of the timefunction About(name, age, city) { this.name = name; this.age = age; this.city = city; } const me = new About("Abhishek", 21, "Mumbai");
Using Object.create() This method allows creating a new object with specified prototype object. You will use this only 0.2% of the time
const aboutData = { greet:function(){ return `Hello, my is ${this.name}`; // {this.name} is the key of this object } } const me = Object.create(aboutData); me.name = 'Abhishek' me.age = 21;
Don't worry much about this :)
Accessing Object Properties
Properties of JS object can be accessed using dot notation and bracket notation.
const me = {
name: "Abhishek",
age:21
}
console.log(me.name);
console.log(me["age"]);
Try run the code snippet.
(The undefined
after each console log is the return value fo the console.log
function itself. Relax, Nothing to worry🕺)
Object Prototypes and Inheritance
At the core of JS, lies the concept of prototype. Every object in JS is associated with a prototype object, which acts as a blueprint for that object.
In short; object prototype serves as a template for creating new objects.
This prototype object contains properties and method that are accessible to all instances created from it.🍰
Inheritance is acheived by linking objects through their prototypes. Consider Object.create() that we used above. It is an method that creates a new object.
Static Method
(Try😃)
Object.keys()
Returns an array of a given object's own enumerable property names.
TL;DR Object.keys() method will return list of keys.
NOTE: Own enumerable refers to the properties of an object that are both owned by the object itself (Not inherited from its property chain)
const aboutMe= { name: "Abhishek", age:21 } let aboutMeKeys = Object.keys(aboutMe); // Expected Output: [ 'name', 'age' ]
Object.values()
Return an array of a given object's own enumerable property values.
TL;DR Object.values() method will return list of values.
const aboutMe= { name: "Abhishek", age:21 } let aboutMeKeys = Object.values(aboutMe); // Expected Output: [ 'Abhishek', 21 ]
Object.assign()
Copies the values of all enumerable own properties from one or more source objects to a target object.
const target = {age: 21} const source = {name: "Abhishek"} const merged = Object.assign(target, source); console.log(merged) // Expected Output: { age: 21, name: 'Abhishek' }
Note: You can add any number of source args.
target will contain the modified object.
console.log(merged === target) // Expected Output: true
Object.create()
Create new object, using an existing object as the prototype.
const me = { name: "Abhishek", eatsAppleDaily: false, printAbout: function(){ console.log(`I am ${this.name}. and I ${this.eatsAppleDaily ? "eat" :"don't eat"} apple daily.`); } }; // Creating a myFriend Object inheriting from me. const myFriend = Object.create(me); // He is my child now😃. myFriend.name = "Ladoo"; myFriend.eatsAppleDaily = true; console.log(me.printAbout()); // Expected Output: I am Abhishek. and I don't eat apple daily. console.log(myFriend.printAbout()); // Expected Output: I am Ladoo. and I eat apple daily.
Object.entries()
Return array of he given object's own enumerable string-keyed property key-value pair😒.
It returns an array where each element is a key-value pair of the object. Each key-value pair is represented as an array with two elements: the key as the first element and the corresponding value as the second element.
const me = { name:"Abhishek", age:21 } console.log(Object.entries(me)) // Expected output: [ [ 'name', 'Abhishek' ], [ 'age', 21 ] ]
Object.fromEntries()
Object.fromEntries transforms a list of key-value pairs into an object.
TL;DR Oppsite of Object.entries().
const me = [ [ 'name', 'Abhishek' ], [ 'age', 21 ] ] console.log(Object.fromEntries(me)) // Expected output: { name: 'Abhishek', age: 21 }
Object.freeze()
The Object.freeze() is a method that "freezes" an object.
When you freeze an object, you prevent new properties from being added to it, existing properties from being removed or changed, and also prevent the prototype from being changed.
const me = { name:"Abhishek", age:21 } Object.freeze(me); // Freezing the object me.name = "scorcism"; me.age = 22; console.log(me) // Expected output: { a: 1, b: 2 }
Changes are not affected to the object
Object.isFrozen()
Determines if the object is frozen
const me = { name:"Abhishek", age:21 } Object.freeze(me); console.log(Object.isFrozen(me)) // Expected output: true
Object.seal()
Object.seal() is a method that "seals" an object.
Sealing an object prevent new properties from being added to it and marks all existing properties an non-configurable (i.e prevent them from bein deleted or theri attributes from being changed).
const me = { name:"Abhishek", age:21 } Object.seal(me); me.name = "scorcism"; // This change will be affected delete me.age; // This deleting will not take effect console.log(me) // Expected Output: { name: 'scorcism', age: 21 }
Note:
Object.freeze()
prevents any changes to the object, whileObject.seal()
allows changes to existing properties but prevents addition or removal of properties.Object.isSealed() Determines if an object is sealed.
const me = { name:"Abhishek", age:21 } Object.seal(me); console.log(Object.isSealed(me)); // Expected output: true
Inheritance static method
Before moving to instance static methods, Lets get idea of this
keyword in object
Suppose we have an Object
const person = { name: 'Abhishek' };
So If we add a function in the object; this
will refer to all the properties of the same object
const person = {
name: 'Abhishek',
sayMyName: function() {
return `My name is ${this.name}`;
}
};
console.log(person.sayMyName());
// Expected Output: My name is Abhishek
As you can observe here, this.name
is replaced with the key name
value.
Now that you have idea of this
keyword usecase, lets continue further
1.. prototype.bind()
The bind()
method creates a new function that, when called, has its this
keyword set to the provided value. This is usefull when we want to borrow a method from one object and use it in the context of other object,
function sayMyName (){
return `My name is ${this.name}`
}
const person = {
name: 'Abhishek',
sayMyName: sayMyName
};
console.log(person.sayMyName());
// Expected Output: My name is Abhishek
const person2 = {
name: 'Walter'
}
const person2NameFunc = sayMyName.bind(person2);
console.log(person2NameFunc());
// Expected Output: My name is Walter
for the person2NameFunc the person object this.name
is taken from the person2 object as we have bind the sayMyName
function with person2 object.
2.. prototype.call()
The call()
method is used to call a function with given this
value and arguments provided individaully.
function introduce(language) {
console.log(`I code in ${language}. My name is ${this.name}.`);
}
const mySelf = {
name: "Abhishek"
}
introduce.call(mySelf, 'Java');
// Expected output: I code in Java. My name is Abhishek.
Here, the introduce function takes a language argument and logs information about the language and the person's name.
The call() method is used to invoke this function with the mySelf object as the this value, allowing access to its properties.
Unlike bind()
, which creates a new function with a specified this
value, call()
directly invokes the function with the specified this
value along with individual arguments.
3.. prototype.apply()
The apply()
method is similar to call()
, but insted of accepting arguments individually, it accepts arguments as an array.
function add(...args){
let sum = args.reduce((acc, curr)=> acc + curr, 0 );
console.log(sum);
}
const numbers = [1,2,3,4,5];
add.apply(null, numbers)
// Expected output: 15
When to use call, bind and apply
call: Use
call
when you want to execute a function immediately and specify whatthis
should refer tobind: Use
bind
when you want to create a new function that, when executed later, has a predeterminfthis
valueapply" Use
apply
when you have an array of arguments that you want to pass to a function.
PS: The reason to use my name everywhere is that, while reading, whenever you see my name, you will tend to try it with your name too
These are the most common one to use, You can explore more here
If the article helps you, leave a like, follow, or anything 🙂.
You can follow me on LinkedIn, GitHub, Dev.to and hashnode.
Bye🍕
Subscribe to my newsletter
Read articles from Abhishek Pathak directly inside your inbox. Subscribe to the newsletter, and don't miss out.
Written by
Abhishek Pathak
Abhishek Pathak
A Learner. Learning things which will exist,