JavaScript Object Types

Anything that is not one of the seven primitives is an object. That one type covers a huge family: plain objects, arrays, functions, dates, Maps, Sets, regexes, errors, and page elements. They all share object behavior, especially how they are copied and compared.

// The Object Family

typeof {}                // "object"
typeof []                // "object"
typeof new Date()        // "object"
typeof new Map()         // "object"
typeof /abc/             // "object"
typeof function() {}     // "function"  (still an object; typeof just labels it specially)

// References: Sharing the Same Object

A variable does not hold an object; it holds a reference to it. Copying the variable copies the reference:

const team = ["Ava", "Ben"];
const roster = team;

roster.push("Cal");
console.log(team);   // ["Ava", "Ben", "Cal"]  same array

// Compared by Identity

const a = { x: 1 };
const b = { x: 1 };
const c = a;

a === b    // false  same contents, different objects
a === c    // true   same object

To compare contents, compare the parts you care about, or for simple data, compare their JSON:

JSON.stringify(a) === JSON.stringify(b)   // true  (only safe for simple data in the same key order)

// Shallow Copies

Spread (and Object.assign, slice) make a new outer object, but anything nested inside is still shared:

const user = { name: "Ava", tags: ["js"] };
const copy = { ...user };

copy.name = "Zed";           // fine: top-level property is independent
copy.tags.push("css");        // changes the SHARED inner array

console.log(user.name, user.tags);

// Deep Copies: structuredClone()

structuredClone copies everything, all the way down:

const user = { name: "Ava", tags: ["js"], joined: new Date(2026, 0, 5) };
const deep = structuredClone(user);

deep.tags.push("css");
console.log(user.tags);                   // ["js"]  untouched
console.log(deep.joined instanceof Date);   // true    still a real Date

// Built-In Object Types

JavaScript comes with many kinds of object ready to use. You have met most of them already:

Typed arrays

A typed array stores numbers of only one exact size. An Int8Array holds whole numbers from -128 to 127, and anything outside that range wraps around:

const bytes = new Int8Array([100, 200, -1]);

console.log(bytes[0], bytes[1], bytes[2]);   // 200 does not fit, so it wraps
console.log(bytes.length, Array.isArray(bytes));

Typed arrays are used for things like image pixels and sound, where memory and speed matter. W3Schools lists Int8Array, Int16Array, Int32Array, Float16Array, Float32Array, Float64Array, and BigInt64Array. There are also unsigned versions for numbers that are never negative, like Uint8Array (0 to 255).

// Identifying Which Kind of Object

Array.isArray(x)            // arrays (the most reliable check)
x instanceof Date            // made by the Date constructor?
x instanceof Map             // ...Map, Set, RegExp, Error, your own classes
x !== null && typeof x === "object"   // "is it any object?"

A universal trick reports the built-in kind of any value:

const kind = v => Object.prototype.toString.call(v).slice(8, -1);

kind([])          // "Array"
kind(new Date())  // "Date"
kind(null)        // "Null"
kind(/x/)         // "RegExp"
kind(42)          // "Number"

// Quick Check

const a = [1, 2];
const b = a;
const c = [...a];
b.push(3);
console.log(a.length, c.length);

// Try It

▶ Open Playground

1. Click Open Playground. Change the nested array through the shallow copy, and log the original
2. Repeat with structuredClone and confirm the original is safe
3. Use instanceof to tell a Date, a Map, and an array apart
4. Open the kind example with its Try it Yourself button and run it on ten different values