JavaScript Array valueOf() Method

What You’ll Learn

The valueOf() method returns the array itself—the same object reference as this. It does not build a string or copy data. This tutorial explains why it exists, how it differs from toString(), and when (rarely) you might call it directly.

Introduction

Every JavaScript object inherits valueOf() from Object.prototype. Arrays override it to return this—the array you called it on. So numbers.valueOf() gives you back numbers, not a flattened string like "1,2,3".

You will rarely call valueOf() directly in everyday code. It matters for understanding type coercion, the object model, and how arrays behave when JavaScript converts values.

Understanding the valueOf() Method

array.valueOf() returns the array object unchanged. Mutations through the returned reference affect the original array because they are the same object.

When an array is turned into a string (for example "Values: " + arr), JavaScript uses toString(), which produces comma-separated text. valueOf() is not the method that creates that string.

📝 Syntax

General form of Array.prototype.valueOf:

array.valueOf()

Parameters

• None.

Return value

• The same array object (this).

Common patterns

• arr.valueOf() — returns arr (same reference).
• arr === arr.valueOf() — always true.
• String(arr) or arr.toString() — for display strings.
• Number(arr) — uses different coercion rules (often NaN).

Examples Gallery

Open DevTools Console (F12) or use Try-it labs. Example N maps to ?tryit=N.

const numbers = [1, 2, 3, 4, 5];

const result = numbers.valueOf();

console.log(result);
// [1, 2, 3, 4, 5]

console.log(numbers === result);
// true

[1, 2, 3, 4, 5]
true

const items = ["a", "b"];

const ref = items.valueOf();
ref.push("c");

console.log(items);
// ["a", "b", "c"]

["a", "b", "c"]

const nums = [10, 20, 30];

console.log(typeof nums.valueOf());
// "object"

console.log(typeof nums.toString());
// "string"

console.log(nums.toString());
// "10,20,30"

object
string
10,20,30

const numbers = [1, 2, 3];

const message = "Values: " + numbers.valueOf();

console.log(message);
// "Values: 1,2,3"

Values: 1,2,3

const a = [1, 2, 3];
const b = [1, 2, 3];

console.log(a.valueOf() === b.valueOf());
// false

console.log(JSON.stringify(a) === JSON.stringify(b));
// true (same contents)

false
true

🚀 Common Use Cases

• Spec compliance — part of the object conversion protocol.
• Learning coercion — understand ToPrimitive behavior.
• Custom objects — contrast with Date, where valueOf returns a number.
• Debugging identity — confirm you still hold the same array reference.
• Legacy libraries — rare explicit calls in older codebases.
• When not to use — string display, deep equality, or cloning.

📝 Notes

• Returns the array object, not a primitive string or number.
• arr === arr.valueOf() is always true.
• Does not clone or copy elements.
• String output comes from toString(), not valueOf().
• Do not use for comparing array contents.
• Dates override valueOf to return milliseconds—arrays do not.
• ES3—universal browser support.

💡 Best Practices