Le direttive export e import esistono sotto forma di diverse varianti.
Nell’articolo precedente, ne abbiamo visto un utilizzo molto semplice, ora esploriamo più esempi.
Export prima della dichiarazione
Possiamo etichettare una qualsiasi dichiarazione come esportata, con il prefisso export, sia che questa sia una variabile, una funzione o una classe.
Ad esempio, i seguenti exports sono tutti validi:
// esportiamo un array
export let months = ['Jan', 'Feb', 'Mar','Apr', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// esportiamo una costante
export const MODULES_BECAME_STANDARD_YEAR = 2015;
// esportiamo una classe
export class User {
constructor(name) {
this.name = name;
}
}
Da notare che il termine export prima di una funzione, non la rende un’espressione di funzione. Rimane sempre una dichiarazione di funzione, viene semplicemente esportata.
Molte style guides di JavaScript sconsigliano l’utilizzo del punto e virgola dopo la dichiarazione di una classe o funzione.
Questo è il motivo per cui non c’è alcun bisogno del punto e virgola dopo export class e export function:
export function sayHi(user) {
alert(`Hello, ${user}!`);
} // no ; at the end
Export oltre alle dichiarazioni
Inoltre, possiamo inserire export separatamente.
In questo caso, prima dichiariamo e successivamente esportiamo:
// 📁 say.js
function sayHi(user) {
alert(`Hello, ${user}!`);
}
function sayBye(user) {
alert(`Bye, ${user}!`);
}
export {sayHi, sayBye}; // una lista di variabili esportate
…Oppure, tecnicamente, potremmo inserire export anche prima delle dichiarazioni delle funzioni.
Import *
Solitamente, inseriamo una lista di ciò che vogliamo importare tra le parentesi graffe import {...}, in questo modo:
// 📁 main.js
import {sayHi, sayBye} from './say.js';
sayHi('John'); // Hello, John!
sayBye('John'); // Bye, John!
Ma nel caso in cui ci fossero molti import, potremmo importare tutto come un oggetto, utilizzando import * as <obj>, ad esempio:
// 📁 main.js
import * as say from './say.js';
say.sayHi('John');
say.sayBye('John');
A prima vista, “importa tutto” sembra una cosa comoda, veloce da scrivere, quindi perché dovremmo esplicitare una lista di ciò che vogliamo importare?
Ecco alcune ragioni valide.
-
Gli strumenti moderni di build (webpack ed altri) impacchettano i moduli in modo da ottimizzarli, velocizzarne il caricamento e rimuovere le cose inutili.
Ipotizziamo di aggiungere una libreria di terze parti
say.jsal nostro progetto, che contiene molte funzioni:// 📁 say.js export function sayHi() { ... } export function sayBye() { ... } export function becomeSilent() { ... }Ora utilizziamo solamente una delle funzioni di
say.jsnel nostro progetto:// 📁 main.js import {sayHi} from './say.js';…Ora l’ottimizzazione se ne accorgerà e rimuoverà le altre funzioni dal codice compilato, rendendo il pacchetto più piccolo. Questo viene chiamato “tree-shaking”.
-
Elencare esplicitamente ciò che vogliamo importare ci fornisce nomi più brevi:
sayHi()piuttosto disay.sayHi(). -
Elencare esplicitamente ciò che vogliamo importare ci fornisce una migliore visione della struttura del codice: cosa viene utilizzato e dove. Rende la manutenibilità e il refactoring del codice più semplice.
Import “as”
Possiamo anche utilizzare la keyword as per importare con nomi differenti.
Ad esempio, importiamo sayHi in una variabile locale hi per brevità, e sayBye come bye:
// 📁 main.js
import {sayHi as hi, sayBye as bye} from './say.js';
hi('John'); // Hello, John!
bye('John'); // Bye, John!
Export “as”
Una sintassi molto simile è disponibile per export.
Esportiamo le funzioni come hi e bye:
// 📁 say.js
...
export {sayHi as hi, sayBye as bye};
Ora hi e bye sono i nomi ufficiali per chi le vede esternamente, quelli da utilizzare per gli import:
// 📁 main.js
import * as say from './say.js';
say.hi('John'); // Hello, John!
say.bye('John'); // Bye, John!
Export default
In pratica, esistono principalmente due tipi di moduli.
- Moduli che contengono una libreria: pacchetti di funzioni, come
say.jsvisto sopra. - Moduli che dichiarano una singola entità: esempio un modulo
user.jsche esporta solamenteclass User.
Nella maggior parte dei casi, si preferisce il secondo approccio, in modo tale che ogni “cosa” stia nel suo modulo.
Naturalmente, questa pratica richiede l’utilizzo di molti files, poiché ogni cosa richiede il suo modulo, ma questo non è un problema. In realtà, la navigazione del codice diventa più semplice se tutti i file hanno dei nomi descrittivi e sono ben strutturati all’interno di cartelle.
I moduli forniscono una speciale sintassi, export default (“export di default”), per rendere la pratica “una cosa per modulo” più elegante.
E’ sufficiente inserire export default prima dell’entità da esportare:
// 📁 user.js
export default class User { // aggiungiamo "default"
constructor(name) {
this.name = name;
}
}
Può esserci solamente un export default per file.
…E possiamo importarlo senza le parentesi graffe:
// 📁 main.js
import User from './user.js'; // non {User}, semplicemente User
new User('John');
Gli import senza parentesi graffe sono più eleganti. Un errore comune quando si inizia ad utilizzare i moduli è quello di dimenticarsi le parentesi graffe. Quindi, ricorda, import richiede le parentesi graffe per i named export, ma non le richiedere per i default export.
| Named export | Default export |
|---|---|
export class User {...} |
export default class User {...} |
import {User} from ... |
import User from ... |
Tecnicamente, potremmo avere sia il default che il named export nello stesso modulo, ma in pratica gli sviluppatori non lo fanno. Un modulo può essere named export o default export.
Poiché possiamo utilizzare al massimo un default export per file, l’entità esportata non richiede alcun nome.
Ad esempio, questi sono tutti export default validi:
export default class { // la classe non ha un nome
constructor() { ... }
}
export default function(user) { // la funzione non ha un nome
alert(`Hello, ${user}!`);
}
// esportiamo un valore, senza dichiarare la variabile
export default ['Jan', 'Feb', 'Mar','Apr', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
Non dare un nome va bene, poiché abbiamo un solo export default per file, quindi import senza parentesi graffe, sa cosa importare.
Senza default, questo export genererebbe un errore:
export class { // Errore! (non-default export richiedono un nome)
constructor() {}
}
Il nome di “default”
In alcune situazioni la keyword default per fare riferimento al default export.
Ad esempio, per esportare una funzione separatamente dalla sua definizione:
function sayHi(user) {
alert(`Hello, ${user}!`);
}
// equivalente a "export default"
export {sayHi as default};
Oppure, un’altra situazione, immaginiamo di avere un modulo