The problem is that your recursive call does not pass the second argument.

Without passing it, each recursive call will just populate its own, new array. It does return that array to the caller, but the caller (making the recursive call) ignores that returned value, so all the work of the recursive call is for nothing.

So the easy fix is to change this:

} else {
    recursion(nE);

to this:

} else {
    recursion(nE, resultAry);

The problem is how you are passing the processing of array, if the value is an array then you are keep calling it causing an infinite loop

function flatten() {
    var flat = [];
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i] instanceof Array) {
            flat.push.apply(flat, flatten.apply(this, arguments[i]));
        } else {
            flat.push(arguments[i]);
        }
    }
    return flat;
}

Demo: Fiddle

Here's a more modern version:

function flatten(items) {
  const flat = [];

  items.forEach(item => {
    if (Array.isArray(item)) {
      flat.push(...flatten(item));
    } else {
      flat.push(item);
    }
  });

  return flat;
}

You're creating a new array instead of passing it to the recursive call.

Do this instead.

DEMO: http://jsfiddle.net/kDtZn/

function addToArray(array) {
    array.push(prompt("Add items to array or 'q' to stop"));
    if (array[array.length-1] == 'q') {
        array.pop();
        document.write(array)
    }
    else {
        addToArray(array);
    }
 }
 addToArray([]);

Now you start with an empty array, and for each recursive call, it passes the same array forward.

Also, I changed it so that it doesn't use .pop() in the if() condition, otherwise you'll always end up with an empty array when it comes time to write it. (The .pop() method actually removes the last item.)

Finally, make sure you're not using document.write after the DOM is loaded. If so, you need to change it to use DOM manipulation methods instead.

You could take a different approach so that you don't need .pop() at all.

DEMO: http://jsfiddle.net/kDtZn/1/

function addToArray(array) {
    var item = prompt("Add items to array or 'q' to stop");
    if (item == 'q') {
        document.body.textContent = array;
    } else {
        array.push(item);
        addToArray(array);
    }
}
addToArray([]);

The reason your while loop didn't work is very likely because of the original .pop() issue.

You need a recursive method to flatten a recursive array.

Here's a pretty basic one:

var data = ["1",
[
    "2",
    [
        "3"
    ],
    [
        "4",
        [
            "5"
        ]
    ]
]];

var flattened = [];

function flatten(data, outputArray) {
    data.forEach(function (element){
        if(Array.isArray(element)) {
            flatten(element, outputArray);
        } else {
            outputArray.push(element);
        }
    });
}

flatten(data, flattened);

This should get you moving in the right direction. Good luck!

If you don't need using recursion, this is an alternative where you can get rid of the second param of the function.

const stringToArray = (str) => {
  const result = [];
  let wordArray = str.split(' ');
  
  while(wordArray.length > 0) {
    result.push(wordArray.join(' '));
    wordArray = wordArray.slice(1);
  }
  
  return result;
};

const partsArray = stringToArray('Chicago IL 12345 United States');

console.log(partsArray);