JavaScript este unul dintre cele mai utilizate limbaje de programare din lume - prezent atât pe partea de client, cât și pe partea de server. Este un limbaj flexibil, dinamic și aflat într-o continuă evoluție. Totuși, scrierea de cod în JavaScript nu este lipsită de dificultăți. JavaScript delimitează blocurile prin acolade, iar Python folosește indentarea. JavaScript are tipizare dinamică, spre deosebire de Java, care are tipizare statică. Un punct și virgulă uitat, o virgulă în plus sau o acoladă lipsă pot bloca întregul program. Pentru dezvoltatorii care petrec zilnic ore întregi la tastatură, precizia este esențială. Prin exerciții de dactilografie înveți să introduci codul precis, fără să privești tastatura. Astfel poți urmări logica programului în timp ce tastezi, în loc să cauți fiecare tastă.

Tipizare dinamică și declararea variabilelor

JavaScript este un limbaj cu tipizare dinamică, ceea ce înseamnă că variabilele pot conține orice valoare și își pot schimba tipul în timpul execuției. Această flexibilitate ușurează învățarea, dar este și o sursă de erori. Pentru variabile noi se folosesc de obicei let și const, ambele cu domeniu de vizibilitate la nivel de bloc. O variabilă declarată cu let poate primi o nouă valoare, dar o legătură declarată cu const nu poate fi reasignată. var rămâne valid și are domeniu de vizibilitate la nivel de funcție, script sau modul. O greșeală de tastare sau o alegere greșită poate genera bug-uri greu de depistat. Prin dactilografie poți exersa tastarea exactă a cuvintelor-cheie const și let. Alegerea lor depinde de modul în care variabila este folosită în program.

// Folosește let pentru variabile care se modifică
let counter = 0;
counter++;

// Folosește const pentru constante
const PI = 3.14159;

// Evită var în codul modern
var legacy = "stil vechi";

Punct și virgulă și inserarea automată

Una dintre cele mai discutate caracteristici ale JavaScript este inserarea automată a punctului și virgulei. Multe instrucțiuni pot fi scrise fără el, dar lipsa poate cauza erori neașteptate. Un exemplu clasic este utilizarea lui return urmat de valoarea de pe linia următoare - JavaScript interpretează acest lucru ca return;. Expresia returnată trebuie să înceapă pe aceeași linie cu return; adăugarea unui punct și virgulă nu rezolvă această problemă. Unele stiluri cer punct și virgulă, iar altele îl omit, așa că urmează regulile proiectului. Dactilografia face ca această mică apăsare repetitivă să devină un obicei natural.

// Periculos: returnează undefined
function bad() {
  return
  {
    name: "Ion"
  };
}

// Corect: punctul și virgula asigură valoarea returnată
function good() {
  return {
    name: "Ion"
  };
}

Obiecte și JSON

JavaScript se bazează pe obiecte. Literalii de obiect necesită acolade {}, două puncte : și virgule , în pozițiile corecte. JSON, care reflectă sintaxa obiectelor din JavaScript, este strict: o singură virgulă suplimentară face fișierul invalid. Prin dactilografie, introducerea acestor simboluri devine automată, iar atenția rămâne asupra structurii datelor.

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

Funcții: declarații, expresii și arrow functions

JavaScript permite definirea funcțiilor în mai multe moduri: declarații clasice, expresii anonime sau arrow functions. Acestea din urmă folosesc =>, o secvență ușor de tastat greșit. Începătorii uită adesea parantezele sau plasează săgeata în poziția greșită. Prin dactilografie, acest tipar devine natural. JavaScript acceptă și parametri impliciți, parametri rest (...args) și destructurarea argumentelor. Toate acestea sporesc expresivitatea limbajului, dar cer mai multă precizie la scriere.

// Funcție clasică
function greet(name) {
  return "Salut " + name;
}

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

// Funcție cu parametri impliciți și rest
function log(message = "Info", ...args) {
  console.log(message, args);
}

Closures și callbacks

Unul dintre aspectele definitorii ale JavaScript este folosirea closures. Funcțiile pot "captura" variabile din scope-ul exterior. Este o funcționalitate puternică, dar și o sursă de erori, mai ales în bucle sau în cod asincron. Scrierea de callbacks implică deseori multe acolade și paranteze. Dactilografia ușurează tastarea acestor structuri repetitive într-un mod fluid și corect.

// Closure care capturează o variabilă
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

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

Cod asincron: callbacks, promises, async/await

JavaScript permite operații asincrone. Acestea pot fi gestionate prin callbacks, promises și sintaxa async/await. Fiecare construcție are propriile cerințe: callbacks duc la multe acolade, promises utilizează lanțuri cu .then(), iar async/await introduce cuvinte cheie noi. Practica de dactilografie ajută la scrierea rapidă și corectă a acestor tipare recurente.

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

// Exemplu cu 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);
  }
}

Stil și convenții

Așa cum în Python se vorbește despre cod "pythonic", în JavaScript discuțiile se poartă despre ghiduri de stil precum Airbnb, StandardJS sau convențiile Google. Acestea tratează indentarea (două sau patru spații), utilizarea punctului și virgulei, convențiile de denumire (camelCase pentru variabile, PascalCase pentru clase) și lungimea liniilor. Instrumente precum ESLint și Prettier pot verifica sau formata codul în funcție de configurare. Prin dactilografie, respectarea acestor standarde devine mai simplă, chiar și în tipare repetitive precum arrow functions sau lanțuri de metode.

Erori frecvente de sintaxă

Printre erorile comune din JavaScript se numără lipsa backtick-ului în template strings, confuzia între ghilimele simple și duble sau lipsa parantezelor închise. Template strings cu interpolare ${...} sunt foarte puternice, dar necesită o secvență exactă: backtick, semnul dolar și acolade. Dactilografia asigură că această secvență este introdusă corect de fiecare dată.

// Template string cu interpolare
const name = "Ion";
console.log(`Salut, ${name}!`);

Clase și programare orientată pe obiecte

Înainte de ES6, JavaScript folosea prototipuri. Astăzi există o sintaxă pentru clase, chiar dacă prototipurile funcționează în continuare în fundal. Metoda constructor inițializează o instanță, dar nu este obligatoriu să o definești. Prin super se apelează constructorul clasei de bază dintr-un constructor propriu al clasei derivate. Metodele se definesc fără cuvântul-cheie function. Este frecvent să se uite this sau să se greșească poziționarea acoladelor. Dactilografia ajută la tastarea acestor structuri repetitive cu mai multă precizie. Ca și în Java, numele claselor în JavaScript se scriu de obicei în PascalCase, ceea ce necesită consecvență.

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

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

Module și imports

JavaScript-ul modern folosește module ES cu import și export. Acestea includ adesea căi lungi și acolade. Tastarea corectă și rapidă a unei instrucțiuni precum import { readFile, writeFile } from "fs"; nu este trivială. Prin dactilografie, folosirea ghilimelelor și acoladelor devine un reflex sigur.

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

Concluzie

JavaScript este un limbaj dinamic, flexibil și expresiv. Sintaxa sa combină multe simboluri - acolade, paranteze pătrate, două puncte, virgule, punct și virgulă, backticks - ceea ce face ca scrierea precisă să fie o provocare constantă. La fel ca Java, JavaScript distinge între majuscule și minuscule; lipsa unui caracter cerut de sintaxă poate împiedica rularea programului. Spre deosebire de Python, nu impune indentarea, dar comunitatea așteaptă consecvență în formatare. Dactilografia ajută dezvoltatorii să îndeplinească aceste cerințe: mai puține greșeli, mai multă rapiditate în scrierea tiparelor repetitive (precum arrow functions și imports) și o concentrare sporită pe arhitectura programului, nu pe tastatură. Dacă scrii JavaScript zilnic, exercițiile de dactilografie pot ușura tastarea precisă a codului. Pentru ca programul să funcționeze corect, trebuie să îi înțelegi și logica și să îi verifici comportamentul.