If you're at all familiar with JavaScript, you've probably heard that JavaScript is an Object-oriented programming language. An object is just a collection of properties and a property is a mapping from a name
to a value
. This name can be any number
, identifier
, or string
. The value
can either be a simple value(like 234
, hello
) or a function in which case the property is known as a method. A method simulates the behaviour of the real-world objects, if we think that the simple key: value
depicts characteristics of the object. Now, I won't bore you with these cringe analogies, so let's dive deeper.
The browser has many objects predefined like the `window` object. The below tree sums up the predefined objects in JavaScript very nicely.
In addition to these objects, you can define your own "custom" objects in JavaScript.
Creating new objects
There are three ways you can define your own objects in JS.
Using object initializers
Object initializers are also known as object literals. These seem consistent with the terminology used by C++ for array initialization using an initializer list.
const myObject = {
property: value1, //name can be identifier,
2: value2, //or a number,
"property n": value3, //or a string
};
For deeper dive into the object initializer you can refer here.
we stored a reference to the defined object in myObject
variable, for later use. If we don't have any later use, then we can avoid storing its reference.
Note: You may need to wrap this object literal in parenthesis, if you wish to use this in an expression, to avoid confusion with a block statement.
Object literals are expressions, and each object literal results in a new object being created whenever the statement in which it appears is executed. Identical object literals 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:
let x;
if (cond) {
x = {greeting: "hi there"}; //obj literals are expressions
}
The following example creates myHonda
with three properties. Note that the engine
property is also an object with its own properties.
const myHonds = {
color: "red",
wheels: 4,
engine: {cylinders: 4, size: 2.2},
};
Objects created with object literals are called plain objects because they are instances of the Object type of JavaScript, but not any other object type. Some object types have special initializer syntaxes -- for example, array intializer and regex literals.
The Object type represents one of JavaScript's data types which is used for storing various keyed collections and more complex entities. Objects can be created using
Object()
constructor or the object literals. Nearly all objects in JS are instances of Object; a typical object inherits properties (including methods) fromObject.prototype,
although these properties may be shadowed (a.k.a. overriden).Changes to the
Object.prototype
object are seen by all objects through prototype chaining, unless the properties and methods subject to those changes are overridden further along the prototype chain. This provides a very powerful although potentially dangerous mechanism to override or extend object behavior. To make it more secure,Object.prototype
is the only object in the core JavaScript language that has immutable prototype — the prototype ofObject.prototype
is alwaysnull
and not changeable.
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:
// defining a constructor function to create an object type - a blueprint of the object.
function Car(make, model, year) {
this.make = make;
this.model = model;
this.year = year;
}
You will think that the syntax for defining this so-called constructor function is the same as a regular function with a weird `this` keyword popping up in the function body, and you'd be right. It is just a regular function. You can define this function even this way also:
// defining a constructor function.
// Avoid using the arrow expression syntax while defining the constructor function.
//You can remember a general rule to not use this keyword in a arrow function, because of its weird behaviour.
const Car = function (make, model, year) {
this.make = make;
this.model = model;
this.year = year;
}
We are calling this a constructor function, because of the way we're going to call this function. The this
keyword is used to assign values to the object's properties based on the values passed to the function.
Now, we can create an object called myCar
as follows:
const myCar = new Car("Eagle", "Talon TSi", 1993);
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.
const kenscar = new Car("Nissan", "300ZX", 1992);
const vpgscar = new Car("Mazda", "Miata", 1990);
An object can have a property that is itself another object. For example, suppose you define an object called Person
as follows:
function Person(name, age, sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
and then instantiate two new Person
objects as follows:
const rand = new Person("Rand McKinnon", 33, "M");
const ken = new Person("Ken Jones", 39, "M");
Then, you can rewrite the definition of Car
to include an owner
property that takes a Person
object, as follows:
function Car(make, model, year, owner) {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
To instantiate the new objects, you then use the following:
const car1 = new Car("Eagle", "Talon TSi", 1993, rand);
const car2 = new Car("Nissan", "300ZX", 1992, ken);
If you want to find out the name of the owner of car2
, you can access the following property `car2.owner.name`.
You can always add a property to a previously defined object. For example, the statement:
car1.color = "black";
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 this.
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.
// Animal properties and method encapsulation
const Animal = {
type: "Invertebrates", // Default value of properties
displayType() {
// Method which will display type of Animal
console.log(this.type);
},
};
// Create new animal type called animal1
const animal1 = Object.create(Animal);
animal1.displayType(); // Logs: Invertebrates
// Create new animal type called fish
const fish = Object.create(Animal);
fish.type = "Fishes";
fish.displayType(); // Logs: Fishes
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.
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.
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:
// Dot notation
myCar.make = "Ford";
myCar.model = "Mustang";
myCar.year = 1969;
// Bracket notation
myCar["make"] = "Ford";
myCar["model"] = "Mustang";
myCar["year"] = 1969;
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:
const myObj = {};
const str = "myString";
const rand = Math.random();
const anotherObj = {};
// Create additional properties on myObj
myObj.type = "Dot syntax for a key named type";
myObj["date created"] = "This key has a space";
myObj[str] = "This key is in variable str";
myObj[rand] = "A random number is the key here";
myObj[anotherObj] = "This key is object anotherObj";
myObj[""] = "This key is an empty string";
console.log(myObj);
// {
// type: 'Dot syntax for a key named type',
// 'date created': 'This key has a space',
// myString: 'This key is in variable str',
// '0.6398914448618778': 'A random number is the key here',
// '[object Object]': 'This key is object anotherObj',
// '': 'This key is an empty string'
// }
console.log(myObj.myString); // 'This key is in variable str'
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.
str = "myString";
myObj[str] = "This key is in variable str";
console.log(myObj.str); // undefined
console.log(myObj[str]); // 'This key is in variable str'
console.log(myObj.myString); // 'This key is in variable str'
This allows accessing any property as determined at runtime:
let propertyName = "make";
myCar[propertyName] = "Ford";
// access different properties by changing the contents of the variable
propertyName = "model";
myCar[propertyName] = "Mustang";
console.log(myCar); // { make: 'Ford', model: 'Mustang' }
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(myObj)
. This method returns an array with only the enumerable own string property names ("keys") in the objectmyObj
, but not those in the prototype chain.Object.getOwnPropertyNames(myObj)
. This method returns an array containing all the own string property names in the objectmyObj
, 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:
function showProps(obj, objName) {
let result = "";
for (const i in obj) {
// Object.hasOwn() is used to exclude properties from the object's
// prototype chain and only show "own properties"
if (Object.hasOwn(obj, i)) {
result += `${objName}.${i} = ${obj[i]}\n`;
}
}
console.log(result);
}
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:
myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969
The above is equivalent to:
function showProps(obj, objName) {
let result = "";
Object.keys(obj).forEach((i) => {
result += `${objName}.${i} = ${obj[i]}\n`;
});
console.log(result);
}
There is no native way to list inherited non-enumerable properties. However, this can be achieved with the following function:
function listAllProperties(myObj) {
let objectToInspect = myObj;
let result = [];
while (objectToInspect !== null) {
result = result.concat(Object.getOwnPropertyNames(objectToInspect));
objectToInspect = Object.getPrototypeOf(objectToInspect);
}
return result;
}
Deleting Properties
You can remove a non-inherited property using the delete
operator. The following code shows how to remove a property.
// Creates a new object, myobj, with two properties, a and b.
const myobj = new Object(); //creating a object literal
myobj.a = 5;
myobj.b = 12;
// Removes the a property, leaving myobj with only the b property.
delete myobj.a; //removing this property
console.log("a" in myobj); // false
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
.
//color: "red" is a shared property between all the instances of Car object type. It is defined by adding a property to the Car.prototype object.
Car.prototype.color = "red";
console.log(car1.color); //red
Defining Methods of Objects
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:
objectName.methodName = functionName;
const myObj = {
myMethod: function (params) {
// do something
},
// this works too!
myOtherMethod(params) {
// do something else
},
};
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:
object.methodName(params);
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.
Car.prototype.displayCar = function () {
const result = `A Beautiful ${this.year} ${this.make} ${this.model}`;
console.log(result);
};
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:
car1.displayCar();
car2.displayCar();
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.
const Manager = {
name: "Karina",
age: 27,
job: "Software Engineer",
};
const Intern = {
name: "Tyrone",
age: 21,
job: "Software Engineer Intern",
};
function sayHi() {
console.log(`Hello, my name is ${this.name}`);
}
// add sayHi function to both objects
Manager.sayHi = sayHi;
Intern.sayHi = sayHi;
Manager.sayHi(); // Hello, my name is Karina
Intern.sayHi(); // Hello, my name is Tyrone
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 setter
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:
const myObj = {
a: 7,
get b() {
return this.a + 1;
},
set c(x) {
this.a = x / 2;
},
};
console.log(myObj.a); // 7
console.log(myObj.b); // 8, returned from the get b() method
myObj.c = 50; // Calls the set c(x) method
console.log(myObj.a); // 25
The myObj
object's properties are:
myObj.a
— a numbermyObj.b
— a getter that returnsmyObj.a
plus 1myObj.c
— a setter that sets the value ofmyObj.a
to half of the valuemyObj.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:
const myObj = { a: 0 };
Object.defineProperties(myObj, {
b: {
get() {
return this.a + 1;
},
},
c: {
set(x) {
this.a = x / 2;
},
},
});
myObj.c = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
console.log(myObj.b); // Runs the getter, which yields a + 1 or 6
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.
// Two variables, two distinct objects with the same properties
const fruit = { name: "apple" };
const fruitbear = { name: "apple" };
fruit == fruitbear; // return false
fruit === fruitbear; // return false
// Two variables, a single object
const fruit = { name: "apple" };
const fruitbear = fruit; // Assign fruit object reference to fruitbear
// Here fruit and fruitbear are pointing to same object
fruit == fruitbear; // return true
fruit === fruitbear; // return true
fruit.name = "grape";
console.log(fruitbear); // { name: "grape" }; not { name: "apple" }
You can read more about inheritance and the prototype chain here.
The Objects
in JS is a really vast topic with many tangential branches and leaves attached to it. Generally, we don't regularly use their properties hidden in the weeds of the JS objects and that is why it doesn't look familiar. But, nevertheless, they are useful to know, or at least the knowledge about their existence is really helpful while going through the Open Source repositories on GitHub.
Hope, you found it helpful.
Adios!! 😊
Reference: MDN Objects in JS