Le basi in

Informazioni su Le basi

JavaScript è un linguaggio dinamico e basato sui prototipi. Ha alcuni tipi primitivi, e tutto il resto è considerato un oggetto.

Sebbene sia noto soprattutto come linguaggio di scripting per le pagine web, anche molti ambienti non browser lo usano, come Node.js. Il linguaggio è in continuo sviluppo e, grazie alla sua natura multi-paradigma, permette molti stili di programmazione. JavaScript è un linguaggio dinamico, che supporta stili orientati agli oggetti, imperativi e dichiarativi (ad esempio la programmazione funzionale).

(Ri)assegnazione

Esistono alcuni modi principali per assegnare valori ai nomi in JavaScript: usando variabili o costanti. Su Exercism, le variabili si scrivono sempre in camelCase; le costanti si scrivono in SCREAMING_SNAKE_CASE. Non esiste una guida ufficiale da seguire, e aziende ed organizzazioni diverse adottano guide di stile diverse. Sentiti libero di scrivere le variabili come preferisci. Il vantaggio di scriverle come sono preparati gli esercizi è che verranno evidenziate in modo diverso nell'interfaccia web e nella maggior parte degli IDE.

In JavaScript, le variabili si possono definire con le parole chiave const, let o var.

Una variabile dichiarata con let o var può fare riferimento a valori diversi nel corso della sua vita. Per esempio, myFirstVariable può essere definita e ridefinita più volte usando l'operatore di assegnazione =:

let myFirstVariable = 1;
myFirstVariable = 'Some string';
myFirstVariable = new SomeComplexClass();

A differenza di let e var, una variabile definita con const può essere assegnata una sola volta. È così che si definiscono le costanti in JavaScript.

const MY_FIRST_CONSTANT = 10;

// Can not be re-assigned.
MY_FIRST_CONSTANT = 20;
// => TypeError: Assignment to constant variable.

Assegnazione delle costanti

La parola chiave const si usa sia per le variabili sia per le costanti. Un altro concetto che viene spesso menzionato a proposito delle costanti è l'(im)mutabilità.

La parola chiave const rende immutabile solo il binding, cioè puoi assegnare un valore ad una variabile const una sola volta. In JavaScript, solo i valori primitivi sono immutabili. I valori non primitivi, invece, si possono comunque mutare.

const MY_MUTABLE_VALUE_CONSTANT = { food: 'apple' };

// This is possible
MY_MUTABLE_VALUE_CONSTANT.food = 'pear';

MY_MUTABLE_VALUE_CONSTANT;
// => { food: "pear" }

Valore costante (immutabilità)

Di norma, su Exercism e in molte altre organizzazioni e guide di stile di progetto, non si mutano i valori che assomigliano a const SCREAMING_SNAKE_CASE. Tecnicamente quei valori si possono cambiare, ma per chiarezza e per non creare aspettative sbagliate su Exercism questo è sconsigliato. Quando bisogna imporlo, 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" }

Nella pratica, è improbabile vedere Object.freeze sparso in tutto il codice, ma la regola di non mutare mai un valore SCREAMING_SNAKE_CASE è una buona regola; spesso viene fatta rispettare con analisi automatiche come un linter.

Dichiarazioni di funzione

In JavaScript, le unità di funzionalità sono incapsulate in funzioni, di solito raggruppate nello stesso file quando stanno insieme. Queste funzioni possono accettare parametri (argomenti) e possono restituire un valore usando la parola chiave return. Le funzioni si chiamano con la sintassi ().

function add(num1, num2) {
  return num1 + num2;
}

add(1, 3);
// => 4

💡 In JavaScript ci sono molti modi diversi per dichiarare una funzione. Questi altri modi sono diversi dall'uso della parola chiave function. Il track cerca di introdurli gradualmente, ma se li conosci già, sentiti libero di usarne uno qualsiasi. Nella maggior parte dei casi, usare l'uno o l'altro non è né meglio né peggio.

Export e import

Le parole chiave export e import sono strumenti potenti che trasformano un normale file JavaScript in un modulo JavaScript. Oltre a permettere al codice di esporre in modo selettivo componenti come funzioni, classi, variabili e costanti, abilitano tutta una serie di altre funzionalità, tra cui:

• Rinominare export e import, che permette di evitare conflitti di nomi,
• gli import dinamici, che caricano il codice su richiesta,
• il tree shaking, che riduce la dimensione del codice finale eliminando i moduli senza effetti collaterali e persino il contenuto dei moduli che non vengono usati,
• l'esportazione di live bindings, che permette di esportare un valore che muta ovunque venga importato, se il valore originale muta.

Un esempio concreto è come funzionano i test sul track JavaScript di Exercism. Ogni esercizio ha almeno un file di implementazione, per esempio lasagna.js, e almeno un file di test, per esempio lasagna.spec.js. Il file di implementazione usa export per esporre l'API pubblica, mentre il file di test usa import per accedervi: è così che può verificare i risultati dell'implementazione.

// 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