JavaScript_Succinctly

That is: a complex value is equal to another complex value when both refer to the
same object.
Due to the nature of complex objects and references, JavaScript objects have
dynamic properties.
JavaScript is mutable, which means that native objects and user-defined object
properties can be manipulated at any time.
Getting/setting/updating an object’s properties is done by using dot notation or
bracket notation. Bracket notation is convenient when the name of the object
property being manipulated is in the form of an expression (e.g.,
Array['prototype']['join'].apply()).
When referencing object properties, a lookup chain is used to first look at the
object that was referenced for the property. If the property is not there, the
property is looked for on the constructor function’s prototype property. If it’s not
found there, because the prototype holds an object value and the value is created
from the Object() constructor, the property is looked for on the Object()
constructor’s prototype property (Object.prototype). If the property is not
found there, then the property is determined to be undefined.
The prototype lookup chain is how inheritance (aka prototypal inheritance) was
design to be accomplished in JavaScript.
Because of the object property lookup chain (aka prototypal inheritance), all
objects inherit from Object() simply because the prototype property is, itself, an
Object() object.
JavaScript functions are first-class citizens: functions are objects with properties
and values.
The this keyword, when used inside a function, is a generic way to reference the
object containing the function.
The value of this is determined during run time based on the context in which the
function is called.
Used in the global scope, the this keyword refers to the global object.
JavaScript uses functions as a way to create a unique scope.
JavaScript provides the global scope, and it’s in this scope that all JavaScript code
exists.
142