Webpack,包教不包会系列(一)

本篇写于2019.10.21,当前webpack的版本为4.X.X。目的是希望新手学会webpack思想,并且自己会搭建webpack的相关插件以及一些其他的loader之类的。好了,话不多说,我们开始写吧!

github:webpack仓库地址

什么是Webpack,以及我们为什么要用他。

现今的很多网页其实可以看做是功能丰富的应用,它们拥有着复杂的JavaScript代码和一大堆依赖包。为了简化开发的复杂度,前端社区涌现出了很多好的实践方法

  • 模块化,让我们可以把复杂的程序细化为小的文件;
  • 类似于TypeScript这种在JavaScript基础上拓展的开发语言:使我们能够实现目前版本的JavaScript不能直接使用的特性,并且之后还能转换为JavaScript文件使浏览器可以识别;
  • Scss,less等CSS预处理器

WebPack和Grunt以及Gulp相比有什么特性

借用两张图表示的话就是。
gulp:
gulp.png

  • gulp是在一个配置文件中,指明对某些文件进行类似编译,组合,压缩等任务的具体步骤,工具之后可以自动替你完成这些任务

webpack:
webpack.png

  • webpack是把你的项目当做一个整体,通过一个给定的主文件(如:index.js),Webpack将从这个文件开始找到你的项目的所有依赖文件,使用loaders处理它们,最后打包为一个(或多个)浏览器可识别的JavaScript文件。

开始使用webpack

// 先全局安装webpack
npm install -g webpack

现在,新建一个文件夹

// 使用npm init
npm init
// init是创建package.json用的,创建的时候叫你填写一些信息,
// 不用管它,对于现在的我们来说先不用了解,然后一路回车。

// 安装局部webpack
npm install --save-dev webpack

现在在package.json文件所在的文件夹里面创建两个文件夹app和public.
此时,项目结构如下图所示。
image.png

在app文件夹里面创建main.js
在public文件里面创建index.html

此时的项目目录结构是这样的:
image.png
要学会第一次打包,先配置webpack配置文件。
在当前目录下,新建一个webpack.config.js的配置文件
文件里面内容为

// webpack.config.js
module.exports = {
  entry:  __dirname + "/app/main.js",//已多次提及的唯一入口文件
  output: {
    path: __dirname + "/public",//打包后的文件存放的地方
    filename: "bundle.js"//打包后输出文件的文件名
  }
}

在index.html文件里面写上一些基础的元素

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>Document</title>
</head>
<body>
  <div id="root"></div>
  <script src="bundle.js"></script>
  <script>
  </script>
</body>
</html>

看到index.html上有一个id为root的dom元素,还有一个script标签,里面指向内容为bundle.js
现在还不理解上面的东西,没关系。接着往下看。
先在app/main.js 里面写上一段代码

document.getElementById('root').innerText = 'webpack好好玩,我好喜欢玩这个啊!'

在package.json里面写上

{
  "name": "sfwebpack",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "webpack"  // 修改这里,json文件不支持注释,复制完成请删除
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "webpack": "^4.41.2",
    "webpack-cli": "^3.3.9"
  }
}
npm的start命令是一个特殊的脚本名称,其特殊性表现在,在命令行中使用npm start就可以执行其对于的命令,如果对应的此脚本名称不是start,想要在命令行中运行时,需要这样用npm run {script name}如npm run build,我们在命令行中输入npm start试试,

image.png
可以看到,我们已经打包成功了!将main.js变为了bundle.js并且将他输出到了public的文件夹下。
到此为止,我们已经知道了在刚才的index.html文件里面bundle.js和id为root的dom元素是干什么了吧?
打开public文件夹下的index.html文件,能够看到页面上显示的是webpack好好玩,我好喜欢玩这个啊!
现在,先别急着往下走。我们先来看看控制台的提示
image.png
它对我们警告,需要配置mode,这里先不用管它,后面会讲这一点,这也是webpack4新加的一个功能。

你现在已经成功的打包了一个webpack文件,这会是一个良好的开始!!!

现在,还必须手动刷新网页,每次更改后都会按下F5,使得调试极其不容易,所以我们想要代码一更新就会自动加载。

// 安装webpack-dev-server
npm install --save-dev webpack-dev-server

这个webpack-dev-server是基于node.js构建的一个本地服务器,简单来说就是能够让你不刷新的情况下,看到更改后的内容
devserver作为webpack配置选项中的一项,以下是它的一些配置选项,更多配置请参考官网,这里给出一些配置信息

devserver的配置选项 功能描述
contentBase 默认webpack-dev-server会为根文件夹提供本地服务器,如果想为另外一个目录下的文件提供本地服务器,应该在这里设置其所在目录(本例设置到“public"目录)
port 设置默认监听端口,如果省略,默认为”8080“
inline 设置为true,当源文件改变时会自动刷新页面

把下面的命令加入到webpack.config.js文件里面

module.exports = {
    entry:  __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
      path: __dirname + "/public",//打包后的文件存放的地方
      filename: "bundle.js"//打包后输出文件的文件名
    },
    devServer: {
        contentBase: "./public",//本地服务器所加载的页面所在的目录
        historyApiFallback: true,//不跳转
        inline: true//实时刷新
      },
  }

将下面的命令加入到package.json文件中

"server":  "webpack-dev-server --open"

我们运行 npm run server就可以看到,浏览器自动打开一个页面,我们修改main.js里的文件内容

// main.js
document.getElementById('root').innerText = '我好喜欢玩这个啊!'

能够看到浏览器自动刷新,不需要我们手动修改它了。

publicPath

一些易混淆的东西建议新手先跳过这段提示,publicPath是有两个的。一个output.publicPath,一个是devServer.publicPath。其中output.publicPath是用来指定资源请求的位置,output.path用来指定打包文件存放的地方。
output.publicPath可以通过下图来进行理解

  output: {
    path: __dirname + "/build",//打包后的文件存放的地方
    filename: "bundle.js",//打包后输出文件的文件名
    // publicPath:"/build/", //打包后资源请求的位置,例如<script src="/build/bundle.js">
  },

image.png

output: {
    path: __dirname + "/build",//打包后的文件存放的地方
    filename: "bundle.js",//打包后输出文件的文件名
    publicPath:"/build/", //打包后资源请求的位置,例如<script src="/build/bundle.js">
  },
  

image.png
webpack-dev-server打包时在内存中的,是不会出现到build文件夹里面,而webpack-dev-server也有一个publicPath,这里publicPath他的作用是指定webpack-dev-server的静态资源服务路径.
请看下面配置

  output: {
    path: __dirname + "/build",//打包后的文件存放的地方
    filename: "bundle.js",//打包后输出文件的文件名
    publicPath:"/build/", //打包后资源请求的位置,例如<script src="/build/bundle.js">
  },
  devServer: {
    publicPath: '/assets/',
    historyApiFallback: true,//不跳转
    inline: true,//实时刷新
    hot: true,
  },

从上面可以看到,Webpack配置中output.path为dist目录,因此bundle.js应该生成在dist目录。但是当我们启动webpack-dev-server的服务后,访问localhost:8080/dist/bundle.js时会得到404.这是因为devServer.publicpath配置项将资源位置指向了localhost:8080/assets/,因此只有访问localhost:8080/assets/bundle.js才能够得到我们想要的结果。

Loaders

loaders是webpack的核心功能了,它的主要作用是将ES6转换为浏览器识别的ES5或者说将LESS/SCSS编译为CSS等等。好了,我们看看如何使用loaders了。

  • test:一个用以匹配loaders所处理文件的拓展名的正则表达式(必须)
  • loader:loader的名称(必须)
  • include/exclude : 手动添加必须处理的文件(文件夹)或屏蔽不需要处理的文件(文件夹)(可选);

Babel

Babel其实是一个编译JavaScript的平台,它可以编译代码帮你达到以下目的:

  • 让你能使用最新的JavaScript代码(ES6,ES7...),而不用管新标准是否被当前使用的浏览器完全支持;

先来一次性的安装这些包

npm install --save-dev  @babel/core @babel/cli @babel/preset-env
npm install --save @babel/polyfill

先配置webpack

module.exports = {
    entry:  __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
      path: __dirname + "/public",//打包后的文件存放的地方
      filename: "bundle.js"//打包后输出文件的文件名
    },
    devServer: {
        contentBase: "./public",//本地服务器所加载的页面所在的目录
        historyApiFallback: true,//不跳转
        inline: true//实时刷新
      },
   module: {
    rules: [
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
    ]
   },
}

在main.js中添加

let a1 = async function a(){
    await console.log('1');
    await console.log('2');
}
a1();

npm start 再次启动webpack服务npm run server
打开控制台,能够看到
image.png
现在已经能够使用ES6的语法了,一些async,await都能够使用了。

小提示,如果有的同学看的认真的话,就会发现我们安装npm install --save @babel/polyfill和npm install --save-dev @babel/core @babel/cli @babel/preset-env是有些不同的,不同之处就在于--save-dev
--save-dev 是你开发时候依赖的东西,--save 是你发布之后还依赖的东西。
比如,你写 ES6 代码,如果你想编译成 ES5 发布那么 babel 就是devDependencies(--save-dev)。
如果你用了 jQuery,由于发布之后还是依赖jQuery,所以是dependencies(--save)

CSS

在webpack的世界里面,一切皆是模块,这也意味着css也可以当做模块进行处理.
webpack提供两个工具处理样式表,css-loader 和 style-loader,二者处理的任务不同,css-loader使你能够使用类似@import 和 url(...)的方法实现 require()的功能,style-loader将所有的计算后的样式加入页面中,二者组合在一起使你能够把样式表嵌入webpack打包后的JS文件中.

npm install --save-dev style-loader css-loader

然后来配置webpack

//webpack
......
module: {
    rules: [
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
       test: /\.css$/,
          use: [
                {
                    loader: "style-loader"
                }, {
                    loader: "css-loader",
                }
               ]
       }
    ]
 },
               

在app的文件夹下创建一个main.css

// main.css
.main{
    background: blue;
    height: 20px;
    width: 20px;
    
}
// main.js
import './main.css';
let main = document.createElement('div');
main.className = 'main';    
document.querySelector('#root').appendChild(main);

image.png
能够看到浏览器里面多了一个蓝色方块。

CSS module

称为CSS modules的技术意在把JS的模块化思想带入CSS中来,通过CSS模块,所有的类名,类名默认都只作用于当前模块。Webpack对CSS模块化提供了非常好的支持,只需要在CSS loader中进行简单配置即可,然后就可以直接把CSS的类名传递到组件的代码中,这样做有效避免了全局污染。具体的代码如下
发现,浏览器能够识别了,并且也已经插入到JS里面使用了。

module: {
    rules: [
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
       test: /\.css$/,
          use: [
                {
                    loader: "style-loader"
                }, {
                    loader: "css-loader",
                    options: {
                            modules: true, // 指定启用css modules
                        },
                    }
               ]
       }
    ]
 },
  • 修改main.js
import style from './main.css';
let main = document.createElement('div');
main.className = style.main;    
document.querySelector('#root').appendChild(main);

效果如下,
image.png

如果想要将类名变为有规律的,我们可以这样改变css-module

....
module: {
    rules: [
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
       test: /\.css$/,
          use: [
                {
                    loader: "style-loader"
                }, {
                    loader: "css-loader",
                    options: {
                            modules: {
                              mode: 'local',
                              localIdentName: '[local]_[hash:base64:8]'
                            },
                        },
                    }
               ]
       }
    ]
 },

名字就变为有规律的了!
image.png
------------------分割线-----------------

插件(Plugins)

插件(Plugins)是用来拓展Webpack功能的,它们会在整个构建过程中生效,执行相关的任务。
Loaders和Plugins常常被弄混,但是他们其实是完全不同的东西,可以这么来说,loaders是在打包构建过程中用来处理源文件的(JSX,Scss,Less..),一次处理一个,插件并不直接操作单个文件,它直接对整个构建过程其作用
先来安装一个插件试一试。

HtmlWebpackPlugin

这个插件的作用是依据一个简单的index.html模板,生成一个自动引用你打包后的JS文件(css文件)的新index.html。这在每次生成的js文件名称不同时非常有用(比如添加了hash值)。
安装

npm install --save-dev html-webpack-plugin

在使用这个插件之前,先对我们的项目目录做一些改造,

  • 1.移除public,利用此插件,index.html文件会自动生成,此外CSS已经通过前面的操作打包到JS中了。
  • 2.在app目录下,创建一个index.html文件模板,这个模板包含title等必须元素,在编译过程中,插件会依据此模板生成最终的html页面,会自动添加所依赖的 css, js,favicon等文件,index.html中的模板源代码如下
//index.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<div id="root"></div>
</body>
</html>
  • 3.更新webpack的配置文件,方法同上,新建一个build文件夹用来存放最终的输出文件

配置webpack

const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
    entry: __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
        path: __dirname + "/build",
        filename: "bundle.js"
    },
    devtool: 'eval-source-map',
    devServer: {
        contentBase: "./public",//本地服务器所加载的页面所在的目录
        historyApiFallback: true,//不跳转
        inline: true//实时刷新
    },
    module: {
        rules: [
            {
                test: /\.js$/, // 能够使用async语法
                use: {
                  loader: "babel-loader",
                  options: {
                    presets: [['@babel/preset-env', {
                      useBuiltIns: "usage",
                    }]]
                  }
                },
                exclude: /node_modules/
            },
            {
                test: /\.css$/,
                use: [
                    {
                        loader: "style-loader"
                    }, {
                        loader: "css-loader",
                        options: {
                            modules: true, // 指定启用css modules
                        }, 
                    },
                ]
            }
        ]
    },
    plugins: [
        new HtmlWebpackPlugin({
            template: __dirname + "/app/index.html"//new 一个这个插件的实例,并传入相关的参数
        })
    ],
};

再次执行npm start你会发现,build文件夹下面生成了bundle.js和index.html。

vue

你已经懂得了一些基础的配置,下面来安装vue吧

先安装以下的安装包

npm install --save-dev vue-loader vue-template-compiler
  • 修改webpack里面的配置文件
const VueLoaderPlugin = require('vue-loader/lib/plugin');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const path = require('path')
module.exports = {
    entry:  __dirname + "/app/main.js",//已多次提及的唯一入口文件
    output: {
      path: __dirname + "/public",//打包后的文件存放的地方
      filename: "bundle.js"//打包后输出文件的文件名
    },
    devServer: {
        contentBase: "./public",//本地服务器所加载的页面所在的目录
        historyApiFallback: true,//不跳转
        inline: true//实时刷新
      },
   module: {
    rules: [
    {
        test: /\.vue$/,
        loader: 'vue-loader',
        exclude: /node_modules/
      },
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
        test: /\.css$/,
        use: [
            {
                loader: "vue-style-loader"
            }, {
                loader: "css-loader",
                options: {
                    modules: true, // 指定启用css modules
                }, 
            },
        ]
       },
    ]
   },
   plugins: [
   //这个插件是必须的! 它的职责是将你定义过的其它规则复制并
   //应用到 .vue 文件里相应语言的块。例如,如果你有一条匹配
   // /\.js$/ 的规则,那么它会应用到 .vue 文件里的 <script> 块
    new VueLoaderPlugin(),
    new HtmlWebpackPlugin({
            template: __dirname + "/app/index.html"//new 一个这个插件的实例,并传入相关的参数
    }),
  ],
   resolve: {
    // 引入路径不用谢对应的后缀名
    extensions: [".vue",".js",  ".json"],
    // 使用template的时候需要使用
    alias: {
      vue$: "vue/dist/vue.esm.js", 
      // 用 webpack 1 时需用 'vue/dist/vue.common.js'
      // app中使用template的时候必须要使用
      
      '@': path.resolve(__dirname, './app')   //当前目录下的/app目录下
    }
  }
 }

首先,我们使用了extensions这样在引入文件的时候可以不需要添加后缀了,其次用@代替了当前目录下的/app目录,然后安装了vue中的相关插件,
来看看实际效果。

  • 安装vue
// 安装vue
npm install vue 
  • 在app目录下,新建APP.vue和Content.vue以及修改main.js
APP.vue
<template>
 <div id="app">
     3333
   <Content></Content>
 </div>
</template>
<script>
import Content from './Content';
export default {
 name:'app',
 components:{Content}
}
</script>
content.vue
<template>
<div>
     <h2>我是标题H2</h2>
 <p>233332222</p>
</div>

 
</template>
<script>
export default {
 name:'Content'
}
console.log('22222')
</script>
<style scoped lang="css">
 h2{
   color: red;
   background: blue;
   display: flex;
   
 }
 p{
     color: blue;
   }
</style>
main.js
import App from './App';
import Vue from 'vue';



new Vue({
  el:'#root',
  components: {App},
  template:'<App/>',
})

打开浏览器,能够看到如下
image.png

CSS预处理器

Sass 和 Less 之类的预处理器是对原生CSS的拓展,它们允许你使用类似于variables, nesting, mixins, inheritance等不存在于CSS中的特性来写CSS,CSS预处理器可以这些特殊类型的语句转化为浏览器可识别的CSS语句

npm install --save-dev sass-loader node-sass

配置相关的webpack

.....
   module: {
    rules: [
    {
        test: /\.vue$/,
        loader: 'vue-loader',
        exclude: /node_modules/
      },
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
        test: /\.scss$/,
        use: [
            {
                loader: "vue-style-loader"
            }, {
                loader: "css-loader",
                options: {
                    modules: true, // 指定启用css modules
                }, 
                
            },
            {
               loader:"sass-loader"
            },
        ]
       },
    ]
   },
....

现在能够在项目里面使用sass了,我们一起来试一试吧
修改Content.vue

<template>
<div>
      <h2>我是标题H2</h2>
  <p>233332222</p>
</div>

  
</template>
<script>
export default {
  name:'Content'
}
console.log('22222')
</script>
<style scoped lang="scss">
  h2{
    color: red;
    background: blue;
    display: flex;
    p{
      color: blue;
    }
    
  }
  
</style>

npm run server运行一下,运行成功!
现在,我们已经能够使用大部分的内容,但是在实际开发中,我们得考虑浏览器兼容的问题,那么下面这个插件就是必不可少的。

postcss-loader

首先来安装postcss-loader 和 autoprefixer(自动添加前缀的插件)

npm install --save-dev postcss-loader  autoprefixer

配置webpack,在目录下新建postcss.config.js,并添加如下代码,重新使用npm start打包时,你写的css会自动根据配置文件来添加前缀了

// postcss.config.js
module.exports = {
    plugins: [

      // 能够使用浏览器兼容,需要注意的是,vue-loader15版本后就不自带postcss了
      require('autoprefixer')
    ]
  }
// package.json
.....
"browserslist": [
    "defaults",
    "not ie < 11",
    "last 2 versions",
    "> 1%",
    "iOS 7",
    "last 3 iOS versions"
  ]
.....
// webpack
   module: {
    rules: [
    {
        test: /\.vue$/,
        loader: 'vue-loader',
        exclude: /node_modules/
      },
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
        test: /\.scss$/,
        use: [
            {
                loader: "vue-style-loader"
            }, {
                loader: "css-loader",
                options: {
                    modules: true, // 指定启用css modules
                }, 
                
            },
            {
                loader:"postcss-loader",
            },
            {
               loader:"sass-loader"
            },
            
        ]
       },
    ]
   },
 .....

image.png
能够看到有所不一样!!

在使用postcss-loader的时候,有一个插件能够模拟scss/less的预处理器的功能
PreCSS它是一个和scss/less很像的预处理器,不过不同的是,这个预处理器是不是scss/less,你可以理解为何另一个预处理器,并且语法和scss极为相似。它和postcss-loader配合更好。

npm install --save-dev precss

更新webpack.config.js

// webpack
   module: {
    rules: [
    {
        test: /\.vue$/,
        loader: 'vue-loader',
        exclude: /node_modules/
      },
      {
        test: /\.js$/, // 能够使用async语法
        use: {
          loader: "babel-loader",
          options: {
            presets: [['@babel/preset-env', {
              useBuiltIns: "usage",
            }]]
          }
        },
        exclude: /node_modules/
      },
      {
        test: /\.scss$/,
        use: [
            {
                loader: "vue-style-loader"
            }, {
                loader: "css-loader",
                options: {
                    modules: true, // 指定启用css modules
                }, 
                
            },
            {
                loader:"postcss-loader",
            },
            
            
        ]
       },
    ]
   },
// postcss.config.js
module.exports = {
    plugins: [
        // 能够使用scss,less等
      require('precss'),
      // 能够使用浏览器兼容,需要注意的是,vue-loader15版本后就不自带postcss了
      require('autoprefixer')
    ]
  }

现在继续在项目中使用scss,能够看到,虽然scss去除掉了,但是还能够使用scss
使用npm start构建成功。

生产模式与开发模式

我们在开发模式下和生产模式下用的webpack配置是不一样的,例如,开发模式下我们可能需要用到style-loader插入到JS文件中,如果把这种东西放到生产模式下,那么JS的文件会变得很大,非常不利于我们的项目打包。所以肯定是需要分开的。

提取公共组件

image.png
我们在npm start的时候发现,bundle.js的文件是在是太大了,如果我们改动一个小小的css就要需要交客户端重新缓存一遍是在是浪费资源,那么我们能不能将一些公共的部分提取出来,例如VUE?
每次改变的时候就只改变我们的内容!

//webpack.config.js
······
 devServer: {
    contentBase: "./public",//本地服务器所加载的页面所在的目录
    historyApiFallback: true,//不跳转
    inline: true,//实时刷新
    hot: true,
  },
  optimization: {
    splitChunks: {
      chunks: 'all',
    },
  },
······

需要写上为何,
再次运行npm start
image.png
发现,bundle.js已经变得非常小了,而多出来的是另一个文件。
现在已经把公共样式抽离出来了.

使用webpack-merge。

webpack-merge

由于在实际工程中,生产与开发要打包的效果也完全不同,例如在开发中要把css插入到JS中,而在生产中,要把JS与CSS分离出来,这个时候就需要用到了webpack-merge了
安装以下包

npm install --save-dev mini-css-extract-plugin webpack-merge

新建一个webpack配置文件webpack.prod.conf.js

const merge = require("webpack-merge");
const baseConfig = require("./webpack.config.js");
// console.log('------------------', baseConfig);
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
module.exports = merge.smart(baseConfig, {
  // mode: "production",
  module: {
    rules: [
      {
        test: /\.scss$/,
        use: [{
          loader: MiniCssExtractPlugin.loader,
          options: {
            // you can specify a publicPath here
            // by default it uses publicPath in webpackOptions.output
            publicPath: '../',
            
          },
        }, {
          loader: "css-loader",
          options: {
            // modules:true,
            modules: {
              mode: 'local',
              localIdentName: '[local]_[hash:base64:8]'
            },

          }
        },
        {
          loader: "postcss-loader",
        },
        ],
        exclude: /node_modules/
      }
    ]
  },
  plugins: [
    // ... 忽略 vue-loader 插件
    new MiniCssExtractPlugin({
      filename: 'style.css'
    })
  ]
});

webpack-merge的作用是通过smart的方法来将相同的test进行覆盖(后者能够覆盖前者),
在这个项目中,webpack.config.js里面有一个scss规则,而在webpack.prod.conf.js里面也有一个scss规则,webpack-merge会根据相同的test将后者覆盖前者,
而mini-css-extract-plugin这个插件能够将css提取出来,单独放到一个文件里面,如果还按照开发模式下的将css插入JS中,那么JS的文件会非常庞大,而且这样也不利于缓存,所以这个插件适合用于生产模式下的东西。
在package.json中添加:

....
"prod":"webpack --config webpack.prod.conf.js",
....

运行npm run prod
发现build文件下多了个css文件,打包成功!

未完待续。。。。

评论

暂无评论