Fundamentos en

Acerca de Fundamentos

JavaScript es un lenguaje dinámico y basado en prototipos. Tiene unos cuantos tipos primitivos, y todo lo demás se considera un objeto.

Aunque es más conocido como el lenguaje de scripting para páginas web, muchos entornos que no son navegadores también lo usan, como Node.js. El lenguaje está en desarrollo activo y, gracias a su naturaleza multiparadigma, permite muchos estilos de programación. JavaScript es un lenguaje dinámico que admite estilos orientados a objetos, imperativos y declarativos (por ejemplo, la programación funcional).

(Re)asignación

Hay algunas formas principales de asignar valores a nombres en JavaScript: usar variables o constantes. En Exercism, las variables siempre se escriben en camelCase; las constantes se escriben en SCREAMING_SNAKE_CASE. No hay una guía oficial que seguir, y distintas empresas y organizaciones tienen distintas guías de estilo. Siéntete libre de escribir las variables como quieras. La ventaja de escribirlas como están preparados los ejercicios es que se resaltarán de forma distinta en la interfaz web y en la mayoría de los IDE.

En JavaScript, las variables se pueden definir con la palabra clave const, let o var.

Una variable puede hacer referencia a distintos valores a lo largo de su vida útil cuando usas let o var. Por ejemplo, myFirstVariable se puede definir y redefinir muchas veces usando el operador de asignación =:

let myFirstVariable = 1;
myFirstVariable = 'Some string';
myFirstVariable = new SomeComplexClass();

A diferencia de let y var, las variables que se definen con const solo se pueden asignar una vez. Esto se usa para definir constantes en JavaScript.

const MY_FIRST_CONSTANT = 10;

// Can not be re-assigned.
MY_FIRST_CONSTANT = 20;
// => TypeError: Assignment to constant variable.

Asignación de constantes

La palabra clave const se menciona tanto para las variables como para las constantes. Otro concepto que se menciona a menudo en relación con las constantes es la (in)mutabilidad.

La palabra clave const solo hace que el vínculo sea inmutable, es decir, solo puedes asignar un valor a una variable const una vez. En JavaScript, solo los valores primitivos son inmutables. Sin embargo, los valores no primitivos todavía se pueden mutar.

const MY_MUTABLE_VALUE_CONSTANT = { food: 'apple' };

// This is possible
MY_MUTABLE_VALUE_CONSTANT.food = 'pear';

MY_MUTABLE_VALUE_CONSTANT;
// => { food: "pear" }

Valor constante (inmutabilidad)

Como regla general, en Exercism, y en muchas otras organizaciones y guías de estilo de proyectos, no mutes valores que se vean como const SCREAMING_SNAKE_CASE. Técnicamente, los valores sí se pueden cambiar, pero por claridad y para gestionar las expectativas en Exercism, esto no se recomienda. Cuando esto tenga que imponerse, usa Object.freeze(value).

const MY_VALUE_CONSTANT = Object.freeze({ food: 'apple' });

// This silently fails
MY_VALUE_CONSTANT.food = 'pear';

MY_VALUE_CONSTANT;
// => { food: "apple" }

En la práctica, es poco probable ver Object.freeze por toda una base de código, pero la regla de no mutar nunca un valor SCREAMING_SNAKE_CASE es una buena regla; a menudo se hace cumplir con análisis automatizados como un linter.

Declaraciones de funciones

En JavaScript, las unidades de funcionalidad se encapsulan en funciones, que normalmente se agrupan en el mismo archivo si van juntas. Estas funciones pueden recibir parámetros (argumentos) y pueden devolver un valor usando la palabra clave return. Las funciones se llaman usando la sintaxis ().

function add(num1, num2) {
  return num1 + num2;
}

add(1, 3);
// => 4

💡 En JavaScript hay muchas formas distintas de declarar una función. Estas otras formas se ven distintas de usar la palabra clave function. El track intenta introducirlas poco a poco, pero si ya las conoces, siéntete libre de usar cualquiera de ellas. En la mayoría de los casos, usar una u otra no es mejor ni peor.

Exportar e importar

Las palabras clave export e import son herramientas potentes que convierten un archivo JavaScript normal en un módulo de JavaScript. Además de permitir que el código exponga de forma selectiva componentes, como funciones, clases, variables y constantes, también habilita toda una serie de otras funcionalidades, como:

• Renombrar exportaciones e importaciones, lo que te permite evitar conflictos de nombres,
• Importaciones dinámicas, que cargan código a demanda,
• Tree shaking, que reduce el tamaño del código final al eliminar módulos sin efectos secundarios e incluso contenido de módulos que no se usa,
• Exportar vínculos en vivo, lo que te permite exportar un valor que muta en todos los lugares donde se importa si el valor original muta.

Un ejemplo concreto es cómo funcionan las pruebas en el Track de JavaScript de Exercism. Cada ejercicio tiene al menos un archivo de implementación, por ejemplo lasagna.js, y cada ejercicio tiene al menos un archivo de pruebas, por ejemplo lasagna.spec.js. El archivo de implementación usa export para exponer la API pública, y el archivo de pruebas usa import para acceder a ella, y así es como puede probar los resultados de la implementación.

// file.js
export const MY_VALUE = 10;

export function add(num1, num2) {
  return num1 + num2;
}

// file.spec.js
import { MY_VALUE, add } from './file';

add(MY_VALUE, 5);
// => 15