Scope en Node.js: Entendiendo el alcance de las variables

¿Qué es el scope?

El scope para una variable, método, clase, etc, es todo lugar aquel donde dicho elemento puede ser utilizado, en base al lugar en donde fue definido.

Vamos a crear una función que salude.

function saludar() {
    console.log("Hola amigo!");
}
saludar();

Y también podemos asignar por referencia una función a una variable.

var saludar = function () {
    console.log("Hola amigo");
};

saludar();

Y podemos incluso encerrar la asignación dentro de paréntesis, esto es convertir la asignación en una expresión.
```
var saludar = function () {
    console.log("Hola amigo");
};

saludar();
```
Esto equivale exactamente al paso 2.

Y si ya tenemos una expresión y sabemos que dicha expresión regresa una función, podemos invocarla directamente así (expresion)() para que esta se ejecute.

// 06_scope/01_funcion_autoexecutable.js
(function () {
    console.log("Hola amigo");
})();

O de esta forma…

// 06_scope/01_funcion_autoexecutable.js
(function () {
    console.log("Hola amigo");
})();

Ahora supongamos que el mensaje fuese dinámico, queremos que el texto del saludo sea transferido a la impresión según el valor de una variable.
```
// 06_scope/01_funcion_autoexecutable.js
var saludo = "Hola amigo";

(function () {
    console.log(saludo);
})();
```
Si ejecutamos el anterior código, en efecto, el mensaje impreso será Hola amigo.

Las funciones pueden acceder a variables cuyo scope sea aquel que las contiene.
Ahora supongamos que cambiamos un poco nuestro código para definir el mensaje de despedida dentro de la función y su impresión fuera de esta.
```
// 06_scope/01_funcion_autoexecutable.js
var saludo = "Hola amigo";

(function () {
    console.log(saludo);
    var despedida = "Adios amigo";
})();

console.log(despedida);
```
Node va a responder lo siguiente…
```
ReferenceError: despedida is not defined
```
Las variables definidas dentro de una función tienen un scope exclusivo dentro de esta función, así que dichas variables no pueden ser utilizadas fuera de la función que las contiene.
Para completar el ejercicio, vamos a simplificarnos aun más, así introduciremos el concepto argumento > parametro.
```
// 06_scope/01_funcion_autoexecutable.js
(function (saludo) {
    console.log(saludo);
})("Hola amigo");
```
La función autoinvocable que hemos definido tiene 1 argumento llamado saludo, y cuando la invocamos le pasamos un parámetro que es un string Hola amigo.

Para entender la diferencia entre argumento y parámetro basta entender lo siguiente…
```
var saludar = function (argumento) {
    console.log(argumento);
}; // las funciones se definen con argumentos
saludar(parametro); // las funciones se invocan con párametros
```
Lo que Nodejs hace cuando creamos un módulo, es encapsular el modulo dentro de una función autoexecutable como la que hemos ejemplificado.
```
(function () {
    var saludar = function (saludo) {
        // .... codigo de la funcion
    };
    module.exports = saludar;
});

return module.exports;
```
Al final como vemos, regresa module.exports que es lo que obtenemos al importar el modulo var saludar = require('./saludar').

Esta es la metodología mediante la cual los módulos mantienen sus variables dentro de su scope, y asi nodejs previene por ejemplo que variables y funciones colapsen entre si.