// Se pueden hacer cosas impresionantes con los closures.
 //
 // Esta es una guía imprescindible (mejor que este fichero)
 // http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html
 
 var my_module = (function () {
         var mod = {};
         var inside;
 
        mod.inside_get = function() {
                return inside;
        }

        mod.inside_set = function(val) {
                inside = val;
        }

        return mod;
})()

my_module.inside_set('Hey!');
var result = my_module.inside_get();
console.log('Inside (getter) is ' + result);

// Esto no funciona porque mod no tiene un 'inside',
// has de utilizar el getter/setter.
console.log('Inside (module) is ' + my_module.inside);

console.log('EOF');

 /**
  * Hace que child herede de parent
  *
  * @param {Object} child Hijo
  * @param {Object} parent Padre
  */
 function inherit(child, parent)
 {
         var parentCopy = Object.create(parent.prototype);
        parentCopy.constructor = child;
        child.prototype = parentCopy;
}

// --- Padre ---

function Clase(val) {
        this.val = val;
}

// Método 'hello'. Los prototipos funcionan así: Si haces obj.método, el
// intérprete buscará método en obj. Si no existe busca en obj.prototype
// y si tampoco existe sigue tirando de la cadena de prototipos. Con
// esto el sistema se puede volver horriblemente lento cuando tienes
// hijos que aportan poco y hay que buscar hasta el padre de los padres
// de nuestros padres. Y los padres de los padres...
Clase.prototype.hello = function() {
        return this.val;
}

obj = new Clase('Hello World!');
console.log("Obj.val: " + obj.val);

// --- Hijo ---

function ClaseGrande() {
        // Con esto llamamos al constructor del padre. El primer
        // argumento del call será el this para la llamada a Clase, que
        // es la función de arriba y a la vez el constructor de Clase.
        // Sí, esto es jodido: las clases en realidad son funciones que
        // manejas como si fueran objetos. En otras palabras, Clase() y
        // Clase.prototype son dos expresiones válidas.
        Clase.call(this, "I'm BIG!");
}

inherit(ClaseGrande, Clase);

ClaseGrande.prototype.hello = function() {
        console.log("Let's go!");

        // Lo mismo que con el constructor. Le pasamos el this de un
        // objeto creado con esta clase (ej: obj_grande más abajo)
        // al hello del prototipo de Clase.
        return Clase.prototype.hello.call(this);
}

obj_grande = new ClaseGrande();

// Llama al hello del ClaseGrande que imprime "Let's go!" y luego
// llama al hello de Clase, que devuelve val del obj_grande
var valor = obj_grande.hello();
console.log(valor);

 // Todos los objetos se pasan por referencia _siempre_.
 
 var obj = {
         uno: 1,
         dos: 2
 }
 
 var grandote = {
         ref: obj,
        f: function() { console.log("hola") }
}

console.log(grandote);

// Nótese que estoy modificando obj, no grandote
obj.dos = 222;

// y sin embargo...
console.log(grandote);