Fundamentos en

Acerca de Fundamentos

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

Aunque es más conocido por ser el lenguaje de scripting de las 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 carácter multiparadigma, admite 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).

Asignación (y reasignació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. Escribe 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.

Las variables en JavaScript se pueden definir con la palabra clave const, let o var.

Una variable puede referenciar distintos valores a lo largo de su vida cuando se usa let o var. Por ejemplo, myFirstVariable se puede definir y redefinir muchas veces con 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 variables como para constantes. Otro concepto que se menciona a menudo en relación con las constantes es la (im)mutabilidad.

La palabra clave const solo hace que la vinculación sea inmutable, es decir, solo puedes asignar un valor una vez a una variable const. 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)

Por norma general, en Exercism, y en muchas otras organizaciones y guías de estilo de proyectos, no se mutan los valores que tienen el aspecto de const SCREAMING_SNAKE_CASE. Técnicamente, los valores pueden cambiarse, pero por claridad y para gestionar las expectativas en Exercism se desaconseja hacerlo. Cuando haya que imponerlo, 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 el mundo real, es poco probable ver Object.freeze por todo un código base, pero la regla de no mutar nunca un valor SCREAMING_SNAKE_CASE es una buena regla; a menudo se aplica 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 fichero si van juntas. Estas funciones pueden recibir parámetros (argumentos) y pueden devolver un valor con la palabra clave return. Las funciones se invocan con 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 tienen un aspecto diferente al de usar la palabra clave function. El track intenta presentarlas poco a poco, pero si ya las conoces, puedes usar la que quieras. 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 fichero 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 cuando se necesita,
• 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 vinculaciones en vivo, lo que te permite exportar un valor que muta en todos los sitios 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 fichero de implementación, por ejemplo lasagna.js, y cada ejercicio tiene al menos un fichero de pruebas, por ejemplo lasagna.spec.js. El fichero de implementación usa export para exponer la API pública y el fichero de pruebas usa import para acceder a ella, que es como puede comprobar 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