Import et export de modules

Depuis ES6, on peut gérer les dépendances entre fichiers avec les mots clés "import" et "export"

export default class Person {
  constructor(name) {
    this.name = name;
  }
  present() {
    console.log("hello, I'm " + this.name);
  }
}

De cette façon, dans un autre script, on pourra avoir :

import Person from "./Person.js";
const p = new Person("Bob")

Attention, il faudra penser à appeler votre js en utilisant l'attribut type="module"

<script type="module" src="test.10-module.js">

Exports et imports multiples

Prenons l'exemple d'un fichier consts.js qui définit les deux constantes pi et nb_or :

export const pi = 3.14159265359;
export const nb_or = 1.61803398875;

Il existe deux syntaxes pour importer ces constantes :

import { pi, nb_or } from "./consts.js";
console.log("pi : ", pi);
console.log("nb_or : ", nb_or);

import * as consts from "./consts.js";
console.log("pi : ", consts.pi);
console.log("nb_or : ", consts.nb_or);

Propriétés privées

Imaginons que nous avons besoin d'une function "createStore" qui permet de créer une propriété state. Imaginons que cette propriété ne doivent pas être accessible en modification directement depuis un autre endroit que la fonction "createStore" elle même.

Voici comment on pourrait s'y prendre :

Fichier store.js

function createStore() {
  let state = 0;
  function getState() {
    return state;
  }
  return {
    getState
  }
}
export default createStore();

Fichier main.js

import store from "./store.js";

console.log("store.state : ", store.getState());

Vous constaterez qu'il n'est pas possible de modifier directement la propriété state de store via main.js avec un code du type :

store.state = 5;

Mode strict

Référence : developer.mozilla.org

L'utilisation des "modules" active le mode "strict".

"use strict";

Le code des modules est automatiquement en mode strict et aucune instruction n'est nécessaire pour passer dans ce mode.

Dans ce mode, le langage js se comporte un peu différement :

Premièrement, il est impossible de créer accidentellement des variables globales.
Deuxièmement, le mode strict fait en sorte que les affectations qui échoueraient silencieusement lèveront aussi une exception. Par exemple, NaN (not a number) est une variable globale en lecture seule. En mode normal, une affectation à NaN ne fera rien ; le développeur ne recevra aucun retour par rapport à cette faute. En mode strict, affecter une valeur quelconque à NaN lèvera une exception.
Troisièmement, le mode strict lèvera une exception lors d'une tentative de suppression d'une propriété non-supprimable (là où cela ne produisait aucun effet en mode non strict) :

"use strict";
```
delete Object.prototype; // lève une TypeError
```
Quatrièmement, le mode strict requiert que toutes les propriétés nommées dans un objet littéral soient uniques. En mode non-strict, les propriétés peuvent être spécifiées deux fois, JavaScript ne retenant que la dernière valeur de la propriété. Cette duplication en devient alors une source de confusion, surtout dans le cas où, dans une modification de ce même code, on se met à changer la valeur de la propriété autrement qu'en changeant la dernière instance. Les noms de propriété en double sont une erreur de syntaxe en mode strict :
```
"use strict";
	var o = { p: 1, p: 2 }; // !!! erreur de syntaxe
```
Cinquièmement, le mode strict requiert que les noms de paramètres de fonction soient uniques. En mode non-strict, le dernier argument dupliqué cache les arguments précédents ayant le même nom. Ces arguments précédents demeurent disponibles via arguments[i], ils ne sont donc pas complètement inaccessibles. Pourtant, cette cachette n'a guère de sens et n'est probablement pas souhaitable (cela pourrait cacher une faute de frappe, par exemple). Donc en mode strict, les doublons de noms d'arguments sont une erreur de syntaxe :
```
function somme(a, a, c) { // !!! erreur de syntaxe
	  "use strict";
	  return a + b + c; // Ce code va planter s'il est exécuté
	}
```
Sixièmement, le mode strict interdit la syntaxe octale. La syntaxe octale ne fait pas partie d'ECMAScript 5, mais elle est supportée dans tous les navigateurs en préfixant le nombre octal d'un zéro : 0644 === 420 et "\045" === "%". La notation octale est supportée en utilisant le préfixe "0o" :

let a = 0o10; // Notation octale ES2015
Les développeurs novices croient parfois qu'un zéro débutant un nombre n'a pas de signification sémantique, alors ils l'utilisent comme moyen d'aligner des colonnes de nombres mais ce faisant, ils changent la valeur du nombre ! La syntaxe octale est rarement utile et peut être utilisée de manière fautive, donc le mode strict le considère comme étant une erreur de syntaxe :
```
"use strict";
	var somme = 015 + // !!! erreur de syntaxe
	            197 +
	            142;
```
Septièmement, le mode strict, à partir d'ECMAScript 2015 interdit de définir des propriétés sur des valeurs primitives. Sans mode strict, de telles définitions sont ignorées. En activant le mode strict cela lèvera une exception TypeError.
```
(function() {
	"use strict";
    false.true = "";         // TypeError
	(14).calvados= "maison";     // TypeError
	"une chaîne".de = "caractères"; // TypeError
	})();
```

coopernet Réussir son site web et ses applications de la conception à la réalisation