Taller > JavaScript
Variables en JavaScript
Las variables en JavaScript son fundamentales para cualquier programa que escribamos. En este artículo, profundizaremos en las variables de JavaScript, para que puedas entender cómo funcionan, cómo declararlas y cómo utilizarlas en tus programas.
¿Qué son las variables en JavaScript?
Las variables son contenedores que nos permiten almacenar y manipular datos en nuestros programas de JavaScript. En otras palabras, una variable es una forma de almacenar un valor en la memoria y luego utilizar ese valor en diferentes partes del programa.
En JavaScript, podemos almacenar diferentes tipos de datos en una variable, como números, cadenas de texto, objetos, matrices, booleanos y más.
Para declarar una variable en JavaScript, utilizamos la palabra clave var, let, o const, seguida del nombre que le daremos a la variable.
Veamos un ejemplo de cómo se declara una variable en JavaScript utilizando la palabra clave var:
var nombre = "Juan";
En este ejemplo, hemos declarado una variable llamada nombre y le hemos asignado el valor "Juan". Podemos utilizar esta variable en diferentes partes del programa y cambiar su valor en cualquier momento.
Es importante tener en cuenta que en JavaScript, las variables son case sensitive, lo que significa que una variable llamada nombre es diferente de una variable llamada Nombre.
En las siguientes secciones, profundizaremos en los diferentes tipos de variables que podemos utilizar en JavaScript y en cómo declarar y asignar valores a estas variables.
Tipos de variables en JavaScript
En JavaScript, existen diferentes tipos de variables que podemos utilizar en nuestros programas. A continuación, presentaremos algunos de los tipos de variables más comunes en JavaScript:
Variables primitivas
Las variables primitivas son variables que contienen un único valor primitivo, como un número, una cadena de texto o un valor booleano.
Ejemplo:
var numero = 42;
var texto = "Hola, mundo";
var booleano = true;
Variables no primitivas
Las variables no primitivas son variables que contienen un objeto. Los objetos pueden ser de diferentes tipos, como matrices, funciones y otros objetos.
Ejemplo:
var persona = { nombre: "Juan", edad: 30 }; var colores = ["rojo", "verde", "azul"];
Variables globales
Las variables globales son variables que se definen fuera de una función y que pueden ser utilizadas en cualquier parte del programa.
Ejemplo:
var mensaje = "Hola, mundo";
function saludar() {
console.log(mensaje);
}
saludar();
// Imprime "Hola, mundo" en la consola
Variables locales
Las variables locales son variables que se definen dentro de una función y que solo pueden ser utilizadas dentro de esa función.
Ejemplo:
function calcularPromedio(numeros) { var suma = 0; for (var i = 0; i < numeros.length; i++) { suma += numeros[i]; } var promedio = suma / numeros.length; return promedio; } var numeros = [2, 4, 6, 8]; var promedio = calcularPromedio(numeros); console.log(promedio); // Imprime 5 en la consola console.log(suma); // Error: la variable "suma" solo está definida dentro de la función "calcularPromedio"
Constantes
Las constantes son variables que se definen utilizando la palabra clave const y que no pueden cambiar su valor una vez que se han asignado.
Ejemplo:
const PI = 3.1416; const URL_API = "https://miapi.com";
En JavaScript existen diferentes tipos de variables que podemos utilizar en nuestros programas, cada una con su propia sintaxis y uso. Es importante entender estos tipos de variables para poder utilizarlas correctamente en nuestro código.
Alcance de las variables en JavaScript
El alcance de una variable se refiere a la parte del programa donde una variable puede ser utilizada. En JavaScript, existen dos tipos de alcance de variables: el alcance global y el alcance local.
Alcance global
Las variables globales son aquellas que se declaran fuera de cualquier función y pueden ser utilizadas en cualquier parte del programa.
Ejemplo:
var nombre = "Juan";
function saludar() {
console.log("Hola, " + nombre);
}
saludar();
// Imprime "Hola, Juan" en la consola
En este ejemplo, la variable nombre se declara fuera de la función saludar() y puede ser utilizada dentro de la función.
Alcance local
Las variables locales son aquellas que se declaran dentro de una función y solo pueden ser utilizadas dentro de esa función. Ejemplo:
function saludar() {
var nombre = "Juan";
console.log("Hola, " + nombre);
}
saludar();
// Imprime "Hola, Juan" en la consola
console.log(nombre);
// Error: la variable "nombre" solo está definida dentro de la función "saludar()"
En este ejemplo, la variable nombre se declara dentro de la función saludar() y solo puede ser utilizada dentro de esa función.
Alcance por la palabra let o const
Es importante tener en cuenta que el alcance de una variable también puede ser afectado por la palabra clave utilizada para declararla.
Por ejemplo, si declaramos una variable utilizando la palabra clave let o const, su alcance se limitará al bloque donde fue declarada.
Ejemplo:
function saludar() {
let nombre = "Juan";
if (true) {
let nombre = "María";
console.log("Hola, " + nombre);
}
console.log("Adiós, " + nombre);
}
saludar();
// Imprime "Hola, María" y "Adiós, Juan" en la consola
En este ejemplo, declaramos la variable nombre dentro de la función saludar() utilizando la palabra clave let. Dentro del bloque if, declaramos otra variable nombre con el mismo nombre, pero con un valor diferente.
Como la variable nombre dentro del bloque if se declara con la palabra clave let, su alcance se limita a ese bloque, mientras que la variable nombre fuera del bloque sigue siendo la misma.
Cómo declarar variables en JavaScript
Para declarar y asignar valores a una variable en JavaScript, utilizamos las palabras clave var, let o const, seguidas del nombre de la variable y, opcionalmente, del valor que queremos asignarle.
var: es la forma más antigua de declarar variables en JavaScript y tiene un alcance de función. Si una variable se declara dentro de una función, su alcance se limita a esa función. Si se declara fuera de una función, su alcance es global.
let: es una forma más nueva de declarar variables en JavaScript y tiene un alcance de bloque. Si una variable se declara dentro de un bloque de código, su alcance se limita a ese bloque.
const: es similar a let, pero el valor de una variable declarada como const no puede ser reasignado. Es decir, es una variable constante.
La sintaxis básica para declarar y asignar valores a una variable en JavaScript es la siguiente:
var nombreVariable = valor;
let nombreVariable = valor;
const nombreVariable = valor;
Ejemplo:
var nombre = "Juan";
let edad = 30;
const pi = 3.14
Es recomendable usar let y const en lugar de var, ya que ofrecen una mayor claridad y control sobre el alcance de las variables en un programa.
En el caso de las variables globales, podemos declararlas en cualquier parte del programa. En el caso de las variables locales, solo podemos declararlas dentro de una función.
Ejemplos:
// Declaración y asignación de una variable global con var var mensaje = "Hola, mundo";
console.log(mensaje);
// Imprime "Hola, mundo" en la consola //
Declaración y asignación de una variable local con let function saludar() {
let nombre = "Juan";
console.log("Hola, " + nombre);
// Imprime "Hola, Juan" en la consola } saludar();
// Declaración y asignación de una constante const PI = 3.1416; console.log(PI);
// Imprime 3.1416 en la consola
También podemos asignar valores a una variable en cualquier momento después de declararla. Para asignar un valor a una variable ya declarada, simplemente utilizamos el nombre de la variable y el operador de asignación = seguido del valor que queremos asignar.
Ejemplo:
var edad;
edad = 30;
// Asignamos el valor 30 a la variable "edad"
console.log(edad);
// Imprime 30 en la consola
Reglas para declarar variables en JavaScript
En JavaScript, existen algunas reglas para definir o declarar variables de forma correcta:
Nombres de variables válidos: los nombres de variables pueden incluir letras, números y guiones bajos, pero deben comenzar con una letra o un guion bajo. Además, los nombres de variables no deben ser palabras reservadas en JavaScript, como var, let, const, function, etc.
Nombres de variables sensibles a mayúsculas y minúsculas: los nombres de variables en JavaScript son sensibles a mayúsculas y minúsculas, lo que significa que nombre y Nombre son variables diferentes.
No se pueden usar caracteres especiales: los nombres de variables no deben incluir caracteres especiales como el punto (.), la exclamación (!), la @, etc.
No se pueden usar palabras reservadas: los nombres de variables no deben ser iguales a las palabras reservadas en JavaScript, como var, let, const, function, etc.
En general, es recomendable seguir convenciones de nombramiento estándar para las variables, como usar nombres descriptivos y camelCase para los nombres de variables compuestos por más de una palabra como:
camelCase: se escribe el primer carácter de la primera palabra en minúsculas y el primer carácter de cada palabra posterior en mayúsculas. Por ejemplo: firstName, lastName, age, etc.
snake_case: se separan las palabras con guiones bajos. Por ejemplo: first_name, last_name, age, etc.
PascalCase: se escriben todas las letras de cada palabra en mayúsculas. Por ejemplo: FirstName, LastName, Age, etc.
Es importante tener en cuenta que los nombres de variables son sensibles a mayúsculas y minúsculas en JavaScript, por lo que nombre y Nombre son variables diferentes.
Buenas prácticas
A continuación, presentaremos algunas buenas prácticas a tener en cuenta al trabajar con variables en JavaScript:
Utilizar nombres descriptivos
Es importante utilizar nombres descriptivos para las variables, de manera que sea fácil entender su función y uso en el programa. Esto puede ayudar a hacer el código más legible y fácil de mantener.
Ejemplo:
// Nombre no descriptivo var x = 42;
// Nombre descriptivo var edadUsuario = 42;
Utilizar “const” para valores que no cambian
Cuando sabemos que el valor de una variable no va a cambiar durante la ejecución del programa, es una buena práctica utilizar la palabra clave const para declararla. Esto puede ayudar a prevenir errores en el código y hacerlo más fácil de entender.
Ejemplo:
const PI = 3.1416;
const URL_API = "https://miapi.com";
Evitar variables globales
Es una buena práctica evitar utilizar variables globales siempre que sea posible, ya que pueden causar errores difíciles de depurar en programas grandes o complejos.
En su lugar, es recomendable utilizar variables locales dentro de funciones y pasar datos entre funciones mediante parámetros y retornos.
Declarar variables al principio de la función
Es una buena práctica declarar todas las variables que se van a utilizar en una función al principio de la función. Esto puede hacer el código más fácil de leer y entender.
Ejemplo:
function calcularPromedio(numeros) {
var suma = 0;
// Declaramos la variable "suma"
var promedio;
// Declaramos la variable "promedio"
for (var i = 0; i < numeros.length;
i++) {
suma += numeros[i];
}
promedio = suma / numeros.length;
// Asignamos un valor a la variable "promedio"
return promedio;
}
Utilizar let y const en lugar de var
A partir de ECMAScript 6, se recomienda utilizar la palabra clave let y const en lugar de var para declarar variables. Esto puede ayudar a prevenir errores en el código y hacerlo más fácil de entender.
Ejemplo:
let nombre = "Juan"; // Utilizamos "let" en lugar de "var"
const PI = 3.1416; // Utilizamos "const" para valores que no cambian
Al trabajar con variables en JavaScript, es importante utilizar nombres descriptivos, evitar variables globales siempre que sea posible, declarar variables al principio de la función, utilizar const para valores que no cambian y utilizar let en lugar de var.
Seguir estas buenas prácticas puede ayudar a hacer el código más legible, fácil de entender y menos propenso a errores.
Uso de variables en JavaScript
El uso de variables en JavaScript se hace para almacenar y manipular valores en el código. Al declarar una variable, se asigna un nombre que hace referencia a ese valor. Luego, se puede utilizar ese nombre para acceder y modificar el valor de la variable en diferentes partes del código.
Hay diferentes maneras de utilizar variables en JavaScript, algunos ejemplos incluyen:
1. Asignación de valores:
Se pueden asignar valores a variables al declararlas o en un momento posterior.
Por ejemplo: var edad = 30;
var edad = 30;
console.log(edad);
// 30
2. Concatenación de cadenas
Se pueden unir dos o más cadenas de texto utilizando el operador +.
Por ejemplo: var nombreCompleto = "Juan" + " Pérez";
var nombre = "Juan";
var apellido = "Pérez";
var nombreCompleto = nombre + " " + apellido;
console.log(nombreCompleto);
// "Juan Pérez"
3. Uso en operaciones matemáticas
Se pueden utilizar variables en operaciones matemáticas para realizar cálculos y asignar el resultado a una nueva variable.
Por ejemplo: var resultado = 10 + 20;
var num1 = 10;
var num2 = 20;
var resultado = num1 + num2;
console.log(resultado);
// 30
4. Uso en condicionales
Se pueden utilizar variables en sentencias condicionales para tomar decisiones en el código.
Por ejemplo: if (edad >= 18) {...}
var edad = 18;
if (edad >= 18) {
console.log("Eres mayor de edad");
}
else {
console.log("Eres menor de edad");
}
// "Eres mayor de edad"
5. Uso en bucles
Se pueden utilizar variables en bucles para repetir un bloque de código varias veces.
Por ejemplo: for (var i = 0; i < 10; i++) {...}
for (var i = 0;
i < 10; i++) {
console.log(i);
} // 0 1 2 3 4 5 6 7 8 9
Variables JavaScript en HTML
Las variables en JavaScript se pueden utilizar en HTML para agregar dinamismo e interactividad a una página web. Al declarar una variable en JavaScript, se puede almacenar información y acceder a ella desde HTML.
Aquí hay un ejemplo de cómo se pueden utilizar las variables en JavaScript en HTML:
Declaración de la variable en JavaScript:
Uso de la variable en HTML: <p>Hola, <script>document.write(nombre);</script>!</p>
El resultado será: Hola, Juan!
En este ejemplo, la variable “nombre” se declara en JavaScript y luego se utiliza en HTML mediante el método document.write() para mostrar su valor en un elemento <p>. Además de utilizar las variables en HTML para mostrar valores, también se pueden utilizar para controlar el comportamiento de la página web, por ejemplo, mostrando y ocultando elementos HTML basados en ciertas condiciones.
De esta forma, se pueden crear experiencias más interactivas y dinámicas para los usuarios.
Más ejemplos Aquí hay un ejemplo más avanzado de cómo se pueden utilizar las variables en JavaScript en HTML:
<!DOCTYPE html>
<html>
<head>
<script>
var num1 = 10;
var num2 = 20;
</script>
</head>
<body>
<h1>Ejemplo de Variables JavaScript en HTML</h1>
<p>El resultado de la suma de <script>document.write(num1);</script> y <script>document.write(num2);</script> es: <script>document.write(num1 + num2);</script></p>
</body>
</html>
El resultado será:
Ejemplo de Variables JavaScript en HTML El resultado de la suma de 10 y 20 es: 30
En este ejemplo, se declaran dos variables en JavaScript: num1 y num2, y luego se utilizan en HTML para calcular la suma de ambos valores y mostrar el resultado en un elemento <p>.
Ejemplos prácticos utilizando variables
A continuación, presentaremos algunos ejemplos prácticos de cómo utilizar las variables en JavaScript en diferentes situaciones:
Ejemplo 1: Calculadora de promedio
En este ejemplo, utilizaremos una función para calcular el promedio de un conjunto de números. Para ello, utilizaremos una variable para almacenar la suma de los números y otra variable para almacenar el promedio.
function calcularPromedio(numeros) {
var suma = 0;
for (var i = 0;
i < numeros.length;
i++) {
suma += numeros[i];
}
var promedio = suma / numeros.length;
return promedio;
}
var numeros = [2, 4, 6, 8];
var promedio = calcularPromedio(numeros);
console.log(promedio);
// Imprime 5 en la consola
Ejemplo 2: Personalización del sitio web
En este ejemplo, utilizaremos una variable para almacenar el nombre del usuario que está interactuando con nuestro sitio web y personalizar la experiencia del usuario en consecuencia.
var nombreUsuario = prompt("Ingrese su nombre:");
var mensajeBienvenida = "Bienvenido, " + nombreUsuario + "!"; document.getElementById("mensaje-bienvenida").innerHTML = mensajeBienvenida;
En este ejemplo, utilizamos la función prompt() para pedir al usuario que ingrese su nombre y almacenamos el valor en la variable nombreUsuario.
Luego, creamos un mensaje de bienvenida utilizando la variable nombreUsuario y lo mostramos en un elemento HTML utilizando la función document.getElementById().
Ejemplo 3: Cambio de colores
En este ejemplo, utilizaremos una variable para almacenar una lista de colores y cambiar el color de fondo de una página web cada vez que se hace clic en un botón.
var colores = ["red", "green", "blue", "yellow", "purple"];
var indiceColor = 0;
document.getElementById("cambiar-color").addEventListener("click", function() {
if (indiceColor == colores.length) {
indiceColor = 0;
}
document.body.style.backgroundColor = colores[indiceColor];
indiceColor++;
});
En este ejemplo, utilizamos la variable colores para almacenar una lista de colores y la variable indiceColor para llevar un seguimiento del índice del color actual.
Luego, utilizamos la función addEventListener() para detectar cuando se hace clic en un botón y cambiamos el color de fondo de la página utilizando la variable indiceColor y la propiedad style.backgroundColor. Si llegamos al final de la lista de colores, volvemos al inicio.
Let en JavaScript
¿Qué es let en JavaScript?
let es una palabra clave de JavaScript que se utiliza para declarar una variable con alcance de bloque. Esto significa que la variable declarada con let solo es visible y accesible dentro del bloque en el que se declaró, lo que puede ayudar a evitar errores y mejorar la legibilidad del código.
La palabra clave let fue introducida en ECMAScript 2015 (también conocido como ES6), una actualización importante del lenguaje que trajo consigo numerosas mejoras y nuevas características.
let aborda algunas de las limitaciones y problemas que los desarrolladores enfrentaban al utilizar la declaración de variables con var, la cual era la única opción disponible antes de ES6.
La sintaxis para declarar una variable con let es:
let variableName;
Por ejemplo:
let age;
age = 30;
console.log(age);
// 30
Además, se puede inicializar una variable al mismo tiempo que se declara:
let name = 'John Doe';
console.log(name);
// John Doe
Es importante tener en cuenta que let es una característica de ECMAScript 6 (ES6) y solo está disponible en navegadores y entornos que soporten ES6. Sin embargo, es una buena práctica usar let en lugar de var para evitar errores comunes relacionados con el alcance.
Diferencia entre var y let
A diferencia de var, que tiene un alcance de función, el alcance de let se limita al bloque en el que se declara. Esto puede ser útil en situaciones en las que no deseas que una variable se utilice fuera de un bloque determinado.
Por ejemplo:
function foo() {
var x = 10;
if (true) {
var x = 20;
console.log(x);
// output: 20
}
console.log(x);
// output: 20 } function bar() {
let y = 10;
if (true) {
let y = 20;
console.log(y);
// output: 20
}
console.log(y);
// output: 10 }
En el ejemplo anterior, var permite la redeclaración de la variable “x” dentro del bloque if,lo que hace que su valor sea 20 tanto dentro como fuera del bloque.
En contraste, let crea una nueva variable “y” dentro del bloque if, lo que hace que su valor sea 20 solo dentro del bloque. Fuera del bloque, la variable “y” mantiene su valor original de 10.
¿Por qué usar let?
Hay varias razones por las que deberíamos considerar el uso de let en lugar de var al declarar variables en JavaScript. Aquí te presentamos algunos de ellos:
1. Evita errores al redeclarar variables
Una de las principales ventajas de let es que evita errores al redeclarar variables. Como vimos en el ejemplo anterior, var permite la redeclaración de una variable dentro de un bloque, lo que puede ser confuso y propenso a errores.
let, por otro lado, no permite la redeclaración de la misma variable dentro de un bloque, lo que ayuda a prevenir errores.
Por ejemplo:
function foo() {
let x = 10;
let x = 20;
// Uncaught SyntaxError: Identifier 'x' has already been declared }
En este ejemplo, se intenta declarar la variable “x” dos veces dentro de la misma función, lo que genera un error de sintaxis. Esto no sucedería si se estuviera utilizando var, lo que podría llevar a errores difíciles de detectar.
2. Alcance de bloque
Otra ventaja de let es que tiene un alcance de bloque, lo que significa que solo es visible y accesible dentro del bloque en el que se declaró. Esto puede ayudar a evitar errores y mejorar la legibilidad del código.
Por ejemplo:
function foo() {
if (true) {
var x = 10;
let y = 20;
}
console.log(x);
// output: 10
console.log(y);
// Uncaught ReferenceError: y is not defined
}
En este ejemplo, var permite que la variable “x” sea visible fuera del bloque if, lo que puede llevar a errores. En cambio, let limita la visibilidad de la variable “y” al bloque if, lo que hace que sea más fácil comprender el flujo del programa.
3. Evita cambios no deseados en variables
Otra ventaja de let es que evita cambios no deseados en variables. Como vimos anteriormente, var permite la redeclaración de una variable dentro de un bloque, lo que puede llevar a cambios no deseados en su valor. let, por otro lado, no permite la redeclaración de la misma variable dentro de un bloque, lo que ayuda a prevenir cambios no deseados en su valor.
Por ejemplo:
function foo() {
let x = 10;
if (true) {
let x = 20;
console.log(x);
// output: 20
}
console.log(x);
// output: 10 }
En este ejemplo, let permite que se cree una nueva variable “x” dentro del bloque if sin afectar al valor de la variable “x” fuera del bloque.
Ejemplos prácticos
Veamos algunos ejemplos prácticos de cómo podemos utilizar let en diferentes situaciones:
1. En bucles
Una de las situaciones más comunes en las que podemos utilizar let es en bucles. Al utilizar var en un bucle, la variable creada se sobrescribe en cada iteración del bucle, lo que puede llevar a errores.
let, por otro lado, crea una nueva variable en cada iteración del bucle, lo que evita estos errores.
Por ejemplo:
for (var i = 0; i < 5; i++) {
setTimeout(function() {
console.log(i);
// output: 5, 5, 5, 5, 5
}, 1000);
} for (let j = 0; j < 5; j++) {
setTimeout(function() {
console.log(j);
// output: 0, 1, 2, 3, 4
}, 1000);
}
En este ejemplo, el primer bucle utiliza var para declarar la variable “i”, lo que lleva a que el valor impreso en la consola sea siempre 5.
En cambio, el segundo bucle utiliza let para declarar la variable “j”, lo que evita este error y permite que se imprima el valor esperado de 0 a 4.
2. En funciones
Otra situación en la que podemos utilizar let es en funciones. Al utilizar let para declarar variables en una función, podemos limitar su visibilidad al ámbito de la función, lo que puede mejorar la legibilidad del código y evitar errores.
Por ejemplo:
function foo() {
var x = 10;
if (true) {
let y = 20;
console.log(x);
// output: 10
console.log(y);
// output: 20
}
console.log(x);
// output: 10
console.log(y);
// Uncaught ReferenceError: y is not defined
}
En este ejemplo, let se utiliza para declarar la variable “y” dentro del bloque if, lo que limita su visibilidad al ámbito de ese bloque.
Esto hace que sea más fácil comprender el flujo del programa y evita errores al intentar acceder a la variable “y” fuera del bloque.
3. En módulos
Finalmente, let también puede ser útil en módulos. Al utilizar let para declarar variables en un módulo, podemos limitar su visibilidad al ámbito del módulo, lo que puede evitar colisiones de nombres y mejorar la legibilidad del código.
Por ejemplo:
// archivo1.js
let x = 10;
export function foo() {
console.log(x);
// output: 10 }
// archivo2.js
let x = 20;
export function bar() {
console.log(x);
// output: 20
}
// main.js
import { foo } from './archivo1.js';
import { bar } from './archivo2.js';
foo(); // output: 10 bar();
// output: 20
En este ejemplo, let se utiliza para declarar la variable “x” en cada uno de los módulos, lo que limita su visibilidad al ámbito del módulo y evita colisiones de nombres al importar las funciones en el archivo main.js. Esto hace que sea más fácil comprender y mantener el código.
Constantes en JavaScript
En este artículo, aprenderemos sobre constantes en JavaScript, su importancia y cómo utilizarlas en nuestros proyectos.
Examinaremos por qué es útil utilizar constantes y cómo pueden ayudarnos a escribir código más mantenible y menos propenso a errores.
¿Qué es una constante en JavaScript?
Una constante en JavaScript es un tipo especial de variable cuyo valor no puede ser modificado una vez que ha sido asignado. A diferencia de las variables regulares, que se pueden actualizar a lo largo de la ejecución de un programa, las constantes mantienen su valor original durante toda su vida útil.
Esto puede ser especialmente útil en situaciones en las que deseamos evitar cambios accidentales en ciertos valores, como configuraciones, ajustes o valores clave en nuestro código.
Propósito de las constantes
Las constantes se definen utilizando la palabra clave const en lugar de var o let. Al utilizar const, le estamos diciendo a JavaScript que el valor asignado a esa variable no debe cambiar.
Si intentamos cambiar el valor de una constante, se producirá un error, lo que nos permite identificar y corregir rápidamente cualquier intento de modificar accidentalmente dicho valor.
El propósito principal de las constantes es garantizar la inmutabilidad de ciertos valores en nuestro código. Al hacer que un valor sea inmutable, podemos estar seguros de que siempre se mantendrá igual y no causará errores o comportamientos inesperados en nuestro programa.
Ventajas de utilizar constantes
Hay varias ventajas en utilizar constantes en lugar de variables regulares en ciertas situaciones:
Evitar modificaciones accidentales: Como las constantes no pueden ser modificadas después de su asignación inicial, podemos estar seguros de que su valor permanecerá igual durante toda la ejecución del programa. Esto puede ayudar a prevenir errores y comportamientos inesperados causados por cambios accidentales en valores clave.
Facilitar la legibilidad del código: Al utilizar constantes para valores que no deben cambiar, estamos comunicando claramente nuestras intenciones a otros desarrolladores que puedan leer nuestro código. Esto facilita la comprensión del propósito y el flujo de nuestro programa.
Facilitar el mantenimiento del código: Cuando utilizamos constantes para valores clave, como configuraciones y ajustes, es más fácil realizar cambios en nuestro código sin afectar otras partes del programa. Si necesitamos cambiar un valor, solo tenemos que actualizar la declaración de la constante, en lugar de buscar y modificar múltiples instancias de dicho valor en nuestro código.
Declaración de constantes en JavaScript
Para declarar una constante en JavaScript, utilizamos la palabra clave const en lugar de var o let. Al igual que con las variables, también debemos asignar un valor inicial a la constante en el momento de la declaración.
A continuación, se explica cómo declarar constantes y se proporcionan ejemplos bien documentados.
Sintaxis para declarar constantes
La sintaxis para declarar una constante en JavaScript es la siguiente:
const nombreConstante = valorInicial;
Donde nombreConstante es el nombre que queremos darle a nuestra constante y valorInicial es el valor que queremos asignarle. Recuerda que las constantes deben ser inicializadas con un valor en el momento de la declaración, y no pueden ser modificadas después.
Declaración de una constante simple
A continuación se muestra un ejemplo de cómo declarar una constante en JavaScript y cómo intentar modificarla resultará en un error:
// Declaración de una constante
const PI = 3.14159;
// Intentar cambiar el valor de la constante producirá un error
// TypeError: Assignment to constant variable.
// PI = 3.14;
console.log('El valor de PI es:', PI);
En este ejemplo, hemos declarado una constante llamada PI y le hemos asignado el valor 3.14159. Cuando intentamos modificar el valor de PI, JavaScript genera un error, lo que nos indica que no podemos cambiar el valor de una constante.
// Declaración de constantes con diferentes tipos de datos
const SALUDO = '¡Hola, mundo!';
const YEAR_FUNDACION = 2021;
const PRECIO = 9.99;
const ES_ACTIVO = true;
// Uso de constantes en el código
console.log(SALUDO);
// Salida: ¡Hola, mundo!
console.log(YEAR_FUNDACION);
// Salida: 2021
console.log(PRECIO);
// Salida: 9.99
console.log(ES_ACTIVO);
// Salida: true
En este segundo ejemplo, hemos declarado varias constantes con diferentes tipos de datos, como cadenas de texto, números y valores booleanos. Luego, utilizamos console.log() para mostrar el valor de cada constante en la salida del programa.
Estos ejemplos demuestran cómo declarar constantes en JavaScript y cómo utilizarlas en nuestro código.
Recuerda que las constantes no pueden ser modificadas una vez que han sido asignadas, lo que nos ayuda a garantizar la inmutabilidad de ciertos valores en nuestro programa.
Constantes y ámbito (scope) en JavaScript
El ámbito (scope) en JavaScript se refiere al contexto en el que una constante o variable está definida y es accesible. Las constantes en JavaScript tienen un ámbito de bloque, lo que significa que solo son accesibles dentro del bloque de código en el que están declaradas.
A continuación, se analiza el ámbito de las constantes y se proporcionan ejemplos bien documentados.
Ámbito global y local
Las constantes pueden tener un ámbito global o local, dependiendo de dónde se declaren en el código. Ámbito global: Cuando una constante se declara fuera de cualquier bloque de código o función, tiene un ámbito global. Esto significa que es accesible desde cualquier parte del código.
Ámbito local: Cuando una constante se declara dentro de un bloque de código o función, tiene un ámbito local. Esto significa que solo es accesible dentro de ese bloque de código o función.
Comparación entre constantes, variables y ámbito
A diferencia de las variables declaradas con
Esto significa que las constantes y variables let son accesibles solo dentro del bloque en el que están declaradas, mientras que las variables var son accesibles en toda la función en la que están declaradas.
Ejemplo práctico
Ámbito global y local de constantes en JavaScript
// Declaración de una constante global
const GLOBAL_CONST = "Soy una constante global";
function ejemploScope() {
// Declaración de una constante local dentro de una función
const LOCAL_CONST = "Soy una constante local";
console.log(GLOBAL_CONST);
// Salida: Soy una constante global
console.log(LOCAL_CONST);
// Salida: Soy una constante local
}
ejemploScope();
// Accediendo a las constantes fuera de la función
console.log(GLOBAL_CONST);
// Salida: Soy una constante global
// console.log(LOCAL_CONST);
// Error: LOCAL_CONST is not defined
En este ejemplo, hemos declarado una constante global (GLOBAL_CONST) y una constante local (LOCAL_CONST). La constante global es accesible tanto dentro como fuera de la función ejemploScope(), mientras que la constante local solo es accesible dentro de la función.
Intentar acceder a LOCAL_CONST fuera de la función resultará en un error, ya que su ámbito está limitado al bloque de código de la función.
Estos ejemplos demuestran cómo el ámbito de las constantes en JavaScript se ve afectado por su ubicación en el código. Comprender el ámbito de las constantes es crucial para evitar errores y garantizar que nuestro código sea fácil de leer y mantener.
Constantes y tipos de datos en JavaScript
En JavaScript, las constantes pueden almacenar diferentes tipos de datos, como tipos de datos primitivos (string, number, boolean) y tipos de datos compuestos (object, array).
A continuación, se exploran constantes con diferentes tipos de datos y se proporcionan ejemplos bien documentados.
Constantes y tipos de datos primitivos
Los tipos de datos primitivos en JavaScript incluyen string (cadenas de texto), number (números) y boolean (valores verdadero o falso). Las constantes pueden almacenar cualquiera de estos tipos de datos primitivos.
Ejemplo de constantes con tipos de datos primitivos:
const NOMBRE = "Juan Pérez";
const EDAD = 30;
const ES_ESTUDIANTE = false;
console.log("Nombre:", NOMBRE);
// Salida: Nombre: Juan Pérez
console.log("Edad:", EDAD);
// Salida: Edad: 30
console.log("¿Es estudiante?:", ES_ESTUDIANTE);
// Salida: ¿Es estudiante?: false
En este ejemplo, hemos declarado y utilizado constantes que almacenan diferentes tipos de datos primitivos, como string, number y boolean.
Constantes y tipos de datos compuestos
Los tipos de datos compuestos en JavaScript incluyen object (objetos) y array (arreglos). Las constantes también pueden almacenar estos tipos de datos compuestos.
Ejemplo de constantes con objetos:
const PERSONA = {
nombre: "María Rodríguez",
edad: 25,
esEstudiante: true
};
console.log("Nombre:", PERSONA.nombre);
// Salida: Nombre: María Rodríguez
console.log("Edad:", PERSONA.edad);
// Salida: Edad: 25
console.log("¿Es estudiante?:", PERSONA.esEstudiante);
// Salida: ¿Es estudiante?: true
En este ejemplo, hemos declarado una constante que almacena un objeto con tres propiedades: nombre, edad y esEstudiante. Luego, accedemos a las propiedades del objeto utilizando la notación de puntos.
Ejemplo de constantes con arreglos:
const FRUTAS = ["manzana", "plátano", "naranja"];
console.log("Fruta 1:", FRUTAS[0]);
// Salida: Fruta 1: manzana
console.log("Fruta 2:", FRUTAS[1]);
// Salida: Fruta 2: plátano
console.log("Fruta 3:", FRUTAS[2]);
// Salida: Fruta 3: naranja
En este ejemplo, hemos declarado una constante que almacena un arreglo de tres elementos. Luego, accedemos a los elementos del arreglo utilizando índices entre corchetes
. Estos ejemplos demuestran cómo las constantes en JavaScript pueden almacenar y trabajar con diferentes tipos de datos, tanto primitivos como compuestos. Comprender cómo utilizar constantes con diversos tipos de datos nos permite aprovechar al máximo la flexibilidad y potencia de JavaScript.
Constantes y objetos en JavaScript
Aunque las constantes en JavaScript no permiten la reasignación de su valor, cuando se trabaja con objetos, es importante tener en cuenta que las propiedades del objeto sí pueden ser modificadas.
En esta sección, exploraremos cómo funcionan las constantes con objetos y proporcionaremos ejemplos bien documentados.
Modificando propiedades de objetos constantes
Cuando una constante almacena un objeto, no se puede reasignar a otro objeto o valor. Sin embargo, las propiedades dentro del objeto pueden ser modificadas, agregadas o eliminadas.
Ejemplo de modificación de propiedades en objetos constantes:
const AUTO = {
marca: "Toyota", modelo: "Corolla", year: 2020 };
// Modificar una propiedad del objeto AUTO.modelo = "Camry";
console.log("Modelo modificado:", AUTO.modelo);
// Salida: Modelo modificado: Camry
// Agregar una nueva propiedad al objeto AUTO.color = "Rojo";
console.log("Color agregado:", AUTO.color);
// Salida: Color agregado: Rojo
// Eliminar una propiedad del objeto delete AUTO.year;
console.log("Propiedad 'año' eliminada:", AUTO.year)
; // Salida: Propiedad 'año' eliminada: undefined
En este ejemplo, hemos declarado una constante que almacena un objeto AUTO. Luego, modificamos una propiedad existente, agregamos una nueva propiedad y eliminamos una propiedad del objeto. Aunque AUTO es una constante, sus propiedades pueden ser modificadas.
Intentando reasignar un objeto constante
A pesar de que las propiedades de un objeto constante pueden ser modificadas, el objeto en sí no puede ser reasignado a otro objeto o valor. Intentar hacerlo resultará en un error.
Ejemplo de intento de reasignación de un objeto constante:
const CIUDAD = {
nombre: "Madrid", país: "España" };
// Intentar reasignar la constante a otro objeto
// TypeError: Assignment to constant variable.
// CIUDAD = {
// nombre: "Barcelona",
// país: "España"
// };
console.log("Nombre de la ciudad:", CIUDAD.nombre);
// Salida: Nombre de la ciudad: Madrid
En este ejemplo, hemos declarado una constante que almacena un objeto CIUDAD. Luego, intentamos reasignar la constante a otro objeto, lo que provoca un error en tiempo de ejecución. Esto demuestra que no podemos reasignar un objeto constante.
En esta sección, exploraremos cómo utilizar constantes con arreglos en JavaScript. Al igual que con los objetos, es posible definir arreglos como constantes, lo que garantiza que su referencia no pueda ser modificada.
Sin embargo, es importante tener en cuenta que los elementos del arreglo en sí aún pueden cambiar, a menos que tomemos precauciones adicionales.
Declaración de arreglos constantes
Para declarar un arreglo constante en JavaScript, utilizamos la palabra clave const seguida del nombre de la constante, en mayúsculas y separado por guiones bajos para facilitar su lectura. Luego, asignamos un arreglo al nombre de la constante usando la sintaxis de corchetes [].
const FRUITS = ['apple', 'banana', 'cherry'];
Inmutabilidad y arreglos constantes
Aunque la referencia al arreglo es constante e inmutable, los elementos dentro del arreglo aún pueden ser modificados.
Veamos un ejemplo:
const FRUITS = ['apple', 'banana', 'cherry'];
console.log(FRUITS);
// ['apple', 'banana', 'cherry'] FRUITS[1] = 'orange';
console.log(FRUITS);
// ['apple', 'orange', 'cherry']
En el ejemplo anterior, hemos cambiado el segundo elemento del arreglo FRUITS. Aunque FRUITS es una constante, sus elementos no están protegidos contra modificaciones.
Si deseamos crear un arreglo completamente inmutable, podemos utilizar el método Object.freeze(). Este método impide que se agreguen, eliminen o modifiquen elementos en un arreglo.
const FRUITS = Object.freeze(['apple', 'banana', 'cherry']);
console.log(FRUITS);
// ['apple', 'banana', 'cherry']
FRUITS[1] = 'orange';
// TypeError: Cannot assign to read-only property '1' of object '[object Array]'
Ahora, si intentamos modificar algún elemento del arreglo FRUITS, JavaScript arrojará un error, ya que el arreglo está congelado y sus elementos no pueden ser modificados.
Uso de constantes con arreglos
Veamos un ejemplo práctico en el que utilizamos constantes con arreglos para almacenar una lista de colores. Luego, crearemos una función que recibe un arreglo de colores y devuelve un mensaje con el color en una posición específica.
const COLORS = Object.freeze(['red', 'blue', 'green', 'yellow', 'purple']);
function getColorMessage(colors, index) {
if (index >= 0 && index < colors.length) {
return `El color en la posición ${index} es ${colors[index]}.`;
}
return 'Índice no válido.';
}
console.log(getColorMessage(COLORS, 2));
// 'El color en la posición 2 es green.'
console.log(getColorMessage(COLORS, 5));
// 'Índice no válido.'
En este ejemplo, hemos utilizado un arreglo constante e inmutable para almacenar una lista de colores. Nuestra función getColorMessage toma como argumentos el arreglo de colores y un índice, y devuelve un mensaje con el color en la posición especificada.
Modificando elementos de arreglos constantes
A pesar de que un arreglo es una constante, sus elementos pueden ser modificados y su longitud puede cambiar mediante la adición o eliminación de elementos.
Ejemplo de modificación de elementos en arreglos constantes:
const NUMEROS = [1, 2, 3, 4, 5];
// Modificar un elemento del arreglo
NUMEROS[2] = 99;
console.log("Arreglo después de modificar el elemento:", NUMEROS);
// Salida: Arreglo después de modificar el elemento: [1, 2, 99, 4, 5]
// Agregar un elemento al final del arreglo
NUMEROS.push(6);
console.log("Arreglo después de agregar un elemento:", NUMEROS);
// Salida: Arreglo después de agregar un elemento: [1, 2, 99, 4, 5, 6]
// Eliminar el último elemento del arreglo
NUMEROS.pop();
console.log("Arreglo después de eliminar un elemento:", NUMEROS);
// Salida: Arreglo después de eliminar un elemento: [1, 2, 99, 4, 5]
En este ejemplo, hemos declarado una constante que almacena un arreglo NUMEROS. Luego, modificamos uno de sus elementos, agregamos un elemento al final del arreglo y eliminamos el último elemento. Aunque NUMEROS es una constante, sus elementos pueden ser modificados y su longitud puede cambiar.
En esta sección, veremos cómo las constantes pueden utilizarse en combinación con funciones en JavaScript.
Las funciones son bloques de código reutilizables que realizan una tarea específica y, a menudo, retornan un valor. Podemos utilizar constantes para almacenar funciones y mantener su referencia inmutable.
Declaración de funciones constantes
Para declarar una función constante en JavaScript, primero necesitamos crear una función utilizando una expresión de función y luego asignarla a una constante. Al hacer esto, garantizamos que la referencia a la función no cambiará durante la ejecución del programa.
Ejemplo práctico: Creación de una función constante
// Crear una función constante que sume dos números
const suma = function(a, b) {
return a + b;
};
// Utilizar la función constante
const resultado = suma(5, 3); console.log(resultado);
// Output: 8
En este ejemplo, hemos creado una función constante llamada suma, que toma dos argumentos, a y b, y devuelve la suma de estos dos números. Luego, llamamos a la función suma y almacenamos el resultado en la variable resultado.
Utilizar constantes como parámetros de funciones
Las constantes pueden ser utilizadas como argumentos al llamar a funciones. Esto asegura que los valores pasados a la función no sean modificados accidentalmente dentro de la función.
Ejemplo práctico:
const PI = 3.14159265359;
const calcularAreaCirculo = (radio) => {
return PI * radio * radio; };
console.log(calcularAreaCirculo(5));
// Output: 78.53981633974
En este ejemplo, utilizamos la constante PI como parte del cálculo del área del círculo en la función calcularAreaCirculo.
Pasar constantes como argumentos a funciones asegura que la función utilice valores inmutables y evita posibles errores.
Utilizar constantes en funciones anidadas
Las constantes también pueden ser utilizadas en funciones anidadas (funciones definidas dentro de otras funciones) para mantener un valor constante a lo largo de todas las llamadas a la función anidada.
Ejemplo práctico:
const FACTOR_CONVERSION = 1.8;
const convertirTemperatura = (temperaturas, unidadDestino) => {
const convertirCelsiusFahrenheit = (gradosCelsius) => {
return gradosCelsius * FACTOR_CONVERSION + 32;
};
const convertirFahrenheitCelsius = (gradosFahrenheit) => {
return (gradosFahrenheit - 32) / FACTOR_CONVERSION;
};
if (unidadDestino === 'F') {
return temperaturas.map(convertirCelsiusFahrenheit);
}
else if (unidadDestino === 'C') {
return temperaturas.map(convertirFahrenheitCelsius);
}
};
const temperaturasCelsius = [0, 20, 30];
console.log(convertirTemperatura(temperaturasCelsius, 'F'));
// Output: [32, 68, 86]
En este ejemplo, hemos definido una constante FACTOR_CONVERSION que se utiliza en las funciones anidadas convertirCelsiusFahrenheit y convertirFahrenheitCelsius para realizar la conversión de temperaturas.
Esto garantiza que el factor de conversión se mantenga constante e inmutable en todas las llamadas a las funciones anidadas.
Funciones puras y constantes
Las constantes son especialmente útiles cuando se trabaja con funciones puras. Las funciones puras son aquellas que no tienen efectos secundarios y siempre devuelven el mismo resultado para los mismos argumentos. Trabajar con funciones puras y constantes puede mejorar la previsibilidad y la capacidad de prueba de nuestro código.
Ejemplo práctico:
const calcularImpuesto = (monto, tasaImpuesto = 0.21) => {
return monto * tasaImpuesto;
};
const IMPUESTO_IVA = 0.21;
const monto = 100;
const impuestoCalculado = calcularImpuesto(monto, IMPUESTO_IVA);
console.log(impuestoCalculado);
// Output: 21
En este ejemplo, hemos definido una función pura llamada calcularImpuesto que calcula el impuesto basado en un monto y una tasa de impuesto. La tasa de impuesto tiene un valor predeterminado, pero también podemos pasar una constante IMPUESTO_IVA como argumento.
Al utilizar constantes y funciones puras, garantizamos que nuestro código sea más predecible y fácil de probar.
Cuando una constante almacena un objeto, no se puede reasignar a otro objeto o valor. Sin embargo, las propiedades dentro del objeto pueden ser modificadas, agregadas o eliminadas.
Ejemplo de modificación de propiedades en objetos constantes:
const AUTO = {
marca: "Toyota", modelo: "Corolla", year: 2020 };
// Modificar una propiedad del objeto AUTO.modelo = "Camry";
console.log("Modelo modificado:", AUTO.modelo);
// Salida: Modelo modificado: Camry
// Agregar una nueva propiedad al objeto AUTO.color = "Rojo";
console.log("Color agregado:", AUTO.color);
// Salida: Color agregado: Rojo
// Eliminar una propiedad del objeto delete AUTO.year;
console.log("Propiedad 'año' eliminada:", AUTO.year)
; // Salida: Propiedad 'año' eliminada: undefined
En este ejemplo, hemos declarado una constante que almacena un objeto AUTO. Luego, modificamos una propiedad existente, agregamos una nueva propiedad y eliminamos una propiedad del objeto. Aunque AUTO es una constante, sus propiedades pueden ser modificadas.
Intentando reasignar un objeto constante
A pesar de que las propiedades de un objeto constante pueden ser modificadas, el objeto en sí no puede ser reasignado a otro objeto o valor. Intentar hacerlo resultará en un error.
Ejemplo de intento de reasignación de un objeto constante:
const CIUDAD = {
nombre: "Madrid", país: "España" };
// Intentar reasignar la constante a otro objeto
// TypeError: Assignment to constant variable.
// CIUDAD = {
// nombre: "Barcelona",
// país: "España"
// };
console.log("Nombre de la ciudad:", CIUDAD.nombre);
// Salida: Nombre de la ciudad: Madrid
En este ejemplo, hemos declarado una constante que almacena un objeto CIUDAD. Luego, intentamos reasignar la constante a otro objeto, lo que provoca un error en tiempo de ejecución. Esto demuestra que no podemos reasignar un objeto constante.
Constantes y arreglos en JavaScript
En esta sección, exploraremos cómo utilizar constantes con arreglos en JavaScript. Al igual que con los objetos, es posible definir arreglos como constantes, lo que garantiza que su referencia no pueda ser modificada.
Sin embargo, es importante tener en cuenta que los elementos del arreglo en sí aún pueden cambiar, a menos que tomemos precauciones adicionales.
Declaración de arreglos constantes
Para declarar un arreglo constante en JavaScript, utilizamos la palabra clave const seguida del nombre de la constante, en mayúsculas y separado por guiones bajos para facilitar su lectura. Luego, asignamos un arreglo al nombre de la constante usando la sintaxis de corchetes [].
const FRUITS = ['apple', 'banana', 'cherry'];
Inmutabilidad y arreglos constantes
Aunque la referencia al arreglo es constante e inmutable, los elementos dentro del arreglo aún pueden ser modificados.
Veamos un ejemplo:
const FRUITS = ['apple', 'banana', 'cherry'];
console.log(FRUITS);
// ['apple', 'banana', 'cherry'] FRUITS[1] = 'orange';
console.log(FRUITS);
// ['apple', 'orange', 'cherry']
En el ejemplo anterior, hemos cambiado el segundo elemento del arreglo FRUITS. Aunque FRUITS es una constante, sus elementos no están protegidos contra modificaciones.
Si deseamos crear un arreglo completamente inmutable, podemos utilizar el método Object.freeze(). Este método impide que se agreguen, eliminen o modifiquen elementos en un arreglo.
const FRUITS = Object.freeze(['apple', 'banana', 'cherry']);
console.log(FRUITS);
// ['apple', 'banana', 'cherry']
FRUITS[1] = 'orange';
// TypeError: Cannot assign to read-only property '1' of object '[object Array]'
Ahora, si intentamos modificar algún elemento del arreglo FRUITS, JavaScript arrojará un error, ya que el arreglo está congelado y sus elementos no pueden ser modificados.
Uso de constantes con arreglos
Veamos un ejemplo práctico en el que utilizamos constantes con arreglos para almacenar una lista de colores. Luego, crearemos una función que recibe un arreglo de colores y devuelve un mensaje con el color en una posición específica.
const COLORS = Object.freeze(['red', 'blue', 'green', 'yellow', 'purple']);
function getColorMessage(colors, index) {
if (index >= 0 && index < colors.length) {
return `El color en la posición ${index} es ${colors[index]}.`;
}
return 'Índice no válido.';
}
console.log(getColorMessage(COLORS, 2));
// 'El color en la posición 2 es green.'
console.log(getColorMessage(COLORS, 5));
// 'Índice no válido.'
En este ejemplo, hemos utilizado un arreglo constante e inmutable para almacenar una lista de colores. Nuestra función getColorMessage toma como argumentos el arreglo de colores y un índice, y devuelve un mensaje con el color en la posición especificada.
Modificando elementos de arreglos constantes
A pesar de que un arreglo es una constante, sus elementos pueden ser modificados y su longitud puede cambiar mediante la adición o eliminación de elementos.
Ejemplo de modificación de elementos en arreglos constantes:
const NUMEROS = [1, 2, 3, 4, 5];
// Modificar un elemento del arreglo
NUMEROS[2] = 99;
console.log("Arreglo después de modificar el elemento:", NUMEROS);
// Salida: Arreglo después de modificar el elemento: [1, 2, 99, 4, 5]
// Agregar un elemento al final del arreglo
NUMEROS.push(6);
console.log("Arreglo después de agregar un elemento:", NUMEROS);
// Salida: Arreglo después de agregar un elemento: [1, 2, 99, 4, 5, 6]
// Eliminar el último elemento del arreglo
NUMEROS.pop();
console.log("Arreglo después de eliminar un elemento:", NUMEROS);
// Salida: Arreglo después de eliminar un elemento: [1, 2, 99, 4, 5]
En este ejemplo, hemos declarado una constante que almacena un arreglo NUMEROS. Luego, modificamos uno de sus elementos, agregamos un elemento al final del arreglo y eliminamos el último elemento. Aunque NUMEROS es una constante, sus elementos pueden ser modificados y su longitud puede cambiar.
Constantes y funciones en JavaScript
En esta sección, veremos cómo las constantes pueden utilizarse en combinación con funciones en JavaScript.
Las funciones son bloques de código reutilizables que realizan una tarea específica y, a menudo, retornan un valor. Podemos utilizar constantes para almacenar funciones y mantener su referencia inmutable.
Declaración de funciones constantes
Para declarar una función constante en JavaScript, primero necesitamos crear una función utilizando una expresión de función y luego asignarla a una constante. Al hacer esto, garantizamos que la referencia a la función no cambiará durante la ejecución del programa.
Ejemplo práctico: Creación de una función constante
// Crear una función constante que sume dos números
const suma = function(a, b) {
return a + b;
};
// Utilizar la función constante
const resultado = suma(5, 3); console.log(resultado);
// Output: 8
En este ejemplo, hemos creado una función constante llamada suma, que toma dos argumentos, a y b, y devuelve la suma de estos dos números. Luego, llamamos a la función suma y almacenamos el resultado en la variable resultado.
Utilizar constantes como parámetros de funciones
Las constantes pueden ser utilizadas como argumentos al llamar a funciones. Esto asegura que los valores pasados a la función no sean modificados accidentalmente dentro de la función.
Ejemplo práctico:
const PI = 3.14159265359;
const calcularAreaCirculo = (radio) => {
return PI * radio * radio; };
console.log(calcularAreaCirculo(5));
// Output: 78.53981633974
En este ejemplo, utilizamos la constante PI como parte del cálculo del área del círculo en la función calcularAreaCirculo.
Pasar constantes como argumentos a funciones asegura que la función utilice valores inmutables y evita posibles errores.
Utilizar constantes en funciones anidadas
Las constantes también pueden ser utilizadas en funciones anidadas (funciones definidas dentro de otras funciones) para mantener un valor constante a lo largo de todas las llamadas a la función anidada.
Ejemplo práctico:
const FACTOR_CONVERSION = 1.8;
const convertirTemperatura = (temperaturas, unidadDestino) => {
const convertirCelsiusFahrenheit = (gradosCelsius) => {
return gradosCelsius * FACTOR_CONVERSION + 32;
};
const convertirFahrenheitCelsius = (gradosFahrenheit) => {
return (gradosFahrenheit - 32) / FACTOR_CONVERSION;
};
if (unidadDestino === 'F') {
return temperaturas.map(convertirCelsiusFahrenheit);
}
else if (unidadDestino === 'C') {
return temperaturas.map(convertirFahrenheitCelsius);
}
};
const temperaturasCelsius = [0, 20, 30];
console.log(convertirTemperatura(temperaturasCelsius, 'F'));
// Output: [32, 68, 86]
En este ejemplo, hemos definido una constante FACTOR_CONVERSION que se utiliza en las funciones anidadas convertirCelsiusFahrenheit y convertirFahrenheitCelsius para realizar la conversión de temperaturas.
Esto garantiza que el factor de conversión se mantenga constante e inmutable en todas las llamadas a las funciones anidadas.
Funciones puras y constantes
Las constantes son especialmente útiles cuando se trabaja con funciones puras. Las funciones puras son aquellas que no tienen efectos secundarios y siempre devuelven el mismo resultado para los mismos argumentos. Trabajar con funciones puras y constantes puede mejorar la previsibilidad y la capacidad de prueba de nuestro código.
Ejemplo práctico:
const calcularImpuesto = (monto, tasaImpuesto = 0.21) => {
return monto * tasaImpuesto;
};
const IMPUESTO_IVA = 0.21;
const monto = 100;
const impuestoCalculado = calcularImpuesto(monto, IMPUESTO_IVA);
console.log(impuestoCalculado);
// Output: 21
En este ejemplo, hemos definido una función pura llamada calcularImpuesto que calcula el impuesto basado en un monto y una tasa de impuesto. La tasa de impuesto tiene un valor predeterminado, pero también podemos pasar una constante IMPUESTO_IVA como argumento.
Al utilizar constantes y funciones puras, garantizamos que nuestro código sea más predecible y fácil de probar.
