Outline numbering for an object tree

Last week I had talked about a layout dilemma that my buddy Justin was having. This reminded me of an issue that programming challenge he hit me with a few months prior. The challenge was to take an object tree and generate the proper outline numbering for it. The object tree was hierarchical with an indefinite number of children and nesting levels. The object tree looks something like this:

var data = [{
  title: "Lorem",
    children: [{
      title: "Ipsum"
  }, {
    title: "Dolor",
    children: [{
      title: "Sit"
    }, {
      title: "Amet"
    }]
  }]
}, {
  title: "Consectetur",
  children: [{
    title: "Adipiscing"
  }, {
    title: "Elit"
  }]
}];

That’s a Javascript object because FUCK YEAH JAVASCRIPT! Also because Justin was working with Javascript and it seemed fair to work the problem out as such. Now that we have our object, let’s take a look at what the desired output is. If you’re not familiar with an outline, each section is numbered like 1.0 or 1.2.3 depending on how many levels deep it is. With the aforementioned object we would be expecting an output like:

1.0 Lorem
1.1 Ipsum
1.2 Dolor
1.2.1 Sit
1.2.2 Amet
2.0 Consectetur
2.1 Adipiscing
2.2 Elit

The challenge didn’t get into indenting based on nesting, but that’s definitely something that could improved. The code itself relies on on recursion since the object can have any number of children which could have any number of children,

outlineNumber = function(items, lastId) {
  var currentId = lastId;

  items.forEach(function(item) {
    currentId[currentId.length - 1]++;

    console.log(currentId.length == 1 ? currentId + '.0' : currentId.join('.'), item.title);

    if (item.children && item.children.length) {
      var childId = lastId.slice(0);
      childId.push(0);
      outlineNumber(item.children, childId);
    }
  });
};

outlineNumber(data, [0]);

The gist is that I start with an array with a single element of zero. For each pass through the function, the last number in the array is incremented. For each increase in nesting, another number is added to the end. Then the array of numbers is combined together (with periods in between) to create the outline number. There’s also some magic to toss in “.0” to the top level numbers.

Got a better way to attack this one? Comment below!