入门 Webpack，看这篇就够了

devtool选项

配置结果

​​source-map​​

在一个单独的文件中产生一个完整且功能完全的文件。这个文件具有最好的​​source map​​，但是它会减慢打包速度；

​​cheap-module-source-map​​

在一个单独的文件中生成一个不带列映射的​​map​​，不带列映射提高了打包速度，但是也使得浏览器开发者工具只能对应到具体的行，不能对应到具体的列（符号），会对调试造成不便；

​​eval（217, 217, 217); padding: 4px 8px; cursor: default; vertical-align: top;">

使用​​eval（231, 243, 237); padding: 0px 3px; border-radius: 4px; overflow-wrap: break-word; text-indent: 0px;">​source map​​​。这个选项可以在不影响构建速度的前提下生成完整的​​sourcemap​​，但是对打包后输出的JS文件的执行具有性能和安全的隐患。在开发阶段这是一个非常好的选项，在生产阶段则一定不要启用这个选项；

​​cheap-module-eval（217, 217, 217); padding: 4px 8px; cursor: default; vertical-align: top;">

这是在打包文件时最快的生成​​source map​​​的方法，生成的​​Source Map​​​ 会和打包后的​​JavaScript​​​文件同行显示，没有列映射，和​​eval（231, 243, 237); padding: 0px 3px; border-radius: 4px; overflow-wrap: break-word; text-indent: 0px;">​eval（231, 243, 237); padding: 0px 3px; border-radius: 4px; overflow-wrap: break-word; text-indent: 0px;">​webpack.config.js​​，进行如下配置:

module.exports = {
  devtool: 'eval（238, 238, 238); opacity: 0.6;">

 ​​cheap-module-eval-source-map​​方法构建速度更快，但是不利于调试，推荐在大型项目考虑时间成本时使用。
使用webpack构建本地服务器
想不想让你的浏览器监听你的代码的修改，并自动刷新显示修改后的结果，其实​​Webpack​​提供一个可选的本地开发服务器，这个本地服务器基于node.js构建，可以实现你想要的这些功能，不过它是一个单独的组件，在webpack中进行配置之前需要单独安装它作为项目依赖
npm install --save-dev webpack-dev-server
devserver作为webpack配置选项中的一项，以下是它的一些配置选项，更多配置可参考​​这里​​
devserver的配置选项
功能描述
contentBase
默认webpack-dev-server会为根文件夹提供本地服务器，如果想为另外一个目录下的文件提供本地服务器，应该在这里设置其所在目录（本例设置到“public"目录）
port
设置默认监听端口，如果省略，默认为”8080“
inline
设置为​​true​​，当源文件改变时会自动刷新页面
historyApiFallback
在开发单页应用时非常有用，它依赖于HTML5 history API，如果设置为​​true​​，所有的跳转将指向index.html
把这些命令加到webpack的配置文件中，现在的配置文件​​webpack.config.js​​如下所示
module.exports = {
  devtool: 'eval（231, 243, 237); padding: 0px 3px; border-radius: 4px; overflow-wrap: break-word; text-indent: 0px;">​package.json​​​中的​​scripts​​对象中添加如下命令，用以开启本地服务器：
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "webpack",
    "server": "webpack-dev-server --open"
  },
在终端中输入​​npm run server​​​即可在本地的​​8080​​端口查看结果
Loaders
鼎鼎大名的Loaders登场了！
​​Loaders​​​是​​webpack​​​提供的最激动人心的功能之一了。通过使用不同的​​loader​​​，​​webpack​​有能力调用外部的脚本或工具，实现对不同格式的文件的处理，比如说分析转换scss为css，或者把下一代的JS文件（ES6，ES7)转换为现代浏览器兼容的JS文件，对React的开发而言，合适的Loaders可以把React的中用到的JSX文件转换为JS文件。
Loaders需要单独安装并且需要在​​webpack.config.js​​​中的​​modules​​关键字下进行配置，Loaders的配置包括以下几方面：
​​test​​：一个用以匹配loaders所处理文件的拓展名的正则表达式（必须）
​​loader​​：loader的名称（必须）
​​include/exclude​​:手动添加必须处理的文件（文件夹）或屏蔽不需要处理的文件（文件夹）（可选）；
​​query​​：为loaders提供额外的设置选项（可选）
不过在配置loader之前，我们把​​Greeter.js​​​里的问候消息放在一个单独的JSON文件里,并通过合适的配置使​​Greeter.js​​可以读取该JSON文件的值，各文件修改后的代码如下：
在app文件夹中创建带有问候信息的JSON文件(命名为​​config.json​​)
{
  "greetText": "Hi there and greetings from JSON!"
}
更新后的Greeter.js
var config = require('./config.json');

module.exports = function() {
  var greet = document.createElement('div');
  greet.textContent = config.greetText;
  return greet;
};

 注 由于
 ​​webpack3.*/webpack2.*​​​已经内置可处理JSON文件，这里我们无需再添加
 ​​​webpack1.*​​​需要的
 ​​​json-loader​​。在看如何具体使用loader之前我们先看看Babel是什么？
Babel
Babel其实是一个编译JavaScript的平台，它可以编译代码帮你达到以下目的：
让你能使用最新的JavaScript代码（ES6，ES7...），而不用管新标准是否被当前使用的浏览器完全支持；
让你能使用基于JavaScript进行了拓展的语言，比如React的JSX；
Babel的安装与配置
Babel其实是几个模块化的包，其核心功能位于称为​​babel-core​​​的npm包中，webpack可以把其不同的包整合在一起使用，对于每一个你需要的功能或拓展，你都需要安装单独的包（用得最多的是解析Es6的​​babel-env-preset​​​包和解析JSX的​​babel-preset-react​​包）。
我们先来一次性安装这些依赖包
// npm一次性安装多个依赖模块，模块之间用空格隔开
npm install --save-dev babel-core babel-loader babel-preset-env babel-preset-react
在​​webpack​​中配置Babel的方法如下:
module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/public",//打包后的文件存放的地方
        filename: "bundle.js"//打包后输出文件的文件名
    },
    devtool: 'eval（\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader",
                    options: {
                        presets: [
                            "env", "react"
                        ]
                    }
                },
                exclude: /node_modules/
            }
        ]
    }
};
现在你的webpack的配置已经允许你使用ES6以及JSX的语法了。继续用上面的例子进行测试，不过这次我们会使用React，记得先安装 React 和 React-DOM
npm install --save react react-dom
接下来我们使用ES6的语法，更新​​Greeter.js​​并返回一个React组件
//Greeter,js
import React, {Component} from 'react'
import config from './config.json';

class Greeter extends Component{
  render() {
    return (
      <div>
        {config.greetText}
      </div>
    );
  }
}

export default Greeter
修改​​main.js​​如下，使用ES6的模块定义和渲染Greeter模块
// main.js
import React from 'react';
import {render} from 'react-dom';
import Greeter from './Greeter';

render(<Greeter />, document.getElementById('root'));
重新使用​​npm start​​​打包，如果之前打开的本地服务器没有关闭，你应该可以在​​localhost:8080​​​下看到与之前一样的内容，这说明​​react​​​和​​es6​​被正常打包了。
Babel的配置
Babel其实可以完全在 ​​webpack.config.js​​​ 中进行配置，但是考虑到babel具有非常多的配置选项，在单一的​​webpack.config.js​​​文件中进行配置往往使得这个文件显得太复杂，因此一些开发者支持把babel的配置选项放在一个单独的名为 ".babelrc" 的配置文件中。我们现在的babel的配置并不算复杂，不过之后我们会再加一些东西，因此现在我们就提取出相关部分，分两个配置文件进行配置（webpack会自动调用​​.babelrc​​里的babel配置选项），如下：
module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/public",//打包后的文件存放的地方
        filename: "bundle.js"//打包后输出文件的文件名
    },
    devtool: 'eval（\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            }
        ]
    }
};
//.babelrc
{
  "presets": ["react", "env"]
}
到目前为止，我们已经知道了，对于模块，Webpack能提供非常强大的处理功能，那那些是模块呢。
一切皆模块
Webpack有一个不可不说的优点，它把所有的文件都都当做模块处理，JavaScript代码，CSS和fonts以及图片等等通过合适的loader都可以被处理。
CSS
webpack提供两个工具处理样式表，​​css-loader​​​ 和 ​​style-loader​​​，二者处理的任务不同，​​css-loader​​​使你能够使用类似​​@import​​​ 和 ​​url(...)​​​的方法实现 ​​require()​​​的功能,​​style-loader​​将所有的计算后的样式加入页面中，二者组合在一起使你能够把样式表嵌入webpack打包后的JS文件中。
继续上面的例子
//安装
npm install --save-dev style-loader css-loader
//使用
module.exports = {

   ...
    module: {
        rules: [
            {
                test: /(\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader"
                    }
                ]
            }
        ]
    }
};

 请注意这里对同一个文件引入多个loader的方法。
接下来，在app文件夹里创建一个名字为"main.css"的文件，对一些元素设置样式
/* main.css */
html {
  box-sizing: border-box;
  -ms-text-size-adjust: 100%;
  -webkit-text-size-adjust: 100%;
}

*, *:before, *:after {
  box-sizing: inherit;
}

body {
  margin: 0;
  font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
}

h1, h2, h3, h4, h5, h6, p, ul {
  margin: 0;
  padding: 0;
}
我们这里例子中用到的​​webpack​​​只有单一的入口，其它的模块需要通过 ​​import​​​, ​​require​​​, ​​url​​等与入口文件建立其关联，为了让webpack能找到”main.css“文件，我们把它导入”main.js “中，如下
//main.js
import React from 'react';
import {render} from 'react-dom';
import Greeter from './Greeter';

import './main.css';//使用require导入css文件

render(<Greeter />, document.getElementById('root'));

 通常情况下，css会和js打包到同一个文件中，并不会打包为一个单独的css文件，不过通过合适的配置webpack也可以把css打包为单独的文件的。
上面的代码说明webpack是怎么把css当做模块看待的，咱们继续看一个更加真实的css模块实践。
CSS module
在过去的一些年里，JavaScript通过一些新的语言特性，更好的工具以及更好的实践方法（比如说模块化）发展得非常迅速。模块使得开发者把复杂的代码转化为小的，干净的，依赖声明明确的单元，配合优化工具，依赖管理和加载管理可以自动完成。
不过前端的另外一部分，CSS发展就相对慢一些，大多的样式表却依旧巨大且充满了全局类名，维护和修改都非常困难。
被称为​​CSS modules​​的技术意在把JS的模块化思想带入CSS中来，通过CSS模块，所有的类名，动画名默认都只作用于当前模块。Webpack对CSS模块化提供了非常好的支持，只需要在CSS loader中进行简单配置即可，然后就可以直接把CSS的类名传递到组件的代码中，这样做有效避免了全局污染。具体的代码如下
module.exports = {

    ...

    module: {
        rules: [
            {
                test: /(\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true, // 指定启用css modules
                            localIdentName: '[name]__[local]--[hash:base64:5]' // 指定css的类名格式
                        }
                    }
                ]
            }
        ]
    }
};
我们在app文件夹下创建一个​​Greeter.css​​文件来进行一下测试
/* Greeter.css */
.root {
  background-color: #eee;
  padding: 10px;
  border: 3px solid #ccc;
}
导入​​.root​​到Greeter.js中
import React, {Component} from 'react';
import config from './config.json';
import styles from './Greeter.css';//导入

class Greeter extends Component{
  render() {
    return (
      <div className={styles.root}> //使用cssModule添加类名的方法
        {config.greetText}
      </div>
    );
  }
}

export default Greeter
放心使用把，相同的类名也不会造成不同组件之间的污染。
CSS modules 也是一个很大的主题，有兴趣的话可以去其​​官方文档​​了解更多。
CSS预处理器
​​Sass​​​ 和 ​​Less​​​ 之类的预处理器是对原生CSS的拓展，它们允许你使用类似于​​variables​​​, ​​nesting​​​, ​​mixins​​​, ​​inheritance​​等不存在于CSS中的特性来写CSS，CSS预处理器可以这些特殊类型的语句转化为浏览器可识别的CSS语句，
你现在可能都已经熟悉了，在webpack里使用相关loaders进行配置就可以使用了，以下是常用的CSS 处理​​loaders​​:
​​Less Loader​​
​​Sass Loader​​
​​Stylus Loader​​
不过其实也存在一个CSS的处理平台​​-PostCSS​​​，它可以帮助你的CSS实现更多的功能，在其​​官方文档​​可了解更多相关知识。
举例来说如何使用PostCSS，我们使用PostCSS来为CSS代码自动添加适应不同浏览器的CSS前缀。
首先安装​​postcss-loader​​​ 和 ​​autoprefixer​​（自动添加前缀的插件）
npm install --save-dev postcss-loader autoprefixer
接下来，在webpack配置文件中添加​​postcss-loader​​​，在根目录新建​​postcss.config.js​​​,并添加如下代码之后，重新使用​​npm start​​打包时，你写的css会自动根据Can i use里的数据添加不同前缀了。
//webpack.config.js
module.exports = {
    ...
    module: {
        rules: [
            {
                test: /(\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true
                        }
                    }, {
                        loader: "postcss-loader"
                    }
                ]
            }
        ]
    }
}
// postcss.config.js
module.exports = {
    plugins: [
        require('autoprefixer')
    ]
}
至此，本文已经谈论了处理JS的Babel和处理CSS的PostCSS的基本用法，它们其实也是两个单独的平台，配合​​webpack​​​可以很好的发挥它们的作用。接下来介绍Webpack中另一个非常重要的功能-​​Plugins​​
插件（Plugins）
插件（Plugins）是用来拓展Webpack功能的，它们会在整个构建过程中生效，执行相关的任务。
 Loaders和Plugins常常被弄混，但是他们其实是完全不同的东西，可以这么来说，loaders是在打包构建过程中用来处理源文件的（JSX，Scss，Less..），一次处理一个，插件并不直接操作单个文件，它直接对整个构建过程其作用。
Webpack有很多内置插件，同时也有很多第三方插件，可以让我们完成更加丰富的功能。
使用插件的方法
要使用某个插件，我们需要通过​​npm​​​安装它，然后要做的就是在webpack配置中的plugins关键字部分添加该插件的一个实例（plugins是一个数组）继续上面的例子，我们添加了一个给打包后代码​​添加版权声明的插件​​。
const webpack = require('webpack');

module.exports = {
...
    module: {
        rules: [
            {
                test: /(\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true
                        }
                    }, {
                        loader: "postcss-loader"
                    }
                ]
            }
        ]
    },
    plugins: [
        new webpack.BannerPlugin('版权所有，翻版必究')
    ],
};
通过这个插件，打包后的JS文件显示如下
这就是webpack插件的基础用法了，下面给大家推荐几个常用的插件
HtmlWebpackPlugin
这个插件的作用是依据一个简单的​​index.html​​​模板，生成一个自动引用你打包后的JS文件的新​​index.html​​​。这在每次生成的js文件名称不同时非常有用（比如添加了​​hash​​值）。
安装
npm install --save-dev html-webpack-plugin
这个插件自动完成了我们之前手动做的一些事情，在正式使用之前需要对一直以来的项目结构做一些更改：
移除public文件夹，利用此插件，​​index.html​​文件会自动生成，此外CSS已经通过前面的操作打包到JS中了。
在app目录下，创建一个​​index.tmpl.html​​​文件模板，这个模板包含​​title​​​等必须元素，在编译过程中，插件会依据此模板生成最终的html页面，会自动添加所依赖的 css, js，favicon等文件，​​index.tmpl.html​​中的模板源代码如下：
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Webpack Sample Project</title>
  </head>
  <body>
    <div id='root'>
    </div>
  </body>
</html>
3.更新​​webpack​​​的配置文件，方法同上,新建一个​​build​​文件夹用来存放最终的输出文件
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/build",
        filename: "bundle.js"
    },
    devtool: 'eval（\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true
                        }
                    }, {
                        loader: "postcss-loader"
                    }
                ]
            }
        ]
    },
    plugins: [
        new webpack.BannerPlugin('版权所有，翻版必究'),
        new HtmlWebpackPlugin({
            template: __dirname + "/app/index.tmpl.html"//new 一个这个插件的实例，并传入相关的参数
        })
    ],
};
再次执行​​npm start​​​你会发现，build文件夹下面生成了​​bundle.js​​​和​​index.html​​。
Hot Module Replacement
​​Hot Module Replacement​​（HMR）也是webpack里很有用的一个插件，它允许你在修改组件代码后，自动刷新实时预览修改后的效果。
在webpack中实现HMR也很简单，只需要做两项配置
在webpack配置文件中添加HMR插件；
在Webpack Dev Server中添加“hot”参数；
不过配置完这些后，JS模块其实还是不能自动热加载的，还需要在你的JS模块中执行一个Webpack提供的API才能实现热加载，虽然这个API不难使用，但是如果是React模块，使用我们已经熟悉的Babel可以更方便的实现功能热加载。
整理下我们的思路，具体实现方法如下
​​Babel​​​和​​webpack​​是独立的工具
二者可以一起工作
二者都可以通过插件拓展功能
HMR是一个webpack插件，它让你能浏览器中实时观察模块修改后的效果，但是如果你想让它工作，需要对模块进行额外的配额；
Babel有一个叫做​​react-transform-hrm​​的插件，可以在不对React模块进行额外的配置的前提下让HMR正常工作；
还是继续上例来实际看看如何配置
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/build",
        filename: "bundle.js"
    },
    devtool: 'eval（\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true
                        }
                    }, {
                        loader: "postcss-loader"
                    }
                ]
            }
        ]
    },
    plugins: [
        new webpack.BannerPlugin('版权所有，翻版必究'),
        new HtmlWebpackPlugin({
            template: __dirname + "/app/index.tmpl.html"//new 一个这个插件的实例，并传入相关的参数
        }),
        new webpack.HotModuleReplacementPlugin()//热加载插件
    ],
};
   
安装​​react-transform-hmr​​
npm install --save-dev babel-plugin-react-transform react-transform-hmr
配置Babel
// .babelrc
{
  "presets": ["react", "env"],
  "env": {
    "development": {
    "plugins": [["react-transform", {
       "transforms": [{
         "transform": "react-transform-hmr",
         
         "imports": ["react"],
         
         "locals": ["module"]
       }]
     }]]
    }
  }
}
现在当你使用React时，可以热加载模块了,每次保存就能在浏览器上看到更新内容。
产品阶段的构建
目前为止，我们已经使用webpack构建了一个完整的开发环境。但是在产品阶段，可能还需要对打包的文件进行额外的处理，比如说优化，压缩，缓存以及分离CSS和JS。
对于复杂的项目来说，需要复杂的配置，这时候分解配置文件为多个小的文件可以使得事情井井有条，以上面的例子来说，我们创建一个​​webpack.production.config.js​​的文件，在里面加上基本的配置,它和原始的webpack.config.js很像，如下
// webpack.production.config.js
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
    entry: __dirname + "/app/main.js", //已多次提及的唯一入口文件
    output: {
        path: __dirname + "/build",
        filename: "bundle.js"
    },
    devtool: 'null', //注意修改了这里，这能大大压缩我们的打包代码
    devServer: {
        contentBase: "./public", //本地服务器所加载的页面所在的目录
        historyApiFallback: true, //不跳转
        inline: true,
        hot: true
    },
    module: {
        rules: [{
            test: /(\.jsx|\.js)$/,
            use: {
                loader: "babel-loader"
            },
            exclude: /node_modules/
        }, {
            test: /\.css$/,
            use: ExtractTextPlugin.extract({
                fallback: "style-loader",
                use: [{
                    loader: "css-loader",
                    options: {
                        modules: true
                    }
                }, {
                    loader: "postcss-loader"
                }],
            })
        }]
    },
    plugins: [
        new webpack.BannerPlugin('版权所有，翻版必究'),
        new HtmlWebpackPlugin({
            template: __dirname + "/app/index.tmpl.html" //new 一个这个插件的实例，并传入相关的参数
        }),
        new webpack.HotModuleReplacementPlugin() //热加载插件
    ],
};
//package.json
{
  "name": "test",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "webpack",
    "server": "webpack-dev-server --open",
    "build": "NODE_ENV=production webpack --config ./webpack.production.config.js --progress"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
...
  },
  "dependencies": {
    "react": "^15.6.1",
    "react-dom": "^15.6.1"
  }
}

 注意:如果是window电脑，
 ​​build​​​需要配置为
 ​​​"build": "set NODE_ENV=production && webpack --config ./webpack.production.config.js --progress"​​.谢谢评论区简友提醒。
优化插件
webpack提供了一些在发布阶段非常有用的优化插件，它们大多来自于webpack社区，可以通过npm安装，通过以下插件可以完成产品发布阶段所需的功能
​​OccurenceOrderPlugin​​ :为组件分配ID，通过这个插件webpack可以分析和优先考虑使用最多的模块，并为它们分配最小的ID
​​UglifyJsPlugin​​：压缩JS代码；
​​ExtractTextPlugin​​：分离CSS和JS文件
我们继续用例子来看看如何添加它们，OccurenceOrder 和 UglifyJS plugins 都是内置插件，你需要做的只是安装其它非内置插件
npm install --save-dev extract-text-webpack-plugin
在配置文件的plugins后引用它们
// webpack.production.config.js
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const ExtractTextPlugin = require('extract-text-webpack-plugin');

module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/build",
        filename: "bundle.js"
    },
    devtool: 'none',
    devServer: {
        contentBase: "./public",//本地服务器所加载的页面所在的目录
        historyApiFallback: true,//不跳转
        inline: true,
        hot: true
    },
    module: {
        rules: [
            {
                test: /(\.jsx|\.js)$/,
                use: {
                    loader: "babel-loader"
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true
                        }
                    }, {
                        loader: "postcss-loader"
                    }
                ]
            }
        ]
    },
    plugins: [
        new webpack.BannerPlugin('版权所有，翻版必究'),
        new HtmlWebpackPlugin({
            template: __dirname + "/app/index.tmpl.html"
        }),
        new webpack.optimize.OccurrenceOrderPlugin(),
        new webpack.optimize.UglifyJsPlugin(),
        new ExtractTextPlugin("style.css")
    ],
};
此时执行​​npm run build​​可以看见代码是被压缩后的
缓存
缓存无处不在，使用缓存的最好方法是保证你的文件名和文件内容是匹配的（内容改变，名称相应改变）
webpack可以把一个哈希值添加到打包的文件名中，使用方法如下,添加特殊的字符串混合体（[name], [id] and [hash]）到输出文件名前
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const ExtractTextPlugin = require('extract-text-webpack-plugin');

module.exports = {
..
    output: {
        path: __dirname + "/build",
        filename: "bundle-[hash].js"
    },
   ...
};
现在用户会有合理的缓存了。
去除​​build​​文件中的残余文件
添加了​​hash​​​之后，会导致改变文件内容后重新打包时，文件名不同而内容越来越多，因此这里介绍另外一个很好用的插件​​clean-webpack-plugin​​。
安装：
​​​cnpm install clean-webpack-plugin --save-dev​​
使用：
引入​​clean-webpack-plugin​​​插件后在配置文件的​​plugins​​中做相应配置即可：
const CleanWebpackPlugin = require("clean-webpack-plugin");
  plugins: [
    ...// 这里是之前配置的其它各种插件
    new CleanWebpackPlugin('build/*.*', {
      root: __dirname,
      verbose: true,
      dry: false
  })
  ]
关于​​clean-webpack-plugin​​​的详细使用可参考​​这里​​
总结

 其实这是一年前的文章了，趁周末重新运行和修改了一下，现在所有的代码都可以正常运行，所用webpack基于最新的
 ​​webpack3.5.3​​。希望依旧能对你有帮助。
这是一篇好长的文章，谢谢你的耐心，能仔细看到了这里，大概半个月前我第一次自己一步步配置项目所需的Webpack后就一直想写一篇笔记做总结，几次动笔都不能让自己满意，总觉得写不清楚。其实关于Webpack本文讲述得仍不完全，不过相信你看完后已经进入Webpack的大门，能够更好的探索其它的关于Webpack的知识了。
欢迎大家在文后发表自己的观点讨论。
    
举报
 
 
相关推荐
 
  
入门Webpack，看这篇就够了
 
csshtml配置文件虚拟化云计算
 
 岛上码农 阅读 62 收藏 0 评论 0
 2022-06-20
  
BigDecimal看这篇就够了
 
java
 
 后来的六六 阅读 141 收藏 0 评论 0
 2022-04-01
  
Linux，看这篇就够了
 
macosusbboot引导windows
 
 王栩的文字 阅读 85 收藏 0 评论 0
 2023-06-13
  
设计原则看这篇就够了
 
java设计模式
 
 嚯霍嚯 阅读 83 收藏 0 评论 0
 2022-01-10
  
OAuth授权 | 看这篇就够了
 
javaSpring ...登录认证OAuthJava技术升华基础原理程序猿阵线联盟...服务端
 
 十里一走马 阅读 53 收藏 0 评论 0
 2021-09-21
  
教小师妹快速入门Mybatis，看这篇就够了
 
日记本程序员
 
 科牛 阅读 25 收藏 0 评论 0
 2021-10-04
  
想入门软件测试？看这篇文章就够了！
 
测试必备知识点测试开发那些事儿
 
 书呆鱼 阅读 128 收藏 0 评论 0
 2021-10-15
  
Java语法基础看这篇就够了
 
java数据类型数组虚拟化云计算
 
 at小涛 阅读 92 收藏 0 评论 0
 2022-08-04
  
线程池？面试？看这篇就够了！
 
jdk源码解析多线程并发多线程java基础面试专题文章Java技术问答Java技术升华
 
 勇敢乌龟 阅读 62 收藏 0 评论 0
 2021-09-25
  
Spring入门看这篇就足够了，特别有趣
 
趣味Java个人学习我不想再做Ja...
 
 月白色的大狒 阅读 81 收藏 0 评论 0
 2021-09-25
 查看更多相关推荐 
0 条评论
 
 
 
评论
 
 
 
 搜索
 
 
杏花疏影1 
 关注
 
 
python调用ollama的模型
Coursera vs. Udemy
office 365后台设置规则将外部域发送给特定收件人的邮件转发某个人
android期末大作业源代码
在数据导入、批量插入操作中，如何设定每次插入数据量的大小？
python程序设计现代方法电子版
《平衡之策：C++应对人工智能不平衡训练数据的数据增强方法》
“天翼云息壤杯”高校AI大赛福建赛区启动！
Windows Server 2019 虚拟机 安装Oracle19c，图文详情（超详细）
使用URDF和Xacro构建差速轮式机器人模型