Ejercicio de mecanografía: Programación en lenguaje JavaScript

JavaScript es uno de los lenguajes de programación más utilizados en el mundo, presente tanto en aplicaciones del lado del cliente como del servidor. Es un lenguaje flexible, dinámico y en constante evolución. Sin embargo, escribir código en JavaScript tiene sus dificultades. A diferencia de Python, donde los espacios en blanco son parte de la sintaxis, o de Java, donde todo está fuertemente tipado y es extenso, JavaScript se sitúa en un punto intermedio: es permisivo, pero lleno de pequeñas trampas. Un punto y coma olvidado, una coma extra o una llave mal cerrada pueden romper el programa. Para los desarrolladores que pasan muchas horas al día frente al teclado, la precisión es esencial. Dominar la mecanografía reduce los errores, disminuye la fatiga y permite centrarse en la lógica en lugar de en las teclas.

Tipado dinámico y declaraciones de variables

JavaScript es un lenguaje de tipado dinámico, lo que significa que las variables pueden almacenar cualquier valor y cambiar de tipo durante la ejecución. Esta flexibilidad facilita el inicio, pero también es fuente de errores. Las declaraciones de variables requieren un uso coherente de let, const y, solo en casos excepcionales, var (que hoy en día está desaconsejado). Cada palabra clave tiene reglas distintas sobre el ámbito. Un error tipográfico o la elección incorrecta pueden causar fallos difíciles de detectar. Con la mecanografía, escribir const y let se convierte en algo automático y refuerza la disciplina de utilizar la palabra correcta en el contexto adecuado.

// Usar let para variables que cambian
let counter = 0;
counter++;

// Usar const para valores constantes
const PI = 3.14159;

// Evitar var en código moderno
var legacy = "estilo antiguo";

Puntos y comas y la inserción automática

Una de las características más controvertidas de JavaScript es la inserción automática de puntos y comas. Muchas sentencias pueden escribirse sin ellos, pero omitirlos puede producir errores extraños. Un ejemplo clásico es cuando se escribe return en una línea y el valor en la siguiente: JavaScript lo interpreta como return;. Por eso, la mayoría de las guías de estilo recomiendan escribir siempre el punto y coma de forma explícita. Para quien domina la mecanografía, es un gesto pequeño pero repetido que se vuelve parte natural de la escritura.

// Peligroso: devuelve undefined
function bad() {
  return
  {
    name: "Ana"
  };
}

// Correcto: el punto y coma asegura el valor de retorno
function good() {
  return {
    name: "Ana"
  };
}

Objetos y JSON

JavaScript se basa en objetos. Los literales de objeto requieren llaves {}, dos puntos : y comas , en los lugares correctos. JSON, que refleja la sintaxis de objetos de JavaScript, es estricto: una coma extra invalida todo el archivo. La mecanografía ayuda a automatizar el uso de estos signos, de modo que la mente se concentre en la estructura de los datos.

// Literal de objeto
const user = {
  id: 1,
  name: "Ana",
  active: true
};

Funciones: declaraciones, expresiones y funciones flecha

JavaScript permite definir funciones de varias formas: declaraciones clásicas, expresiones anónimas y funciones flecha. Estas últimas utilizan =>, que es fácil de escribir mal. Los principiantes suelen olvidar un paréntesis o colocar la flecha en el lugar incorrecto. Con la mecanografía, esta secuencia se convierte en un hábito. Además, JavaScript admite parámetros por defecto, parámetros rest (...args) y desestructuración, lo que lo hace expresivo pero exige precisión.

// Función clásica
function greet(name) {
  return "Hola " + name;
}

// Función flecha
const greetArrow = (name) => "Hola " + name;

// Función con parámetro por defecto y rest
function log(message = "Info", ...args) {
  console.log(message, args);
}

Closures y callbacks

Una característica de JavaScript son los closures. Las funciones pueden capturar variables de su entorno. Es muy potente pero también propenso a errores, sobre todo en bucles o código asíncrono. Escribir callbacks implica muchos niveles de llaves y paréntesis. La mecanografía facilita la escritura fluida de estas estructuras, reduciendo la probabilidad de olvidarse de un carácter.

// Closure que captura una variable
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

Código asíncrono: callbacks, promises, async/await

JavaScript fue diseñado desde el inicio para operaciones asíncronas. Al principio se usaban callbacks, hoy en día se prefieren promises y async/await. Cada construcción requiere precisión: los callbacks significan muchas llaves anidadas, las promises necesitan cadenas de .then(), y async/await introduce nuevas palabras clave. Con la mecanografía se hace más fácil escribir estructuras repetidas como try { ... } catch(e) { ... } o await fetch(...) de forma rápida y sin errores.

// Uso de Promise
fetch("/api/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => console.error(err));

// Uso de async/await
async function loadData() {
  try {
    const response = await fetch("/api/data");
    const data = await response.json();
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

Estilo y convenciones

Mientras que en Python se habla de ser "pythonic", en JavaScript las discusiones giran en torno a guías de estilo como Airbnb, StandardJS o las convenciones de Google. Estas cubren la indentación (dos o cuatro espacios), el uso de puntos y comas, las convenciones de nombres (camelCase para variables, PascalCase para clases) y la longitud de las líneas. Herramientas como ESLint y Prettier imponen estas reglas. Con la mecanografía es más fácil seguirlas con constancia y ritmo, incluso en patrones repetitivos como funciones flecha o cadenas de métodos.

Errores de sintaxis comunes

Entre los errores más comunes en JavaScript están olvidar cerrar un template string con backtick, confundir comillas simples y dobles o no cerrar paréntesis. Los template strings con interpolación ${...} son poderosos, pero requieren la secuencia exacta: backtick, símbolo de dólar y llaves. La mecanografía convierte esa secuencia en un movimiento rutinario.

// Template string con interpolación
const name = "Ana";
console.log(`Hola, ${name}!`);

Clases y orientación a objetos

Antes de ES6, JavaScript usaba prototipos. Hoy existe la sintaxis de clases, aunque los prototipos siguen estando presentes en segundo plano. Escribir clases requiere constructor, super y métodos sin la palabra clave function. Es fácil olvidar this o una llave. Con la mecanografía estas estructuras repetitivas son más fáciles y rápidas de escribir. Igual que en Java, las clases en JavaScript se nombran en PascalCase, lo que también exige consistencia.

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} hace un sonido.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} ladra.`);
  }
}

Módulos e imports

La JavaScript moderna usa módulos ES con import y export. A menudo implican rutas largas y llaves. Escribir import { readFile, writeFile } from "fs"; de forma rápida y correcta no es trivial. Con la mecanografía, los programadores adquieren memoria muscular para llaves y comillas, lo que acelera el trabajo con módulos.

import { readFile, writeFile } from "fs";
import express from "express";

Resumen

JavaScript es un lenguaje dinámico, flexible y expresivo. Su sintaxis combina muchos signos - llaves, corchetes, dos puntos, comas, puntos y comas, backticks - lo que convierte la escritura precisa en un reto constante. A diferencia de Java, no es tan verboso, pero está lleno de pequeñas trampas donde un carácter faltante rompe el programa. A diferencia de Python, no obliga a indentar, pero la comunidad espera un formato consistente. La mecanografía ayuda a los desarrolladores a cumplir con estas exigencias: reduce errores, facilita la escritura de patrones repetitivos (funciones flecha, imports) y permite concentrarse en el diseño del programa en lugar del teclado. Para quienes escriben JavaScript varias horas al día, no es solo una cuestión de velocidad: es claridad, fiabilidad y código que funciona a la primera.