You shouldn't need a counter to locate a single node with a matching id. Try this simpler approach:

function findNode (id, array) {
  for (const node of array) {
    if (node.id === id) return node;
    if (node.children) {
      const child = findNode(id, node.children);
      if (child) return child;
    }
  }
}

It will return undefined if there is no match.

If I'm understanding you correctly, you want each 'child' to have a parentID (defined by its parent; 0 otherwise) and an index (based on its position within it sibling set).

function normalize(parent) {
    if (parent && parent.children) {
        for (var i = 0, l = parent.children.length; i < l; ++i) {
            var child = parent.children[i];
            child.index = i;
            if (!child.parentId) child.parentId = parent.id || '0';
            normalize(child);
        }
    }
}

normalize(data);

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;
}

generics

Let's start with a immutable update(t, func) that takes a value of any type, t, and a callable updater function, func. func transforms t per the caller's specified return value. If no value is returned, ie undefined, then update will remove that value from the tree -

function update(t, func) {
  switch (t?.constructor) {
    case Object:
      return Object.entries(t).reduce((r, [k, v]) => {
        const newValue = update(func(v), func)
        if (newValue !== undefined) r[k] = newValue
        return r
      }, {})
    case Array:
      return t.flatMap(v => {
        const newValue = update(func(v), func)
        return newValue === undefined ? [] : [newValue]
      })
    default:
      return t
  }
}

Immutable remove(t, func) can be defined as a specialization of update -

function remove(t, func) {
  return update(t, v => Boolean(func(v)) ? undefined : v)
}

special forms

The functions can be further specialized to match your particular needs. updateWithObj(t, obj) will recursively update t where a node's id matches obj.id -

function updateWithObj(t, obj) {
  return update(t, v => v.id == obj.id ? {...v, ...obj} : v)
}

Likewise removeWithObj(t, obj) recursively removes from t where a node's id matches obj.id -

function removeWithObj(t, obj) {
  return remove(t, v => v.id == obj.id)
}

examples

Let's create some sample data. For what it's worth, update doesn't care whether it is an array of elements, [...] or a single object, {...} -

const data = [
  {id: 1, data: 50 },
  {id: 2, data: {id: 3, data: "foo"}},
  {id: 4, data: [{id: 5, data: 3.141}, {id: 6, data: {id: 7, data: "bar"}}]}
]

We'll start with a simple update on obj.id == 1. Note the existing data attribute remains in tact and a new ok attribute is added. All other nodes remain unchanged -

console.log(updateWithObj(data, {id: 1, ok: ""}))

[
  {
    "id": 1,
    "data": 50,  //  remains unchanged
    "ok": ""  //  updated
  },
  {
    "id": 2,
    "data": {
      "id": 3,
      "data": "foo"
    }
  },
  {
    "id": 4,
    "data": [
      {
        "id": 5,
        "data": 3.141
      },
      {
        "id": 6,
        "data": {
          "id": 7,
          "data": "bar"
        }
      }
    ]
  }
]

Here we see a deeply nested update with obj.id == 7. Note the data attribute for this node is updated and a new ok attribute is added -

console.log(updateWithObj(data, {id: 7, data: 0.123, ok: ""}))

[
  {
    "id": 1,
    "data": 50
  },
  {
    "id": 2,
    "data": {
      "id": 3,
      "data": "foo"
    }
  },
  {
    "id": 4,
    "data": [
      {
        "id": 5,
        "data": 3.141
      },
      {
        "id": 6,
        "data": {
          "id": 7,
          "data": 0.123, //  updated
          "ok": ""     //  updated
        }
      }
    ]
  }
]

Now let's see removal using removeWithObj. Notice obj.id == 6 is removed along with its descendants -

console.log(removeWithObj(data, {id: 6}))

[
  {
    "id": 1,
    "data": 50
  },
  {
    "id": 2,
    "data": {
      "id": 3,
      "data": "foo"
    }
  },
  {
    "id": 4,
    "data": [
      {
        "id": 5,
        "data": 3.141
      }
      //  node removed
    ]
  }
]

live demo

Here's a demo you can run in your own browser -

function update(t, func) {
  switch (t?.constructor) {
    case Object:
      return Object.entries(t).reduce((r, [k, v]) => {
        const newValue = update(func(v), func)
        if (newValue !== undefined) r[k] = newValue
        return r
      }, {})
    case Array:
      return t.flatMap(v => {
        const newValue = update(func(v), func)
        return newValue === undefined ? [] : [newValue]
      })
    default:
      return t
  }
}

function remove(t, func) {
  return update(t, v => Boolean(func(v)) ? undefined : v)
}

function updateWithObj(t, obj) {
  return update(t, v => v.id == obj.id ? {...v, ...obj} : v)
}

function removeWithObj(t, obj) {
  return remove(t, v => v.id == obj.id)
}

const data = [
  {id: 1, data: 50 },
  {id: 2, data: {id: 3, data: "foo"}},
  {id: 4, data: [{id: 5, data: 3.141}, {id: 6, data: {id: 7, data: "bar"}}]}
]

console.log(updateWithObj(data, {id: 1, ok: ""}))
console.log(updateWithObj(data, {id: 7, data: 0.123, ok: ""}))
console.log(removeWithObj(data, {id: 6}))

.as-console-wrapper { min-height: 100%; top: 0; }

why undefined?

@Scott's comment draws attention to use of undefined as the mechanism for removal. I have always advocated for the programmer to reserve the right to use undefined for her/his particular needs. If a user gives undefined to a program, they can expect undefined behavior. For update, the undefined value is explicitly used to make a value not defined, or not there, ie remove it.

Other reasons support this choice. In most cases, an object with an explicitly undefined key behaves the same as one without the key. If the user really wants a var/key to be present but not yet set to a value, this is the perfect use of null -

const a = { foo: undefined }  // foo is defined, but also not defined ??
const b = {}                  // does not have foo
console.log(a.foo, b.foo)     // same behavior
// undefined undefined

JSON considers an undefined as "not defined" and so removes it when serializing an object -

const o = { a: undefined, b: null, c: false, d: 0, e: "" }
const j = JSON.stringify(o)

// "a" is not defined, so it's not serialized
console.log(j)

// looking for "a"? it's not defined :D
console.log(JSON.parse(j).a)

// undefined input gives undefined output. it's not defined :D
console.log(JSON.stringify(undefined))

ReScript plainly encodes None (ie "no value") as undefined in its Option module. Any Some(value) is represented as value -

// rescript
let foo = Some(1)

switch foo {
  | Some(z) => Js.log(z)
  | None => Js.log("no value")
}

// compiled javascript
var foo = 1;

if (foo !== undefined) {
  console.log(foo);
} else {
  console.log("no value");
}

explicit symbol

Maybe none of that convinces you and your fragile program still depends on having that undefined appear in the output. An explicit none sentinel can be used to signal to update that a particular value should be removed -

const none = Symbol() //  removal sentinel

function update(t, func) {
  switch (t?.constructor) {
    case Object:
      return Object.entries(t).reduce((r, [k, v]) => {
        const newValue = update(func(v), func)
        if (newValue !== none) r[k] = newValue // 
        return r
      }, {})
    case Array:
      return t.flatMap(v => {
        const newValue = update(func(v), func)
        return newValue === none ? [] : [newValue] // 
      })
    default:
      return t
  }
}

function remove(t, func) {
  return update(t, v => Boolean(func(v)) ? none : v) // 
}

Add tab.concat() on the recursive call for join the items returned by the recursive fn.

const entries = {
  root: {
    data: true,
    key: "root",
    text: "some text"
  },
  test: {
    one: {
      two: {
        data: true,
        key: "test.one.two",
        text: "some text.again"
      },
      three: {
        data: true,
        key: "test.one.three",
        text: "some.more.text"
      }
    },
    other: {
      data: true,
      key: "test3",
      text: "sometext.text"
    }
  },
  a: {
    b: {
      data: true,
      key: "a.b",
      text: "a.b.text"
    },
    c: {
      d: {
        data: true,
        key: "a.c.d",
        text: "some.a.c.d"
      }
    }
  }
};


function recursiveFunc(data) {
  let tab = [];
  for (let property in data) {
    if (data.hasOwnProperty(property)) {
      if (data[property].data === true) {
        tab.push(data[property]);
        console.log("t", tab);
      } else { 
        tab = tab.concat(recursiveFunc(data[property]));
      }
    } 
  } 
  return tab
}
console.log(recursiveFunc(entries));

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!

I made a FIDDLE for you. I am storing a stack string and then output it, if the property is of primitive type:

function iterate(obj, stack) {
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                    iterate(obj[property], stack + '.' + property);
                } else {
                    console.log(property + "   " + obj[property]);
                    $('#output').append($("<div/>").text(stack + '.' + property))
                }
            }
        }
    }

iterate(object, '')

Update: 17/01/2019

There used to be a different implementation, but it didn't work. See this answer for a prettier solution