From e01b824995a52300a4d4e276a386328b396f28b7 Mon Sep 17 00:00:00 2001 From: yatoogamii Date: Tue, 15 Oct 2019 14:35:32 +0200 Subject: [PATCH] french translate of Dynamic imports finished --- .../03-modules-dynamic-imports/article.md | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/1-js/13-modules/03-modules-dynamic-imports/article.md b/1-js/13-modules/03-modules-dynamic-imports/article.md index b638fd347..1af9557e2 100644 --- a/1-js/13-modules/03-modules-dynamic-imports/article.md +++ b/1-js/13-modules/03-modules-dynamic-imports/article.md @@ -1,48 +1,48 @@ -# Dynamic imports +# Importations dynamiques -Export and import statements that we covered in previous chapters are called "static". The syntax is very simple and strict. +Les déclarations d'exportation et d'importation décrites dans les chapitres précédents sont appelées "statiques". La syntaxe est très simple et stricte. -First, we can't dynamically generate any parameters of `import`. +Premièrement, nous ne pouvons générer dynamiquement aucun paramètre d'`import`. -The module path must be a primitive string, can't be a function call. This won't work: +Le chemin du module doit être une chaîne de caractères, il ne peut pas être un appel de fonction. Exemple, cela ne fonctionnera pas: ```js -import ... from *!*getModuleName()*/!*; // Error, only from "string" is allowed +import ... from *!*getModuleName()*/!*; // Erreur, seulement une chaîne de caractères est autorisé ``` -Second, we can't import conditionally or at run-time: +Deuxièmement, nous ne pouvons pas importer de manière conditionnelle ou au moment de l’exécution: ```js if(...) { - import ...; // Error, not allowed! + import ...; // Erreur, pas autorisé! } { - import ...; // Error, we can't put import in any block + import ...; // Erreur, nous ne pouvons pas importer dans un bloc } ``` -That's because `import`/`export` aim to provide a backbone for the code structure. That's a good thing, as code structure can be analyzed, modules can be gathered and bundled into one file by special tools, unused exports can be removed ("tree-shaken"). That's possible only because the structure of imports/exports is simple and fixed. +C’est parce que `import`/`export` vise à fournir une structure de base à la structure du code. C’est une bonne chose, car la structure du code peut être analysée, les modules peuvent être rassemblés et regroupés dans un fichier à l’aide d’outils spéciaux, les exportations inutilisées peuvent être supprimées ("tree-shaken"). Cela n’est possible que parce que la structure des importations / exportations est simple et fixe. -But how can we import a module dynamically, on-demand? +Mais comment importer un module de manière dynamique, à la demande? -## The import() expression +## L'expression import() -The `import(module)` expression loads the module and returns a promise that resolves into a module object that contains all its exports. It can be called from any place in the code. +L'expression `import(module)` charge le module et renvoie une promesse résolue en un objet de module contenant toutes ses exportations. Il peut être appelé de n’importe quel endroit du code. -We can use it dynamically in any place of the code, for instance: +Nous pouvons l’utiliser dynamiquement à n’importe quel endroit du code, par exemple: ```js let modulePath = prompt("Which module to load?"); import(modulePath) .then(obj => ) - .catch(err => ) + .catch(err => ) ``` -Or, we could use `let module = await import(modulePath)` if inside an async function. +Ou bien, nous pourrions utiliser `let module = await import(modulePath)` s'il se trouve dans une fonction asynchrone. -For instance, if we have the following module `say.js`: +Par exemple, si nous avons le module suivant, `say.js`: ```js // 📁 say.js @@ -55,7 +55,7 @@ export function bye() { } ``` -...Then dynamic import can be like this: +...Alors l'importation dynamique peut être comme ça: ```js let {hi, bye} = await import('./say.js'); @@ -64,7 +64,7 @@ hi(); bye(); ``` -Or, if `say.js` has the default export: +Ou, si `say.js` a l'exportation par défaut: ```js // 📁 say.js @@ -73,26 +73,26 @@ export default function() { } ``` -...Then, in order to access it, we can use `default` property of the module object: +...Ensuite, pour y accéder, nous pouvons utiliser la propriété `default` de l'objet module: ```js let obj = await import('./say.js'); let say = obj.default; -// or, in one line: let {default: say} = await import('./say.js'); +// ou en une ligne: let {default: say} = await import('./say.js'); say(); ``` -Here's the full example: +Voici l’exemple complet: [codetabs src="say" current="index.html"] ```smart -Dynamic imports work in regular scripts, they don't require `script type="module"`. +Les importations dynamiques fonctionnent dans des scripts standard, elles n’exigent pas de `script type="module"`. ``` ```smart -Although `import()` looks like a function call, it's a special syntax that just happens to use parentheses (similar to `super()`). +Bien que `import()` ressemble à un appel de fonction, il s’agit d’une syntaxe spéciale qui utilise des parenthèses (similaire à `super()`). -So we can't copy `import` to a variable or use `call/apply` with it. That's not a function. +Nous ne pouvons donc pas copier `import` dans une variable ni utiliser `call/apply` avec elle. Ce n'est pas une fonction. ```