• a hash of key:value pairs;
• the key can be a Number or a String;
• the value can be anything and it can be called a property;
• if a value is a function, it can be called a method.

var animal = {
  isDog: true,
  name: 'Sparky',
  bark: function(){
    return 'Bark!'
  }
} 

• also objects;
• have numeric properties that are auto-incremented;
• have a length property;
• inherits some methods like:
• push();
• splice();
• sort();
• join();
• and more.

var array = [1,2,3];

>> array.length //3

array.push(4);

>> array.length //4

• also objects;
• have properties and methods;
• can be copied, deleted, augmented;
• special, because can be invoked;
• all functions return a value (implicitly undefined);
• can return other functions.

//Function Declaration
function fn(x){
   return x;
}

//Function Expression
var fn = function(){
   return x;
}

• return this when they are invoked with new;
• this can be modified before it's returned;
• can return another object.

var Person = function(name){
   this.name = name;
   this.sayName = function(){
      return 'My name is ' + this.name;
   };
};

//Create new instance
var john = new Person('John');

>> john.sayName(); //John
>> john instanceof Person //true
>> john instanceof Object //true

• a property of the function object;
• can be overwritten or augmented.

var Person = function(name){
   this.name = name;
   this.sayName = function(){
      return 'My name is ' + this.name;
   };
};

//Create new instance
var james= new Person('James');

//Augment the prototype object
Person.prototype.changeName = function (newName) {
   this.name = newName;
};

james.changeName('Joe');

>>james.sayName(); //Joe

• it's not directly exposed in all browsers;
• it's a reference to constructor prototype property.

var Person = function(name){
   this.name = name;
};

Person.prototype.changeName = function (newName) {
   this.name = newName;
};

Person.prototype.sayName = function(){
   return 'My name is ' + this.name;
};

var james= new Person('James');

>> james.hasOwnProperty('changeName'); //false
>> james.__proto__.hasOwnProperty('changeName'); //true

• no block scope

if(true){
   var inside = 1;
}

>>inside //1

• every variable is global unless it’s in a function and is declared with var;
  
• global namespace should be kept clean;
• function scope is very helpful;

function fn(){
   var private = true;
   //private it's available here
}

>>private //undefined

(function(){
   var a = 1;
   var b = 2;

   alert(a + b);
})();

• Closures are functions that refer to independent (free) variables.;
• In other words, the function defined in the closure 'remembers' the environment in which it was created. 

(function(win){
  var a = 1, b = 2,
      //Closure
      sum = function(){
         return a + b; 
      }

  win.sum = sum;
})(window);

>> sum()//3

//bad
for (var i = 0; i < 5; i++) { 
   window.setTimeout(function(){ 
      alert(i); // will alert 5 every time
   }, 200); 
} 

//good
for (var i = 0; i < 5; i++) { 
   (function(index) {
      window.setTimeout(function() { alert(index); }, 100);
   })(i);
}