Fastest array flatten.
Fastest implementation compared to several published packages and many unpublished variations.
The outermost array (the one provided to
flatten()) is mutated. If you want to preserve the outermost array as well (inner arrays are always preserved) then wrap it in an array when supplying it:
flatten([array]). Then the new array is the one which will be changed. And, the flatten operation will still be far faster than the other implementations.
For this repo, run
npm run perf to compare the performance of this implementation to:
See screenshot of performance results below.
Note, on a Mac I use the
renice command to give the performance testing process high priority before answering the "run?" prompt.
npm install --save @flatten/array
var flatten =console// [ 1, 2, 3, 4, 5, 6, 7 ]// NOTE: it's an in-place change to the array supplied.var array = 1 2 3 4 5 6 7 8 9 10// array = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]// no need to assign array to it.// but, you can, if you want to because it returns it// to allow inline use.// want to preserve your array? wrap it:var dontChangeThisArray =// wrap it in an array when passing it.// this is still much faster than other implementations.
Don't Change My Array!
No problem. Wrap your array and you're all set.
And, it's still faster than the other implementations.
array =// NOTE: extra spaces added for emphasis
tl;dr This is the fastest flatten implementation.
An in-place flatten on the top-most array is significantly faster than producing a new array with the flattened results. Run this project's performance test to see it compared to the implementations listed above.
Also, use my fork of the
array-flatten project to compare this implementation, called
inplace2.js there, against many other implementations.
Normally it's an anti-pattern to alter a provided array unless it is the specific intent (such as a sort utility). In this case, it is the specific intent, the fastest implementation, and the common use pattern.
The third reason, "common use pattern", means it's common to create a new array which contains many other things which may, or may not, be arrays. Then, that top-most array is provided to
@flatten/array. So, it's a brand new array created to contain the results and is therefore a perfect candidate to mutate to hold the final results.
Performance results screenshot shows this implementation is significantly faster than the others: