転載：フロントエンドモジュール式のコメント

 

 

モジュラー理解

1.モジュールとは何ですか？

• 特定のルール（仕様）に基づいて、複雑なプロセスは、いくつかのブロック（ファイル）にパッケージ化し、合わせ
• 内部データ・ブロックは、ちょうど他の外部モジュールと外部通信するために、いくつかのインタフェース（メソッド）を公開、独自で実装されています

　　セット、インターフェイスを介して外部からアクセス可能なプライベート特定の機能的役割の内部データやメソッド、

2.モジュラー進化

• グローバル関数モード：異なるグローバル機能パッケージに異なる機能
  • コード：別のグローバル機能のパッケージに異なる機能
  • 質問：グローバルな名前空間を汚染し、簡単に抵触または名前付きデータ不安につながるが、モジュールのメンバー間の直接の関係が表示されません

function m1(){
  //...
}
function m2(){
  //...
}

• 2.namespaceモード：シンプルオブジェクトパッケージ
  • 役割：グローバル変数、解決の名前の競合を削減
  • 問題：データが安全でない（外部データはモジュール内で直接変更することができます）

let myModule = {
  data: 'www.baidu.com',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}
myModule.data = 'other data' //能直接修改模块内部的数据
myModule.foo() // foo() other data

このような文言は、モジュールのすべてのメンバーにさらされることになる、内部の状態を外部から書き換えることができます。

• 3.IIFEモード：関数からの匿名呼び出し（閉鎖）
  • 効果：唯一の方法により、データがプライベートで、外部被ばくの操作
  • 符号化：行動と、内部関数にカプセル化されたデータの属性を追加することにより、インターフェースには、外側に窓を露出させます
  • 質問：このモジュールが他のモジュール電流に依存している場合はどのように行うには？

// index.html文件
<script type="text/javascript" src="module.js"></script>
<script type="text/javascript">
    myModule.foo()
    myModule.bar()
    console.log(myModule.data) //undefined 不能访问模块内部数据
    myModule.data = 'xxxx' //不是修改的模块内部的data
    myModule.foo() //没有改变
</script>

// module.js文件
(function(window) {
  let data = 'www.baidu.com'
  //操作数据的函数
  function foo() {
    //用于暴露有函数
    console.log(`foo() ${data}`)
  }
  function bar() {
    //用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }
  function otherFun() {
    //内部私有的函数
    console.log('otherFun()')
  }
  //暴露行为
  window.myModule = { foo, bar } //ES6写法
//完整写法 window,myModule={foo:foo,bar:bar}
})(window)

最後に、結果が得られ：

• 生命維持の強化モード：依存導入

これは、近代的なモジュールが実装の基礎となるものです

// module.js文件
(function(window, $) {
  let data = 'www.baidu.com'
  //操作数据的函数
  function foo() {
    //用于暴露有函数
    console.log(`foo() ${data}`)
    $('body').css('background', 'red')
  }
  function bar() {
    //用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }
  function otherFun() {
    //内部私有的函数
    console.log('otherFun()')
  }
  //暴露行为
  window.myModule = { foo, bar }
})(window, jQuery)

 // index.html文件
  <!-- 引入的js必须有一定顺序 -->
  <script type="text/javascript" src="jquery-1.10.1.js"></script>
  <script type="text/javascript" src="module.js"></script>
  <script type="text/javascript">
    myModule.foo()
  </script>

赤にページの背景色の例によるjQueryのメソッドは、そのjQueryライブラリの導入は、パラメータとして図書館を置く必要があります。モジュール間の依存関係、さらには明らかになるように、モジュールの独立性を確保するためにそうすることに加えて。

モジュール方式のメリット3。

• （名前空間の汚染を減らすこと）を避けるの名前の競合
• 良好な分離、デマンドロード
• 高い再利用性
• 高いメンテナンス性

4.複数の導入の<script>問題の後

• あまりにも多くの要求

まず、につながる、それが複数の要求を送信しますので、モジュールの数に依存する必要が過度の要求

• 依存ブラー

我々は彼らの特定の依存関係があるのか分からないことが非常にあり、簡単に彼らは間の依存関係を理解していないので、リード負荷シーケンシング・エラーを。

• 維持することは困難

全体が深刻な問題を投影する可能性が高い鉛であるとして、それを維持するのが困難につながっているこれら二つの理由は、実際の状況に影響を与えます。
モジュラーコースは、しかし、複数ページのjsファイルを導入する必要性をいくつかの利点があり、これらの問題の多くのがあるでしょう。これらの問題は、次のは、最も人気のあるcommonjs、AMD、ES6、CMD仕様の開発を説明し、モジュラー仕様によって解決することができます。

第二に、モジュラー仕様

1.CommonJS

現在のノードがCommonJs明細書に使用されます

（1）概要

ノードアプリケーションはCommonJSモジュール仕様を使用して、モジュールから構成されています。各ファイルは、モジュールで、独自のスコープを持っています。変数、関数を定義した文書では、クラスは他の文書に見え、プライベートではありません。サーバー側では、ロードモジュールがロードされ、実行時の同期であり、ブラウザ側では、事前にモジュールコンパイラパッケージの契約。

（2）機能

• モジュールスコープ内のすべてのコードが実行されると、グローバルスコープを汚染しません。
• モジュールは、結果を実行し、複数回ロードすることができますが、ときに最初のロード後にのみ実行され、キャッシュされ、以降、直接リードキャッシュ結果をロードされます。モジュールを再度実行するために取得するには、キャッシュをクリアしなければなりません。
• 順次モジュール、彼らはコードに表示される順序をロードしました。

（3）基本的な構文

• 露出モジュール：module.exports = valueまたはexports.xxx = value
• モジュールの導入：require(xxx)サードパーティ製のモジュール場合、xxxはモジュール名であり、それはカスタムモジュールの場合、モジュールファイルパスのXXX

ここでは、質問があります：？最終的にどのようなCommonJSの露出モジュールは、  CommonJSの仕様、各内部モジュール、モジュール変数は、現在のモジュールを表します。この変数はオブジェクトで、その輸出の属性（すなわちmodule.exportsは）は外部インタフェースです。モジュールをロードし、実際には、それはモジュールのmodule.exportsはプロパティをロードされます。

// example.js
var x = 5;
var addX = function (value) {
  return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

変数xと出力機能module.exportsはADDXによって上記のコード。

var example = require('./example.js');//如果参数字符串以“./”开头，则表示加载的是一个位于相对路径
console.log(example.x); // 5
console.log(example.addX(1)); // 6

コマンドはモジュールファイルをロードするために使用されている必要があります。基本機能は、モジュールのエクスポートオブジェクトを返し、その後読み込み、JavaScriptファイルを実行し、コマンドが必要です。あなたは、指定されたモジュールのエラーが見つからない場合。

（4）モジュールのローディング機構

注：入力値のコピーが出力されているCommonJSモジュールローディング機構。モジュール内の値出力の変化が値には影響しません一度それは、あります。これは、モジュラーES6との大きな違いである（後で説明します）、次の例を考えてみます。

// lib.js
var counter = 3;
function incCounter() {
  counter++;
}
module.exports = {
  counter: counter,
  incCounter: incCounter,
};

上記のコード出力内部変数内部カウンタと、この変数incCounter書き換え方法。

// main.js
var counter = require('./lib').counter;
var incCounter = require('./lib').incCounter;

console.log(counter);  // 3
incCounter();
console.log(counter); // 3

コードは、カウンタに影響を及ぼさないモジュールlib.js内のカウンタの出力が変化した後、上記。これは、カウンタ値がプリミティブ型であるため、それがキャッシュされますです。関数として書かれていない限り、内部変更の値を取得します。

 

（5）サーバ側の実装

①ダウンロードしてインストールするのNode.js

②プロジェクト構造を作成します

注：NPM初期化時間を使用して自動的に生成されたpackage.jsonは、パッケージ名（パッケージ名）は中国との資本を持つことはできません

|-modules
  |-module1.js
  |-module2.js
  |-module3.js
|-app.js
|-package.json
  {
    "name": "commonJS-node",
    "version": "1.0.0"
  }

③ダウンロードサードパーティ製のモジュール

npm install uniq --save // 用于数组去重

④定義モジュールコード

//module1.js
module.exports = {
  msg: 'module1',
  foo() {
    console.log(this.msg)
  }
}

//module2.js
module.exports = function() {
  console.log('module2')
}

//module3.js
exports.foo = function() {
  console.log('foo() module3')
}
exports.arr = [1, 2, 3, 3, 2]

// app.js文件
// 引入第三方库，应该放置在最前面
let uniq = require('uniq')
let module1 = require('./modules/module1')
let module2 = require('./modules/module2')
let module3 = require('./modules/module3')

module1.foo() //module1
module2() //module2
module3.foo() //foo() module3
console.log(uniq(module3.arr)) //[ 1, 2, 3 ]

⑤ノードを通してapp.jsを実行

コマンドラインを入力しnode app.js、JSファイルを実行します

 

（6）ブラウザ側の実装（補助Browserify）

Browserifyは、ブラウザ環境のためのモジュールは、ほかでノード環境のように、ツールをパッケージに使用されrequire(‘modules‘)、両方がNPMモジュールを引用し、あなたも、あなた自身の参照モジュールを書くことができ、モジュール間の参照と依存関係を整理し、その後にパッケージ化JSファイル、およびその後のページを通して<script>負荷にタグ。

もちろん、多くのNodeJSのためにもbrowserifyで梱包後、確かに彼らはあなたができる、ブラウザ側枝サポートモジュールを書き換えるために使用される場合、ブラウザ環境で実行することはできません、操作に関連するようなモジュールIOとして、モジュールbrowserify検索でこれらのモジュールを検索します。

 

①プロジェクト構造を作成します

|-js
  |-dist //打包生成文件的目录
  |-src //源码所在的目录
    |-module1.js
    |-module2.js
    |-module3.js
    |-app.js //应用主源文件
|-index.html //运行于浏览器上
|-package.json
  {
    "name": "browserify-test",
    "version": "1.0.0"
  }

②ダウンロードbrowserify

• グローバル：NPMインストールbrowserify -g
• 局部：NPMはbrowserify --save-devのインストール

③定義モジュールコード（同じサーバー）

注：index.htmlブラウザで実行するファイル、それはbrowserify必要app.js直接場合、ファイルにコンパイルパッケージをindex.html導入しapp.js、エラーがされます！

④プロセスのJSを梱包

ルートディレクトリに実行しますbrowserify js/src/app.js -o js/dist/bundle.js

或者browserify JS / SRC / app.js> JS / DIST / bundle.js

⑤ページが再配布します

index.htmlファイルで導入<script type="text/javascript" src="js/dist/bundle.js"></script>

 

 

 

 

2.AMD

CommonJSの仕様ロードモジュールは、同期である後続の動作を実行するために、唯一のローディングが完了したことを意味します。AMDの仕様では、非同期ロードモジュールでコールバック関数を指定することができ、。Node.jsのは、主にサーバーのプログラミングに使用されているので、モジュールのファイルは、一般的に、すでにCommonJSより適用規範ので、関係なく、道の非同期読み込みのため、より迅速にアップロードし、ローカルのハードディスクに存在しています。しかし、ブラウザ環境場合は、サーバー側のロード・モジュールから、あなたは非同期モードを使用する必要があり、ブラウザは一般的にAMDの仕様を使用します。また、標準よりもAMDの仕様は、初期のブラウザで前方に来るようにCommonJSを達成します。

（1）AMDの基本的な構文仕様

露出モジュールの定義：

//定义没有依赖的模块
define(function(){
   return 模块
})

//定义有依赖的模块
define(['module1', 'module2'], function(m1, m2){
   return 模块
})

モジュールの使用の導入：

require(['module1', 'module2'], function(m1, m2){
   使用m1/m2
})

未使用require.jsを用いて（2）AMD仕様

比較の両方の方法を実装することで、AMDの仕様を使用することの利点を説明します。

• 未使用のAMDの仕様

// dataService.js文件
(function (window) {
  let msg = 'www.baidu.com'
  function getMsg() {
    return msg.toUpperCase()
  }
  window.dataService = {getMsg}
})(window)

// alerter.js文件
(function (window, dataService) {
  let name = 'Tom'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  window.alerter = {showMsg}
})(window, dataService)

// main.js文件
(function (alerter) {
  alerter.showMsg()
})(alerter)

// index.html文件
<div><h1>Modular Demo 1: 未使用AMD(require.js)</h1></div>
<script type="text/javascript" src="js/modules/dataService.js"></script>
<script type="text/javascript" src="js/modules/alerter.js"></script>
<script type="text/javascript" src="js/main.js"></script>

次のように最終的な結果は以下のとおりです。

まず、それ以外の場合は文句を言うでしょう、導入に続いて、JSファイルの順番が間違っていることができない、複数のリクエストを送信します。この方法では、明らかな欠点です！

• require.jsを使用してください

RequireJSは、ツールライブラリ、クライアントを管理するためのメインモジュールです。AMDの仕様に準拠するために、そのモジュラー管理は、基本的な考え方は、メソッドを定義することによりRequireJS、コードをモジュールとして定義されている;方法によってモジュールローディングコードを達成するために必要とします。
次AMDの仕様では、ブラウザで実装手順を説明します。

①ダウンロードrequire.js、との紹介

• 公式サイト： http://www.requirejs.cn/
• githubの： https://github.com/requirejs/requirejs

そして、require.jsインポートプロジェクト：JS / libsに/ require.js

②プロジェクト構造を作成します

|-js
  |-libs
    |-require.js
  |-modules
    |-alerter.js
    |-dataService.js
  |-main.js
|-index.html

③モジュールコード定義require.js

// dataService.js文件
// 定义没有依赖的模块
define(function() {
  let msg = 'www.baidu.com'
  function getMsg() {
    return msg.toUpperCase()
  }
  return { getMsg } // 暴露模块
})

//alerter.js文件
// 定义有依赖的模块
define(['dataService'], function(dataService) {
  let name = 'Tom'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  // 暴露模块
  return { showMsg }
})

// main.js文件
(function() {
  require.config({
    baseUrl: 'js/', //基本路径 出发点在根目录下
    paths: {
      //映射: 模块标识名: 路径
      alerter: './modules/alerter', //此处不能写成alerter.js,会报错
      dataService: './modules/dataService'
    }
  })
  require(['alerter'], function(alerter) {
    alerter.showMsg()
  })
})()

// index.html文件
<!DOCTYPE html>
<html>
  <head>
    <title>Modular Demo</title>
  </head>
  <body>
    <!-- 引入require.js并指定js主文件的入口 -->
    <script data-main="js/main" src="js/libs/require.js"></script>
  </body>
</html>

④ページの導入は、モジュールをrequire.js：

index.htmlの中に導入 <script data-main="js/main" src="js/libs/require.js"></script>

**また、どのようにサードパーティのライブラリプロジェクトに？**ただ、コードベースの軽微な変更上記：

// alerter.js文件
define(['dataService', 'jquery'], function(dataService, $) {
  let name = 'Tom'
  function showMsg() {
    alert(dataService.getMsg() + ', ' + name)
  }
  $('body').css('background', 'green')
  // 暴露模块
  return { showMsg }
})

// main.js文件
(function() {
  require.config({
    baseUrl: 'js/', //基本路径 出发点在根目录下
    paths: {
      //自定义模块
      alerter: './modules/alerter', //此处不能写成alerter.js,会报错
      dataService: './modules/dataService',
      // 第三方库模块
      jquery: './libs/jquery-1.10.1' //注意：写成jQuery会报错
    }
  })
  require(['alerter'], function(alerter) {
    alerter.showMsg()
  })
})()

上記の例では、alerter.js jQueryのファイルでサードパーティライブラリの導入であるファイルパス構成が対応しなければならないmain.js。
概要：二つの方法を比較することで、AMDモジュールの非常に明確な定義を取得することができるが、地球環境を汚染しないであろう、それが依存関係を明確に示すことができます。AMDブラウザ環境モードが使用され、必要に応じてモジュールを動的にロードすることができ、非同期ロードモジュールを可能にすることができます。

 

 

3.CMD

具体的には、ブラウザ側のロードモジュールのCMD仕様は非同期で、それはロードモジュールを実行します。CMD仕様は、機能のCommonJSとAMDの仕様が組み込まれています。Sea.jsでは、すべてのJavaScriptモジュールは、CMDモジュール定義された仕様に従ってください。

（1）CMDの基本的な構文仕様

露出モジュールの定義：

//定义没有依赖的模块
define(function(require, exports, module){
  exports.xxx = value
  module.exports = value
})

//定义有依赖的模块
define(function(require, exports, module){
  //引入依赖模块(同步)
  var module2 = require('./module2')
  //引入依赖模块(异步)
    require.async('./module3', function (m3) {
    })
  //暴露模块
  exports.xxx = value
})

モジュールの使用の導入：

define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})

（2）簡単なチュートリアルをsea.js

①ダウンロードsea.js、との紹介

• 公式サイト：  http://seajs.org/
• github : https://github.com/seajs/seajs

然后将sea.js导入项目: js/libs/sea.js

②创建项目结构

|-js
  |-libs
    |-sea.js
  |-modules
    |-module1.js
    |-module2.js
    |-module3.js
    |-module4.js
    |-main.js
|-index.html

③定义sea.js的模块代码

// module1.js文件
define(function (require, exports, module) {
  //内部变量数据
  var data = 'atguigu.com'
  //内部函数
  function show() {
    console.log('module1 show() ' + data)
  }
  //向外暴露
  exports.show = show
})

// module2.js文件
define(function (require, exports, module) {
  module.exports = {
    msg: 'I Will Back'
  }
})

// module3.js文件
define(function(require, exports, module) {
  const API_KEY = 'abc123'
  exports.API_KEY = API_KEY
})

// module4.js文件
define(function (require, exports, module) {
  //引入依赖模块(同步)
  var module2 = require('./module2')
  function show() {
    console.log('module4 show() ' + module2.msg)
  }
  exports.show = show
  //引入依赖模块(异步)
  require.async('./module3', function (m3) {
    console.log('异步引入依赖模块3  ' + m3.API_KEY)
  })
})

// main.js文件
define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})

④在index.html中引入

<script type="text/javascript" src="js/libs/sea.js"></script>
<script type="text/javascript">
  seajs.use('./js/modules/main')
</script>

最后得到结果如下：

 

4.ES6模块化

ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性。

(1)ES6模块化语法

export命令用于规定模块的对外接口，import命令用于输入其他模块提供的功能。

/** 定义模块 math.js **/
var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };
/** 引用模块 **/
import { basicNum, add } from './math';
function test(ele) {
    ele.textContent = add(99 + basicNum);
}

如上例所示，使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。

// export-default.js
export default function () {
  console.log('foo');
}

// import-default.js
import customName from './export-default';
customName(); // 'foo'

模块默认输出, 其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。

(2)ES6 模块与 CommonJS 模块的差异

它们有两个重大差异：

① CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。

② CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

第二个差异是因为 CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

下面重点解释第一个差异，我们还是举上面那个CommonJS模块的加载机制例子:

// lib.js
export let counter = 3;
export function incCounter() {
  counter++;
}
// main.js
import { counter, incCounter } from './lib';
console.log(counter); // 3
incCounter();
console.log(counter); // 4

ES6 模块的运行机制与 CommonJS 不一样。ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

(3) ES6-Babel-Browserify使用教程

简单来说就一句话：使用Babel将ES6编译为ES5代码，使用Browserify编译打包js。

①定义package.json文件

 {
   "name" : "es6-babel-browserify",
   "version" : "1.0.0"
 }

②安装babel-cli, babel-preset-es2015和browserify

• npm install babel-cli browserify -g
• npm install babel-preset-es2015 --save-dev
• preset 预设(将es6转换成es5的所有插件打包)

③定义.babelrc文件

  {
    "presets": ["es2015"]
  }

④定义模块代码

//module1.js文件
// 分别暴露
export function foo() {
  console.log('foo() module1')
}
export function bar() {
  console.log('bar() module1')
}

//module2.js文件
// 统一暴露
function fun1() {
  console.log('fun1() module2')
}
function fun2() {
  console.log('fun2() module2')
}
export { fun1, fun2 }

//module3.js文件
// 默认暴露 可以暴露任意数据类项，暴露什么数据，接收到就是什么数据
export default () => {
  console.log('默认暴露')
}

// app.js文件
import { foo, bar } from './module1'
import { fun1, fun2 } from './module2'
import module3 from './module3'
foo()
bar()
fun1()
fun2()
module3()

⑤ 编译并在index.html中引入

• 使用Babel将ES6编译为ES5代码(但包含CommonJS语法) : babel js/src -d js/lib
• 使用Browserify编译js : browserify js/lib/app.js -o js/lib/bundle.js

然后在index.html文件中引入

 <script type="text/javascript" src="js/lib/bundle.js"></script>

最后得到如下结果：

此外第三方库(以jQuery为例)如何引入呢？
首先安装依赖npm install jquery@1
然后在app.js文件中引入

//app.js文件
import { foo, bar } from './module1'
import { fun1, fun2 } from './module2'
import module3 from './module3'
import $ from 'jquery'

foo()
bar()
fun1()
fun2()
module3()
$('body').css('background', 'green')

三、总结

• CommonJS规范主要用于服务端编程，加载模块是同步的，这并不适合在浏览器环境，因为同步意味着阻塞加载，浏览器资源是异步加载的，因此有了AMD CMD解决方案。
• AMD规范在浏览器环境中异步加载模块，而且可以并行加载多个模块。不过，AMD规范开发成本高，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。
• CMD规范与AMD规范很相似，都用于浏览器编程，依赖就近，延迟执行，可以很容易在Node.js中运行。不过，依赖SPM 打包，模块的加载逻辑偏重
• ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。