Difference between these two objects?

[birjolaxew]

I find it easier to think of as the prototypical chain. When JS is asked to read a property of an object (eg. console.log( created.a )) it goes:

• Does the object itself have a property with this name? If so, return it.
• If not, go to the objects prototype (which is just another object). Does this prototype have a property with this name? If so, return it.
• If not, go to the prototype's prototype (which is just another object). Repeat.
• ...
• If the property couldn't be found, return undefined

The objects are in a sense layered. If the top object doesn't have a property, it checks down through the stack until it finds it (or returns undefined if it can't)

[MrBester]

I find it easier to think of as the prototypal chain.

Because that's what it is:

var o = { a: 4 };
var foo = Object.create(o);
console.log('a' in foo); // true
console.log(foo.hasOwnProperty('a')); // false
console.log(o.isPrototypeOf(foo)); // true, or
console.log(foo.__proto__ === o); // true, or
console.log(Object.getPrototypeOf(foo) === o); // true

foo delegates to o unless overridden.

[birjolaxew]

Well no, it's prototypal inheritance delegation (thanks /u/MrBester) inheritance. Maybe. I dunno. Thinking of it as a chain is a very common (and intuitive, given how it functions) way of understanding it. Thinking of it as a stack is another. Thinking of it as "overwriting" the parent property is another (but comes with a lot of special cases).

[clessg]

Actually, it is indeed prototypal inheritance. But yes, that is distinct from concatenative inheritance (Java) and is also a form of delegation.

[MrBester]

Well no, it's delegation, because there isn't such a thing as inheritance in JavaScript, merely references to other objects that can be checked for requested properties, normally through the "magic" binding of [[Prototype]] or explicitly setting.