Eine ausführliche Einführung in die Webpack-Prinzipien (mit Beispielen)

Dieser Artikel bietet Ihnen eine ausführliche Einführung in die Prinzipien von Webpack (mit Beispielen). Ich hoffe, dass er Ihnen als Referenz dienen wird.

Dieser Artikel wurde aus „Webpack in einfachen Worten“ kopiert. Es wird empfohlen, dass diejenigen, die die Prinzipien lernen möchten, ihn einmal eingeben, ihn einmal bedienen und ihn anderen erklären werden Kennen Sie es.

Ich hoffe, Sie haben praktische Erfahrung im Zusammenhang mit Webpack, sonst werden Sie es nach dem Lesen nicht verstehen.

Es dauert ein paar Minuten, diesen Artikel zu lesen Es dauert lange, es selbst zu verstehen

0 Konfigurationsdatei

Werfen Sie zunächst einen kurzen Blick auf die Webpack-Konfigurationsdatei (webpack.config.js). ):

var path = require('path');
var node_modules = path.resolve(__dirname, 'node_modules');
var pathToReact = path.resolve(node_modules, 'react/dist/react.min.js');

module.exports = {
  // 入口文件，是模块构建的起点，同时每一个入口文件对应最后生成的一个 chunk。
  entry: {
    bundle: [
      'webpack/hot/dev-server',
      'webpack-dev-server/client?http://localhost:8080',
      path.resolve(__dirname, 'app/app.js')
    ]
  },
  // 文件路径指向(可加快打包过程)。
  resolve: {
    alias: {
      'react': pathToReact
    }
  },
  // 生成文件，是模块构建的终点，包括输出文件与输出路径。
  output: {
    path: path.resolve(__dirname, 'build'),
    filename: '[name].js'
  },
  // 这里配置了处理各模块的 loader ，包括 css 预处理 loader ，es6 编译 loader，图片处理 loader。
  module: {
    loaders: [
      {
        test: /\.js$/,
        loader: 'babel',
        query: {
          presets: ['es2015', 'react']
        }
      }
    ],
    noParse: [pathToReact]
  },
  // webpack 各插件对象，在 webpack 的事件流中执行对应的方法。
  plugins: [
    new webpack.HotModuleReplacementPlugin()
  ]
};

1. Überblick über das Arbeitsprinzip

1.1 Grundkonzepte

Bevor Sie die Prinzipien von Webpack verstehen, müssen Sie den folgenden Kern beherrschen Konzepte

• Eintrag: Der erste Schritt der Webpack-Erstellung beginnt mit dem Eintrag

• Modul: Modul Im Webpack entspricht ein Modul einem Datei. Webpack beginnt mit dem Eintrag und findet rekursiv alle abhängigen Module

• Chunk: Codeblock besteht aus mehreren Modulen und wird zum Zusammenführen und Aufteilen von Code verwendet

• Loader: Modulkonverter, der verwendet wird, um den ursprünglichen Inhalt des Moduls nach Bedarf in neuen Inhalt umzuwandeln

• Plugin: Erweiterungs-Plug-in, im Webpack-Build-Prozess Entsprechende Ereignisse wird zu bestimmten Zeiten ausgestrahlt, und Plug-Ins können das Auftreten dieser Ereignisse überwachen und zu bestimmten Zeiten entsprechende Aktionen ausführen

1.2 Prozessübersicht

Webpack vom Start bis end Führen Sie die folgenden Vorgänge nacheinander aus:

graph TD
初始化参数 --> 开始编译 
开始编译 -->确定入口 
确定入口 --> 编译模块
编译模块 --> 完成编译模块
完成编译模块 --> 输出资源
输出资源 --> 输出完成

Die in jeder Phase ausgeführten Vorgänge sind wie folgt:

1. Initialisierungsparameter: Aus der Konfigurationsdatei lesen (Standard webpack.config .js) und Shell-Anweisungen Rufen Sie die Parameter ab und führen Sie sie zusammen, um die endgültigen Parameter zu erhalten

2. Kompilieren starten: Initialisieren Sie das Comiler-Objekt mit den im vorherigen Schritt erhaltenen Parametern, laden Sie alle konfigurierten Plug-Ins , und führen Sie die Ausführungsmethode des Objekts aus. Beginnen Sie mit dem Kompilieren

3. Bestimmen Sie den Eintrag: Finden Sie alle Eintragsdateien gemäß dem Eintrag in der Konfiguration

4. Kompilieren Sie das Modul: Rufen Sie ausgehend von der Eintragsdatei „Alle konfigurierten Loader übersetzen das Modul“ auf, ermitteln Sie dann die Module, von denen das Modul abhängt, und wiederholen Sie dann diesen Schritt, bis alle eintragsabhängigen Dateien verarbeitet wurden

5. Kompilieren Sie das Modul: nach dem vierten Schritt. Nach diesem Schritt werden die endgültigen übersetzten Inhalte jedes Moduls und die Abhängigkeiten zwischen ihnen erhalten.

6. Ausgaberessourcen: Entsprechend den Abhängigkeiten Zwischen dem Eintrag und den Modulen werden sie zu einzelnen Blöcken mehrerer Module zusammengestellt, dann wird jeder Block in eine separate Datei konvertiert und zur Ausgabeliste hinzugefügt. Dies ist die letzte Möglichkeit, den Ausgabeinhalt zu ändern

7. Ausgabe ist abgeschlossen: nach Bestätigung Bestimmen Sie nach der Ausgabe des Inhalts den Ausgabepfad und Dateinamen gemäß der Konfiguration (webpack.config.js && Shell) und schreiben Sie den Inhalt der Datei in das Dateisystem (fs)

Im obigen Prozess sendet Webpack bestimmte Ereignisse zu bestimmten Zeitpunkten, das Plug-in hört auf die Ereignisse und führt die entsprechende Logik aus, und das Plug-in kann Rufen Sie die von Webpack bereitgestellte API auf, um die laufenden Ergebnisse von Webpack zu ändern

1.3 Prozessdetails

Der Webpack-Erstellungsprozess kann in die folgenden drei Phasen unterteilt werden.

1. Initialisierung: Build starten, Konfigurationsparameter lesen und zusammenführen, Plugin laden, Compiler instanziieren

2. Kompilierung: ab Eintrag, für jeden Das Modul ruft seriell den entsprechenden Loader auf, um den Inhalt in der Datei zu übersetzen, findet dann das Modul, von dem das Modul abhängt, und kompiliert es rekursiv

3. Ausgabe: Die kompilierten Module in Chunks kombinieren, konvertieren den Chunk in eine Datei umwandeln und an das Dateisystem ausgeben

Wenn es nur einmal ausgeführt wird, ist der Prozess wie oben, aber wenn der Überwachungsmodus aktiviert ist, ist der Prozess wie folgt folgt

graph TD

  初始化-->编译;
  编译-->输出;
  输出-->文本发生变化
  文本发生变化-->编译

1.3 .1 Initialisierungsphase

Die Ereignisse, die während der Initialisierungsphase auftreten, sind wie folgt

事件	描述
初始化参数	从配置文件和shell语句中读取与合并参数，得出最终的参数，这个过程还会执行配置文件中的插件实例化语句 new Plugin()
实例化Compiler	实例化Compiler,传入上一步得到的参数，Compiler负责文件监听和启动编译。在Compiler实例中包含了完整的webpack配置，全局只有一个Compiler实例。
加载插件	依次调用插件的apply方法，让插件可以监听后续的所有事件节点。同时向插件中传入compiler实例的引用，以方便插件通过compiler调用webpack的api
environment	开始应用Node.js风格的文件系统到compiler对象，以方便后续的文件寻找和读取
Entry-option	读取配置的Entrys,为每个Entry实例化一个对应的EntryPlugin,为后面该Entry的递归解析工作做准备
After-plugins	调用完所有内置的和配置的插件的apply方法
After-resolvers	根据配置初始化resolver,resolver负责在文件系统中寻找指定路径的文件

#### 1.3.2 Kompilierungsphase (Ereignisnamen sind alle in Kleinbuchstaben geschrieben)

事件	解释
run	启动一次编译
Watch-run	在监听模式下启动编译，文件发生变化会重新编译
compile	告诉插件一次新的编译将要启动，同时会给插件带上compiler对象
compilation	当webpack以开发模式运行时，每当检测到文件的变化，便有一次新的compilation被创建。一个Compilation对象包含了当前的模块资源、编译生成资源、变化的文件等。compilation对象也提供了很多事件回调给插件进行拓展
make	一个新的compilation对象创建完毕,即将从entry开始读取文件,根据文件类型和编译的loader对文件进行==编译==,编译完后再找出该文件依赖的文件,递归地编译和解析
after-compile	一次compilation执行完成
invalid	当遇到错误会触发改事件,该事件不会导致webpack退出

Das wichtigste Ereignis in der Kompilierungsphase ist die Kompilierung, da Loader in der Kompilierungsphase aufgerufen wird, um jedes Ereignis abzuschließen ==Conversion==-Vorgang des Moduls. In der Kompilierungsphase treten viele kleine Ereignisse auf, wie in der folgenden Tabelle dargestellt:

事件	解释
build-module	使用相应的Loader去转换一个模块
Normal-module-loader	在使用loader转换完一个模块后，使用acorn解析转换后的内容，输出对应的抽象语法树（AST），以方便webpack对代码进行分析
program	从配置的入口模块开始，分析其AST,当遇到require等导入其他模块的语句时，便将其加入依赖的模块列表中，同时对于新找出来的模块递归分析，最终弄清楚所有模块的依赖关系
seal	所有模块及依赖的模块都通过Loader转换完成，根据依赖关系生成Chunk

2.3 Ausgabephase

Ereignisse und Erklärungen, die in der Ausgabephase auftreten:

事件	解释
should-emit	所有需要输出的文件已经生成,询问插件有哪些文件需要输出,有哪些不需要输出
emit	确定好要输出哪些文件后,执行文件输出,==可以在这里获取和修改输出的内容==
after-mit	文件输出完毕
done	成功完成一次完整的编译和输出流程
failed	如果在编译和输出中出现错误,导致webpack退出,就会直接跳转到本步骤,插件可以在本事件中获取具体的错误原因

在输出阶段已经得到了各个模块经过转化后的结果和其依赖关系,并且将相应的模块组合在一起形成一个个chunk.在输出阶段根据chunk的类型,使用对应的模板生成最终要输出的文件内容. |

//以下代码用来包含webpack运行过程中的每个阶段
//file:webpack.config.js

const path = require('path');
//插件监听事件并执行相应的逻辑
class TestPlugin {
  constructor() {
    console.log('@plugin constructor');
  }

  apply(compiler) {
    console.log('@plugin apply');

    compiler.plugin('environment', (options) => {
      console.log('@environment');
    });

    compiler.plugin('after-environment', (options) => {
      console.log('@after-environment');
    });

    compiler.plugin('entry-option', (options) => {
      console.log('@entry-option');
    });

    compiler.plugin('after-plugins', (options) => {
      console.log('@after-plugins');
    });

    compiler.plugin('after-resolvers', (options) => {
      console.log('@after-resolvers');
    });

    compiler.plugin('before-run', (options, callback) => {
      console.log('@before-run');
      callback();
    });

    compiler.plugin('run', (options, callback) => {
      console.log('@run');
      callback();
    });

    compiler.plugin('watch-run', (options, callback) => {
      console.log('@watch-run');
      callback();
    });

    compiler.plugin('normal-module-factory', (options) => {
      console.log('@normal-module-factory');
    });

    compiler.plugin('context-module-factory', (options) => {
      console.log('@context-module-factory');
    });

    compiler.plugin('before-compile', (options, callback) => {
      console.log('@before-compile');
      callback();
    });

    compiler.plugin('compile', (options) => {
      console.log('@compile');
    });

    compiler.plugin('this-compilation', (options) => {
      console.log('@this-compilation');
    });

    compiler.plugin('compilation', (options) => {
      console.log('@compilation');
    });

    compiler.plugin('make', (options, callback) => {
      console.log('@make');
      callback();
    });

    compiler.plugin('compilation', (compilation) => {

      compilation.plugin('build-module', (options) => {
        console.log('@build-module');
      });

      compilation.plugin('normal-module-loader', (options) => {
        console.log('@normal-module-loader');
      });

      compilation.plugin('program', (options, callback) => {
        console.log('@program');
        callback();
      });

      compilation.plugin('seal', (options) => {
        console.log('@seal');
      });
    });

    compiler.plugin('after-compile', (options, callback) => {
      console.log('@after-compile');
      callback();
    });

    compiler.plugin('should-emit', (options) => {
      console.log('@should-emit');
    });

    compiler.plugin('emit', (options, callback) => {
      console.log('@emit');
      callback();
    });

    compiler.plugin('after-emit', (options, callback) => {
      console.log('@after-emit');
      callback();
    });

    compiler.plugin('done', (options) => {
      console.log('@done');
    });

    compiler.plugin('failed', (options, callback) => {
      console.log('@failed');
      callback();
    });

    compiler.plugin('invalid', (options) => {
      console.log('@invalid');
    });

  }
}

#在目录下执行
webpack
#输出以下内容
@plugin constructor
@plugin apply
@environment
@after-environment
@entry-option
@after-plugins
@after-resolvers
@before-run
@run
@normal-module-factory
@context-module-factory
@before-compile
@compile
@this-compilation
@compilation
@make
@build-module
@normal-module-loader
@build-module
@normal-module-loader
@seal
@after-compile
@should-emit
@emit
@after-emit
@done
Hash: 19ef3b418517e78b5286
Version: webpack 3.11.0
Time: 95ms
    Asset     Size  Chunks             Chunk Names
bundle.js  3.03 kB       0  [emitted]  main
   [0] ./main.js 44 bytes {0} [built]
   [1] ./show.js 114 bytes {0} [built]

2 输出文件分析

2.1 举个栗子

下面通过 Webpack 构建一个采用 CommonJS 模块化编写的项目，该项目有个网页会通过 JavaScript 在网页中显示 Hello,Webpack。

运行构建前，先把要完成该功能的最基础的 JavaScript 文件和 HTML 建立好，需要如下文件：

页面入口文件 index.html

  <meta>


<p></p>
<!--导入 Webpack 输出的 JavaScript 文件-->
<script></script>

JS 工具函数文件 show.js

// 操作 DOM 元素，把 content 显示到网页上
function show(content) {
  window.document.getElementById('app').innerText = 'Hello,' + content;
}

// 通过 CommonJS 规范导出 show 函数
module.exports = show;

JS 执行入口文件 main.js

// 通过 CommonJS 规范导入 show 函数
const show = require('./show.js');
// 执行 show 函数
show('Webpack');

Webpack 在执行构建时默认会从项目根目录下的 webpack.config.js 文件读取配置，所以你还需要新建它，其内容如下：

const path = require('path');

module.exports = {
  // JavaScript 执行入口文件
  entry: './main.js',
  output: {
    // 把所有依赖的模块合并输出到一个 bundle.js 文件
    filename: 'bundle.js',
    // 输出文件都放到 dist 目录下
    path: path.resolve(__dirname, './dist'),
  }
};

由于 Webpack 构建运行在 Node.js 环境下，所以该文件最后需要通过 CommonJS 规范导出一个描述如何构建的 Object 对象。

|-- index.html
|-- main.js
|-- show.js
|-- webpack.config.js

一切文件就绪，在项目根目录下执行 webpack 命令运行 Webpack 构建，你会发现目录下多出一个 dist目录，里面有个 bundle.js 文件， bundle.js 文件是一个可执行的 JavaScript 文件，它包含页面所依赖的两个模块 main.js 和 show.js 及内置的 webpackBootstrap 启动函数。 这时你用浏览器打开 index.html 网页将会看到 Hello,Webpack。

2.2 bundle.js文件做了什么

看之前记住：一个模块就是一个文件，

首先看下bundle.js长什么样子：

注意：序号1处是个自执行函数，序号2作为自执行函数的参数传入

具体代码如下：（建议把以下代码放入编辑器中查看，最好让index.html执行下，弄清楚执行的顺序）

(function(modules) { // webpackBootstrap
  // 1. 缓存模块
  var installedModules = {};
  // 2. 定义可以在浏览器使用的require函数
  function __webpack_require__(moduleId) {

    // 2.1检查模块是否在缓存里，在的话直接返回
    if(installedModules[moduleId]) {
      return installedModules[moduleId].exports;
    }
    // 2.2 模块不在缓存里，新建一个对象module=installModules[moduleId] {i:moduleId,l:模块是否加载,exports:模块返回值}
    var module = installedModules[moduleId] = {
      i: moduleId,//第一次执行为0
      l: false,
      exports: {}
    };//第一次执行module:{i:0,l:false,exports:{}}
    // 2.3 执行传入的参数中对应id的模块 第一次执行数组中传入的第一个参数
          //modules[0].call({},{i:0,l:false,exports:{}},{},__webpack_require__函数)
    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
    // 2.4 将这个模块标记为已加载
    module.l = true;
    // 2.5 返回这个模块的导出值
    return module.exports;
  }
  // 3. webpack暴露属性 m c d n o p
  __webpack_require__.m = modules;
  __webpack_require__.c = installedModules;
  __webpack_require__.d = function(exports, name, getter) {
    if(!__webpack_require__.o(exports, name)) {
      Object.defineProperty(exports, name, {
        configurable: false,
        enumerable: true,
        get: getter
      });
    }
  };
  __webpack_require__.n = function(module) {
    var getter = module && module.__esModule ?
      function getDefault() { return module['default']; } :
      function getModuleExports() { return module; };
    __webpack_require__.d(getter, 'a', getter);
    return getter;
  };
  __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  __webpack_require__.p = "";
  // 4. 执行reruire函数引入第一个模块(main.js对应的模块)
  return __webpack_require__(__webpack_require__.s = 0);
})
([ // 0. 传入参数，参数是个数组

  /* 第0个参数 main.js对应的文件*/
  (function(module, exports, __webpack_require__) {

    // 通过 CommonJS 规范导入 show 函数
    const show = __webpack_require__(1);//__webpack_require__(1)返回show
    // 执行 show 函数
    show('Webpack');

  }),
  /* 第1个参数 show.js对应的文件 */
  (function(module, exports) {

    // 操作 DOM 元素，把 content 显示到网页上
    function show(content) {
      window.document.getElementById('app').innerText = 'Hello,' + content;
    }
    // 通过 CommonJS 规范导出 show 函数
    module.exports = show;

  })
]);

以上看上去复杂的代码其实是一个自执行函数(文件作为自执行函数的参数)，可以简写如下：

(function(modules){
    //模拟require语句
    function __webpack_require__(){}
    //执行存放所有模块数组中的第0个模块(main.js)
    __webpack_require_[0]
})([/*存放所有模块的数组*/])

bundles.js能直接在浏览器中运行的原因是，在输出的文件中通过__webpack_require__函数,定义了一个可以在浏览器中执行的加载函数(加载文件使用ajax实现),来模拟Node.js中的require语句。

原来一个个独立的模块文件被合并到了一个单独的 bundle.js 的原因在于浏览器不能像 Node.js 那样快速地去本地加载一个个模块文件，而必须通过网络请求去加载还未得到的文件。 如果模块数量很多，加载时间会很长，因此把所有模块都存放在了数组中，执行一次网络加载。

修改main.js,改成import引入模块

import show from './show';
show('Webpack');

在目录下执行webpack，会发现：

1. 生成的代码会有所不同，但是主要的区别是自执行函数的参数不同，也就是2.2代码的第二部分不同

([//自执行函数和上面相同，参数不同
/* 0 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__show__ = __webpack_require__(1);

Object(__WEBPACK_IMPORTED_MODULE_0__show__["a" /* default */])('Webpack');


}),
/* 1 */
(function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = show;
function show(content) {
  window.document.getElementById('app').innerText = 'Hello,' + content;
}


})
]);

参数不同的原因是es6的import和export模块被webpack编译处理过了,其实作用是一样的，接下来看一下在main.js中异步加载模块时，bundle.js是怎样的

2.3异步加载时，bundle.js代码分析

main.js修改如下

import('./show').then(show=>{
    show('Webpack')
})

构建成功后会生成两个文件

1. bundle.js  执行入口文件

2. 0.bundle.js 异步加载文件

其中0.bundle.js文件的内容如下：

webpackJsonp(/*在其他文件中存放的模块的ID*/[0],[//本文件所包含的模块
/* 0 */,
/* 1 show.js对应的模块 */
(function(module, __webpack_exports__, __webpack_require__) {

  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony export (immutable) */ 
  __webpack_exports__["default"] = show;

  function show(content) {
    window.document.getElementById('app').innerText = 'Hello,' + content;
  }

})
]);

bundle.js文件的内容如下：

注意：bundle.js比上面的bundle.js的区别在于：

1. 多了一个__webpack_require__.e,用于加载被分割出去的需要异步加载的chunk对应的文件

2. 多了一个webpackJsonp函数，用于从异步加载的文件中安装模块

(function(modules) { // webpackBootstrap
    // install a JSONP callback for chunk loading
  var parentJsonpFunction = window["webpackJsonp"];
  // webpackJsonp用于从异步加载的文件中安装模块
  // 将webpackJsonp挂载到全局是为了方便在其他文件中调用
  /**
   * @param chunkIds 异步加载的模块中需要安装的模块对应的id
   * @param moreModules 异步加载的模块中需要安装模块列表
   * @param executeModules 异步加载的模块安装成功后需要执行的模块对应的index
   */
    window["webpackJsonp"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {
        // add "moreModules" to the modules object,
        // then flag all "chunkIds" as loaded and fire callback
        var moduleId, chunkId, i = 0, resolves = [], result;
        for(;i {
    show('Webpack')
})


/***/ })
]);

Das obige ist der detaillierte Inhalt vonEine ausführliche Einführung in die Webpack-Prinzipien (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!