Generated recursive object based on array

Question

I have an array, which is a list of keys: ['one', 'two', 'three'].

I need to generate an object, of the following format:

{
  path: 'one',
  nested: {
    path: 'two',
    nested: {
      path: 'three'
    }
  }
}

So far I've tried a couple of approaches, but they seem quite messy (I have one method which uses while(current = array.pop()) but it requires several conditionals to handle the first and last elements.

Is there a neater recursive strategy?

@Barmar I haven't found any answer that solves the problem recursively in both places, and I have purely recursive solution to share, please reopen this questionç — Bakhtiiar Muzakparov
– Bakhtiiar Muzakparov, Commented Jul 5, 2017 at 16:55
What is the expected result when the array is empty? Yes, your current structure does indeed require special handling of the last element, it would be better if it had something like nested: null. — Bergi
– Bergi, Commented Jul 5, 2017 at 17:07
@Bergi we would just add extra condition that checks for that and returns immediately empty object jsfiddle.net/6rpg5jc1 — Bakhtiiar Muzakparov
– Bakhtiiar Muzakparov, Commented Jul 5, 2017 at 17:11

Nenad Vracar · Accepted Answer · 2017-07-05 16:53:48Z

6

You can use reduce() method and as accumulator pass object that you want add properties to.

var arr = ['one', 'two', 'three']
var obj = {}

arr.reduce(function(r, e, i) {
  r.path = e;
  return arr[i+1] ? r.nested = {} : r
}, obj)

console.log(obj)

If you want to use just recursion without loop you can create function like this.

var data = ['one', 'two', 'three']
var obj = {}

function makeObj(arr, n, o) {
  if (n == arr.length - 1) o.path = arr[n]
  else {
    o.path = arr[n];
    o.nested = {}
    makeObj(arr, n += 1, o.nested)
  }
  return o.nested
}

makeObj(data, 0, obj)
console.log(obj)

edited Jul 5, 2017 at 16:53

answered Jul 5, 2017 at 16:20

Nenad Vracar

122k16 gold badges160 silver badges184 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Bergi Over a year ago

Mutating the accumulator is absolutely ugly. Why not just use reduceRight instead?

Thomas · Accepted Answer · 2017-07-05 16:46:16Z

3

var arr = ['one', 'two', 'three'];
var tree = arr.reduceRight((nested, path) => {
  return nested? {path, nested}: {path};
}, null);

console.log(tree);

or even better/simpler, just:

var arr = ['one', 'two', 'three'];
var tree = arr.reduceRight((nested, path) => ({path, nested}), null);

console.log(tree);

It simplifies things for the JS engine if all objects have the same hidden class (simplified: same property names).

edited Jul 5, 2017 at 16:46

answered Jul 5, 2017 at 16:39

Thomas

12.8k1 gold badge16 silver badges31 bronze badges

2 Comments

Bergi Over a year ago

reduceRight is the only correct appraoch here. +1!

Bergi Over a year ago

The engine optimisation isn't really relevant. It mostly simplifies things in the code and for the programmer!

Angels · Accepted Answer · 2017-07-05 16:33:33Z

1

let arr = ['one', 'two', 'three'], obj = {};

obj['path'] = arr[arr.length - 1];
for(let i = arr.length - 2; i >= 0; i--) {
  obj = {
    path: arr[i],
    nested: obj
  };
}
console.log(obj);

edited Jul 5, 2017 at 16:33

answered Jul 5, 2017 at 16:23

Angels

2401 silver badge8 bronze badges

3 Comments

Bakhtiiar Muzakparov Over a year ago

it doesn't look recursive to me

Angels Over a year ago

Recursive solution will fail if array will contain too many elements. But if author needs only recursive solution, so be it ;)

War10ck Over a year ago

How will a recursive solution fail?

War10ck · Accepted Answer · 2017-07-05 16:24:31Z

0

You can use a decrementing for loop to solve this problem:

var props = ['one','two','three'],
    obj;
    
for(var a = props.length;a--;) {
    var temp = { path: props[a] };
    if(obj) {
        temp.nested = obj;
    }
    obj = temp;
}

console.log(obj);

answered Jul 5, 2017 at 16:24

War10ck

12.5k7 gold badges46 silver badges56 bronze badges

Comments

Khaled Ayed · Accepted Answer · 2025-05-20 17:13:23Z

-1

You can use Array.reduceRight() method:

function createNestedObject(keys, index = 0) {
  if (index >= keys.length) return null;
  
  return {
   path: keys[index],
   nested: createNestedObject(keys, index + 1)
  };
}

const keys = ['one', 'two', 'three'];
const result = createNestedObject(keys);
console.log(result);

edited May 20 at 17:13

answered May 20 at 16:07

Khaled Ayed

1,3904 gold badges17 silver badges34 bronze badges

2 Comments

Mr. Polywhirl May 20 at 16:47

Same as Thomas' response.

Khaled Ayed May 20 at 17:14

Modified @Mr.Polywhirl

Collectives™ on Stack Overflow

Generated recursive object based on array

5 Answers 5

1 Comment

2 Comments

3 Comments

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

2 Comments

3 Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related