My goal is to have otherFoo inherit from foo, but then not inherit back up to the parent. I've tried a few angles with Object.create but it keeps inheriting back to the parent.
var foo = { "bar": {"data1":"02", "data2":"03"}, "otherBar":"09"};
var otherFoo = {};
otherFoo.bar = foo.bar;
otherFoo.bar.data1 = "04";
I want the end result to be
// foo = { "bar": {"data1":"02", "data2":"03"}};
// otherFoo = { "bar": {"data1":"04", "data2":"03"}};
Here is a JSFiddle for Convenience
Do you mean Object.assign() ?
let foo = { "bar": {"data1":"02", "data2":"03"}, "otherBar":"09"};
let otherFoo = Object.assign({}, foo);
foo.otherBar = 10;
console.log(foo);
console.log(otherFoo);You could try using a class:
function template(data1) {
this.data = { "bar": {"data1": typeof data1 !== 'undefined' ? data1: '02', "data2":"03"}};
}
var foo = new template();
var otherFoo = new template('04');
console.log(foo.data);
console.log(otherFoo.data);
Close to Talha's answer, but figured i'd just go ahead and post it (as it mimicks your example almost exactly above on what you want the data represented like)
const bar = function(data){
this.bar = data;
}
let foo = new bar({"data1":"02", "data2":"03"})
let otherFoo = new bar({"data1":"04", "data2":"03"})
console.log(foo)
console.log(otherFoo)If you can use Object spread operator:
var foo = { "bar": {"data1":"02", "data2":"03"}, "otherBar":"09"};
var { otherBar, ...bar } = foo
foo = bar
var fooBar = {
bar: { ...foo.bar, data2: "04" }
}
Otherwise you need a deep clone of your object.
Here's a function that can deep clone any object, including cyclical objects. It also maintains cyclical references as they are in the original object, without referencing any values from the original, except for values in the prototype chain:
function clone (object, objects = new WeakMap()) {
// this will omit copying primitives
if (typeof object !== 'object' && typeof object !== 'function' || object === null) {
return object;
}
if (objects.has(object)) {
return objects.get(object);
}
const proto = Object.getPrototypeOf(object);
const descriptors = Object.getOwnPropertyDescriptors(object);
const copy = typeof object === 'function'
? object.call.bind(object)
: Object.create(proto);
objects.set(object, copy);
Object.values(descriptors).forEach(descriptor => {
if ('value' in descriptor) {
descriptor.value = clone(descriptor.value, objects);
}
});
return Object.defineProperties(copy, descriptors);
}
let foo = { bar: { data1: '02', data2: '03' }, otherBar: '09' };
class Test {
constructor (...args) { this.args = args; }
cool () { return 'feature'; }
}
foo.bar.foo = foo;
foo.bar.bar = foo.bar;
foo.test = new Test('foo', 'bar');
foo.bar.test = foo.test;
foo.bar.func = () => 'func';
console.log(foo);
var otherFoo = clone(foo);
// everything copies as expected
console.log(otherFoo);
console.log(otherFoo.test instanceof Test);
console.log(otherFoo.bar.func() === 'func');
console.log(typeof otherFoo.bar.func === 'function');
// nothing references the original object
console.log(foo !== otherFoo);
console.log(foo.bar !== otherFoo.bar);
console.log(foo.test !== otherFoo.test);
console.log(foo.bar.func !== otherFoo.bar.func);
// doesn't copy prototypes
console.log(foo.test.cool === otherFoo.test.cool);.as-console-wrapper{max-height:100%!important}
barnototherBarotherFoo = Object.create(foo); otherFoo.bar = Object.create(foo.bar);? Have a look at this question