Flatten an Array in JavaScript: Use flat() to Handle Nested Arrays

JavaScript flat function

Arrays often hold other arrays. This happens with API responses, form data, or nested objects. These layers add extra steps when you want to work with the values. A flat array in JavaScript removes the inner arrays and gives you one simple list.

Let’s move on to the following section to cover everything you need to learn about how the flat() function works in JavaScript and see examples.

What Does It Mean to Flat an Array in JavaScript?

JavaScript includes a built-in method called .flat() to flatten arrays. It allows you to remove inner arrays and combine all values into one list.

Syntax:

array.flat([depth])
  • array is the original array.
  • depth is optional. It tells how deep to flatten the array.
  • The default depth is 1.

Parameters:

  • flat(1) flattens one level (default).
  • flat(2) flattens two levels.
  • flat(Infinity) flattens all nested levels.

For example:

const nested = [1, [2, 3], [4, [5]]];
const flat = nested.flat(2); 

Output:

 [1, 2, 3, 4, 5]

The nested array holds numbers and other arrays inside it. The flat(2) call removes two levels of nesting and returns one flat list.

Understand the Deep Flat in JavaScript

A deep flat means you want to flatten an array all the way, no matter how many nested levels it has.

To do this, pass Infinity as the depth:

const arr = [1, [2, [3, [4, 5]]]];
const deepFlat = arr.flat(Infinity);

The output:

[1, 2, 3, 4, 5]

So in this context:

  • flat() = shallow flatten (default is 1 level)
  • flat(Infinity) = deep flatten (removes all nested levels)

Use Infinity when you don’t know how many levels the nesting goes.

Browser Support and Polyfill for flat()

The Array.prototype.flat() method is supported in most modern browsers:

BrowserSupport
Chrome69+
Firefox62+
Edge79+
Safari12+
Node.js11+
Internet ExplorerNot Supported

This code adds support for .flat() in older browsers:

if (!Array.prototype.flat) {
  Array.prototype.flat = function(depth = 1) {
    return this.reduce((acc, val) => {
      if (Array.isArray(val) && depth > 0) {
        acc.push(...val.flat(depth - 1));
      } else {
        acc.push(val);
      }
      return acc;
    }, []);
  };
}

console.log([12,3,[14, [undefined, 15, [null, true]]],55,[5544]].flat(5));

The output:

[ 12, 3, 14, undefined, 15, null, true, 55, 5544 ]

It checks if .flat() exists. If not, it defines the method using reduce and recursion. Add this before you use .flat() to make sure the method works everywhere.

Examples

Nested arrays:

You can flatten nested arrays with the flat function. It works in modern browsers and takes an optional depth value.

const numbers = [10, [20, 30], [40, [50]]];
const firstLevel = numbers.flat(1);
console.log(firstLevel);  

Output:

[ 10, 20, 30, 40, [ 50 ] ]

This removes only the first layer of nesting. Deeper arrays stay as they are.

Flatten all levels:

const deepArray = [10, [20, [30, [40]]]];
const fullFlat = deepArray.flat(Infinity);
console.log(fullFlat);  

Output:

[10, 20, 30, 40]

You can pass Infinity to flatten every layer, no matter how deep.

Flatten an array with custom objects:

const data = [
  { id: 1 },
  [{ id: 2 }, { id: 3 }],
  [[{ id: 4 }], [{ id: 5 }]],
];

const flatData = data.flat(2);
console.log(flatData);

Here you have a list of objects nested in arrays. The .flat(2) call brings all objects to one level, so you can loop through them. It doesn’t need a check for depth.

Flatten deeply nested form data:

const formData = [
  ['name', 'John'],
  [['email', 'coder@example.com']],
  [[[['age', 30]]]],
];

const cleanData = formData.flat(Infinity);
console.log(cleanData);

Output:

[ 'name', 'John', 'email', 'coder@example.com', 'age', 30 ]

If form data comes in layers from a server or script, you can flatten it completely. This gives a clean list you can loop through or pair up later.

Wrapping Up

You learned what it means to flatten an array and why it’s useful for nested data. You also explored how to use the built-in .flat() method and how the depth parameter works.

Here’s a quick recap:

  • Use .flat() to turn nested arrays into a single-level array.
  • Set depth to control how many levels to flatten.
  • Use Infinity for full flattening.
  • Add a polyfill if you need support in older browsers.

Similar Reads

JavaScript Unary Operators: How they Work with Examples

Unary operators in JavaScript work with only one value. They can change, test, or change the type of that value,…

JavaScript Logical Operators with Examples

Logical operators in JavaScript let you check conditions and combine multiple checks in your code. In this guide, you will…

JavaScript for Loop: How to Iterate Arrays by Examples

JavaScript runs code in different ways, but the for loop stays one of the most common tools. You use it…

Understanding Data Types and Conversion in JavaScript

JavaScript works with different kinds of values. Each value has a type, known as a data type. These types help…

Math.sign in JavaScript: Check Number Signs

JavaScript includes Math.sign to find out if a number is positive. It also helps detect negative values or zero. It…

What Is AJAX? How It Works in Web Development with Examples

AJAX keeps your web app fast. You do not need to reload the page every time you send or get…

JavaScript toSorted Function Guide with Examples

This guide shows how toSorted function works in JavaScript with arrays. It covers syntax, rules, and examples for numbers, text,…

Math pow in JavaScript : How to Raise Numbers to Power

The Math.pow() function in JavaScript solves one common task. It raises a number to a power. This helps avoid loops…

JavaScript Hello World: Write a Simple Program in 3 Ways

If you are ready to take your first steps into the realm of web development, then there cannot be a…

JavaScript toString Function: How it Works with Examples

The toString function in JavaScript converts a value to a string form without change. It works on numbers, arrays, and…

Previous Article

Print in JavaScript Console Using Log, Info, Warn, and Error

Next Article

JavaScript While Loop: How It Works with Examples

Write a Comment

Leave a Comment

Your email address will not be published. Required fields are marked *


Subscribe to Get Updates

Get the latest updates on Coding, Database, and Algorithms straight to your inbox.
No spam. Unsubscribe anytime.