JavaScript Objects #

General notes on objects, including properties and methods (see methods for details on specific methods).

Variables #

Objects can be assigned to variables.

Use {} for object literals.

let someVar = {};

Keys without spaces or special characters can be presented without quotes.

Value can be anything, including functions.

let someKV = {
    name: "Bob",
    age: 20
};

console is in fact a global JavaScript object. Correspondingly, .log() is a method of that object.

console.log()

To access properties, use form <object>.<key>.

For example:

someKV.name;

Another way to access properties: bracket notation, a la [].

someKV['name'];

Bracket notation must be used if the key name is not some valid identifier name, such as if it starts with a number or special character.

Bracket notation can also be used to extract a property using a variable rather than a string.

let someKV = {
    name: "Bob",
    age: 20
};

let targetKey = 'name';

console.log(someKV[targetKey]);

Use either dot or bracket notation and assignment operator = to perform an assignment.

Assignment can add something new or replace something existing.

let someKV = {
    name: "Bob",
    age: 20
};

someKV.name = 'George'; //replace
someKV.weight = '200'; //adds a new property

Properties can be deleted with delete operator.

delete someKV.weight;

Functions tied to objects.

Usually follows form: <thing>.<method>()

Different data types have different methods (strings have sting methods, numerics have numeric methods, etc.)

console.log('yo'.toUpperCase())

Methods can be added to objects with key-value pairs. Key is the method name, the value is an anonymous function.

let someObj = {
    someMethod: function() {
        ...;
    }
};

With ES6 syntax, colon and function can be omitted:

let someObj = {
    someMethod () {
        ...;
    }
};

Invoke with someObj.someMethod().

Objects can be nested (object in an object in an object…)

let someObj = {
    firstObj: {
        propA: 1,
        propB: 'Z'
    },
    secondObj: {
        propC: 4,
        propD: 'Y'
    }
}

Operators can be chained to extract nested properties or methods:

someObj[FirstObj].propA;