Esercizio di dattilografia: Programmazione in linguaggio JavaScript

JavaScript è uno dei linguaggi di programmazione più diffusi al mondo - utilizzato sia nelle applicazioni lato client che lato server. È un linguaggio flessibile, dinamico e in continua evoluzione. Tuttavia, scrivere codice in JavaScript presenta diverse difficoltà. A differenza di Python, dove gli spazi bianchi fanno parte della sintassi, o di Java, dove tutto è fortemente tipizzato e verboso, JavaScript si colloca in una posizione intermedia: permissivo, ma ricco di piccole insidie. Un punto e virgola dimenticato, una virgola di troppo o una parentesi graffa non chiusa possono compromettere l'intero programma. Per gli sviluppatori che passano ore al giorno davanti alla tastiera, la precisione è fondamentale. La dattilografia riduce gli errori, diminuisce l'affaticamento e permette di concentrarsi sulla logica piuttosto che sui tasti.

Tipizzazione dinamica e dichiarazione delle variabili

JavaScript è un linguaggio a tipizzazione dinamica, il che significa che le variabili possono contenere qualsiasi tipo di valore e cambiare tipo durante l'esecuzione. Questa flessibilità rende l'apprendimento più semplice, ma è anche fonte di errori. La dichiarazione delle variabili richiede un uso coerente di let, const e, solo raramente, var (oggi considerato obsoleto). Ciascuna di queste parole chiave ha regole diverse riguardo all'ambito. Un errore di battitura o la scelta sbagliata possono portare a bug difficili da individuare. Con la dattilografia, scrivere const e let diventa automatico e rafforza la disciplina nell'uso della parola chiave corretta nel contesto giusto.

// Usare let per variabili che cambiano
let counter = 0;
counter++;

// Usare const per valori costanti
const PI = 3.14159;

// Evitare var nel codice moderno
var legacy = "stile vecchio";

Punti e virgola e inserimento automatico

Una delle caratteristiche più controverse di JavaScript è l'inserimento automatico dei punti e virgola. Molte istruzioni possono essere scritte senza di essi, ma la loro omissione può portare a errori strani. Un esempio classico è l'uso di return seguito dal valore sulla riga successiva: JavaScript lo interpreta come return;. Per questo motivo, la maggior parte delle guide di stile consiglia di scrivere sempre esplicitamente i punti e virgola. Con la dattilografia, questo gesto piccolo ma ripetitivo diventa un'abitudine naturale.

// Pericoloso: restituisce undefined
function bad() {
  return
  {
    name: "Anna"
  };
}

// Corretto: il punto e virgola assicura il valore di ritorno
function good() {
  return {
    name: "Anna"
  };
}

Oggetti e JSON

JavaScript si basa sugli oggetti. I letterali di oggetto richiedono parentesi graffe {}, due punti : e virgole , nei punti giusti. JSON, che riflette la sintassi degli oggetti JavaScript, è rigoroso: una virgola in più invalida l'intero file. La dattilografia aiuta a rendere la scrittura di questi simboli automatica, lasciando la mente concentrata sulla struttura dei dati.

// Letterale di oggetto
const user = {
  id: 1,
  name: "Anna",
  active: true
};

Funzioni: dichiarazioni, espressioni e arrow functions

JavaScript consente di definire funzioni in vari modi: dichiarazioni classiche, espressioni anonime o arrow functions. Queste ultime utilizzano il simbolo =>, facile da digitare in modo errato. I principianti spesso dimenticano una parentesi o posizionano la freccia nel posto sbagliato. Con la dattilografia, questa sequenza diventa un gesto naturale. JavaScript supporta anche parametri di default, parametri rest (...args) e destrutturazione degli argomenti. Tutto ciò rende il linguaggio espressivo, ma aumenta anche la necessità di precisione nella scrittura del codice.

// Funzione classica
function greet(name) {
  return "Ciao " + name;
}

// Arrow function
const greetArrow = (name) => "Ciao " + name;

// Funzione con parametri di default e rest
function log(message = "Info", ...args) {
  console.log(message, args);
}

Closures e callback

Una delle caratteristiche di JavaScript è l'uso delle closures. Le funzioni possono catturare variabili dal loro contesto. È un concetto potente ma anche fonte di errori, soprattutto nei cicli o nel codice asincrono. Scrivere callback implica spesso molte parentesi graffe annidate. La dattilografia permette di gestire meglio queste strutture, rendendo la scrittura più fluida.

// Closure che cattura una variabile
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

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

Codice asincrono: callback, promise, async/await

JavaScript è stato progettato fin dall'inizio per le operazioni asincrone. Inizialmente si usavano i callback, oggi sono più diffuse le promise e la sintassi async/await. Ciascun approccio ha le proprie esigenze: i callback portano a molti livelli di parentesi, le promise utilizzano catene di .then(), mentre async/await introduce nuove parole chiave. La dattilografia aiuta a scrivere velocemente e senza errori questi schemi ricorrenti.

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

// Esempio con 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);
  }
}

Stile e convenzioni

Mentre in Python si parla di codice "pythonic", in JavaScript le discussioni ruotano attorno a guide di stile come Airbnb, StandardJS o le convenzioni di Google. Queste trattano dell'indentazione (due o quattro spazi), dell'uso dei punti e virgola, delle convenzioni di denominazione (camelCase per le variabili, PascalCase per le classi) e della lunghezza delle righe. Strumenti come ESLint e Prettier fanno rispettare queste regole. Con la dattilografia, il rispetto degli standard diventa più naturale, anche nei modelli ripetitivi come le arrow functions o le catene di metodi.

Errori di sintassi comuni

Tra gli errori più comuni in JavaScript ci sono l'oblio dei backtick nei template string, la confusione tra virgolette semplici e doppie o la mancata chiusura delle parentesi. I template string con interpolazione ${...} sono potenti, ma richiedono una sequenza precisa: backtick, simbolo del dollaro e parentesi graffe. La dattilografia rende questa sequenza un gesto meccanico e naturale.

// Template string con interpolazione
const name = "Anna";
console.log(`Ciao, ${name}!`);

Classi e programmazione orientata agli oggetti

Prima di ES6, JavaScript usava i prototipi. Oggi esiste una sintassi per le classi, anche se i prototipi continuano a funzionare in background. Scrivere classi richiede constructor, super e metodi definiti senza la parola chiave function. Errori comuni sono dimenticare this o posizionare male una parentesi graffa. Con la dattilografia, la scrittura di queste strutture ricorrenti diventa più fluida e precisa. Come in Java, le classi in JavaScript vengono solitamente nominate in PascalCase, il che richiede coerenza.

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

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

Moduli e import

Il JavaScript moderno utilizza i moduli ES con import ed export. Questi spesso contengono percorsi lunghi e parentesi graffe. Scrivere correttamente e rapidamente un'istruzione come import { readFile, writeFile } from "fs"; non è scontato. Con la dattilografia, l'inserimento di parentesi e virgolette diventa automatico e affidabile.

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

Conclusione

JavaScript è un linguaggio dinamico, flessibile ed espressivo. La sua sintassi combina molti simboli - parentesi graffe, parentesi quadre, due punti, virgole, punti e virgola, backtick - rendendo la scrittura precisa una sfida costante. A differenza di Java, non è così prolisso, ma è ricco di piccole trappole. A differenza di Python, non impone l'indentazione, ma la comunità si aspetta una formattazione coerente. La dattilografia aiuta gli sviluppatori a soddisfare queste esigenze: riduce gli errori, accelera la scrittura dei modelli ripetitivi (arrow functions, import) e consente di concentrarsi sul design del programma piuttosto che sulla tastiera. Per chi scrive JavaScript quotidianamente, non è solo una questione di velocità: significa chiarezza, affidabilità e codice funzionante al primo tentativo.