入門 Webpack

么是WebPack，為什么要使用它？

為什要使用WebPack

現今的很多網頁其實可以看做是功能豐富的應用，它們擁有著復雜的JavaScript代碼和一大堆依賴包。為了簡化開發的復雜度，前端社區涌現出了很多好的實踐方法

模塊化，讓我們可以把復雜的程序細化為小的文件;
類似于TypeScript這種在JavaScript基礎上拓展的開發語言：使我們能夠實現目前版本的JavaScript不能直接使用的特性，并且之后還能轉換為JavaScript文件使瀏覽器可以識別；
Scss，less等CSS預處理器
...

這些改進確實大大的提高了我們的開發效率，但是利用它們開發的文件往往需要進行額外的處理才能讓瀏覽器識別,而手動處理又是非常繁瑣的，這就為WebPack類的工具的出現提供了需求。

什么是Webpack

WebPack可以看做是模塊打包機：它做的事情是，分析你的項目結構，找到JavaScript模塊以及其它的一些瀏覽器不能直接運行的拓展語言（Scss，TypeScript等），并將其轉換和打包為合適的格式供瀏覽器使用。

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

其實Webpack和另外兩個并沒有太多的可比性，Gulp/Grunt是一種能夠優化前端的開發流程的工具，而WebPack是一種模塊化的解決方案，不過Webpack的優點使得Webpack在很多場景下可以替代Gulp/Grunt類的工具。

Grunt和Gulp的工作方式是：在一個配置文件中，指明對某些文件進行類似編譯，組合，壓縮等任務的具體步驟，工具之后可以自動替你完成這些任務。

Webpack的工作方式是：把你的項目當做一個整體，通過一個給定的主文件（如：index.js），Webpack將從這個文件開始找到你的項目的所有依賴文件，使用loaders處理它們，最后打包為一個（或多個）瀏覽器可識別的JavaScript文件。

如果實在要把二者進行比較，Webpack的處理速度更快更直接，能打包更多不同類型的文件。

開始使用Webpack

初步了解了Webpack工作方式后，我們一步步的開始學習使用Webpack。

安裝

Webpack可以使用npm安裝，新建一個空的練習文件夾（此處命名為webpack sample project），在終端中轉到該文件夾后執行下述指令就可以完成安裝。

//全局安裝
npm install -g webpack
//安裝到你的項目目錄
npm install --save-dev webpack

正式使用Webpack前的準備

在上述練習文件夾中創建一個package.json文件，這是一個標準的npm說明文件，里面蘊含了豐富的信息，包括當前項目的依賴模塊，自定義的腳本任務等等。在終端中使用npm init命令可以自動創建這個package.json文件

npm init

輸入這個命令后，終端會問你一系列諸如項目名稱，項目描述，作者等信息，不過不用擔心，如果你不準備在npm中發布你的模塊，這些問題的答案都不重要，回車默認即可。

package.json文件已經就緒，我們在本項目中安裝Webpack作為依賴包

// 安裝Webpack
npm install --save-dev webpack

回到之前的空文件夾，并在里面創建兩個文件夾,app文件夾和public文件夾，app文件夾用來存放原始數據和我們將寫的JavaScript模塊，public文件夾用來存放之后供瀏覽器讀取的文件（包括使用webpack打包生成的js文件以及一個index.html文件）。接下來我們再創建三個文件:

index.html --放在public文件夾中;
Greeter.js-- 放在app文件夾中;
main.js-- 放在app文件夾中;

此時項目結構如下圖所示

我們在index.html文件中寫入最基礎的html代碼，它在這里目的在于引入打包后的js文件（這里我們先把之后打包后的js文件命名為bundle.js，之后我們還會詳細講述）。

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Webpack Sample Project</title>
  </head>
  <body>
    <div id='root'>
    </div>
    <script src="bundle.js"></script>
  </body>
</html>

我們在Greeter.js中定義一個返回包含問候信息的html元素的函數,并依據CommonJS規范導出這個函數為一個模塊：

// Greeter.js
module.exports=function() {
  var greet=document.createElement('div');
  greet.textContent="Hi there and greetings!";
  return greet;
};

main.js文件中我們寫入下述代碼，用以把Greeter模塊返回的節點插入頁面。

//main.js 
const greeter=require('./Greeter.js');
document.querySelector("#root").appendChild(greeter());

正式使用Webpack

webpack可以在終端中使用，在基本的使用方法如下：

# {extry file}出填寫入口文件的路徑，本文中就是上述main.js的路徑，
# {destination for bundled file}處填寫打包文件的存放路徑
# 填寫路徑的時候不用添加{}
webpack {entry file} {destination for bundled file}

指定入口文件后，webpack將自動識別項目所依賴的其它文件，不過需要注意的是如果你的webpack不是全局安裝的，那么當你在終端中使用此命令時，需要額外指定其在node_modules中的地址，繼續上面的例子，在終端中輸入如下命令

# webpack非全局安裝的情況
node_modules/.bin/webpack app/main.js public/bundle.js

結果如下

可以看出webpack同時編譯了main.js 和Greeter,js,現在打開index.html,可以看到如下結果

有沒有很激動，已經成功的使用Webpack打包了一個文件了。不過在終端中進行復雜的操作，其實是不太方便且容易出錯的，接下來看看Webpack的另一種更常見的使用方法。

通過配置文件來使用Webpack

Webpack擁有很多其它的比較高級的功能（比如說本文后面會介紹的loaders和plugins），這些功能其實都可以通過命令行模式實現，但是正如前面提到的，這樣不太方便且容易出錯的，更好的辦法是定義一個配置文件，這個配置文件其實也是一個簡單的JavaScript模塊，我們可以把所有的與打包相關的信息放在里面。

繼續上面的例子來說明如何寫這個配置文件，在當前練習文件夾的根目錄下新建一個名為webpack.config.js的文件，我們在其中寫入如下所示的簡單配置代碼，目前的配置主要涉及到的內容是入口文件路徑和打包后文件的存放路徑。

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

注：“__dirname”是node.js中的一個全局變量，它指向當前執行腳本所在的目錄。

有了這個配置之后，再打包文件，只需在終端里運行webpack(非全局安裝需使用node_modules/.bin/webpack)命令就可以了，這條命令會自動引用webpack.config.js文件中的配置選項，示例如下：

又學會了一種使用Webpack的方法，這種方法不用管那煩人的命令行參數，有沒有感覺很爽。如果我們可以連webpack(非全局安裝需使用node_modules/.bin/webpack)這條命令都可以不用，那種感覺會不會更爽~，繼續看下文。

更快捷的執行打包任務

在命令行中輸入命令需要代碼類似于node_modules/.bin/webpack這樣的路徑其實是比較煩人的，不過值得慶幸的是npm可以引導任務執行，對npm進行配置后可以在命令行中使用簡單的npm start命令來替代上面略微繁瑣的命令。在package.json中對scripts對象進行相關設置即可，設置方法如下。

{
  "name": "webpack-sample-project",
  "version": "1.0.0",
  "description": "Sample webpack project",
  "scripts": {
    "start": "webpack" // 修改的是這里，JSON文件不支持注釋，引用時請清除
  },
  "author": "zhang",
  "license": "ISC",
  "devDependencies": {
    "webpack": "3.10.0"
  }
}

注：package.json中的script會安裝一定順序尋找命令對應位置，本地的node_modules/.bin路徑就在這個尋找清單中，所以無論是全局還是局部安裝的Webpack，你都不需要寫前面那指明詳細的路徑了。

npm的start命令是一個特殊的腳本名稱，其特殊性表現在，在命令行中使用npm start就可以執行其對于的命令，如果對應的此腳本名稱不是start，想要在命令行中運行時，需要這樣用npm run {script name}如npm run build，我們在命令行中輸入npm start試試，輸出結果如下：

現在只需要使用npm start就可以打包文件了，有沒有覺得webpack也不過如此嘛，不過不要太小瞧webpack，要充分發揮其強大的功能我們需要修改配置文件的其它選項，一項項來看。

Webpack的強大功能

生成Source Maps（使調試更容易）

開發總是離不開調試，方便的調試能極大的提高開發效率，不過有時候通過打包后的文件，你是不容易找到出錯了的地方，對應的你寫的代碼的位置的，Source Maps就是來幫我們解決這個問題的。

通過簡單的配置，webpack就可以在打包時為我們生成的source maps，這為我們提供了一種對應編譯文件和源文件的方法，使得編譯后的代碼可讀性更高，也更容易調試。

在webpack的配置文件中配置source maps，需要配置devtool，它有以下四種不同的配置選項，各具優缺點，描述如下：

devtool選項	配置結果
source-map	在一個單獨的文件中產生一個完整且功能完全的文件。這個文件具有最好的source map，但是它會減慢打包速度；
cheap-module-source-map	在一個單獨的文件中生成一個不帶列映射的map，不帶列映射提高了打包速度，但是也使得瀏覽器開發者工具只能對應到具體的行，不能對應到具體的列（符號），會對調試造成不便；
eval-source-map	使用eval打包源文件模塊，在同一個文件中生成干凈的完整的source map。這個選項可以在不影響構建速度的前提下生成完整的sourcemap，但是對打包后輸出的JS文件的執行具有性能和安全的隱患。在開發階段這是一個非常好的選項，在生產階段則一定不要啟用這個選項；
cheap-module-eval-source-map	這是在打包文件時最快的生成source map的方法，生成的Source Map 會和打包后的JavaScript文件同行顯示，沒有列映射，和eval-source-map選項具有相似的缺點；

正如上表所述，上述選項由上到下打包速度越來越快，不過同時也具有越來越多的負面作用，較快的打包速度的后果就是對打包后的文件的的執行有一定影響。

對小到中型的項目中，eval-source-map是一個很好的選項，再次強調你只應該開發階段使用它，我們繼續對上文新建的webpack.config.js，進行如下配置:

module.exports={
  devtool: 'eval-source-map',
  entry:  __dirname + "/app/main.js",
  output: {
    path: __dirname + "/public",
    filename: "bundle.js"
  }
}

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-source-map',

  entry:  __dirname + "/app/main.js",
  output: {
    path: __dirname + "/public",
    filename: "bundle.js"
  },

  devServer: {
    contentBase: "./public",//本地服務器所加載的頁面所在的目錄
    historyApiFallback: true,//不跳轉
    inline: true//實時刷新
  } 
}

在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-source-map',
    devServer: {
        contentBase: "./public",//本地服務器所加載的頁面所在的目錄
        historyApiFallback: true,//不跳轉
        inline: true//實時刷新
    },
    module: {
        rules: [
            {
                test: /(\.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-source-map',
    devServer: {
        contentBase: "./public",//本地服務器所加載的頁面所在的目錄
        historyApiFallback: true,//不跳轉
        inline: true//實時刷新
    },
    module: {
        rules: [
            {
                test: /(\.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有很多內置插件，同時也有很多第三方插件，可以讓我們完成更加豐富的功能。

使用插件的方法

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-source-map',
    devServer: {
        contentBase: "./public",//本地服務器所加載的頁面所在的目錄
        historyApiFallback: true,//不跳轉
        inline: 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 一個這個插件的實例，并傳入相關的參數
        })
    ],
};

再次執行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-source-map',
    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 一個這個插件的實例，并傳入相關的參數
        }),
        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的詳細使用可參考這里

吐槽一下。上個破班，閑嘛閑得要死，人都要爛掉。又加上等著過年，不知未來在何方哈哈。如今不缺糧草，又不愁冷暖。只是要滿足自己對美好品質生活的渴望，最終用自己的方式來真正創造實現人生價值。

不負能量了。最近有在使用 electron + react 自己開發一個客戶端應用。首先整個項目是通過 electron-boilerplate 模板來創建的，using Electron, React and Typescript。地址：https://github.com/sindresorhus/electron-boilerplate

ps: 當想在 github 搜學習資源時，可以檢索 awesome + [theme] 比如 awesome JavaScript, awesome Vue, etc.

基于這個模板創建的項目,其中 react 的 webpack 配置文件是 webpack/react.webpack.js ，最初好像都沒配置 css-loader，更別提什么 css 模塊化了…幸好有點 webpack 基礎和之前也比較系統地了解學習了 react。

css 模塊化：隨著 react、vue 等基于模塊化框架的普及，我們通常會將頁面拆分為多個小組件，然后將多個組件拼接組成最終程序呈現的頁面。但是如果頁面中兩個組件使用了相同的類名，后者的樣式會把前者的覆蓋掉，造成樣式的命名沖突。所以就出現了 css 模塊化的概念。vue 是我們在組件中寫樣式的時候加上 scoped 就好了，但是 react 通常要自己進行配置。CSS 模塊化使得我們可以向 import js 一樣來引用我們的 css 代碼，代碼中的每一個類名都是引入對象的一個屬性。通過這種方式，在使用時明確指定所引用的 css 樣式。在打包的時候自動地將類名轉換為 hash 值，完全杜絕 css 類名沖突的問題。

css 命名規范 BEM：BEM，塊 block，元素 element，修飾符 modifier。由 Yandex 團隊提出的一種前端命名方法論，使得 css 類對其他開發者來說更加透明且更有意義。

/* 塊通常是指 Web 應用開發中的組件或模塊.每個塊在邏輯和功能上都是相互獨立的*/

.block{}

/* 元素是塊中的組成部分.元素不能離開塊使用,且 BEM 不推薦在元素中嵌套其他元素*/

.block__element{}

/* 修飾符是用來定義塊或元素的外觀和行為.同樣的塊在應用不同的修飾符之后,會有不同的外觀*/

.block--modifier{}

餓了么團隊開源的 element-ui 組件庫的 css 類命名采用的就是此規范。而螞蟻金服的 ant-design 好像并沒有哈哈。之后自己也將一直遵守這樣的規范，逐漸養成自己的一整套規范！開發就是要規范化，爭取不寫垃圾代碼。

配置 css 模塊化：

首先 npm install –save-dev style-loader css-loaderstyle-loader 是通過 JS 腳本創建一個 style 標簽，里面包含樣式。但是并不能單獨使用，因為它不負責解析 css 之前的依賴關系，所以還需安裝 css-loader。webpack 使用 js 寫的，運行在 node 環境下，打包的時候只會處理 js 之間的依賴關系。所以處理 css 文件需要引入 css-loader 來識別，通過特定的語法規則進行內容轉換最后導出。
修改 webpack 配置項，這里的 webpack 版本是 4.42.1。

   module.exports={
   module: {
   rules: [
    {
    test: /\.css$/,
    use: [
    'style-loader',
    // 開啟模塊化并自定義 hash 名稱
    {loader:'css-loader',options:{modules:{localIdentName:'[path][name]\_\_[local]--[hash:base64:5]'}}},
    ],
    // 排除 node_modules 文件夾
    exclude: path.resolve(rootPath,'node_modules'),
   },
   ]
   }

定義 css 文件。

   .className {
   color: green;
   }
   /_ 編寫全局樣式 _/
   :global(.className) {
   color: red;
   }

當然還可以引入 less-loader 等 css 預處理器，同樣開啟模塊化。這邊給出我在項目中的配置。

   module.exports={
   module: {
   rules: [
    {
    // CSS 全局處理
    test: /\.css$/,
    use: [
    'style-loader',
    'css-loader'
    ],
    exclude: path.resolve(rootPath,'node_modules'),

   },
   {
    // less 模塊化處理
    test: /\.less$/,
    exclude: path.resolve(rootPath,'node_modules'),
    use: [
    'style-loader',
    {loader:'css-loader',options:{modules:{localIdentName:'[local]-[hash:5]'}}},
    'less-loader'
    ]
   }
   ]
   }

最后引入 AntDesign。項目地址https://ant-design.gitee.io/docs/react/introduce-cn。

首先 npm i antd -S 安裝，然后在項目入口文件中引入 antd 樣式 import ‘~antd/dist/antd.css’。當然前提是你的 webpack 支持解析 css 文件。

如果優雅地使用該組件庫并結合 ts 寫 react 項目，可以參考https://github.com/ant-design/ant-design-pro

css 的發展也應該進行到了可以使用 js 語言寫 css，同樣可以實現 css 模塊化，比較好的方案是 styled-components。不過我暫時沒法接受這樣的寫法，，感覺開發效率也不高。

本篇博客想記錄的就是這些吧，寫得有點匆忙。不過通過寫博客，對自己學習的幫助真的很大！同時要強迫自己繼續堅持和養成寫博客的好習慣。

原文地址：https://zzfd.github.io/2021/02/02/reactCSS 模塊化和引入 AntDesign

參考資料：如有侵權，請告知，將第一時間刪除部分內容。

https://zhuanlan.zhihu.com/p/100133524

https://blog.csdn.net/wu_xianqiang/article/details/104560613

https://github.com/ant-design/ant-design-pro

https://github.com/sindresorhus/electron-boilerplate

述

官網：https://www.postgresql.org/docs/11/sql-createuser.html

Pg權限分為兩部分，一部分是“系統權限”或者數據庫用戶的屬性，可以授予role或user（兩者區別在于login權限）；一部分為數據庫對象上的操作權限。對超級用戶不做權限檢查，其它走acl。對于數據庫對象，開始只有所有者和超級用戶可以做任何操作，其它走acl。在pg里，對acl模型做了簡化，組和角色都是role，用戶和角色的區別是角色沒有login權限。

PostgreSQL是通過角色來管理數據庫訪問權限的，我們可以將一個角色看成是一個數據庫用戶，或者一組數據庫用戶。角色可以擁有數據庫對象，如表、索引，也可以把這些對象上的權限賦予其它角色，以控制哪些用戶對哪些對象擁有哪些權限。

一、用戶/角色管理

1、創建用戶/角色

1.1、語法

注意：創建好用戶（角色）之后需要連接的話，還需要修改2個權限控制的配置文件（pg_hba.conf、pg_ident.conf）。并且創建用戶（user）和創建角色（role）一樣，唯一的區別是用戶默認可以登錄，而創建的角色默認不能登錄。創建用戶和角色的各個參數選項是一樣的。

1.2、實例

2、修改用戶/角色屬性

2.1、語法

注意：option選項里的用戶都可以通過alter role進行修改

2.2、實例

3、查看用戶/角色

說明：視圖 pg_roles提供訪問數據庫角色有關信息的接口。它只是一個 pg_authid 表的公開可讀部分的視圖，把口令字段用空白填充了。

二、權限管理

數據庫對象在被創建時都會被賦予一個所有者，通常而言，所有者就是執行對象創建語句的角色。對于大多數類型的對象，其初始狀態是只有所有者(或超級用戶)可以對該對象做任何事情。如果要允許其它用戶可以使用該對象，必須賦予適當的權限。PostgreSQL中預定義了許多不同類型的內置權限，如：SELECT、INSERT、UPDATE、DELETE、RULE、REFERENCES、TRIGGER、CREATE、TEMPORARY、EXECUTE和USAGE。

1、權限說明

2、授權，定義訪問權限

3、撤銷權限

4、查看用戶權限

select * from information_schema.table_privileges;

覺得有用的朋友多幫忙轉發哦！后面會分享更多devops和DBA方面的內容，感興趣的朋友可以關注下~

在線咨詢

上一篇：前端播放直播視頻流(flv+m3u8)
下一篇：前端開發教程之CSS（四）

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。

整合營銷服務商