Exercício de digitação: Programação em linguagem JavaScript

JavaScript é uma das linguagens de programação mais utilizadas no mundo - presente tanto em aplicações do lado do cliente quanto do lado do servidor. É uma linguagem flexível, dinâmica e em constante evolução. No entanto, escrever código em JavaScript não é tarefa simples. Diferente do Python, onde os espaços em branco fazem parte da sintaxe, ou do Java, fortemente tipado e verboso, o JavaScript fica em uma posição intermediária: permissivo, mas cheio de pequenas armadilhas. Um ponto e vírgula esquecido, uma vírgula a mais ou uma chave não fechada podem travar todo o programa. Para desenvolvedores que passam horas todos os dias diante do teclado, a precisão é essencial. A prática de digitação, especialmente a datilografia com os dez dedos, ajuda a reduzir erros, diminuir o cansaço e manter o foco na lógica em vez das teclas.

Tipagem dinâmica e declaração de variáveis

JavaScript é uma linguagem de tipagem dinâmica, o que significa que variáveis podem conter qualquer valor e mudar de tipo durante a execução. Essa flexibilidade facilita o aprendizado, mas também é fonte de erros. A declaração de variáveis exige o uso consistente de let e const, enquanto var (hoje considerado ultrapassado) deve ser evitado. Cada palavra-chave possui regras próprias de escopo. Um erro de digitação ou a escolha equivocada pode gerar bugs difíceis de identificar. Com a prática da digitação, escrever const e let se torna automático, reforçando a disciplina no uso adequado das palavras-chave.

// Usar let para variáveis que mudam
let counter = 0;
counter++;

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

// Evitar var em código moderno
var legacy = "estilo antigo";

Ponto e vírgula e inserção automática

Uma das características mais polêmicas do JavaScript é a inserção automática de ponto e vírgula. Muitas instruções podem ser escritas sem eles, mas essa omissão pode causar erros inesperados. Um exemplo clássico é o uso de return seguido do valor na linha seguinte - o JavaScript interpreta isso como return;. Por isso, a maioria dos guias de estilo recomenda sempre escrever os pontos e vírgulas de forma explícita. Graças à digitação treinada, esse pequeno gesto repetitivo se torna um hábito natural.

// Perigoso: retorna undefined
function bad() {
  return
  {
    name: "Maria"
  };
}

// Correto: o ponto e vírgula garante o valor de retorno
function good() {
  return {
    name: "Maria"
  };
}

Objetos e JSON

JavaScript é baseado em objetos. Literais de objeto exigem chaves {}, dois-pontos : e vírgulas , nos lugares corretos. O JSON, que reflete a sintaxe de objetos do JavaScript, é rígido: uma vírgula extra invalida todo o arquivo. A prática de digitação ajuda a tornar a escrita desses símbolos automática, deixando o programador concentrado na estrutura dos dados.

// Objeto literal
const user = {
  id: 1,
  name: "Maria",
  active: true
};

Funções: declarações, expressões e arrow functions

JavaScript permite definir funções de várias maneiras: declarações clássicas, expressões anônimas ou arrow functions. Estas últimas utilizam o símbolo =>, fácil de digitar incorretamente. Iniciantes frequentemente esquecem um parêntese ou posicionam a seta no lugar errado. Com a prática de digitação, essa sequência se torna automática. JavaScript também suporta parâmetros padrão, parâmetros rest (...args) e desestruturação de argumentos. Isso torna a linguagem expressiva, mas aumenta a exigência de precisão na hora de escrever o código.

// Função clássica
function greet(name) {
  return "Olá " + name;
}

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

// Função com parâmetros padrão e rest
function log(message = "Info", ...args) {
  console.log(message, args);
}

Closures e callbacks

Uma das características do JavaScript é o uso de closures. Funções podem capturar variáveis de seu escopo externo. É um recurso poderoso, mas também fonte de erros, principalmente em laços ou em código assíncrono. Escrever callbacks envolve frequentemente várias chaves aninhadas. A digitação com os dez dedos facilita a escrita dessas estruturas repetitivas de forma mais fluida e confiável.

// Closure que captura uma variável
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

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

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

JavaScript foi projetado desde o início para lidar com operações assíncronas. No começo usava-se callbacks, hoje em dia são mais comuns promises e async/await. Cada construção tem suas exigências: callbacks geram muitas chaves, promises usam encadeamento com .then(), e async/await introduz novas palavras-chave. Com a prática da digitação, escrever padrões recorrentes como try { ... } catch(e) { ... } ou await fetch(...) se torna mais rápido e confiável.

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

// Exemplo com 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 e convenções

Enquanto no Python se fala em código "pythonic", no JavaScript as discussões giram em torno de guias de estilo como Airbnb, StandardJS ou as convenções do Google. Esses guias tratam de indentação (dois ou quatro espaços), uso de ponto e vírgula, convenções de nomenclatura (camelCase para variáveis, PascalCase para classes) e tamanho de linha. Ferramentas como ESLint e Prettier aplicam essas regras. A prática de datilografia ajuda a manter esses padrões de forma natural, mesmo em estruturas repetitivas como arrow functions ou cadeias de métodos.

Erros comuns de sintaxe

Entre os erros mais comuns no JavaScript estão esquecer o backtick em template strings, confundir aspas simples e duplas ou não fechar parênteses. Template strings com interpolação ${...} são poderosas, mas exigem uma sequência exata: backtick, cifrão e chaves. A digitação precisa torna essa sequência parte do hábito diário.

// Template string com interpolação
const name = "Maria";
console.log(`Olá, ${name}!`);

Classes e programação orientada a objetos

Antes do ES6, o JavaScript usava protótipos. Hoje existe uma sintaxe de classes, ainda que os protótipos continuem funcionando em segundo plano. Escrever classes exige constructor, super e métodos sem a palavra-chave function. É comum esquecer o this ou posicionar incorretamente uma chave. A prática de digitação ajuda a escrever essas estruturas repetitivas com mais precisão. Assim como no Java, as classes em JavaScript geralmente são escritas em PascalCase, o que requer consistência.

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} faz um som.`);
  }
}

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

Módulos e imports

O JavaScript moderno usa módulos ES com import e export. Estes frequentemente incluem caminhos longos e chaves. Escrever corretamente e rapidamente uma linha como import { readFile, writeFile } from "fs"; não é trivial. Com a prática da digitação, inserir aspas e chaves torna-se automático e confiável.

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

Conclusão

JavaScript é uma linguagem dinâmica, flexível e expressiva. Sua sintaxe combina muitos símbolos - chaves, colchetes, dois-pontos, vírgulas, ponto e vírgula, backticks - o que torna a escrita precisa um desafio constante. Diferente do Java, não é tão verboso, mas está cheio de pequenas armadilhas. Diferente do Python, não impõe indentação, mas a comunidade espera consistência no formato. A prática da digitação e a datilografia com os dez dedos ajudam os desenvolvedores a cumprir essas exigências: menos erros, mais rapidez na escrita de padrões repetitivos (como arrow functions e imports) e maior foco no design do programa em vez do teclado. Para quem escreve JavaScript diariamente, isso não é apenas uma questão de velocidade - é uma questão de clareza, confiabilidade e código que funciona já na primeira execução.