For ES module environment, use import
to import methods:
import { get, set } from 'object-hierarchy-access';
For commonjs environment, use requre
to import methods:
const { get, set } = require('object-hierarchy-access')
For AMD module environment, define module object-hierarchy-access
from file dist/index
.
For global mode, methods are under global variable ObjectHierarchyAccess
.
All methods for setting a value below have same parameters definition:
setValue(targetObject, ...hierarchyProperties, lastProperty, value);
setValue(targetObject, [...hierarchyProperties, lastProperty], value);
Set value to object's hierarchy properties, returns the object:
import { set } from 'object-hierarchy-access';
const obj = {};
set(obj, 'a', 'b', 'c', 100);
console.log(obj.a.b.c); // 100
Properties could be in arrays:
import { set } from 'object-hierarchy-access';
const obj = {};
set(obj, ['a', 'b', 'c'], 100);
console.log(obj.a.b.c); // 100
set(obj, ['d', 'e', 'f'], ['g', 'h', 'i'], 200);
console.log(obj.d.e.f.g.h.i); // 200
Create root object at the same time:
import { set } from 'object-hierarchy-access';
const obj = set({}, 'a', 'b', 'c', 100);
console.log(obj.a.b.c); // 100
Only set value if last hierarchy property not exists or its value is undefined
:
import { setIfUndef } from 'object-hierarchy-access';
const obj = {};
setIfUndef(obj, 'a', 'b', 'collection', []);
obj.a.b.collection.push(100);
console.log(obj.a.b.collection); // [100]
setIfUndef(obj, 'a', 'b', 'collection', []); // will not override previous array
obj.a.b.collection.push(200);
console.log(obj.a.b.collection); // [100, 200]
It is also possible to create the object at the same time:
import { setIfUndef } from 'object-hierarchy-access';
const obj = setIfUndef({}, 'a', 'b', 'c', 100);
console.log(obj.a.b.c); // 100
Property can ba a descriptor object rather than a primitive value for non-last property item. The descriptor shape is {name|getName, value|type|create, override?, created?, skipped?, got?}
.
-
name
is a primitive property name -
getName(parent)
is a callback function to get property name -
value
should be an object assign to parent object'sname
-
type
is a constructor function(or class) with no parameter that can be used to create object, assign to parent object'sname
-
create(parent, name)
is a callback function that returns a customized object assign toparent
object'sname
-
override
determines if always create new hierarchy object even property already exists -
created(parent, name, current)
is a callback function when new hierarchy object has been created -
skipped(parent, name, current)
is a callback function when hierarchy object already exists and skipped -
got(parent, name, current)
is a callback function when current hierarchy object got no matter it is created or skipped.
Property can also be a function, it just act as getName
callback in object descriptor.
If no name related option specified, property name will be undefined
.
If no value related option specified, value will be {}
.
const obj = set({}, 'a', {name: 'b', value: []}, '0', 100);
console.log(obj); // {a: {b: [100]}}
const obj2 = set({}, 'a', {name: 'b', value: {}}, 'c', 100);
console.log(obj2); // {a: {b: {c: 100}}
const obj = set({}, 'a', {name: 'b', type: Array}, '0', 100);
console.log(obj); // {a: {b: [100]}}
const obj = set({}, 'a', {name: 'b', create: () => [1, 2, 3]}, '3', 200);
console.log(obj); // {a: {b: [1, 2, 3, 200]}}
const obj = set({}, 'a', 'b', 'c', 100);
setIfUndef(obj, 'a', 'b', 'c', 200);
console.log(obj.a.b.c); // 100
setIfUndef(obj, 'a', {name: 'b', override: true}, 'c', 300);
console.log(obj.a.b.c); // 300
Just like set
and setIfUndef
, but returns the second last hierarchy object which contains the last hierarchy property.
Cannot create root object at the same time since the whole object is not returned.
import { assign } from 'object-hierarchy-access';
const obj = {};
const result = assign(obj, 'a', 'b', 'c', 100);
console.log(obj.a.b.c); // 100
console.log(result); // {c: 100}
console.log(result === obj.a.b); // true
Just like set
and setIfUndef
, but returns the last hierarchy value.
Cannot create root object at the same time since the whole object is not returned.
import { putIfUndef } from 'object-hierarchy-access';
const obj = {};
const collection = putIfUndef(obj, 'a', 'b', 'collection', []);
collection.push(100);
const anotherCollection = putIfUndef(obj, 'a', 'b', 'collection', []);
anotherCollection.push(200);
console.log(anotherCollection); // [100, 200];
console.log(collection === anotherCollection); // true
console.log(collection === obj.a.b.collection); // true
All methods for creating hierarchy properties structure below have same parameters definition:
createHierarchyProperty(targetObject, ...hierarchyProperties);
createHierarchyProperty(targetObject, [hierarchyProperties]);
Use primitive value as property name or property descriptor object to create hierarchy property. Can create root object at the same time. Returns the object.
import { setProp } from 'object-hierarchy-access';
const obj1 = {};
setProp(obj1, 'a', 'b', 'c');
console.log(obj1); // {a:{b:{c:{}}}}
const obj2 = setProp({}, 'a', 'b', {name:'c', type:Array});
console.log(obj2); // {a:{b:{c:[]}}}
Only create last hierarchy property if not exists or its value is undefined
.
import { setPropIfUndef } from 'object-hierarchy-access';
const obj = {};
setPropIfUndef(obj, 'a', 'b', {name:'c', value:[100]});
console.log(obj); // {a:{b:{c:[100]}}}
setPropIfUndef(obj, 'a', 'b', {name:'c', value:{}}); // will not override previous array
console.log(obj); // {a:{b:{c:[100]}}}
Just like setProp
and setPropIfUndef
, but returns the second last hierarchy.
Cannot create root object at the same time.
import { assignProp } from 'object-hierarchy-access';
const obj = {};
const result = assignProp(obj, 'a', 'b', 'c');
console.log(obj); // {a:{b:{c:{}}}}
console.log(result); // {c:{}}
Just like setProp
and setPropIfUndef
, but returns the last hierarchy.
Cannot create root object at the same time.
import { putProp } from 'object-hierarchy-access';
const obj = {};
const result = putProp(obj, 'a', 'b', 'c');
console.log(obj); // {a:{b:{c:{}}}}
console.log(result); // {}
console.log(result === obj.a.b.c); // true
Sometimes setting value methods and creating hierarchy property methods can be replaced with each other. The following two blocks of codes have the same effect:
import { set } from 'object-hierarchy-access';
set({}, 'a', 'b', 'c', []);
import { setProp } from 'object-hierarchy-access';
setProp({}, 'a', 'b', {name:'c', value:[]});
The first example is shorter, while the second one is useful if you want to combine property name with its value as a descriptor.
For -IfUndef
methods, if last hierarchy property value is very expensive for creating, use creating hierarchy methods with descriptor's property type
or create
,
could avoid creating unnecessary values except the first time.
import { setIfUndef } from 'object-hierarchy-access';
const obj = {};
setIfUndef(obj, 'a', 'b', 'c', []);
setIfUndef(obj, 'a', 'b', 'c', []); // the array instance is created and then abandoned
import { setPropIfUndef } from 'object-hierarchy-access';
const obj = {};
setPropIfUndef(obj, 'a', 'b', {name:'c', type:Array}); // the array instance is created
setPropIfUndef(obj, 'a', 'b', {name:'c', type:Array}); // will not create array instance
setPropIfUndef(obj, 'a', 'b', {name:'c', create: ()=>[]}); // will not create array instance
For setting value methods, hierarchy properties only created if not exists by default, unless override
is specified.
Value will always be overridden unless using -IfUndef
related methods.
For creating hierarchy property methods, non-last hierarchy properties only created if not exists by default, unless override
is specified.
For last hierarchy property,
non -IfUndef
methods overrides existing property and ignore override
,
while -IfUndef
methods will not unless override
is true
.
const obj = {};
setPropIfUndef(obj,'a','b',{name:'c', value:[]}); // obj.a.b.c === []
setPropIfUndef(obj,'a','b',{name:'c', value:{}}); // obj.a.b.c not changed
setPropIfUndef(obj,'a','b',{name:'c', value:{}, override:true}); // obj.a.b.c === {}
Returns\Category | Setting Value | Creating Hierarchy Property |
---|---|---|
Root Object |
set , setIfUndef
|
setProp , setPropIfUndef
|
Second Last Hierarchy |
assign , assignIfUndef
|
assignProp , assignPropIfUndef
|
Last Hierarchy |
put , putIfUndef
|
putProp , putPropIfUndef
|
Get value from object's hierarchy properties.
Parameter definition:
get(targetObject, ...hierarchyProperties);
get(targetObject, [hierarchyProperties]);
Specifying properties by string, number or symbol:
import { get } from 'object-hierarchy-access';
const obj = {a: {b: {c: 100}}};
get(obj, 'a', 'b'); // returns {c: 100}
get(obj, 'a', 'b', 'c'); // returns 100
get(obj, ['a', 'b', 'c']); // returns 100
Property can be a descriptor object, which its shape is {name|getName|getValue, got?}
.
-
name
is a primitive property name -
getName(parent)
is a callback function to get property name -
getValue(parent)
is a callback function to get property value directly -
got(parent, name, current)
is a callback when value has been got fromparent
'sname
property,name
will be 'undefined' if value is got bygetValue
import { get } from 'object-hierarchy-access';
const obj = {a: {b: {c: 100}}};
get(obj,
{
name: 'a',
got: (parent, name, current) => {
/*
parent => {a: {b: {c: 100}}};
name => 'a';
current => {b: {c: 100}};
*/
}
},
{
getName: () => 'b',
got: (parent, name, current) => {
/*
parent => {b: {c: 100}};
name => 'b';
current => {c: 100};
*/
}
},
{
getValue: parent => parent.c,
got: (parent, name, current) => {
/*
parent => {c: 100};
name => 'undefined';
current => 100;
*/
}
}
);
Property can also be a function, it just acts as getValue
callback in object descriptor.
const obj = {a: {value: 1, b1: {c: 100}, b2: {c: 200}}};
get(obj, 'a', parent => parent.value === 1 ? parent.b1 : parent.b2, 'c'); // returns 100
Check if hierarchical property name exists on target object,
not care if last hierarchy property value is undefined
or null
.
Parameter definition:
exist(target, ...propertyNames);
exist(target, [propertyNames]);
import { exist } from 'object-hierarchy-access';
const obj = {a: {b: {c: 0}}};
exist(obj, 'a', 'b', 'c'); // true
exist(obj, 'a', 'b', 'd'); // false
Turns array of object into a hash map entries.
Parameter definition:
array2map(sourceArray, keyHierarchyProperty|[keyHierarchyProperties], valueHierarchyProperty|[valueHierarchyProperties]);
"hierarchyProperty" is same as get
's, can be a property name, a descriptor, or a function act as getValue
.
It is used for each item in array.
import { array2map } from 'object-hierarchy-access';
const products = [
{
productId: 'p1',
price: 100
},
{
productId: 'p2',
price: 200
}
];
const productPrices = array2map(products, 'productId', 'price');
/*
{
p1: 100,
p2: 200
}
*/
import { array2map } from 'object-hierarchy-access';
const products = [
{
product: {id: 'p1'},
price: {value: 100}
},
{
product: {id: 'p2'},
price: {value: 200}
}
];
const productPrices = array2map(products, ['product', 'id'], ['price', 'value']);
/*
{
p1: 100,
p2: 200
}
*/
Turns hash map entries object into array.
Parameter definition:
map2array(sourceEntry, keyPropName|getKeyPropName, valuePropName|getValuePropName);
-
keyPropName
will becomes result item's property name to hold key -
getKeyPropName(source, hashKey, hashValue)
can customizekeyName
for each entry -
valuePropName
will becomes result item's property name to hold value -
getValuePropName(source, hashKey, hashValue)
can customizevalueName
for each entry
import { map2array } from 'object-hierarchy-access';
const productPrices = {
p1: 100,
p2: 200
};
const products = map2array(productPrices, 'productId', 'price');
/*
[
{
productId: 'p1',
price: 100
},
{
productId: 'p2',
price: 200
}
]
*/
To customize getting value from more complex structure, consider using pick
.
Go through each hierarchy with a callback (parent, name, current) => false?
.
Valid hierarchy property format is same as get
.
Returns false
in callback to terminate hierarchy iteration.
Parameter definition:
traverse(targetObject, ...hierarchyProperties, callback);
traverse(targetObject, [hierarchyProperties], callback);
import { traverse } from 'object-hierarchy-access';
const node1 = {}, node2 = {}, node3 = {};
node1.next = node2;
node2.next = node3;
node3.next = null;
const linkedList = { next: node1 };
let nextId = 1;
traverse(linkedList, 'next', 'next', 'next', (parent, name, current) => { current.id = nextId++; });
console.log(node1.id, node2.id, node3.id); // 1, 2, 3
Just like traverse
, but callback was invoked from last hierarchy to first hierarchy.
Returns false
in callback to terminate hierarchy iteration.
import { traverseReverse } from 'object-hierarchy-access';
const task = {
done: false,
subTasks: [
{
done: false,
subTasks: [
{done: false}, // will be done
{done: true}
]
}
]
};
task.subTasks[0].subTasks[0].done = true;
traverseReverse(task, 'subTasks', 0, 'subTasks', (parent, name, current) => {
if (Array.isArray(current)) {
parent.done = current.every(task => task.done);
}
});
console.log(task.done); // true
console.log(task.subTasks[0].done); // true
Choose hierarchy properties from object, and got a new object only contains chosen properties.
Parameter definition:
select(targetObject, ...selectedHierarchyProperties);
Each selected hierarchy property parameter can be an array of properties, a single primitive property,
a descriptor object {names|getNames, got?, mapName?, mapValue?, mapped?}
or a callback function as descriptor object's getNames
.
-
names
is an array of primitive properties, or a single primitive property -
getNames(current)
is a callback function to get property names, should returns array of properties or a single property. -
got(parent, name, current)
is a callback function when current hierarchy property value is got. -
mapName(parent, name, current)
is a callback function if you want to rename hierarchy property, make sure mapped names are not conflict under same hierarchy. -
mapValue(parent, name, current)
is a callback function if you want to transform property value into another shape. Deeper hierarchy selection will based on mapped value. -
mapped(parent, mappedName, mappedCurrent)
is a callback function when mapping is done.
To select all properties of an object, specify undefined
as names, no matter this object is an array or regular object.
import { select } from 'object-hierarchy-access';
const rooms = {
building1: {
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}],
floor2: [{roomNo: '1-201'}, {roomNo: '1-202'}, {roomNo: '1-203'}],
floor3: [{roomNo: '1-301'}, {roomNo: '1-302'}, {roomNo: '1-303'}]
},
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}],
floor2: [{roomNo: '2-201'}, {roomNo: '2-202'}, {roomNo: '2-203'}],
floor3: [{roomNo: '2-301'}, {roomNo: '2-302'}, {roomNo: '2-303'}]
},
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}],
floor2: [{roomNo: '3-201'}, {roomNo: '3-202'}, {roomNo: '3-203'}],
floor3: [{roomNo: '3-301'}, {roomNo: '3-302'}, {roomNo: '3-303'}]
},
building4: {}
};
const allFloor1Rooms = select(rooms, ['building1', 'building2', 'building3', 'building4'], 'floor1');
/*
{
building1: {
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}]
},
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}]
},
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}]
},
building4: {}
}
*/
Similar to select
, but only picks last hierarchy values into the same array and return.
Hierarchy selection option mapName
is useless in this case.
import { pick } from 'object-hierarchy-access';
const rooms = {
building1: {
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}],
floor2: [{roomNo: '1-201'}, {roomNo: '1-202'}, {roomNo: '1-203'}],
floor3: [{roomNo: '1-301'}, {roomNo: '1-302'}, {roomNo: '1-303'}]
},
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}],
floor2: [{roomNo: '2-201'}, {roomNo: '2-202'}, {roomNo: '2-203'}],
floor3: [{roomNo: '2-301'}, {roomNo: '2-302'}, {roomNo: '2-303'}]
},
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}],
floor2: [{roomNo: '3-201'}, {roomNo: '3-202'}, {roomNo: '3-203'}],
floor3: [{roomNo: '3-301'}, {roomNo: '3-302'}, {roomNo: '3-303'}]
},
building4: {}
};
const allFloor1Rooms = pick(rooms, ['building1', 'building2', 'building3', 'building4'], 'floor1', undefined);
/*
[
{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'},
{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'},
{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'},
{roomNo: 'x-101'}, {roomNo: 'x-102'}, {roomNo: 'x-103'}
]
*/
import { pick } from 'object-hierarchy-access';
const productPrices = {
p1: {price: 100},
p2: {price: 200}
};
const products = pick(productPrices, {
names: undefined,
mapValue: (parent, name, current) => ({
productId: name,
price: current.price
})
});
/*
[
{
productId: 'p1',
price: 100
},
{
productId: 'p2',
price: 200
}
]
*/
Divide first hierarchy properties into different hierarchical groups.
If original object is an Array, the grouped data are also arrays.
Parameter definition:
group(targetObject, ...groupParams);
group(targetObject, [groupParams]);
groupParam
can be an descriptor object which its shape is {type?|create?, by}
, or a callback function as descriptor object's by
.
-
type
is the group container object type, defaults toObject
-
create(parent)
is a callback function to create group container object -
by(parent, name, current)
is a callback for iterating each property on first hierarchy, should returns a group name
parent
is targetObject
. name
is a property name of first hierarchy. current
is parent[name]
.
Specify multiple groupParams
will create multiple group hierarchies.
import { group } from 'object-hierarchy-access';
const rooms = {
building1: {
floor0: [{roomNo: '1-001'}, {roomNo: '1-002'}, {roomNo: '1-003'}],
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}],
floor2: [{roomNo: '1-201'}, {roomNo: '1-202'}, {roomNo: '1-203'}],
floor3: [{roomNo: '1-301'}, {roomNo: '1-302'}, {roomNo: '1-303'}]
},
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}],
floor2: [{roomNo: '2-201'}, {roomNo: '2-202'}, {roomNo: '2-203'}],
floor3: [{roomNo: '2-301'}, {roomNo: '2-302'}, {roomNo: '2-303'}]
},
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}],
floor2: [{roomNo: '3-201'}, {roomNo: '3-202'}, {roomNo: '3-203'}],
floor3: [{roomNo: '3-301'}, {roomNo: '3-302'}, {roomNo: '3-303'}],
floor4: [{roomNo: '3-401'}, {roomNo: '3-402'}, {roomNo: '3-403'}]
},
building4: {}
};
const groupByHasFloor0ByOddEven = group(
rooms,
(parent, name, current) => current.floor0 ? 'hasFloor0' : 'hasNoFloor0',
(parent, name, current) => Object.keys(current).length % 2 ? 'oddFloors' : 'evenFloors'
);
/*
{
hasFloor0: {
evenFloors: {
building1: {
floor0: [{roomNo: '1-001'}, {roomNo: '1-002'}, {roomNo: '1-003'}],
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}],
floor2: [{roomNo: '1-201'}, {roomNo: '1-202'}, {roomNo: '1-203'}],
floor3: [{roomNo: '1-301'}, {roomNo: '1-302'}, {roomNo: '1-303'}]
}
}
},
hasNoFloor0: {
evenFloors: {
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}],
floor2: [{roomNo: '3-201'}, {roomNo: '3-202'}, {roomNo: '3-203'}],
floor3: [{roomNo: '3-301'}, {roomNo: '3-302'}, {roomNo: '3-303'}],
floor4: [{roomNo: '3-401'}, {roomNo: '3-402'}, {roomNo: '3-403'}]
},
building4: {},
},
oddFloors: {
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}],
floor2: [{roomNo: '2-201'}, {roomNo: '2-202'}, {roomNo: '2-203'}],
floor3: [{roomNo: '2-301'}, {roomNo: '2-302'}, {roomNo: '2-303'}]
}
}
}
}
*/
const groupByHasFloor0ByArray = group(
rooms,
(parent, name, current) => current.floor0 ? 'hasFloor0' : 'hasNoFloor0',
{
type: Array,
by: (parent, name, current) => Object.keys(current).length % 2
}
);
/*
{
hasFloor0: [
{
building1: {
floor0: [{roomNo: '1-001'}, {roomNo: '1-002'}, {roomNo: '1-003'}],
floor1: [{roomNo: '1-101'}, {roomNo: '1-102'}, {roomNo: '1-103'}],
floor2: [{roomNo: '1-201'}, {roomNo: '1-202'}, {roomNo: '1-203'}],
floor3: [{roomNo: '1-301'}, {roomNo: '1-302'}, {roomNo: '1-303'}]
}
}
],
hasNoFloor0: [
{
building3: {
floor1: [{roomNo: '3-101'}, {roomNo: '3-102'}, {roomNo: '3-103'}],
floor2: [{roomNo: '3-201'}, {roomNo: '3-202'}, {roomNo: '3-203'}],
floor3: [{roomNo: '3-301'}, {roomNo: '3-302'}, {roomNo: '3-303'}],
floor4: [{roomNo: '3-401'}, {roomNo: '3-402'}, {roomNo: '3-403'}]
},
building4: {},
},
{
building2: {
floor1: [{roomNo: '2-101'}, {roomNo: '2-102'}, {roomNo: '2-103'}],
floor2: [{roomNo: '2-201'}, {roomNo: '2-202'}, {roomNo: '2-203'}],
floor3: [{roomNo: '2-301'}, {roomNo: '2-302'}, {roomNo: '2-303'}]
}
}
]
}
*/
Change hierarchy dimension of an object.
Parameter definition:
redim(targetObject, ...hierarchyIndexes);
redim(targetObject, [hierarchyIndexes]);
The hierarchyIndex
is the original depth of targetObject
, starting from 0
.
import { redim } from 'object-hierarchy-access';
const obj1 = {
red: {
wooden: {house: 'red wooden house', ship: 'red wooden ship'},
iron: {house: 'red iron house', ship: 'red iron ship'},
stone: {house: 'red stone house', ship: 'red stone ship'}
},
green: {
wooden: {house: 'green wooden house', ship: 'green wooden ship'},
iron: {house: 'green iron house', ship: 'green iron ship'},
stone: {house: 'green stone house', ship: 'green stone ship'}
},
blue: {
wooden: {house: 'blue wooden house', ship: 'blue wooden ship'},
iron: {house: 'blue iron house', ship: 'blue iron ship'},
stone: {house: 'blue stone house', ship: 'blue stone ship'}
}
};
const result1 = redim(obj1, 1, 2, 0);
/*
{
wooden: {
house: {red: "red wooden house", green: "green wooden house", blue: "blue wooden house"},
ship: {red: "red wooden ship", green: "green wooden ship", blue: "blue wooden ship"}
},
iron: {
house: {red: "red iron house", green: "green iron house", blue: "blue iron house"},
ship: {red: "red iron ship", green: "green iron ship", blue: "blue iron ship"}
},
stone: {
house: {red: "red stone house", green: "green stone house", blue: "blue stone house"},
ship: {red: "red stone ship", green: "green stone ship", blue: "blue stone ship"}
}
}
*/
const obj2 = [
{a: 1, b: 2, c: 3},
{a: 10, b: 20, c: 30},
{a: 100, b: 200, c:300},
];
const result2 = redim(obj2, 1, 0);
/*
{
a: [1, 10, 100],
b: [2, 20, 200],
c: [3, 30, 300]
}
*/
Notice: The returned object's depth from 0
to Max(hierarchyIndexes)
will be created as new objects.
Thus values that reference to these hierarchies point to original hierarchies.