modules

Author: gambitier

server/calculatorCommonjs.js

@@ -0,0 +1,12 @@
+function add(a, b) {
+	return a + b;
+}
+
+function multiply(a, b) {
+	return a * b;
+}
+
+module.exports = {
+	add,
+	multiply,
+};

server/calculatorEs6.mjs

@@ -0,0 +1,9 @@
+function add(a, b) {
+	return a + b;
+}
+
+function multiply(a, b) {
+	return a * b;
+}
+
+export { add, multiply };

session 1/server/index.html server/index.htmlsession 1/server/index.html renamed to server/index.html

@@ -0,0 +1,3 @@
+var calculator = require('./calculatorCommonjs');
+
+console.log(calculator.add(12, 3));

server/index.js

@@ -0,0 +1,3 @@
+import * as calculator from './calculatorEs6.mjs';
+
+console.log(calculator.add(12, 3));

server/indexEs6.mjs

@@ -0,0 +1,146 @@
+# Modules
+
+As our application grows bigger, we want to split it into multiple files, so called “modules”. A module may contain a class or a library of functions for a specific purpose.
+
+# CommonJS
+
+CommonJS is a volunteer working group that designs and implements JavaScript APIs for declaring modules.
+
+A CommonJS module is essentially a reusable piece of JavaScript which exports specific objects, making them available for other modules to `require` in their programs.
+
+With CommonJS, each JavaScript file stores modules in its own unique module context (just like wrapping it in a closure). In this scope, we use the module.exports object to expose modules, and require to import them.
+
+The require() function is only available by default on Node.js environment.
+
+When you’re defining a CommonJS module, it might look something like this:
+
+```javascript
+function myModule() {
+	this.hello = function () {
+		return 'hello!';
+	};
+
+	this.goodbye = function () {
+		return 'goodbye!';
+	};
+}
+
+module.exports = myModule;
+```
+
+We use the special object module and place a reference of our function into module.exports.
+Then when someone wants to use myModule, they can require it in their file, like so:
+
+```javascript
+var myModule = require('myModule');
+
+var myModuleInstance = new myModule();
+myModuleInstance.hello(); // 'hello!'
+myModuleInstance.goodbye(); // 'goodbye!'
+```
+
+multiple exports
+
+```javascript
+const method = () => {
+	// your method logic
+};
+
+const otherMethod = () => {
+	// your method logic
+};
+
+module.exports = {
+	method,
+	otherMethod,
+	// anotherMethod
+};
+```
+
+**NOTE** that CommonJS takes a server-first approach and **synchronously loads modules**. This matters because if we have three other modules we need to require, it’ll load them one by one.
+
+# ES6 Modules
+
+A module is just a file. One script is one module. As simple as that.
+
+Modules can load each other and use special directives export and import to interchange functionality, call functions of one module from another one:
+
+```javascript
+// 📁 sayHi.js
+export function sayHi(user) {
+	alert(`Hello, ${user}!`);
+}
+
+// 📁 main.js
+import { sayHi } from './sayHi.js';
+
+alert(sayHi); // function...
+sayHi('John'); // Hello, John!
+```
+
+## Multiple named exports
+
+```javascript
+//------ lib.js ------
+export const sqrt = Math.sqrt;
+export function square(x) {
+	return x * x;
+}
+export function diag(x, y) {
+	return sqrt(square(x) + square(y));
+}
+
+//------ main.js ------
+import { square, diag } from 'lib';
+console.log(square(11)); // 121
+console.log(diag(4, 3)); // 5
+```
+
+You can also import the complete module:
+
+```javascript
+//------ main.js ------
+import * as lib from 'lib';
+console.log(lib.square(11)); // 121
+console.log(lib.diag(4, 3)); // 5
+```
+
+## Single default export
+
+There can be a single default export. For example, a function:
+
+```javascript
+//------ myFunc.js ------
+export default function () { ··· } // no semicolon!
+
+//------ main1.js ------
+import myFunc from 'myFunc';
+myFunc();
+```
+
+Or a class:
+
+```javascript
+//------ MyClass.js ------
+export default class { ··· } // no semicolon!
+
+//------ main2.js ------
+import MyClass from 'MyClass';
+const inst = new MyClass();
+```
+
+# ES modules v/s CommonJS
+
+**The ES module format was created to standardize the JavaScript module system.**
+
+    The CommonJS module system, on the other hand, is built into Node.js. Prior to the introduction of the ES module in Node.js, CommonJS was the standard for Node.js modules. As a result, there are plenty of Node.js libraries and modules written with CommonJS.
+
+**CommonJS loads modules synchronously, ES modules are asynchronous**
+
+    One of the limitations of using require() is that it loads modules synchronously. This means that modules are loaded and processed one by one.
+
+    As you might have guessed, this can pose a few performance issues for large-scale applications that hundreds of modules. In such a case, import might outperform require() based on its asynchronous behavior.
+
+**Node.js support for ES modules**
+
+    Older Node.js versions don’t support ES modules