webpack从相识到合葬(4)-webpack优化配置

HMR

HMR: hot module replacement 热模块替换 / 模块热替换
通常不做任何配置的话,当你修改一个模块后,webpack会将所有模块重新构建打包一次,如果你有几百上千个模块,那效率无疑大打折扣.
作用:一个模块发生变化,只会重新打包这一个模块(而不是打包所有模块) 
极大提升构建速度
  
样式文件:可以使用HMR功能:因为style-loader内部实现了~
js文件:默认不能使用HMR功能 --> 需要修改js代码,添加支持HMR功能的代码
注意:HMR功能对js的处理,只能处理非入口js文件的其他文件。
html文件: 默认不能使用HMR功能.同时会导致问题:html文件不能热更新了~ (一般来说只有一个html文件,不用做HMR功能)
解决:修改entry入口,将html文件引入
module.exports = {
  //修改成数组
  entry: ['./src/js/index.js', './src/index.html'],
  output: {},
  module: {},
  plugins: [],
  mode: 'development',
  devServer: {
    contentBase: resolve(__dirname, 'build'),
    compress: true,
    port: 3000,
    open: true,
    // 开启HMR功能
    // 当修改了webpack配置,新配置要想生效,必须重新webpack服务
    hot: true
  }
};

##########修改js代码,使js支持hmr
if (module.hot) {
  // 一旦 module.hot 为true,说明开启了HMR功能。 --> 让HMR功能代码生效
  module.hot.accept('./print.js', function() {
    // 方法会监听 print.js 文件的变化,一旦发生变化,其他模块不会重新打包构建。
    // 会执行后面的回调函数
    print();
  });
}

source-map

module.exports = {
  entry: '',
  output: {},
  module: {},
  plugins: [],
  mode: 'development',
  devServer: {},
  //使用source-map
  devtool: 'eval-source-map'
};
source-map: 一种提供源代码到构建后代码映射技术(如果构建后代码出错了,通过映射可以追踪源代码错误)
配置可选组合
[inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map

内联 和 外部的区别:1. 外部生成了文件,内联没有 2. 内联构建速度更快

source-map:外部
  错误代码准确信息 和 源代码的错误位置
inline-source-map:内联
  只生成一个内联source-map
  错误代码准确信息 和 源代码的错误位置
hidden-source-map:外部
  错误代码错误原因,但是没有错误位置
  不能追踪源代码错误,只能提示到构建后代码的错误位置
eval-source-map:内联
  每一个文件都生成对应的source-map
  错误代码准确信息 和 源代码的错误位置
nosources-source-map:外部
  错误代码准确信息, 但是没有任何源代码信息
cheap-source-map:外部
  错误代码准确信息 和 源代码的错误位置 
  只能精确的行
cheap-module-source-map:外部
  错误代码准确信息 和 源代码的错误位置 
  module会将loader的source map加入


开发环境:速度快,调试更友好
  速度快(eval>inline>cheap>...)
    eval-cheap-souce-map
    eval-source-map
  调试更友好  
    souce-map
    cheap-module-souce-map
    cheap-souce-map
  最终选择
  --> eval-source-map  / eval-cheap-module-souce-map

生产环境:源代码要不要隐藏? 调试要不要更友好
  内联会让代码体积变大,所以在生产环境不用内联
  nosources-source-map 全部隐藏
  hidden-source-map 只隐藏源代码,会提示构建后代码错误信息
  最终选择
  --> source-map / cheap-module-souce-map

oneOf

 正常情况下每种文件都会通过rules进行命中判断,但是想让每个文件被命中之后不再做判断,这就需要oneOf了.有点像在遍历中加了一个break跳出循环的感觉
 但是js文件要判断两次,而oneOf里只允许同一种文件配置一次,所以要将多次命中判断移到oneOf外面,只留一个在oneOf内
// 复用loader
const commonCssLoader = [
  MiniCssExtractPlugin.loader,
  'css-loader',
  {
    // 还需要在package.json中定义browserslist
    loader: 'postcss-loader',
    options: {
      ident: 'postcss',
      plugins: () => [require('postcss-preset-env')()]
    }
  }
];

module.exports = {
  entry: '',
  output: },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        enforce: 'pre',
        loader: 'eslint-loader',
        options: {
          fix: true
        }
      },
      {
        // 以下loader只会匹配一个
        // 注意:不能有两个配置处理同一种类型文件
        oneOf: [
          {
            test: /\.css$/,
            use: [...commonCssLoader]
          },
          {
            test: /\.less$/,
            use: [...commonCssLoader, 'less-loader']
          },
          {
            test: /\.js$/,
            exclude: /node_modules/,
            loader: 'babel-loader',
            options: {
              presets: [
                [
                  '@babel/preset-env',
                  {
                    useBuiltIns: 'usage',
                    corejs: {version: 3},
                    targets: {
                      chrome: '60',
                      firefox: '50'
                    }
                  }
                ]
              ]
            }
          },
          {
            test: /\.(jpg|png|gif)/,
            loader: 'url-loader',
            options: {
              limit: 8 * 1024,
              name: '[hash:10].[ext]',
              outputPath: 'imgs',
              esModule: false
            }
          },
          {
            test: /\.html$/,
            loader: 'html-loader'
          },
          {
            exclude: /\.(js|css|less|html|jpg|png|gif)/,
            loader: 'file-loader',
            options: {
              outputPath: 'media'
            }
          }
        ]
      }
    ]
  },
  plugins: [],
  mode: 'production'
};

缓存

缓存分为两方面,一个是babel,一个是用hash缓存静态资源.
babel是把我们编写的js模块,翻译成浏览器通识的js语言,比如应用中有100个js模块,而我们只修改了一个,打包时babel会翻译全部的js模块,最优方案肯定是只翻译修改的那一个.
之前说到的HMR是在开发环境下基于devServer的,不适用于生产环境
当我们对静态资源设置了cache-control时,即便服务器资源发生了变化,浏览器一样读取memory cache.比如一个css文件,第一次加载会发送请求,第二次直接从memory中加载,大大加快页面加载速度.
第一种hash是打包时webpack生成的hash值,放到静态资源的文件名中,让每次请求的文件名都不一样,cache-control自然也就失效了,但是缓存失效并不是我们想要的结果.
第二种叫做chunkhash,打包资源如果来源于同一个chunk,那么hash就一样,但是呢,css一般是引用到js中的,它们的thunkhash也是一样的.
第三种是contenthash,是根据文件内容生成的hash值,这就是我们想要的,有点类似于对文件进行md5加密,下载后比对,防止文件被篡改
const { resolve } = require('path');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');

/*
  缓存:
    babel缓存
      cacheDirectory: true
      --> 让第二次打包构建速度更快
    文件资源缓存
      hash: 每次wepack构建时会生成一个唯一的hash值。
        问题: 因为js和css同时使用一个hash值。
          如果重新打包,会导致所有缓存失效。(可能我却只改动一个文件)
      chunkhash:根据chunk生成的hash值。如果打包来源于同一个chunk,那么hash值就一样
        问题: js和css的hash值还是一样的
          因为css是在js中被引入的,所以同属于一个chunk
      contenthash: 根据文件的内容生成hash值。不同文件hash值一定不一样    
      --> 让代码上线运行缓存更好使用
*/

module.exports = {
  entry: '',
  output: {
    //使用contenthash
    filename: 'js/built.[contenthash:10].js',
    path: resolve(__dirname, 'build')
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        enforce: 'pre',
        loader: 'eslint-loader',
        options: {
          fix: true
        }
      },
      {
        oneOf: [
          {
            test: /\.css$/,
            use: [...commonCssLoader]
          },
          {
            test: /\.less$/,
            use: [...commonCssLoader, 'less-loader']
          },
          {
            test: /\.js$/,
            exclude: /node_modules/,
            loader: 'babel-loader',
            options: {
              presets: [
                [
                  '@babel/preset-env',
                  {
                    useBuiltIns: 'usage',
                    corejs: { version: 3 },
                    targets: {
                      chrome: '60',
                      firefox: '50'
                    }
                  }
                ]
              ],
              // 开启babel缓存
              // 第二次构建时,会读取之前的缓存
              cacheDirectory: true
            }
          }
          }
        ]
      }
    ]
  },
  plugins: [
    new MiniCssExtractPlugin({
      //使用contenthash
      filename: 'css/built.[contenthash:10].css'
    }),
  ],
  mode: 'production',
};

tree shaking

tree shaking的字面意思是'树摇',把我们的应用想象成一棵树,被引用的库/源代码是绿色的叶子,没被引用的是枯萎的灰叶子,摇一摇树,把灰叶子摇下来.
使用tree shaking目的是去除应用中没有使用的代码,减小代码体积
启用前提:1. 必须使用ES6模块化  2. mode=production
有一个小问题,不同版本的tree shaking会有一些差异,有的会把css文件当做未引用代码给干掉了,我们需要在package.json中做一些配置
所有代码都没有副作用(都可以进行tree shaking)
"sideEffects": false 
问题:可能会把css / @babel/polyfill (副作用)文件干掉
标记哪些资源不需要tree shaking
"sideEffects": ["*.css", "*.less"]

code split

代码分割可以将打包生产的一个chunk分割成多个文件.
比如将一个大文件分割成3个,那么加载时,就可以并行加载.同时分割成多个文件后,我们可以实现按需加载的功能
第一种方式:多入口
const { resolve } = require('path');

module.exports = {
  // 单入口
  // entry: './src/js/index.js',
  entry: {
    // 多入口:有一个入口,最终输出就有一个bundle
    index: './src/js/index.js',
    test: './src/js/test.js'
  },
  output: {
    // [name]:取文件名
    filename: 'js/[name].[contenthash:10].js',
    path: resolve(__dirname, 'build')
  },
  plugins: [],
  mode: 'production'
};
开发中大部分都是SPA,多页面的应用并不常见
第二种方式:多入口/单入口 + optimization
const { resolve } = require('path');

module.exports = {
  // 单入口
  // entry: './src/js/index.js',
  entry: {
    index: './src/js/index.js',
    test: './src/js/test.js'
  },
  output: {
    // [name]:取文件名
    filename: 'js/[name].[contenthash:10].js',
    path: resolve(__dirname, 'build')
  },
  plugins: [],
  /*
    1. 可以将node_modules中代码单独打包一个chunk最终输出
    2. 如果是多入口,会自动分析多入口chunk中,有没有公共的文件。如果有会打包成单独一个chunk
  */
  optimization: {
    splitChunks: {
      chunks: 'all'
    }
  },
  mode: 'production'
};
第三种: 单入口 + optimization + import动态导入
const { resolve } = require('path');

module.exports = {
  // 单入口
  entry: './src/js/index.js',
  output: {
    // [name]:取文件名
    filename: 'js/[name].[contenthash:10].js',
    path: resolve(__dirname, 'build')
  },
  plugins: [],
  
  optimization: {
    splitChunks: {
      chunks: 'all'
    }
  },
  mode: 'production'
};

/*
  通过js代码,让某个文件被单独打包成一个chunk
  import动态导入语法:能将某个文件单独打包
  webpackChunkName:打包后的文件名,否则是按照打包顺序的1,2,3..命名
*/
import(/* webpackChunkName: 'test' */'./test')
  .then(result => {
    // eslint-disable-next-line
    console.log(result);
  })
  .catch(() => {
    // eslint-disable-next-line
    console.log('文件加载失败~');
  });

懒加载与预加载

比方说,在一个点击事件里,才会用到引入文件里的方法.使用正常的import,会在主页面加载时就会一起加载,即使此时还没有使用.
懒加载就是在你使用时才去加载,但如果import的文件过大,在触发时就需要等一段较长时间.
预加载虽然看network好像是跟其他资源一样,在页面初始时就加载,但不同于正常的文件加载,预加载是在浏览器空闲时偷偷加载,但预加载的兼容性不太可靠
懒加载
document.getElementById('btn').onclick = function() {
  // 懒加载:当文件需要使用时才加载~
  import(/*webpackChunkName: 'test'*/'./test').then(({ mul }) => {
    console.log(mul(4, 5));
  });
};
预加载
document.getElementById('btn').onclick = function() {
  // 预加载 prefetch:会在使用之前,提前加载js文件 
  // 正常加载可以认为是并行加载(同一时间加载多个文件)  
  // 预加载 prefetch:等其他资源加载完毕,浏览器空闲了,再偷偷加载资源
  import(/* webpackChunkName: 'test', webpackPrefetch: true */'./test').then(({ mul }) => {
    console.log(mul(4, 5));
  });
};

PWA

PWA(Progressive Web App),渐进式WEB应用,可以做到离线访问应用.由于兼容性,并没有很好的普及,只有如淘宝一些大厂在使用 
//下载workbox-webpack-plugin
//配置
const WorkboxWebpackPlugin = require('workbox-webpack-plugin');
...
  plugins: [
    new WorkboxWebpackPlugin.GenerateSW({
      /*
        1. 帮助serviceworker快速启动
        2. 删除旧的 serviceworker
        生成一个 serviceworker 配置文件~
      */
      clientsClaim: true,
      skipWaiting: true
    })
  ],
...
//入口js文件
// 注册serviceWorker
if ('serviceWorker' in navigator) {
  window.addEventListener('load', () => {
    navigator.serviceWorker
      .register('/service-worker.js')
      .then(() => {
        console.log('sw注册成功了~');
      })
      .catch(() => {
        console.log('sw注册失败了~');
      });
  });
}
webpack打包后,会生成service-worker.js,注册它即可.
注册成功,打开页面,在chrome开发者工具的Application中的Service Workers中就会看到注册的资源.
同时在Cache Storage中能看到缓存的数据.之后将network设置为offline,刷新页面,也是能访问页面的.
Service Worker只能运行在服务器上,所以测试时不要直接把js文件运行到浏览器中,要使用nodejs或serve等等的方式

多进程打包

下载thread-loader
//配置
  module: {
    rules: [
    {
        test: /\.js$/,
        exclude: /node_modules/,
        use: [
          /* 
            开启多进程打包。 
            进程启动耗时,进程通信也有开销,所以只有工作消耗时间比较长,才需要多进程打包,不然可能反而耗时更长
          */
          {
            loader: 'thread-loader',
            options: {
              workers: 2 // 进程2个,不配置的话,默认为cpu核数-1
            }
          },
          {
            loader: 'babel-loader',
            options: {
              presets: [
                [
                  '@babel/preset-env',
                  {
                    useBuiltIns: 'usage',
                    corejs: { version: 3 },
                    targets: {
                      chrome: '60',
                      firefox: '50'
                    }
                  }
                ]
              ],
              cacheDirectory: true
            }
          }
        ]
        },
      ]
   }

externals

防止某些包打包到最终的bundle中,比如我希望jquery是使用cdn链接的方式,就可以使用externals忽略掉它
const { resolve } = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
  entry: './src/js/index.js',
  output: {
    filename: 'js/built.js',
    path: resolve(__dirname, 'build')
  },
  plugins: [
    new HtmlWebpackPlugin({
      template: './src/index.html'
    })
  ],
  mode: 'production',
  externals: {
    // 拒绝jQuery被打包进来
    //格式为 忽略库名:npm包名
    jquery: 'jQuery'
  }
};
忽略打包之后,一定要在页面中引入
<script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>

dll

dll,动态链接库,就是将某些依赖库,单独打包,之后只要引用就好了
externals是彻底不打包,需要引入cdn链接.dll是需要打包一次,之后引用
创建一个名为webpack.dll.js的文件
/*
  使用dll技术,对某些库(第三方库:jquery、react、vue...)进行单独打包
*/

const { resolve } = require('path');
const webpack = require('webpack');

module.exports = {
  entry: {
    // 最终打包生成的[name] --> jquery
    // ['jquery'] --> 要打包的库是jquery
    jquery: ['jquery'],
  },
  output: {
    filename: '[name].js',
    path: resolve(__dirname, 'dll'),
    library: '[name]_[hash]' // 打包的库里面向外暴露出去的内容叫什么名字
  },
  plugins: [
    // 打包生成一个 manifest.json --> 提供和jquery映射
    new webpack.DllPlugin({
      name: '[name]_[hash]', // 映射库的暴露的内容名称
      path: resolve(__dirname, 'dll/manifest.json') // 输出文件路径
    })
  ],
  mode: 'production'
};

运行 webpack --config webpack.dll.js
只要不修改webpack.dll.js文件,以后都不需要运行它,那些被单独打包的库仅仅只需要打包一次

配置webpack.config.js
const { resolve } = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const webpack = require('webpack');
const AddAssetHtmlWebpackPlugin = require('add-asset-html-webpack-plugin');

module.exports = {
  entry: './src/index.js',
  output: {
    filename: 'built.js',
    path: resolve(__dirname, 'build')
  },
  plugins: [
    new HtmlWebpackPlugin({
      template: './src/index.html'
    }),
    // 告诉webpack哪些库不参与打包,同时使用时的名称也得变~
    new webpack.DllReferencePlugin({
      manifest: resolve(__dirname, 'dll/manifest.json')
    }),
    // 将某个文件打包输出去,并在html中自动引入该资源
    new AddAssetHtmlWebpackPlugin({
      filepath: resolve(__dirname, 'dll/jquery.js')
    })
  ],
  mode: 'production'
};

总结一下

以下手段,请按需按实际情况组合
开发环境优化
构建速度:
HMR

代码调试:
source-map

生产环境优化
构建速度:
oneOf
babel缓存
多进程打包
externals
dll

运行性能:
contentHash缓存
tree shaking
code split
pwa

评论

暂无评论