详解 vue-cli 的打包配置文件代码

爱被打了一巴掌 2021-10-13 01:25 348阅读 0赞

## 一、前言 ##

对于webpack基础不好，node指令不通的童鞋。估计对自己搭建Vue、react脚手架是相当头疼的，有种无从下手的感觉。然而，从头看这2块，耗时太长，而且说实话得练才行，不练练手看不明白。那大多数人就采取折中的方案，修改成熟的脚手架，改成自己想要的样子。这个相对来说难度降低了不少，不过依然会有很多难点不加不明白。所以这里就以Vue的脚手架为例子，将源码加上注释，方便大家加深对项目配置的理解，少走弯路。

## 二、vue-cli 都做了什么 ##

先跟大家简单说说，vue-cli 都做了什么，大家也对他有个大体的了解

1、build/dev-server.js 文件 项目node的启动文件，这里面做了webpack配置和node操作，

2、build/webpack.base.conf.js webpack基本配置文件

3、build/webpack.dev.conf.js 开发环境webpack配置

4、build/webpack.prod.conf.js 正式环境的webpack配置

5、build/build.js 执行打包的配置文件

6、config/index.js 开发、线上环境的文件输出、打包等一些配置

这是脚手架里面的一些主要配置文件，通过配置，整个项目分为开发环境和生产环境，不需要你多做很多繁琐的工作，用起来很方便，如果你想按照自己的喜好或者需求，可以修改主题文件的配置，下面我们就附上上述每个文件的代码和注释。　　　　ps：代码我修改过，不是完全一样的，大家主要看看文件功能，和一些代码、组件的含义。

## 三、具体文件代码详解 ##

1、build/dev-server.js

// 检查 Node 和 npm 版本
    require('./check-versions')()
    
    // 获取 config/index.js 的默认配置
    var config = require('../config')
    
    // 如果 Node 的环境无法判断当前是 dev / product 环境
    // 使用 config.dev.env.NODE_ENV 作为当前的环境
    if (!process.env.NODE_ENV) { 
      process.env.NODE_ENV = JSON.parse(config.dev.env.NODE_ENV)
    }
    
    // 一个可以强制打开浏览器并跳转到指定 url 的插件
    var opn = require('opn')
    // 使用 NodeJS 自带的文件路径工具
    var path = require('path')
    // 使用 express
    var express = require('express')
    // 使用 webpack
    var webpack = require('webpack')
    // 使用 proxyTable 热更新
    var proxyMiddleware = require('http-proxy-middleware')
    // 使用 dev 环境的 webpack 配置
    var webpackConfig = require('./webpack.dev.conf')
    // 使用axios请求
    var axios = require('axios')
    
    // 如果没有指定运行端口，使用 config.dev.port 作为运行端口
    var port = process.env.PORT || config.dev.port
    
    
    var autoOpenBrowser = !!config.dev.autoOpenBrowser
    
    // 使用 config.dev.proxyTable 的配置作为 proxyTable 的代理配置
    var proxyTable = config.dev.proxyTable
    // 使用 express 启动一个服务，URL改一下，这里是做服务转发，还可以对
    var app = express()
    
    var apiRoutes = express.Router()
    
    apiRoutes.get('/getDiscList', function (req, res) { 
      var url = 'https://c.y.qq.com/splcloud/fcgi-bin/fcg_get_diss_by_tag.fcg'
      axios.get(url, { 
        headers: { 
          referer: 'https://c.y.qq.com/',
          host: 'c.y.qq.com'
        },
        params: req.query
      }).then((response) => { 
        res.json(response.data)
      }).catch((e) => { 
        console.log(e)
      })
    })
    
    apiRoutes.get('/lyric', function (req, res) { 
      var url = 'https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg'
    
      axios.get(url, { 
        headers: { 
          referer: 'https://c.y.qq.com/',
          host: 'c.y.qq.com'
        },
        params: req.query
      }).then((response) => { 
        var ret = response.data
        if (typeof ret === 'string') { 
          var reg = /^\w+$({[^()]+})$$/
          var matches = ret.match(reg)
          if (matches) { 
            ret = JSON.parse(matches[1])
          }
        }
        res.json(ret)
      }).catch((e) => { 
        console.log(e)
      })
    })
    
    app.use('/api', apiRoutes)
    
    var compiler = webpack(webpackConfig)
    // 启动 webpack-dev-middleware，将 编译后的文件暂存到内存中
    var devMiddleware = require('webpack-dev-middleware')(compiler, { 
      publicPath: webpackConfig.output.publicPath,
      quiet: true
    })
    // 启动 webpack-hot-middleware，也就是我们常说的 Hot-reload
    var hotMiddleware = require('webpack-hot-middleware')(compiler, { 
      log: () => { }
    })
    // force page reload when html-webpack-plugin template changes
    compiler.plugin('compilation', function (compilation) { 
      compilation.plugin('html-webpack-plugin-after-emit', function (data, cb) { 
        hotMiddleware.publish({  action: 'reload' })
        cb()
      })
    })
    
    // 将 proxyTable 中的请求配置挂在到启动的 express 服务上
    Object.keys(proxyTable).forEach(function (context) { 
      var options = proxyTable[context]
      if (typeof options === 'string') { 
        options = {  target: options }
      }
      app.use(proxyMiddleware(options.filter || context, options))
    })
    
    // 使用 connect-history-api-fallback 匹配资源，如果不匹配就可以重定向到指定地址
    app.use(require('connect-history-api-fallback')())
    
    // 将暂存到内存中的 webpack 编译后的文件挂在到 express 服务上
    app.use(devMiddleware)
    
    // 将 Hot-reload 挂在到 express 服务上
    app.use(hotMiddleware)
    
    // 拼接 static 文件夹的静态资源路径
    var staticPath = path.posix.join(config.dev.assetsPublicPath, config.dev.assetsSubDirectory)
    // 为静态资源提供响应服务
    app.use(staticPath, express.static('./static'))
    
    var uri = 'http://localhost:' + port
    
    var _resolve
    var readyPromise = new Promise(resolve => { 
      _resolve = resolve
    })
    
    console.log('> Starting dev server...')
    devMiddleware.waitUntilValid(() => { 
      console.log('> Listening at ' + uri + '\n')
      // 如果不是测试环境，自动打开浏览器并跳到我们的开发地址
      if (autoOpenBrowser && process.env.NODE_ENV !== 'testing') { 
        opn(uri)
      }
      _resolve()
    })
    // 让我们这个 express 服务监听 port 的请求，并且将此服务作为 dev-server.js 的接口暴露
    var server = app.listen(port)
    
    module.exports = { 
      ready: readyPromise,
      close: () => { 
        server.close()
      }
    }

2、build/webpack.base.conf.js

var path = require('path')
    var utils = require('./utils')
    var config = require('../config')
    // .vue 文件配置 loader 及工具 (autoprefixer)
    var vueLoaderConfig = require('./vue-loader.conf')
    // 拼接我们的工作区路径为一个绝对路径的函数
    function resolve(dir) { 
      return path.join(__dirname, '..', dir)
    }
    
    // webpack 配置，输入、输出、模块、插件
    module.exports = { 
      entry: { 
        app: './src/main.js'
      },
      output: { 
          // 编译输出的根路径
        path: config.build.assetsRoot,
        // 编译输出的文件名
        filename: '[name].js',
        // 正式发布环境下编译输出的发布路径
        publicPath: process.env.NODE_ENV === 'production'
          ? config.build.assetsPublicPath
          : config.dev.assetsPublicPath
      },
      resolve: { 
          // 自动补全的扩展名
        extensions: ['.js', '.vue', '.json'],
        // 默认路径代理，即起别名，例如 import Vue from 'vue'，会自动到 'vue/dist/vue.common.js'中寻找
        alias: { 
          '@': resolve('src'),
          'common': resolve('src/common'),
          'components': resolve('src/components'),
          'base': resolve('src/base'),
          'api': resolve('src/api')
        }
      },
      module: { 
        rules: [
              // 需要处理的文件及使用的 loader
          { 
            test: /\.(js|vue)$/,
            loader: 'eslint-loader',
            enforce: 'pre',
            include: [resolve('src'), resolve('test')],
            options: { 
                  // eslint 代码检查配置工具
              formatter: require('eslint-friendly-formatter')
            }
          },
          { 
            test: /\.vue$/,
            loader: 'vue-loader',
            options: vueLoaderConfig
          },
          { 
            test: /\.js$/,
            loader: 'babel-loader',
            include: [resolve('src'), resolve('test')]
          },
          { 
            test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
            loader: 'url-loader',
            options: { 
              limit: 10000,
              name: utils.assetsPath('img/[name].[hash:7].[ext]')
            }
          },
          { 
            test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
            loader: 'url-loader',
            options: { 
              limit: 10000,
              name: utils.assetsPath('fonts/[name].[hash:7].[ext]')
            }
          }
        ]
      }
    }

3、build/webpack.dev.conf.js

// 使用一些小工具
    var utils = require('./utils')
    var webpack = require('webpack')
    // 同样的使用了 config/index.js 的预设配置
    var config = require('../config')
    // 使用 webpack 配置合并插件
    var merge = require('webpack-merge')
    // 加载 webpack.base.conf
    var baseWebpackConfig = require('./webpack.base.conf')
    // 使用 html-webpack-plugin 插件，这个插件可以帮我们自动生成 html 并且注入到 .html 文件中
    var HtmlWebpackPlugin = require('html-webpack-plugin')
    // 一个友好的错误提示插件
    var FriendlyErrorsPlugin = require('friendly-errors-webpack-plugin')
    
    // 将 Hol-reload 相对路径添加到 webpack.base.conf 的 对应 entry 前
    Object.keys(baseWebpackConfig.entry).forEach(function (name) { 
      baseWebpackConfig.entry[name] = ['./build/dev-client'].concat(baseWebpackConfig.entry[name])
    })
    // 将我们 webpack.dev.conf.js 的配置和 webpack.base.conf.js 的配置合并
    module.exports = merge(baseWebpackConfig, { 
      module: { 
          // 使用 styleLoaders
        rules: utils.styleLoaders({  sourceMap: config.dev.cssSourceMap })
      },
      // 使用 #eval-source-map 模式作为开发工具，此配置可参考 DDFE 往期文章详细了解
      devtool: '#cheap-module-eval-source-map',
      plugins: [
        // definePlugin 接收字符串插入到代码当中, 所以你需要的话可以写上 JS 的字符串
        new webpack.DefinePlugin({ 
          'process.env': config.dev.env
        }),
        // definePlugin 接收字符串插入到代码当中, 所以你需要的话可以写上 JS 的字符串
        // HotModule 插件在页面进行变更的时候只会重回对应的页面模块，不会重绘整个 html 文件
        new webpack.HotModuleReplacementPlugin(),
        // 遇到报错，跳过还行，并提示错误信息
        new webpack.NoEmitOnErrorsPlugin(),
        // 将 index.html 作为入口，注入 html 代码后生成 index.html文件
        new HtmlWebpackPlugin({ 
          filename: 'index.html',
          template: 'index.html',
          inject: true
        }),
        // 使用这个插件，更好的输出错误信息
        new FriendlyErrorsPlugin()
      ]
    })

4、build/webpack.prod.conf.js

var path = require('path')
    var utils = require('./utils')
    var webpack = require('webpack')
    var config = require('../config')
    // 加载 webpack 配置合并工具
    var merge = require('webpack-merge')
    // 加载 webpack.base.conf.js文件
    var baseWebpackConfig = require('./webpack.base.conf')
    var CopyWebpackPlugin = require('copy-webpack-plugin')
    // 一个可以插入 html 并且创建新的 .html 文件的插件
    var HtmlWebpackPlugin = require('html-webpack-plugin')
    // 一个 webpack 扩展，可以提取一些代码并且将它们和文件分离开
    // 如果我们想将 webpack 打包成一个文件 css js 分离开，那我们需要这个插件
    var ExtractTextPlugin = require('extract-text-webpack-plugin')
    var OptimizeCSSPlugin = require('optimize-css-assets-webpack-plugin')
    
    var env = config.build.env
    
    // 合并 webpack.base.conf.js
    var webpackConfig = merge(baseWebpackConfig, { 
      module: { 
          // 使用的 loader
        rules: utils.styleLoaders({ 
          sourceMap: config.build.productionSourceMap,
          extract: true
        })
      },
      // 是否使用 #source-map 开发工具，更多信息可以查看 DDFE 往期文章
      devtool: config.build.productionSourceMap ? '#source-map' : false,
      output: { 
          // 编译输出目录
        path: config.build.assetsRoot,
        // 编译输出文件名
        // 我们可以在 hash 后加 :6 决定使用几位 hash 值
        filename: utils.assetsPath('js/[name].[chunkhash].js'),
        // 没有指定输出名的文件输出的文件名
        chunkFilename: utils.assetsPath('js/[id].[chunkhash].js')
      },
      plugins: [
        // definePlugin 接收字符串插入到代码当中, 所以你需要的话可以写上 JS 的字符串
        new webpack.DefinePlugin({ 
          'process.env': env
        }),
        // 压缩 js (同样可以压缩 css)
        new webpack.optimize.UglifyJsPlugin({ 
          compress: { 
            warnings: false
          },
          sourceMap: true
        }),
        // 将 css 文件分离出来
        new ExtractTextPlugin({ 
          filename: utils.assetsPath('css/[name].[contenthash].css')
        }),
        // Compress extracted CSS. We are using this plugin so that possible
        // duplicated CSS from different components can be deduped.
        new OptimizeCSSPlugin({ 
          cssProcessorOptions: { 
            safe: true
          }
        }),
        // 输入输出的 .html 文件
        new HtmlWebpackPlugin({ 
          filename: config.build.index,
          template: 'index.html',
          // 是否注入 html
          inject: true,
          // 压缩的方式
          minify: { 
            removeComments: true,
            collapseWhitespace: true,
            removeAttributeQuotes: true
          },
          chunksSortMode: 'dependency'
        }),
        // 没有指定输出文件名的文件输出的静态文件名
        new webpack.optimize.CommonsChunkPlugin({ 
          name: 'vendor',
          minChunks: function (module, count) { 
            // any required modules inside node_modules are extracted to vendor
            return (
              module.resource &&
              /\.js$/.test(module.resource) &&
              module.resource.indexOf(
                path.join(__dirname, '../node_modules')
              ) === 0
            )
          }
        }),
        // 没有指定输出文件名的文件输出的静态文件名
        new webpack.optimize.CommonsChunkPlugin({ 
          name: 'manifest',
          chunks: ['vendor']
        }),
        // copy custom static assets
        new CopyWebpackPlugin([
          { 
            from: path.resolve(__dirname, '../static'),
            to: config.build.assetsSubDirectory,
            ignore: ['.*']
          }
        ])
      ]
    })
    // 开启 gzip 的情况下使用下方的配置
    if (config.build.productionGzip) { 
      // 加载 compression-webpack-plugin 插件
      var CompressionWebpackPlugin = require('compression-webpack-plugin')
    
      webpackConfig.plugins.push(
          // 使用 compression-webpack-plugin 插件进行压缩
        new CompressionWebpackPlugin({ 
          asset: '[path].gz[query]',
          algorithm: 'gzip',
          test: new RegExp(
            '\\.(' +
            config.build.productionGzipExtensions.join('|') +
            ')$'
          ),
          threshold: 10240,
          minRatio: 0.8
        })
      )
    }
    
    if (config.build.bundleAnalyzerReport) { 
        // 懒加载插件
      var BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
      webpackConfig.plugins.push(new BundleAnalyzerPlugin())
    }
    
    module.exports = webpackConfig

5、build/build.js

// 检查 Node 和 npm 版本
    require('./check-versions')()
    // 当node无法判断是本地还是线上时，这里默认写上线上
    process.env.NODE_ENV = 'production'
    // 一个很好看的 loading 插件
    var ora = require('ora')
    var rm = require('rimraf')
    var path = require('path')
    var chalk = require('chalk')
    var webpack = require('webpack')
    var config = require('../config')
    // 加载 webpack.prod.conf文件
    var webpackConfig = require('./webpack.prod.conf')
    // 使用 ora 打印出 loading + log
    var spinner = ora('building for production...')
    // 开始 loading 动画
    spinner.start()
    
    // 删除打包后的文件夹，重新生成打包后的文件
    rm(path.join(config.build.assetsRoot, config.build.assetsSubDirectory), err => { 
      if (err) throw err
      // 开始 webpack 的编译
      webpack(webpackConfig, function (err, stats) { 
          // 编译成功的回调函数
        spinner.stop()
        if (err) throw err
        process.stdout.write(stats.toString({ 
          colors: true,
          modules: false,
          children: false,
          chunks: false,
          chunkModules: false
        }) + '\n\n')
    
        console.log(chalk.cyan(' Build complete.\n'))
        console.log(chalk.yellow(
          ' Tip: built files are meant to be served over an HTTP server.\n' +
          ' Opening index.html over file:// won\'t work.\n'
        ))
      })
    })

6、config/index.js

// see http://vuejs-templates.github.io/webpack for documentation.
    var path = require('path')
    module.exports = { 
      // production 环境
      build: { 
          // 使用 config/prod.env.js 中定义的编译环境
        env: require('./prod.env'),
        port: 9000,
        index: path.resolve(__dirname, '../dist/index.html'),
        // 编译输出的静态资源根路径
        assetsRoot: path.resolve(__dirname, '../dist'),
        // 编译输出的二级目录
        assetsSubDirectory: 'static',
        // 编译发布上线路径的根目录，可配置为资源服务器域名或 CDN 域名
        assetsPublicPath: '',
        // 是否开启 cssSourceMap
        productionSourceMap: true,
        // 是否开启 gzip
        productionGzip: false,
        // 需要使用 gzip 压缩的文件扩展名
        productionGzipExtensions: ['js', 'css'],
        // 插件叫做bundleAnalyzerReport，上面有几行注释，讲的是只要在打包的时候输入npm run build --report,就可以在打包的同时查看每个打包生成的js，里面的库的构成情况，方便我们进行相关的删减，比如有的库太大了，是否可以自己实现，有的库是否有必要，可否删除之类
        bundleAnalyzerReport: process.env.npm_config_report
      },
      // 使用 config/dev.env.js 中定义的编译环境
      dev: { 
        env: require('./dev.env'),
        // 运行测试页面的端口
        port: 8080,
        // 是否自动打开浏览器
        autoOpenBrowser: true,
        // 编译输出的二级目录
        assetsSubDirectory: 'static',
        // 编译发布上线路径的根目录，可配置为资源服务器域名或 CDN 域名
        assetsPublicPath: '/',
        // 需要 proxyTable 代理的接口（可跨域）
        proxyTable: { },
        // 是否开启 cssSourceMap
        cssSourceMap: false
      }
    }

## 四、小结 ##

上述就是vue-cli的主要文件详解了，由于涉及的东西比较多，有一些我也不是很熟悉，只能对大家做一个简单的解释。至于里面具体模块，有兴趣的可以自己去Google。

如果，注释或者言论有不当、错误之处，还请童鞋们之处。以免误导他人。 ps： 喜欢我博客的朋友，可以关注一下，我们沟通技术互相进步！