How to deflat an array efficiently

I have a requirement where I need to flat and deflat an array frequently. So, I solved that with usual way using reduce function like below

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let arr = [[1,2], [3,4]] 
let flatendarr = arr.flat(2)
console.log("flat", flatendarr)

let deflatarr =  flatendarr.reduce((pv, cv) => {
     pv.temp.push(cv)    
     if(pv.temp.length == 2) {
          pv.res.push(pv.temp)
          pv.temp = []
     }
     return pv
}, {res: [], temp: []})

console.log("de-flat",deflatarr.res)

<!-- end snippet -->

Since I need to run this code several times may be 500 to 1000 times I'm concerning about efficiency.

Since for large data I'm facing a delay of 1 to 2 seconds I'm searching Is there any other approach which is more efficient.

Don't do pushing and reduce

That is not going to be performant.

I assume that you genuinely need to de-flatten, because you won't in practice be starting with the de-flattened array and so won't have the option to simply retain it.

Try a standard loop

• Create an array for the de-flattened output, of the correct length
• Loop over the elements of this output array, inserting into each entry the array of relevant values from the flattened array

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let arr = [
  [1, 2],
  [3, 4]
]
let flatendarr = arr.flat(2)
console.log("flat", flatendarr)

const deflatarr = Array(Math.floor(flatendarr.length/2 ))
for (let i = 0; i < flatendarr.length/2; i ++) {
  deflatarr[i] = [flatendarr[2 * i], flatendarr[2 * i + 1]]
}

console.log("de-flat", deflatarr)

<!-- end snippet -->

You seem keen on a functional approach: if so, try .map

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let arr = [
  [1, 2],
  [3, 4]
]
let flatendarr = arr.flat(2)
console.log("flat", flatendarr)

const deflatarr = Array(Math.floor(flatendarr.length / 2)).fill(0).map(
  (dummy, i) => [flatendarr[2 * i], flatendarr[2 * i + 1]]
)
console.log("de-flat", deflatarr)

<!-- end snippet -->

Speed is best tested on large datasets

Try your speed comparison on this dataset:

let flatendarr = Array(50000).fill(0).map((dummy,i)=>1+i)

const deflatarr = Array((flatendarr.length / 2)).map(
  (dummy, i) => [flatendarr[2 * i], flatendarr[2 * i + 1]]
)
console.log("de-flat", deflatarr)

Another approach would be where you don't flatten the array, but provide utility functions for those parts of the logic that expects it to be flat.

Here are some ideas:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const flatAt = (arr, i) => arr[i >> 1][i & 1];
const flatPutAt = (arr, i, val) => arr[i >> 1][i & 1] = val;
const flatLength = (arr) => arr.length * 2;

function* flatValues(arr) {
    for (const pair of arr) yield* pair;
}

// Demo
let arr = [[1,2], [3,4]];

console.log("get");
for (let i = 0, size = flatLength(arr); i < size; i++) {
    console.log(flatAt(arr, i));
}
console.log("double");
for (let i = 0, size = flatLength(arr); i < size; i++) {
    console.log(flatPutAt(arr, i, flatAt(arr, i) * 2));
}
console.log("iter", ...flatValues(arr));

<!-- end snippet -->

You could take it a step further and create a class for it:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

class ArrayAsFlat extends Array {
    flatAt(i) {
        return this[i >> 1][i & 1];
    }
    flatPutAt(i, val) {
        return this[i >> 1][i & 1] = val;
    }
    *flatValues() {
        for (const pair of this) yield* pair;    
    }
    get flatLength() {
        return this.length * 2;
    }
}

// Demo
const arr = new ArrayAsFlat([1,2], [3,4]);

console.log("get");
for (let i = 0, size = arr.flatLength; i < size; i++) {
    console.log(arr.flatAt(i));
}
console.log("double");
for (let i = 0, size = arr.flatLength; i < size; i++) {
    console.log(arr.flatPutAt(i, arr.flatAt(i) * 2));
}
console.log("iter", ...arr.flatValues());

<!-- end snippet -->

Whether or not this turns out to be more efficient depends on how many actions you have to perform using the additional methods.

If most of your code needs the flat type of access, then you could do the inverse, and store the array as flat from the start and provide methods that will return (or set) values as if the array were nested.

The best solution would be to convert your code so it uses one type of access only, so no conversion is needed.