Les directives d’exportation et d’importation ont plusieurs variantes de syntaxe.
Dans l’article précédent, nous avons vu une utilisation simple, explorons maintenant plus d’exemples.
Exporter avant les déclarations
Nous pouvons étiqueter n’importe quelle déclaration comme exportée en plaçant export devant elle, que ce soit une variable, une fonction ou une classe.
Par exemple, ici toutes les exportations sont valides:
// exporter un tableau
export let months = ['Jan', 'Feb', 'Mar','Apr', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// exporter une constante
export const MODULES_BECAME_STANDARD_YEAR = 2015;
// exporter une classe
export class User {
constructor(name) {
this.name = name;
}
}
Veuillez noter que l’export avant une classe ou une fonction n’en fait pas une function expression. C’est toujours une fonction déclaration, bien qu’elle soit exportée.
La plupart des guides de bonnes pratiques JavaScript ne recommandent pas les points-virgules après les déclarations de fonctions et de classes.
C’est pourquoi il n’est pas nécessaire d’utiliser un point-virgule à la fin de export class et de export function:
export function sayHi(user) {
alert(`Hello, ${user}!`);
} // pas de ; à la fin
Exporter en dehors des déclarations
En outre, nous pouvons mettre l’export séparément.
Ici, nous déclarons d’abord, puis exportons:
// 📁 say.js
function sayHi(user) {
alert(`Hello, ${user}!`);
}
function sayBye(user) {
alert(`Bye, ${user}!`);
}
export {sayHi, sayBye}; // une liste de variables exportées
… Ou, techniquement, nous pourrions également définir les fonctions d’export au-dessus des fonctions.
Import *
Habituellement, nous mettons une liste de ce qu’il faut importer entre accolades import {...}, comme ceci:
// 📁 main.js
import {sayHi, sayBye} from './say.js';
sayHi('John'); // Hello, John!
sayBye('John'); // Bye, John!
Mais s’il y a beaucoup à importer, nous pouvons tout importer en tant qu’objet en utilisant import * as <obj>, par exemple:
// 📁 main.js
import * as say from './say.js';
say.sayHi('John');
say.sayBye('John');
À première vue, “importer tout” semble être une chose tellement cool, simple a écrire, pourquoi devrions-nous explicitement énumérer ce que nous devons importer?
Eh bien, il y a quelques raisons.
- Lister explicitement ce qu’il faut importer donne des noms plus courts :
sayHi()au lieu desay.sayHi(). - La liste explicite des importations donne un meilleur aperçu de la structure du code : ce qui est utilisé et où. Cela facilite la prise en charge du code et la refactorisation.
Les outils de construction modernes, tels que webpack et d’autres, regroupent les modules et les optimisent pour accélérer le chargement. Ils ont également supprimé les importations inutilisées.
Par exemple, si vous importer import * as library à partir d’une énorme bibliothèque de codes, puis n’utilisez que quelques méthodes, celles qui ne sont pas utilisées [ne seront pas incluses] (https://github.com/webpack/webpack/tree/main/ examples/harmony-unused#examplejs) dans le bundle optimisé.
Import “as”
Nous pouvons également utiliser as pour importer sous différents noms.
Par exemple, importons sayHi dans la variable locale hi par souci de concision, et importons sayBye en bye:
// 📁 main.js
import {sayHi as hi, sayBye as bye} from './say.js';
hi('John'); // Hello, John!
bye('John'); // Bye, John!
Export “as”
La syntaxe similaire existe pour l’export.
Exportons les fonctions en tant que hi et bye:
// 📁 say.js
...
export {sayHi as hi, sayBye as bye};
Maintenant, hi et bye sont les noms à utiliser dans les importations:
// 📁 main.js
import * as say from './say.js';
say.hi('John'); // Hello, John!
say.bye('John'); // Bye, John!
Export default
En pratique, il existe principalement deux types de modules.
- Les modules qui contiennent une bibliothèque, un pack de fonctions, comme
say.jsci-dessus. - Les modules qui déclarent une seule entité, par exemple un module
user.jsqui exporte uniquement laclass User.
La deuxième approche est généralement privilégiée, de sorte que chaque “chose” réside dans son propre module.
Naturellement, cela nécessite beaucoup de fichiers, car toute chose veut son propre module, mais ce n’est pas un problème du tout. En fait, la navigation dans le code devient plus facile si les fichiers sont bien nommés et structurés en dossiers.
Les modules fournissent une syntaxe spéciale export default (“l’exportation par défaut”) afin d’améliorer l’aspect “une chose par module”.
Placez export default avant l’entité à exporter:
// 📁 user.js
export default class User { // ajouter juste "default"
constructor(name) {
this.name = name;
}
}
Il ne peut y avoir qu’un seul export default par fichier.