JavaScript, Does Object has similar dual-nature like String in Javascript?

Does Object has similar dual-nature like String in Javascript?

Yes, Object in JavaScript has a dual nature similar to String. Just like String, Object serves both as a constructor function and a global object. Here's how Object functions in both of these roles:

1. Object as a Constructor Function:

Object is a constructor function that you can use to create new plain objects.

When you use new Object(), you create an instance of a general object that can store key-value pairs (properties and methods).

This is a very basic way to create an object in JavaScript, although in practice, most objects are created using the object literal syntax {}.

Example:

const obj = new Object(); // Creates an empty object

obj.name = 'Alice';

obj.age = 25;

console.log(obj); // { name: 'Alice', age: 25 }

console.log(obj instanceof Object); // true

Here, obj is an object created using the Object constructor. It behaves like a plain object, and it can have properties added to it.

2. Object as a Global Object:

Object is also a built-in global object in JavaScript. It provides static methods that are commonly used for working with objects in JavaScript.

You can use Object as an object to access methods like Object.keys(), Object.values(), Object.assign(), and Object.create().

Object also serves as the prototype from which all JavaScript objects inherit, meaning all objects in JavaScript are descendants of Object.prototype.

Example:

const person = { name: 'Alice', age: 25 };

// Using Object's static methods

const keys = Object.keys(person);   // ['name', 'age']

const values = Object.values(person); // ['Alice', 25]

console.log(keys);   // ['name', 'age']

console.log(values); // ['Alice', 25]

In this example, Object is used as a global object to access the static method Object.keys() to retrieve the keys of the person object.

3. Object as the Prototype for All JavaScript Objects:

Every JavaScript object inherits from Object.prototype. This means that all objects in JavaScript (created either using the object literal {} or new Object()) have access to methods and properties defined on Object.prototype, such as toString(), hasOwnProperty(), and valueOf().

Example:

const obj = { name: 'Alice' };

console.log(obj.hasOwnProperty('name')); // true

Here, hasOwnProperty is a method defined on Object.prototype, which is inherited by all objects.

Summary of Dual Nature:

Feature Object as a Constructor Object as a Global Object

Definition A constructor function used to create plain objects. A built-in global object providing static methods.

Usage Used with new Object() to create objects. Provides static methods like Object.keys(), Object.values(), etc.

Prototype Objects created from Object inherit from Object.prototype. Object.prototype is the prototype for all objects in JavaScript.

Memory/Behavior Creates a new object instance. Provides utility methods for working with objects.

Example Showing Both Roles:

// Using Object as a constructor

const obj1 = new Object();  // Creates a plain object

obj1.name = 'Alice';

console.log(obj1); // { name: 'Alice' }

// Using Object as a global object (static methods)

const obj2 = { age: 30, job: 'Engineer' };

const keys = Object.keys(obj2); // ['age', 'job']

console.log(keys); // ['age', 'job']

Summary:

Object functions as a constructor function to create new objects, allowing you to create plain objects dynamically.

Object also serves as a global object, providing various static methods (like Object.keys(), Object.create()) to manipulate and interact with objects, and is the prototype for all JavaScript objects.