var a = 5, b = a;
b = 7;
console.log(a,b);

var a = {val:5}, b = a;
b.val =  7;
console.log(a.val,b.val);

var obj = new Object();
var objRef = obj;
obj.oneProperty = true;
obj.oneProperty === objRef.oneProperty

var items = new Array( "one", "two", "three");
var itemsRef = items;
items.push( "four" );
items.length == itemsRef.length

var foo = "test"; // global scope
if ( true ) { var foo = "new test"; }
alert( foo == "new test" );
function test() {
   var foo = "old test"; }
test();  alert( foo == "new test" );
function test() {  foo = "test2"; }
// Call the function to set the value of foo
test();  alert( window.foo == "test2" );

• Closures are means through which inner functions can refer to the variables present in their outer enclosing function after their parent functions have already terminated.
• Closures are created when a function that’s nested inside another function accesses a variable from its parent’s scope. This is really useful for passing state around your application when the inner function is called after the outer function has exited

var baz; 
(function() { var foo = 10;  var bar = 2;  baz = function() { 
	return foo * bar;  };
})();
baz();
// baz can access foo and bar, even though it is executed outside of the function

function foo() { 	var a= 10; 
	function bar() {  a*= 2;  return a; }
	return bar; }
var baz = foo();  // baz is now a reference to function bar.
baz(); // returns 20.
baz(); // returns 40.
baz(); // returns 80.
var blat = foo(); // blat is another reference to bar.
blat();  // returns 20, because anew copy of a foo is being used.

The context of a function can be explicitly set using function.apply() and function.call()

( function eatCake(){
    alert("So delicious and moist");
} )();

• In JavaScript, objects can create new objects, and objects can inherit from other objects.
• There are two ways to create a JavaScript object: Constructor functions and Literal notation. 

var ixigo = new Object();
ixigo.name = "ixigo";
ixigo.species = “travel";
ixigo.hello = function() { alert(“fly high"); }

• There’s nothing that makes a constructor function different from a regular javascript function. It’s just an ordinary function that has the logic needed to create a new object instead of regular program logic.
• You can use a constructor function to automatically make the object for you.

function Pet(name, species, hello){ 
	this.name = name;
	this.species = species;
	this.hello = hello;
	this.sayHello = function() { alert(this.hello);}
}

• It’s invoked with the new keyword
• It’s passed a reference to an empty object (this) which you need to instantiate
• Automatically returns the newly instantiated object

var rufus = new Pet("Rufus", "cat", "miaow");
rufus.sayHello();

• Objects maintain a link to the function that created them.

alert(rufus.constructor.toString());

• Constructor functions aren’t classes.
• All a constructor function gives you is an object that has been instantiated in a particular way

• In class based languages there is a separation between objects and classes
• javascript is prototype based language, the javascript object prototype is javascript’s way of sharing implementation across similar objects
• Prototype based language objects are created by adding properties to an empty object or by cloning an existing one.

Implementation is shared using the prototype property of the constructor function

• Prototypes are implemented in javascript using the prototype property of constructor functions. Any property or method that’s added to the constructor’s prototype automatically becomes part of every object created by that function.
  

function Pet(name, species, hello){
    this.name = name;
    this.species = species;
    this.hello = hello; } 
Pet.prototype.sayHello = function()  {  alert(this.hello); } 
var rufus = new Pet("Rufus", "cat", "miaow");
rufus.sayHello();

• When a new function is created the prototype property is set to an empty object, exactly the same if we said Pet.prototype = new Object() when we created the function. Javascript does this by default whenever you create a new function to make sure that any objects created by calling the function will automatically get all of the methods and properties that are belong to every Object (like toString()).
  

• Prototype chaining is used to build new types of objects based on existing ones. It has a very similar job to inheritance in a class based language.

function Person( name ) { this.name = name; }
Person.prototype.getName = function() {  return this.name; };

function User( name, password ) {
	// Notice that this does not support graceful overloading/inheritance
	// e.g. being able to call the super class constructor
	this.name = name;  this.password = password;  
};

// The User object inherits all of the Person object's methods
User.prototype = new Person();
User.prototype.getPassword = function() {
return this.password; };

function Person( name ) { this.name = name; }
Person.prototype.getName = function() { return this.name; };

function User( name, password ) {
	Person.call(this, name); // Call the superclass's constructor in the scope of this.
	this.password = password;
};

// The User object inherits all of the Person object's methods
User.prototype = new Person();
User.prototype.constructor = User; // Set the constructor attribute to User
User.prototype.getPassword = function() {
	return this.password; 
};