Flatten Typescript Array

README.md

flatten

A simple Typescript implementation of a map reduce method to flatten a multidimensional array.

Position of array value should be preserved in the same order it was given

API

type MultiDimensionalArray<T> = (T | (T | T[])[])[];

flatten<T>(arrayToBeFlattened: MultiDimensionalArray<T>): T[]

Usage

Flatten simple arrays

  const array: MultiDimensionalArray<number> = [[3], [3], [3]];

  flatten(array) // returns [3, 3, 3]

Flatten multidimensional arrays

  const array: MultiDimensionalArray<number> = [[1], [[2]], [[3], 4]];

  flatten(array) // returns [1, 2, 3, 4]

Even flatten strings!

  const array: MultiDimensionalArray<string> = [['t'], [['h']], [['e'], 'o', 'r', ['e', 'm']]];

  flatten(array) // returns ['t', 'h', 'e', 'o', 'r', 'e', 'm']

flatten.test.ts

import { expect } from 'chai';

import 'mocha';

import { flatten, MultiDimensionalArray } from './flatten';

describe('Flatten', () => {
  it('should flatten a 2 dimensional array', () => {
    const array: MultiDimensionalArray<number> = [[3], [3], [3]];

    const expectation: number[] = [3, 3, 3];

    expect(flatten(array)).to.deep.equal(expectation);
  });

  it('should maintain the position of items in the array', () => {
    const array: MultiDimensionalArray<number> = [[1, 2, [3]], 4];

    const expectation: number[] = [1, 2, 3, 4];

    expect(flatten(array)).to.deep.equal(expectation);
  });

  it('should maintian the position of the items in the array with a different initial state', () => {
    const array: MultiDimensionalArray<number> = [[1], [[2]], [[3], 4]];

    const expectation: number[] = [1, 2, 3, 4];

    expect(flatten(array)).to.deep.equal(expectation);
  });

  it('should work with multiple types', () => {
    const array: MultiDimensionalArray<string> = [['t'], [['h']], [['e'], 'o', 'r', ['e', 'm']]];

    const expectation: string[] = 'theorem'.split('');

    expect(flatten(array)).to.deep.equal(expectation);
  });

  it('should preserve an array which is already flat', () => {
    const array: MultiDimensionalArray<number> = [1, 2, 3, 4];

    const expectation: number[] = [1, 2, 3, 4];

    expect(flatten(array)).to.deep.equal(expectation);
  });
})

flatten.ts

/**
 * @file flatten.ts
 * 
 * Contains method and typings for flattening multidimensional arrays
 */


/**
 * MultiDimensionalArray type takes T argument to indicate the type
 * of the multimendisional array
 */
export type MultiDimensionalArray<T> = (T | (T | T[])[])[];


/**
 * flatten
 * This method takes a multidimensional array and returns
 * a flattened array with the positions of the numbers intact
 * 
 * @param arrayArg {MultiDimensionalArray<T>} Takes a multidimensional array
 * @returns {T[]} A flattened array
 */
export function flatten<T>(arrayArg: MultiDimensionalArray<T>): T[] {
  return arrayArg.map((value: T) => {

    if (Array.isArray(value)) {
      return flatten(value);
    }

    return value;
  }).reduce<T[]>((prev, curr) => {
    return prev.concat(curr);
  }, []);
};

package.json

{
  "name": "flatten",
  "version": "1.0.0",
  "main": "flatten.ts",
  "license": "MIT",
  "dependencies": {
    "@types/chai": "^4.2.8",
    "@types/mocha": "^7.0.1",
    "chai": "^4.2.0",
    "mocha": "^7.0.1",
    "ts-node": "^8.6.2",
    "typescript": "^3.7.5"
  },
  "scripts": {
    "test": "mocha -r ts-node/register flatten.test.ts"
  }
}