References Object

Object

The Object type represents one of

JavaScript's data types. It is used to store
various keyed collections and more complex
entities. Objects can be created using the
Object() constructor or the object initializer /
literal syntax.

Description
Nearly all objects in JavaScript are instances of
Object ; a typical object inherits properties
(including methods) from Object.prototype ,
although these properties may be shadowed
(a.k.a. overridden). The only objects that don't
inherit from Object.prototype are those with
null prototype, or descended from other null
prototype objects.

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 of
Object.prototype is always null and not
changeable.

Object prototype properties

You should avoid calling any Object.prototype
method, especially those that are not intended
to be polymorphic (i.e. only its initial behavior
makes sense and no descending object could
override it in a meaningful way). All objects
descending from Object.prototype may define
a custom own property that has the same
name, but with entirely different semantics
from what you expect. Furthermore, these
properties are not inherited by null -prototype
objects. All modern JavaScript utilities for
working with objects are static. More
specifically:

valueOf() , toString() , and

toLocaleString() exist to be polymorphic
and you should expect the object to define
its own implementation with sensible
behaviors, so you can call them as instance
methods. However, valueOf() and
toString() are usually implicitly called
through type conversion and you don't
need to call them yourself in your code.

__defineGetter__() , __defineSetter__() ,
__lookupGetter__() , and
__lookupSetter__() are deprecated and
should not be used. Use the static
alternatives Object.defineProperty() and
Object.getOwnPropertyDescriptor()

instead.

The __proto__ property is deprecated and

should not be used. The
Object.getPrototypeOf() and
Object.setPrototypeOf() alternatives are
static methods.

The propertyIsEnumerable() and

hasOwnProperty() methods can be
replaced with the
Object.getOwnPropertyDescriptor() and
Object.hasOwn() static methods,
respectively.

The isPrototypeOf() method can usually

be replaced with instanceof , if you are
checking the prototype property of a
constructor.

In case where a semantically equivalent static

method doesn't exist, or if you really want to
use the Object.prototype method, you should
directly call() the Object.prototype method
on your target object instead, to prevent the
object from having an overriding property that
produces unexpected results.

JS

const obj = {
foo: 1,
// You should not define such a
method on your own object,
// but you may not be able to
prevent it from happening if
// you are receiving the object from
external input
propertyIsEnumerable() {
return false;
},
};

obj.propertyIsEnumerable("foo"); //
false; unexpected result
Object.prototype.propertyIsEnumerable.
call(obj, "foo"); // true; expected
result

Deleting a property from an object

There isn't any method in an Object itself to
delete its own properties (such as
Map.prototype.delete() ). To do so, one must
use the delete operator.

null-prototype objects
Almost all objects in JavaScript ultimately
inherit from Object.prototype (see inheritance
and the prototype chain). However, you may
create null -prototype objects using
Object.create(null) or the object initializer
syntax with __proto__: null (note: the
__proto__ key in object literals is different from
the deprecated Object.prototype.__proto__
property). You can also change the prototype
of an existing object to null by calling
Object.setPrototypeOf(obj, null) .

JS

const obj = Object.create(null);

const obj2 = { __proto__: null };

An object with a null prototype can behave in

unexpected ways, because it doesn't inherit
any object methods from Object.prototype .
This is especially true when debugging, since
common object-property converting/detecting
utility functions may generate errors, or lose
information (especially if using silent error-
traps that ignore errors).

For example, the lack of

Object.prototype.toString() often makes
debugging intractable:

JS

const normalObj = {}; // create a

normal object
const nullProtoObj =
Object.create(null); // create an
object with "null" prototype

console.log(`normalObj is:
${normalObj}`); // shows "normalObj
is: [object Object]"
console.log(`nullProtoObj is:
${nullProtoObj}`); // throws error:
Cannot convert object to primitive
value

alert(normalObj); // shows [object

Object]
alert(nullProtoObj); // throws error:
Cannot convert object to primitive
value

Other methods will fail as well.

JS

normalObj.valueOf(); // shows {}
nullProtoObj.valueOf(); // throws
error: nullProtoObj.valueOf is not a
function

normalObj.hasOwnProperty("p"); //
shows "true"
nullProtoObj.hasOwnProperty("p"); //
throws error:
nullProtoObj.hasOwnProperty is not a
function

normalObj.constructor; // shows
"Object() { [native code] }"
nullProtoObj.constructor; // shows
"undefined"

We can add the toString method back to the

null-prototype object by assigning it one:

JS

nullProtoObj.toString =
Object.prototype.toString; // since
new object lacks toString, add the
original generic one back

console.log(nullProtoObj.toString());
// shows "[object Object]"
console.log(`nullProtoObj is:
${nullProtoObj}`); // shows
"nullProtoObj is: [object Object]"

Unlike normal objects, in which toString() is

on the object's prototype, the toString()
method here is an own property of
nullProtoObj . This is because nullProtoObj
has no ( null ) prototype.

In practice, objects with null prototype are

usually used as a cheap substitute for maps.
The presence of Object.prototype properties
will cause some bugs:

JS

const ages = { alice: 18, bob: 27 };

function hasPerson(name) {
return name in ages;
}

function getAge(name) {
return ages[name];
}

hasPerson("hasOwnProperty"); // true
getAge("toString"); // [Function:
toString]

Using a null-prototype object removes this

hazard without introducing too much
complexity to the hasPerson and getAge
functions:

JS

const ages = Object.create(null, {

alice: { value: 18, enumerable: true
},
bob: { value: 27, enumerable: true
},
});

hasPerson("hasOwnProperty"); // false
getAge("toString"); // undefined

In such case, the addition of any method

should be done cautiously, as they can be
confused with the other key-value pairs stored
as data.

Making your object not inherit from

Object.prototype also prevents prototype
pollution attacks. If a malicious script adds a
property to Object.prototype , it will be
accessible on every object in your program,
except objects that have null prototype.

JS

const user = {};

// A malicious script:
Object.prototype.authenticated = true;

// Unexpectedly allowing
unauthenticated user to pass through
if (user.authenticated) {
// access confidential data
}

JavaScript also has built-in APIs that produce

null -prototype objects, especially those that
use objects as ad hoc key-value collections.
For example:

The return value of

Array.prototype.group()

The groups and indices.groups properties

of the result of RegExp.prototype.exec()

Array.prototype[@@unscopables] (all
@@unscopables objects should have null -
prototype)

import.meta

Module namespace objects, obtained

through import * as ns from "module"; or
import()

The term " null -prototype object" often also

includes any object without Object.prototype
in its prototype chain. Such objects can be
created with extends null when using classes.

Object coercion
Many built-in operations that expect objects
first coerce their arguments to objects. The
operation can be summarized as follows:

Objects are returned as-is.

undefined and null throw a TypeError .

Number , String , Boolean , Symbol , BigInt

primitives are wrapped into their
corresponding object wrappers.

The best way to achieve the same effect in

JavaScript is through the Object()
constructor. Object(x) converts x to an
object, and for undefined or null , it returns a
plain object instead of throwing a TypeError .

Places that use object coercion include:

The object parameter of for...in loops.

The this value of Array methods.

Parameters of Object methods such as

Object.keys() .

Auto-boxing when a property is accessed

on a primitive value, since primitives do not
have properties.

The this value when calling a non-strict

function. Primitives are boxed while null
and undefined are replaced with the global
object.

Unlike conversion to primitives, the object

coercion process itself is not observable in any
way, since it doesn't invoke custom code like
toString or valueOf methods.

Constructor

Object()

Turns the input into an object.

Static methods

Object.assign()

Copies the values of all enumerable own

properties from one or more source objects
to a target object.

Object.create()

Creates a new object with the specified

prototype object and properties.

Object.defineProperties()

Adds the named properties described by the

given descriptors to an object.

Object.defineProperty()

Adds the named property described by a

given descriptor to an object.

Object.entries()

Returns an array containing all of the [key,

value] pairs of a given object's own
enumerable string properties.

Object.freeze()

Freezes an object. Other code cannot delete

or change its properties.

Object.fromEntries()

Returns a new object from an iterable of

[key, value] pairs. (This is the reverse of
Object.entries ).

Object.getOwnPropertyDescriptor()

Returns a property descriptor for a named

property on an object.

Object.getOwnPropertyDescriptors()

Returns an object containing all own property

descriptors for an object.

Object.getOwnPropertyNames()

Returns an array containing the names of all

of the given object's own enumerable and
non-enumerable properties.

Object.getOwnPropertySymbols()

Returns an array of all symbol properties

found directly upon a given object.

Object.getPrototypeOf()

Returns the prototype (internal

[[Prototype]] property) of the specified
object.

Object.hasOwn()

Returns true if the specified object has the

indicated property as its own property, or
false if the property is inherited or does not
exist.

Object.is()

Compares if two values are the same value.

Equates all NaN values (which differs from
both IsLooselyEqual used by == and
IsStrictlyEqual used by === ).

Object.isExtensible()

Determines if extending of an object is

allowed.

Object.isFrozen()

Determines if an object was frozen.

Object.isSealed()

Determines if an object is sealed.

Object.keys()

Returns an array containing the names of all

of the given object's own enumerable string
properties.

Object.preventExtensions()

Prevents any extensions of an object.

Object.seal()

Prevents other code from deleting properties

of an object.

Object.setPrototypeOf()

Sets the object's prototype (its internal

[[Prototype]] property).

Object.values()

Returns an array containing the values that

correspond to all of a given object's own
enumerable string properties.

Instance properties
These properties are defined on
Object.prototype and shared by all Object
instances.

Object.prototype.__proto__

Points to the object which was used as

prototype when the object was instantiated.

Object.prototype.constructor

The constructor function that created the

instance object. For plain Object instances,
the initial value is the Object constructor.
Instances of other constructors each inherit
the constructor property from their
respective Constructor.prototype object.

Instance methods

Object.prototype.__defineGetter__()

Associates a function with a property that,

when accessed, executes that function and
returns its return value.

Object.prototype.__defineSetter__()

Associates a function with a property that,

when set, executes that function which
modifies the property.

Object.prototype.__lookupGetter__()

Returns the function bound as a getter to the

specified property.

Object.prototype.__lookupSetter__()

Returns the function bound as a setter to the

specified property.

Object.prototype.hasOwnProperty()

Returns a boolean indicating whether an

object contains the specified property as a
direct property of that object and not
inherited through the prototype chain.

Object.prototype.isPrototypeOf()

Returns a boolean indicating whether the

object this method is called upon is in the
prototype chain of the specified object.

Object.prototype.propertyIsEnumerable()

Returns a boolean indicating whether the

specified property is the object's enumerable
own property.

Object.prototype.toLocaleString()

Calls toString() .

Object.prototype.toString()

Returns a string representation of the object.

Object.prototype.valueOf()

Returns the primitive value of the specified

object.

Examples