Si Node.JS fuera una novela, las variables serían los personajes que siempre cambian de opinión y las constantes el abuelo sabio que nunca se mueve del sofá.
En este capítulo aprenderás a crear y utilizar constantes y variables en Node.JS, además de ver algunas pautas para darles nombre. Como el curso está orientado a quienes ya tienen cierta base en programación, no entraremos a explicar qué es exactamente una variable ni en qué se diferencia de una constante.
Conviene recordar que Node.JS no es un lenguaje en sí mismo, sino un runtime que ejecuta código JavaScript. Por simplicidad, en algunos pasajes diremos “en Node.JS” cuando lo correcto sería decir “en JavaScript”.
Todos los ejemplos que verás aquí son muy sencillos. Puedes ejecutarlos directamente con node en modo REPL (tal como explicamos en el capítulo Node.JS del bloque introductorio), o bien copiarlos a un archivo .js y ejecutarlo después con node. El REPL suele ser más rápido y visual para este tipo de pruebas.
Índice
Pautas de nombrado
Como vimos ya en el capítulo introductorio de esta unidad, existen convenciones de estilo al programar en cualquier lenguaje. En este curso seguiremos la guía de estilos de MDN.
Una de esas convenciones afecta a cómo llamamos a las constantes y variables. En JavaScript (y por tanto en Node.JS) se utiliza la notación camelCase: se empieza en minúsculas, sin guiones, y cada palabra adicional comienza con mayúscula. Ejemplos: result, resultValue, oneTwoThree. En este curso, además, usaremos nombres tanto en inglés como en español para constantes, variables, funciones y archivos.
Variables
Para definir una variable en Node.JS usamos la palabra reservada let:
// Este código define la variable 'message'
// con valor "Hola, mundo!"
// e imprime su valor por pantalla
let message = "Hola, mundo!"
console.log(message)
A diferencia de otros lenguajes más estrictos, en Node.JS no es necesario declarar el tipo de una variable: el lenguaje no es fuertemente tipado.
Además, es dinámicamente tipado: una variable puede cambiar de tipo sin problema. Ejemplo:
// Imprime la cadena "Hola, mundo!"
let message = "Hola, mundo!"
console.log(message)
// Ahora 'message' pasa a ser un número
// Imprime 123457 (123456 + 1)
message = 123456
console.log(message + 1)
Incluso es posible (aunque nada recomendable) declarar variables sin let o sin asignarles un valor:
// Puesto que 'noVar' no se ha definido,
// esta línea genera un error
// "Uncaught ReferenceError: noVar is not defined"
console.log(noVar)
// Se define 'undefinedVar' sin valor inicial
// Se imprimirá "undefined" sin error
let undefinedVar
console.log(undefinedVar)
// Definir sin 'let' crea implícitamente una variable global
message = "Hola, mundo!"
console.log(message)
// Declaraciones en bloque, con y sin let
let a = b = "Hola, mundo!"
console.log(a) // "Hola, mundo!"
console.log(b) // "Hola, mundo!"
c = d = "Hola, mundo!"
console.log(c)
console.log(d)
Como ves, sin unas normas claras esto puede convertirse en un caos. Mi consejo es seguir estas reglas:
- Declara siempre las variables con
let - Asigna un valor inicial siempre que sea posible
- No uses declaraciones en bloque
- Mantén el mismo tipo de valor en cada variable, no lo cambies
let y var
También existe la palabra reservada var, pero su uso está desaconsejado. Tanto la guía de estilos de MDN como expertos como Douglas Crockford coinciden en que debe evitarse.
Resumen: olvídate de var y usa solo let. Tu código será más limpio y tú más feliz.
Constantes
Las constantes son como variables cuyo valor no puede cambiar. Se definen con const.
const message = "Hola, mundo!"
console.log(message)
A diferencia de las variables, aquí no hay margen de “libertad”: no puedes declararlas sin const, ni sin valor inicial, ni en bloque:
// Incorrecto: falta el valor inicial
const message
// Incorrecto: sin 'const' no es una constante
message = "Esto es una variable"
// Parece que hay dos constantes, pero no:
// a es constante y b es una variable
const a = b = 1
// Error al intentar reasignar a
a = 0
// b sí puede cambiar, porque es variable
b = 0
Buenas prácticas con constantes:
- Usa
constsiempre que el valor no vaya a cambiar - No combines definición de constantes y variables en la misma línea
Contexto de constantes y variables
Las instrucciones pueden agruparse en bloques delimitados por { y }. Dichos bloques definen el ámbito o contexto donde existen las constantes y variables.
// Una sola instrucción
console.log("Hola, mundo!")
// Un bloque de instrucciones
{
console.log("Hola otra vez, mundo!")
console.log("Adiós, mundo cruel!")
}
Una variable solo existe en el bloque donde se definió:
{
let message = "Hola, mundo!"
console.log(message) // "Hola, mundo!"
}
// Aquí 'message' ya no existe
console.log(message) // ReferenceError
Node.JS no permite redefinir variables en el mismo contexto, pero sí en contextos distintos o anidados:
let message = "Hola, mundo!"
{
console.log(message) // "Hola, mundo!"
let message = "Adiós, mundo!"
console.log(message) // "Adiós, mundo!"
}
console.log(message) // "Hola, mundo!"
Lo bueno y lo malo de los contextos
Redefinir una variable en un contexto anidado es muy mala práctica. Lo importante es entender que cada bloque tiene su propio ámbito: dentro de él puedes definir variables con el mismo nombre que en otros bloques, sin que interfieran entre sí.
{
let message = "Hola, mundo!"
console.log(message)
}
{
let message = "Adiós, mundo!"
console.log(message)
}
Aquí todavía parece un detalle sin mucha utilidad, pero será clave cuando estudiemos estructuras de control, funciones y clases.
Lo que hemos conseguido
Ahora sabes cómo definir constantes y variables en Node.JS, y cómo aplicar buenas prácticas para mantener tu código legible.
También conoces las reglas sobre el contexto donde existen y qué errores evitar al usarlas.
Y lo más importante: has visto ejemplos que puedes probar tanto en el REPL de node como en archivos .js.
Qué viene a continuación
En el siguiente capítulo veremos los tipos de datos básicos: bool, number y string, que ya han aparecido en algunos ejemplos.