flatten an array without using .flat();

Question

how can i flatten an array without using flat(). by 1 level?

so far i have this

function flatten(array) {
  let flattened = [];
  for (let i = 0; i < array.length; i++) {
    const current = array[i];
    for (let j = 0; i < current.length; j++) {
      flattened.push(current[j])
    }
  }
  return flattened
}

console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
flatten([[1], [2], 3, 4, [5]]);
// -> [1, 2, 3, 4, 5]
flatten([false, [true, [false]], [true]]);
// -> [false, true, [false], true]
flatten([]);
// -> []

and its crashing my memory

`for (let j = 0; i < current.length; j++) {` here you have an infinite loop. if `i < current.length` is true, It won't ever change (inside that loop). so the inner loop is doing `flattened.push(current[j])` untill something crashes. — Thomas, Jul 05 '20 at 18:48
... personal opinion ... in terms of simplicity, readability and thus, beauty, only approaches that read like that ... `... .reduce((acc, el) => acc.concat(el), [])` ... should be candidates for the accepted answer. — Peter Seliger, Jul 05 '20 at 19:02
Does this answer your question? [Merge/flatten an array of arrays](https://stackoverflow.com/questions/10865025/merge-flatten-an-array-of-arrays) (check out the non-accepted answers) — SuperStormer, Oct 09 '22 at 10:13

score 5 · Answer 1 · answered Jul 05 '20 at 18:45

5

I hope this helps

var twoDimension = [[1], [2], 3, 4, [5]];

var plano = twoDimension.reduce((acc, el) => acc.concat(el), []);

console.log(plano);

answered Jul 05 '20 at 18:45

sonEtLumiere

4,461
3
8
35

what is concat doing here? and what is the [] doing at the 2nd parameter? – tryingToBeBetter Jul 05 '20 at 18:48
@sonEtLumiere `Array.reduce` takes 2 arguments, a callback function and an initial value. – goto Jul 05 '20 at 19:09

goto · Answer 2 · 2020-07-05T18:46:58.330

You could use Array.reduce and the spread syntax:

function flatten(array) {
  return array.reduce(
    (accumulator, item) => {
      // if `item` is an `array`,
      // use the `spread syntax` to 
      // append items of the array into 
      // the `accumulator` array
      if (Array.isArray(item)) {
        return [...accumulator, ...item];
      }
      // otherwise, return items in the 
      // accumulator plus the new item
      return [...accumulator, item];
    }
  , []); // initial value of `accumulator`
}

console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

References:

@americanguy93 I added comments with explanations, but this basically checks if the item in the array is another array, and if so, it takes it's items and combines it with the final array — goto, Jul 05 '20 at 18:48

score 3 · Answer 3 · answered Jun 01 '22 at 17:46

To flatten by a single level only, Array#concat() can be leveraged. It accepts any amount of arguments, so an array can be spread into the function call:

[].concat(...arr)

This avoids any explicit loops. JavaScript handles everything:

function flatten(arr) {
  return [].concat(...arr);
}

console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

score 2 · Answer 4 · answered Jun 08 '22 at 20:55

2

You can use the following method if your array have primitive data type and want to flat it completely:

arr.toString().split(',');

answered Jun 08 '22 at 20:55

Mahipal

344
2
13

score 1 · Answer 5 · answered Jul 05 '20 at 18:47

you can use the reducer of javascript as an alternative to flat().

const arr = [1, 2, [3, 4]];

arr.reduce((acc, val) => acc.concat(val), []);
// [1, 2, 3, 4]

or you can use decomposition syntax

const flattened = arr => [].concat(...arr);

For more details, go to Mozilla MDN

SHASHI BHUSHAN · Answer 6 · 2022-10-04T08:47:38.770

1

//Using Recursion

    const arr = [1, 2, 3, 4, [5, 6, [6, 7], 7, 8]]
    
    let arr2 = [];
    function flat(arr) {
         arr.forEach(element => {
              if (typeof (element) == 'object') {
                   flat(element);
              } else {
                   arr2.push(element);
              }
         });
    }
    
    flat(arr);
    
    console.log(arr2);

edited Oct 04 '22 at 08:47

answered Oct 04 '22 at 08:46

SHASHI BHUSHAN

11
2

bill.gates · Answer 7 · 2020-07-05T18:56:54.283

0

Well you can use spread operator with reduce.

function flatten(array) {

   return array.reduce((a,v) => [...a, ...(Array.isArray(v) ? v : [v])], []);
}

console.log(flatten([['foo', 'bar'], 'baz', 'qux']))

edited Jul 05 '20 at 18:56

answered Jul 05 '20 at 18:44

bill.gates

14,145
3
19
47

what does the ...a ...v mean here? – tryingToBeBetter Jul 05 '20 at 18:48
`...` is the spread operator. https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Spread_operator – bill.gates Jul 05 '20 at 18:50
1

Please consider editing or erasing this code. This purely (unguarded) spread operator based approach fails already for flattening `[[1,2,3], 4,5,6]`. Have a look at the solution of *goto1*. – Peter Seliger Jul 05 '20 at 18:50
@PeterSeliger i have added an check to check if its an array – bill.gates Jul 05 '20 at 18:57

score 0 · Answer 8 · answered Jul 05 '20 at 18:47

You have an error here:

for (let j = 0; i < current.length; j++) {
//              ^ wrong variable, should be j

And you need to check if the value is not an array, then just push the current value and continue the loop.

function flatten(array) {
  let flattened = [];
  for (let i = 0; i < array.length; i++) {
    const current = array[i];
    if (!Array.isArray(current)) {
        flattened.push(current);
        continue;
    }
    for (let j = 0; j < current.length; j++) {
      flattened.push(current[j])
    }
  }
  return flattened
}

console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

Is using `continue` instead of an if else loop a better practice, or just a preference? — symlink, Jul 05 '20 at 18:53

score 0 · Answer 9 · answered Jul 05 '20 at 18:51

You had a typo where in your innermost loop you set i to 0 instead of j. The only other thing you needed to do was check to see if each element in the outer array was scalar (not an array) and push it to the returned array if so.

function flatten(arr) {
  let flat = []
  for (let i=0; i < arr.length; i++) {
    const cur = arr[i]
    if(!Array.isArray(cur)){
      flat.push(cur)
    }else{
      for (let j=0; j < cur.length; j++) {
        flat.push(cur[j])
      }
    }
  }
  return flat
}

console.log(flatten([['foo','bar'],['baz','qux']]))
console.log(flatten([[1],[2],3,4,[5]]))
console.log(flatten([false,[true,[false]],[true]]))
console.log(flatten([]))

score 0 · Answer 10 · answered May 20 '22 at 21:39

Following could be used as a general implementation of Array.prototype.flat()

function flattenArray(arr, depth = 1) {
  if (!Array.isArray(arr)) {
    return [arr];
  }
  return depth > 0
    ? arr.reduce(
        (acc, curr) =>
          acc.concat(
            Array.isArray(curr) ? flattenArray(curr, depth - 1) : curr
          ),
        []
      )
    : arr.slice();
}

const a = [1, 2, 3, 4];
const b = "a";
const c = [1, [2, 3], 4];
const d = [1, [2, [3, 4], 5], 6];
const e = [1, [2, [3, [4, [5], [6]], 7], 8], 9];
console.log(flattenArray(a, Infinity));
console.log(flattenArray(b, Infinity));
console.log(flattenArray(c, Infinity));
console.log(flattenArray(d, Infinity));
console.log(flattenArray(e, Infinity));

Ali · Answer 11 · 2022-07-18T06:06:28.457

There is another interesting way to do it.

Stringify the array
remove all array start symbol ([) and array end symbol(])
Add array start symbol at the beginning and array end symbol at the end.
Now parse the resulting string

const arr2 = [0, 1, 2, [5, [10, [3, 4]]]]

const arr2 = [0, 1, 2, [5, [10, [3, 4]]]]
console.log( JSON.parse('['+ JSON.stringify(arr2).replace(/\[/g, ' ').replace(/\]/g, ' ') + ']'))

ArifMustafa · Answer 12 · 2022-07-31T16:53:31.593

Suppose given flatten number list without using the flat function is:

let array = [2,3,[5,2,[6,[3, [4, 5, [5, 1, 3]]]],1,1],9];
//let array= [2,3,[5,2,[6,[3, [4, 5, [5, {"key":"value"}, 3]]]],1,1],9]; 
//achieve above commented nested array condition using second approach.

The best answer already given by @Mahipal that would be first approach i.e.

array.toString().split(',')

with number array conversion

array.toString().split(',').map(n => +n)

another approach would be using function recursion without toString()

function flatter(arr) {
  if (!Array.isArray(arr) && (!isNaN(arr) || typeof arr === "object")) {
    return arr;
  }
  return arr.reduce((a, b) => {
   a.push(...[].concat(flatter(b)));
   return a; 
  }, [])
}

flatter(array);

and output is:

[ 2, 3, 5, 2, 6, 3, 4, 5, 5, 1, 3, 1, 1, 9 ]

Hope this would help many ones.

score 0 · Answer 13 · edited Nov 01 '22 at 06:56

0

var multiDimensionArray = [["a"],["b","c"],["d"]]; //array of arrays
var flatArray = Array.prototype.concat.apply([], multiDimensionArray); //flatten array of arrays
console.log(flatArray);

edited Nov 01 '22 at 06:56

Wai Ha Lee

8,598
83
57
92

answered Oct 27 '22 at 12:26

Ahmad Tahir

1
1

Hello, please see https://meta.stackoverflow.com/editing-help Thanks! – Eric Aya Oct 27 '22 at 14:29
As it’s currently written, your answer is unclear. Please [edit] to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – Community Oct 31 '22 at 06:58
While this code may answer the question, providing additional context regarding how and/or why it solves the problem would improve the answer's long-term value. You can find more information on how to write good answers in the help center: https://stackoverflow.com/help/how-to-answer . Good luck – nima Nov 01 '22 at 07:53
That's just [this answer](https://stackoverflow.com/a/62750495/), isn't it? – General Grievance Nov 01 '22 at 12:47

score 0 · Answer 14 · answered Jan 13 '23 at 19:41

0

This worked for me:


    function myFlattern(arr) {
  let check;
  do{
    check=false;
    for(let i=0;i<arr.length;i++)
    {
      if(Array.isArray(arr[i]))
      {
        check=true;
        let x=arr[i];
        arr.splice(i,1,...x);        
      }
    }

  }while(check)
  return arr;
}

answered Jan 13 '23 at 19:41

Dhyanesh Panchal

1

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – 3ddavies Jan 15 '23 at 05:38

score 0 · Answer 15 · edited Jul 09 '23 at 15:22

0

let array = [1,[3,5],[6,8],[3,[0,9],7],4];

let flattened = [];
for (let i = 0; i < array.length; i++) {
  const current = array[i];
  if (!Array.isArray(current)) {
      flattened.push(current);
  }
  for (let j = 0; j < current.length; j++) {
    if (!Array.isArray(current[j])){
        flattened.push(current[j]);
    }else if (Array.isArray(current[j])){
        let newle = current[j]
        flattened.push(newle[0]);
        flattened.push(newle[1]);
    }
  }
}

console.log(flattened);

edited Jul 09 '23 at 15:22

moken

3,227
8
13
23

answered Jul 05 '23 at 05:49

user22177121

1

1

As it’s currently written, your answer is unclear. Please [edit] to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – Community Jul 06 '23 at 10:37

score 0 · Answer 16 · answered Jul 25 '23 at 05:49

0

//For infinite nested array
const ar =[1,2,[3,[4,5,[6,7,[8,9]]]]]
 function flatten(ar) {
 return ar.reduce((ac, cur) =>{
   if(Array.isArray(cur)){
     return [...ac, ...flatten(cur)]
   }
   return [...ac, cur];
 },[])
}
console.log(flatten(ar))

answered Jul 25 '23 at 05:49

sandeep jadhav

1

1

Answer needs supporting information Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers [in the help center](https://stackoverflow.com/help/how-to-answer). – moken Jul 25 '23 at 12:25

score -1 · Answer 17 · answered Jul 06 '20 at 06:36

-1

A possible alternative would be without using flat():

var arr = [['object1', 'object2'],['object1'],['object1','object2','object3']];

var flattened = [].concat.apply([],arr);

answered Jul 06 '20 at 06:36

Mohsen Alyafei

4,765
3
30
42

score -1 · Answer 18 · answered May 10 '22 at 09:13

-1

You can use this to forget about the depth of nesting:

let multiArr = [1, [1, 2, [3, 4]], [2, 4, [45, 98]]];
  while (multiArr.find((elem) => Array.isArray(elem))) {
  multiArr = [].concat.apply([], multiArr);
}
console.log(multiArr);

answered May 10 '22 at 09:13

Valerii Vitenko

21
6

flatten an array without using .flat();

18 Answers18

Related