Arrays in javascript have a wide selection methods including push() and pop(). Suppose the world got taken over by a dictator who wanted to get rid of the last month of the year?
The dictator would just do...

months.pop();

And of course, the dictator will eventually want to add a month after himself when everyone will have to worship him:

months.push("me");

Callbacks
Since functions are objects, they can be passed as arguments to other functions.

function peakOil(callback) {
//... code
callback(); // the parentheses mean the function is executed!
}
function changeCivilisationCallback(){
//...
}
// Now pass the changeCivilisationCallback to peakOil.
// Note: no changeCivilisationCallback parentheses because it is not
// executed at this point.
// It will be excuted later inside peak oil.
peakOil(changeCivilisationCallback);

In the example above, the chanceCivilisationCallback callback function is invoked by peakOil.
Logic could be added to check if the energy returns from solar panels and wind farms were sufficient
in which case another callback, other than changeCivilisationCallback could be added.

Configuration Object
Instead of passing around a bunch of related properties...

The use of a configuration object makes it makes it easier to write clean APIs that don't
need to take a huge long list of parameters. They also means you are less likely to get silly errors if parameters are in the wrong order.
Closures
There are three ways to creats objects in Javascript: using literals, using the constuctor function and by using a closure. What closures offer that the other two approaches do not is encapsulation. Closures make it possible to hide away functions and variables.

Note: The closure is the object literal returned from annoymous function. It "closes" over the count variable. No-one can access it except for the closure. It is encapsulated. The closure also has a sense of state. Note also how the it maintains the value of the counter.

Constructor Functions (Built in)
There are no classes in Javascript but there are construtor functions which use the new keyword syntax similar to the class based object creation in Java or other languages. Javascript has some built-in constructor functions. These include Object(), Date(), String() etc.

Constructor Functions (Custom)
When a function is invoked with the keyword new, it is referred to as a Constructor function.
The new means that the new object will have a hidden link to value of the function's prototype member and the this keyword will be bound to the new object.

The convention is that constructor functions should begin with a capital letter.
Note: if the new keyword is not used, then the 'this' variable inside the function will refer to the global object. Can you smell a potential mess? Hence why the capital letter convention for constructor functions is used. The capital letter means: "I am a constructor function, please use the new keyword".

Currying
Currying is the process of reducing the number of arguments passed to a function by setting some argument(s) to predefined values. Consider this function.

Functions are literals
This is an important one for people coming from a Java background. Functions do not need to have names. They can be anonymous, they can be passed into and returned from other functions without any needing a name - they can be treated literally. When a Java developer sees a function, they can't help thinking they are analogous to Java methods. But, Java methods can never be anonymous, they can be never be passed to or returned from other methods. They can be wrapped in an anonymous object defined on the fly; but they need that object that in many cases does nothing else - the methods themselves can never be treated literally. JavaScript ability to treat functions literally gives it a lot of expressive power.

Function declaration
In a function declaration, the function stands on its own and does not need to be assigned to anything.

Functional Inheritance
Functional inheritance is mechanism of inheritance that provides encapsulation by using closures.
Before trying to understand the syntax, take an example first. Suppose we want to represent planets in the solar system. We decided to have a planet base object and then several planet child objects which inherit from the base object. Here is the base planet object:

Now for some planets. Let's start with Earth and Jupiter and to amuse ourselves let's add a function for Earth for people to leave and a function to Jupiter for people arriving. Sarah Palin has taken over and things have got pretty bad!!!

In the function above, the var declaration in the function means that the first log will "see" the mylocation in the function scope and not the one declared in the global scope. After declaration, the local mylocation var will have
the value "undefined", hence why this is outputted first. Functions that are assigned to variables can also be hoisted. The only difference being that when functions are hoisted, their definitions also are - not just their declarations.

Immediate Function Expressions
Immediate function expression are executed as soon as they are defined.

(function() {
console.log("I ain't waiting around");
}());

There are two aspects of the syntax to note here. Firsty, there is a () immediately after the function definiton, this makes it execute. Secondly, the function can only execute if it is a function expression as opposed to a function declaration. The outer () make the function an expression. Another way to define a an immediate function expression is:

JSON
JavaScript Object Notation (JSON) is a notation used to represent objects. It is very similar to the format used for Javascript Object literals except the property names must be wrapped in quotes. The JSON format is not exclusive to javascript; it can be used by any language (Python, Ruby etc). JSON makes it very easy to see what's an array and what's an object. In XML this would be much harder. An external document - such as XSD - would have to be consulted. In this example, Mitt Romney has an array describing who might vore for him and an object which is his son.

Method
When a function is stored as a property of an object, it is referred to as a method.

var myObject {
myProperty: function () {
//...
// the this keyword in here will refer to the myObject instance.
// This means the "method" can read and change variables in the
// object.
}
}

Modules
The goal of modules is to enable javascript code bases to more modular. Functions and variables are collated into a module and then the module can decide what functions and what variables the outside world can see - in the same way as encapsulations works in the object orientated paradigms.
In javascript we create modules by combining characteristics of closures and immediate function expressions.

The function expression moduleScope has its own scope. The private variable balance
and the private function doSomethingPrivate, exist only within this scope and are only visible
to functions within this scope.

The moduleScope function returns an object literal. This is a closure which has access to the
private variables and functions of moduleScope. The returned object's properties are
"public" and accesible to the outside world.

The returned object is automatically assigned to bankAccountModule

The immediate function ()) syntax is used. This means that the module is initialised immediately.

Because the returned object (the closure) is assigned to bankAccountModule, it means we can access the bankAccountModule as:

bankAccountModule.addMoney(20);
bankAccoumtModule.withdrawMoney(15);

By convention, the filename of a module should match its namespace. So in this example, the filename should be bankAccountModule.js.

Namespace Pattern
Javascript doesn't have namespaces built into the language, meaning it is easy for variables to clash.
Unless variables are defined in a function, they are considered global. However, it is possible to use "." in variables names. Meaning you can pretend you have name spaces.

DUBLINTECH.myName = "Alex"
DUBLINTECH.myAddress = "Dublin"

Object Literal Notation
In javascript you can define an object as collection of name value pairs. The values can be property values or functions.

Prototype properties (inheritance)
Every object has a prototype object. It is useful when you want to add a property to all instances of a particular
object. Suppose you have a constructor function, which representent Irish people who bought in the boom.

Now, when this approach is used, all instances of IrishPersonBoughtInTheBoom share the save copy of the debt property. This means, that they all have the same value as illustrated in this example.

Returning functions
A function always returns a value. If return is not specified for a function, the undefined value type will be returned. Javascript functions can also return some data or another function.

Note, in this case the inner function which is returned "closes" over the count variable - making it a closure - since it encapsulates its own count variable. This means it gets its own copy which is different to the variable return by nextValue.count.

this keyword
The this keyword in Java has different meanings, depending on the context it is used.
In summary:

In a method context, this refers to the object that contains the method.

In a function context, this refers to the global object. Unless the function is a property of another object. In which case the this refers to that object.

If this is used in a constructor, the this in the constructor function refers to the object which uses the constructor function.

When the apply or call methods are used the value of this refers to what was explictly specified in the apply or call invocation.

typeof
typeof is a unary operator with one operand. It is used to determine the types of things (a bit like getClass() in Java). The values outputted by typeof are "number", "string", "boolean", "undefined", "function", "object".

Some implementations return "object" for typeof for regular expressions; others return "function".
But the biggest problem with typeof is that it returns object for null. To test for null, use strict equality...

if (myobject === null) {
...
}

Self-redefining functions
This is a good performance technique. Suppose you have a function and the first time it is called you want it to perform some set up code that you never want to perfom again. You can execute the set up code and then make the function redefine itself after that so that the setup code is never re-excuted.

var myFunction = function () {
//set up code only to this once
alert("set up, only called once");
// set up code now complete.
// redefine function so that set up code is not re-executed
myFunction = function() {
alert("no set up code");
}
}
myFunction(); // outputs - Set up, only called once
myFunction(); // outputs - no set up code this time
myFunction(); // outputs - no set up code this time

Note, any properties added to the set up part of this function will be lost when the function redefines itself.
In addition, if this function is used with a different name (i.e. it is assigned to a variable), the re-definition will not happen and the set up code will re-execute.

Scope
In javascript there is a global scope and a function scope available for variables. The var keyword does not need to be used to define variable in the global scope but it must be used to define variable in the local function scope. When a variable is scoped to a local function shares the name with a global variable, the local scope takes precedence - unless var was not used to declare the local variable in which case any local references are pointing to the global reference.
There is no block scope in javascript. By block we mean the code between {}, aka curly braces.

var myFunction = function () {
var noBlockScope = function ( ) {
if (true) {
// you'd think that d would only be visible to this if statement
var d = 24;
}
if (true) {
// this if statement can see the variable defined in the other if statement
console.log(d);
}
}
noBlockScope();

Single var pattern
You can define all variables used by a function in one place. It is ensures tidy code and is considered best practise.

If a variable is declared but not initialized with a value it will have the value undefined.Strict Equality
In javascript it is possible to compare two objects using ==. However, in some cases this will perform type conversion which can yield unexpected equality matches. To ensure there is strict comparison (i.e. no type conversions) use
the === syntax.

Truthy and Falsey
When javascript expects a boolean, you may specify a value of any type. Values that convert to true are said to be truthy and values that convert to false are said to be falsey.
Example of truthy values are objects, arrays, functions, strings and numbers:

About Me

Alex Staveley is a software professional passionate about software
engineering and technical architecture. He blogs about architectural
approaches, Java topics, web solutions and various technical bits and
pieces.