Necesidad de entender el ejemplo de elevación de la función Javascript

En Javascript hay diferencias sutiles entre los dos

 function square(x) { return x*x; }

Y

 var square = function(x) { return x*x; }

La mayor diferencia es que en el primer caso la asignación del objeto de función al nombre square se realiza al entrar en el ámbito, no al llegar a la línea. Esto permite llamar a funciones que se definen más adelante en el código fuente... por ejemplo:

console.log(cube(12));
function cube(x) { return x*x*x; }

Es un script válido que funcionará, incluso si la llamada ocurre "antes" de la definición de la función (y, por la manera, permitiendo este tipo de código es IMO la razón de la regla que está en el idioma).

En el segundo caso, la asignación es solo una instrucción regular y se ejecuta cuando (y si) el flujo de control pasa a través de ella.

Si desea que ese fragmento funcione como espera, simplemente cambie el código de

function <name> (...) { ... }

A

var <name> = function (...) { ... }

PD: puede repetir el nombre también en la segunda forma, pero normalmente no se hace y se usan funciones anónimas en su lugar.

Http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html

Este es el mejor artículo que he leído sobre alojamiento.

Declaraciones, Nombres y Elevación

En JavaScript, un nombre entra en un ámbito de una de cuatro maneras básicas:

Definido por el lenguaje: Todos los ámbitos tienen, por defecto, los nombres this y arguments. Parámetros formales: Las funciones pueden tener parámetros formales con nombre, que se circunscriben al cuerpo de esa función. Declaraciones de funciones: Estos son de la función de forma foo () {}. Declaraciones de variables: Estas toman la forma var foo;. Las declaraciones de funciones y las declaraciones de variables son siempre movidas ("izadas") invisiblemente a la parte superior de su ámbito contenedor por el intérprete JavaScript. Los parámetros de las funciones y los nombres definidos por el idioma, obviamente, ya están allí. Esto significa que el código como este:

function foo() {
    bar();
    var x = 1;
}

En realidad se interpreta así:

function foo() {
    var x;
    bar();
    x = 1;
}

Resulta que no importa si la línea que contiene la declaración se ejecutaría alguna vez. Las dos funciones siguientes son equivalentes:

function foo() {
    if (false) {
        var x = 1;
    }
    return;
    var y = 1;
}
function foo() {
    var x, y;
    if (false) {
        x = 1;
    }
    return;
    y = 1;
}

Observe que la parte de asignación de las declaraciones no se izó. Sólo el nombre es ho. Este no es el caso con las declaraciones de función, donde también se izará todo el cuerpo de la función. Pero recuerde que hay dos formas normales de declarar funciones. Considere el siguiente JavaScript:

function test() {
    foo(); // TypeError "foo is not a function"
    bar(); // "this will run!"
    var foo = function () { // function expression assigned to local variable 'foo'
        alert("this won't run!");
    }
    function bar() { // function declaration, given the name 'bar'
        alert("this will run!");
    }
}
test();

En este caso, solo la declaración de función tiene su cuerpo elevado a la superior. El nombre 'foo' se ho, pero el cuerpo se deja atrás, para ser asignado durante la ejecución.

Que cubre los conceptos básicos de elevación, que no es tan complejo o confuso como parece. Por supuesto, al ser JavaScript, hay un poco más de complejidad en ciertos casos especiales.

Es posible que ya entienda la forma de declarar las funciones para evitar la elevación, pero en caso de que no: puedes escribirlo como:

var is_android = true;
if (is_android) {
    var foo = function() {
        alert(5);
    };
} else {
    var foo = function() {
        alert(7);
    };
}
foo();

Y foo() no serán evaluados hasta que el intérprete javascript haya evaluado la sentencia condicional.

Estás mezclando conceptos.

Comience con este código:

function foo() {
    alert('1');
}
function foo() {
    alert('2');
}
foo();

Esto no dará error. En su lugar solo alertas 2. Porque la segunda definición de foo() anula la primera.

Intente ahora el siguiente código:

if (false) {
    function foo() { alert('false');}
}
foo();

Esto solo alertará a false. Aunque foo está definido dentro de un bloque que no se ejecuta (un si false) las declaraciones de función siempre son procesadas por JavaScript.

Con estos dos ejemplos en mente es fácil entender lo que sucede en su código: Se define dos veces una función foo, y la segunda definición anula la primera.

Lo que estabas intentando en tu código es algo muy cercano a la "compilación condicional"y este comportamiento se puede simular en JavaScript declarando funciones como variables:

if (true) {
    var foo = function() {alert ('true');}
}
else {
    var foo = function() {alert ('false');}
}
foo(); 

Este código solo alerta true. Tenga en cuenta que ahora foo se define como una variable (que contiene una función, pero una variable).

Saludos