// Returns undefined. No warning
return 
{
    status: true
};

//  can be avoided by moving the bracket to the top line
return {
    status: true
};

var I;
var properties = [

	'first-name',
	'middle-name',
	'last-name',
	'profession'
	];
for (I = 0, properties.length; I +=1) {
	document.writeln(propoerties[i] + ': ' +
	another_stooge[properties[i]]);
}

var add = function (a, b) {
	Return a + b;
};

function outer() {
	return function () {
		console.log("returning a function within a function");
	}
}

function outer() {
	var name = "Bob";
	function inner() {
		Alert(name);    // 'Bob'
	}
	return inner;
}
var something = outer();
something();     // 'Bob'

var myObject = {
	value: 0,
	increment: function ( inc ) {
		this.value += typeof inc === 'number' ? inc : 1;
	}
};

	myObject.double = function() {
		var that = this ; // Workaround
		
		var helper  = function () {
			That.value = add(that.value, that.value);
		};
		Helper();    
	};
	myObject.double();

// What we see
function funcName() {}

// Under the hood
var funcName = function funcName() {}

// stores ref to anon function
var funcRef = function () {};

// stores ref to named fun
var fundRef = func funcName() {};

var red = new Color(255, 0, 0);
var blue = {r:255, g:0, b:0}

// Outputs true
console.log(red instanceof Color);
// Outputs false
console.log(blue instanceof Color);

var Quo = (string) {
	this.status = string;
};

var array = [3, 4];
var sum = add.apply(null, array);  // sum is 7

var status {
	Status: 'A-OK'
};

var status = Quo.prototype.get_status.apply(statusObject);
// status is "A-OK'

var sum = function () {
	var I, sum = 0;
	For (I = 0; I < arguments.length; I +=1) {
		Sum += arguments[i];
	}
	Return sum;
}

Hoisted();   // logs "foo"

function hoisted() {
	Console.log("foo");
}

notHoisted();    // Will not work

var notHoisted = function() {
	Console.log("bar");
}

(function(){ /* code */ }()); // Crockford recommends this one
(function(){ /* code */ })(); // But this one works just as well

function Container(param) {
	function dec() {
		if (secret > 0) {
			 secret -= 1;
			 return true;
		} else {
			 return false;
		}
	}
	this.member = param;
	var secret = 3;
	var that = this;
	
	// privileged method
	this.service = function () {
		return dec() ? that.member : null;
	};
}

function Constructor (…) {
	this.membername = value;
}
Constructor.prototype.membername = value;

function Constructor(…){
	var self = this;
	var membername = value;
	function membername(…) {…}
}

function Constructor(…) {
	this.membername = function(…) {…};
}

(function(global) {
	"use strict";
	var MySingletonClass = function() {
		if ( MySingletonClass.prototype._singletonInstance ) {
			return MySingletonClass.prototype._singletonInstance;
		}
		MySingletonClass.prototype._singletonInstance = this;
		this.Foo = function() {
			// ...
		};
	};
	var a = new MySingletonClass();
	var b = MySingletonClass();
	global.result = a === b;
}(window));
console.log(result);

if (typeof Object.create !== 'function') {
	Object.create = function (o) {
		function F() {}
		F.prototype = o;
		return new F();
	};
}
newObject = Object.create(oldObject);

function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

Number.method('integer', function () {...});
String.method('trim', function () {...});

for(var name in obj) {
    if (obj.hasOwnProperty(name)) {
    }
}

var numbers = [1,2,3,4],
	squareNumbers = function (number) {
		return number * number;
	},
	squares = $.map(numbers, squareNumbers);
console.log(squares);
//logs [1,4,9,16]

var numbers = [1,2,3,4],
	squares = numbers.map(squareNumbers);
 
	console.log(squares);//logs [1,4,9,16]

function foo( a, b ) {
  a = a || '123';
  b = b || 55;
  Print( a + ',' + b );
}

foo(); // prints: 123,55
foo('bar'); // prints: bar,55
foo('x', 'y'); // prints x,y

var html = ['aaa', 'bbb', 'ccc', ...].join('');

// Create an anonymous function expression that gets invoked immediately,
// and assign its *return value* to a variable. This approach "cuts out the
// middleman" of the named `makeWhatever` function reference.
//
// As explained in the above "important note," even though parens are not
// required around this function expression, they should still be used as a
// matter of convention to help clarify that the variable is being set to
// the function's *result* and not the function itself.

var counter = (function(){
	var i = 0;

	return {
		get: function(){
			return i;
		},
		set: function( val ){
			i = val;
		},
		increment: function() {
			return ++i;
		}
	};
}());
 
// `counter` is an object with properties, which in this case happen to be
// methods.
 
counter.get(); // 0
counter.set( 3 );
counter.increment(); // 4
counter.increment(); // 5
 
counter.i; // undefined (`i` is not a property of the returned object)
i; // ReferenceError: i is not defined (it only exists inside the closure)

function foo() {
  var args = [];
  for (var i = 0; i < arguments.length; ++i) {
	args[i] = arguments[i];
   }  // ...
}