DIV CSS 佈局教程網

深入 Vue.js 組件化開發:從 ES6、響應式原理到 Vuex 的實戰全解析
編輯:關於JavaScript     

前言:不想再造輪子了

團隊做 H5 活動頁已經有一段時間,凡是結構相近的活動,幾乎每次都要從零再寫一遍相似的邏輯,重複勞動的比例高得驚人。後來接到一個「模板化活動設計系統」的需求,正好是一次把這些沉澱下來的機會,於是有了這篇文章記錄的整套思路與落地過程。

一、組件化:我們是怎麼走到今天的

需求確定之後,第一個要回答的問題是技術選型。考慮到 MVVM 框架與組件化開發方式已是前端主流,最終技術棧定為:Vue + ES6 + 組件化。

回頭看 Web 前端的組件化,大致經歷了三個階段。

1. 以目錄聚合職能

最早期的做法很樸素,把同一功能的文件收攏到一個目錄裡:

- lib/components/calendar
  |- calendar.css
  |- calendar.js
  |- calendar.html

結構清晰、職責明確,視圖、樣式、腳本的關係一目了然,也便於做單元測試——這是最小可用的獨立展示與交互單元。

2. 引入生命週期與數據綁定

隨後,組件被賦予了完整的生命週期:初始化、拉取資源、渲染、更新、銷毀。各階段被理順之後,從創建到銷毀的整體脈絡變得容易理解,而每個階段的鉤子也為擴展提供了切入點。再加上對外接口、數據綁定(或說數據倉庫)的引入,以及各類 xMD 模塊加載器的出現,這種開發方式的抽象層級又上移了一格。ExtJs、YUI 都是這一路線的代表。

3. MVVM 與構建工具時代

進步顯著,但問題依然存在:組件的可復用性(基礎樣式、基礎邏輯、可沉澱的穩定業務邏輯)、組件間通信、全局狀態管理,乃至代碼組織方式本身。Angular、React、Polymer、Vue 等 MVVM 框架,配合 webpack、browserify 這類構建與預編譯工具,正是為了解決這幾件事而出現的。

二、ES6:改善的重點不是語法糖

ES6 經過多年打磨,最終在 2015 年下半年定稿,正式名稱是 EcmaScript2015。每個剛接觸它的人大概都問過同一個問題:它究竟為了解決什麼?舊版 ES4/5 坑確實不少,Brendan Eich 對 JS 的評價頗為傳神——「優秀之處並非原創,原創之處並不優秀」。但我們也正是這樣去其糟粕、取其精華,一路填坑走過來的。

項目中常用到的特性包括:class、箭頭函數、對象與數組解構、默認參數、不定參數、對象合併、let/const、for...of、字符串模板、對象字面量增強與同名縮寫、模塊化 import/export、Map、Promise、generator 等。挑幾個重點說明。

class 與 extends

在沒有 class 的時代,標準做法是把非函數屬性寫在構造函數裡,函數屬性掛到原型鏈上;繼承則有對象冒充、call/apply、原型鏈等多種流派。ES6 用 class 與 extends 給出了一套統一規範:

class People {
  constructor (name, age, gender) { this.name = name }
  sayName () { return this.name }
}
class Student extends People {
  constructor (name, age, gender, skill) {
    super(name, age, gender)
    this.skill = skill
  }
  saySkill () { return this.skill }
}
let tom = new Student('tom', 16, 'male', 'computer')
tom.sayName()   // => 'tom'
tom.saySkill()  // => 'computer'
tom.__proto__ == Student.prototype  // => true
Student.__proto__ == People         // => true

語法雖新,底層規則未變:對象的 __proto__ 仍指向其構造函數的 prototype。對象字面量的 __proto__ 注入同樣可以快速實現繼承。

let 與塊級作用域

ES6 之前 JS 只有函數作用域。let 帶來了塊級作用域,if、else、for 這些結構終於也有了邊界,塊內用 let 聲明的變量在塊外訪問不到,預解析時也不會被提升到函數作用域頂部。由此,for 迭代的每一輪都會產生獨立的迭代變量:

var arr = [];
for (let i = 0; i < 10; i++) {
  arr[i] = function () { return i }
}
arr[6]()  // => 6

// 若改用 var,每次迭代的函數都通過閉包引用同一個 i,
// 該變量不會被回收,最終結果全部指向 10。
// 以往的繞行方案是 IIFE:
for (var i = 0; i < 10; i++) {
  arr[i] = (function (i) {
    return function () { return i }
  })(i)
}

箭頭函數

普通函數有個惱人的特點:函數內部的 this 並不由它在哪裡定義決定,而由誰調用決定。當我們不希望如此時,只能先保存 this、或用 call/apply、bind 來校正上下文。箭頭函數把這件事變簡單了——它的 this 由定義位置決定,無論被誰調用都不會改變。

var obj = {
  test1 : function () {
    window.setTimeout(function () { console.info(this) }, 100)
  },
  test2 : function () {
    window.setTimeout(() => { console.info(this) }, 100)
  }
}
obj.test1()  // => Window
obj.test2()  // => obj

普通函數與箭頭函數並非互相取代的關係,選哪個取決於具體邏輯,前提是先弄清差異。箭頭函數另一個實用特性是能簡化 return 的書寫:

var a = function (n) { return n }
var b = (n) => n   // 可省略 return 與花括號
var c = n => n     // 只有一個參數時括號也可省
a(1)  // => 1
b(1)  // => 1
c(1)  // => 1

幾個小例子不難看出,ES6 的價值主要在於對舊有不合理之處的修正,而非單純增加語法糖。

三、Vue.js:只聚焦視圖層

Vue.js(讀音 /vjuː/,近似 view)是一個構建數據驅動 Web 界面的庫,目標是用盡可能簡單的 API 實現響應式數據綁定與可組合的視圖組件。它並不做全能框架,只聚焦視圖層,因此學習成本低、易於與既有項目整合;而配合相關工具與支持庫,它同樣足以驅動複雜的單頁應用。(以下部分內容整理自 Vue 官方文檔。)

響應式數據綁定

<div id="app">
  <p>{{ message }}</p>
  <input v-model="message">
</div>

new Vue({
  el : '#app',
  data : { message : 'Hello Vue.js!' }
})

改變輸入框的值,段落文本會同步變化。

原理並不複雜:input 的值與實例的 message 屬性綁定,p 的文本也與 message 綁定;輸入變化改寫 message,message 變化再反映到 p 上。

用 jQuery 手工操作 DOM 時,代碼往往是命令式、重複且容易出錯的。Vue.js 擁抱數據驅動的視圖概念:在 HTML 模板中用特殊語法把 DOM 綁定到底層數據,綁定一旦建立,DOM 便與數據保持同步。於是應用邏輯幾乎只剩「修改數據」這一件事,不必與 DOM 更新糾纏在一起,代碼更易寫、易讀、易維護。

組件系統

組件系統是另一個核心概念,它提供了一種抽象,讓我們能用獨立可復用的小組件拼裝大型應用。以此視角看,幾乎任意應用的界面都能抽象成一棵組件樹:

Vue 組件很像自定義元素(Web Components 規範的一部分),其語法也確實參考了該規範,例如實現了 Slot API 與 is 特性。但關鍵差異有幾點:

  • Web Components 規範當年仍遠未完成,且沒有瀏覽器實現;Vue 組件無需任何 polyfill,在 IE9 及以上版本中表現一致。
  • Vue 組件提供了原生自定義元素不具備的能力:組件間數據流、自定義事件系統,以及帶過渡效果的動態組件替換。

四、響應式原理:依賴收集 vs 髒檢查

Vue 的數據觀測與 Angular 有本質區別。Angular 採用髒檢查(dirty checking):每個指令有一個 watcher,作用域中 watcher 眾多;界面需要更新時,框架遍歷當前作用域的所有 watcher 逐一求值,與舊值比較,變化則觸發更新,這一輪過程稱作 digest cycle。

髒檢查有兩個繞不開的問題:

1. 任何數據變動都意味著當前作用域的每個 watcher 都要重新求值,watcher 數量龐大時性能必然下滑,且很難優化。

2. 框架無法主動偵測變化發生,需要手動觸發 digest cycle 才能更新 DOM。Angular 靠在 DOM 事件處理函數中自動觸發部分規避了這一點,但仍有大量場景需要開發者手動介入。

Vue 走的是基於依賴收集的觀測路線,原理上與老牌 MVVM 框架 Knockout 同源:

1. 把原生數據改造為「可觀察對象」,可取值也可賦值。

2. watcher 求值過程中,每個被取值的可觀察對象都會把當前 watcher 註冊為自己的訂閱者,並成為該 watcher 的依賴。

3. 當被依賴的可觀察對象被賦值時,它通知所有訂閱者重新求值並觸發更新。

4. 這樣做的好處是可以精確、主動地追蹤變化,前述兩個問題都不存在。但傳統實現(如 Knockout)通常需要包裹原生數據來製造可觀察對象,取值賦值都得寫成函數調用,寫法繁瑣不直觀,對複雜嵌套結構的支持也不理想。

Vue 的做法是利用 ES5 的 Object.defineProperty,直接把原生對象的屬性改造成 getter/setter,在這兩個函數內部完成依賴收集與觸發,並完美支持嵌套結構;數組則通過包裹 push 等可變方法來監聽變化。這樣一來,操作 Vue 數據與操作原生對象幾乎沒有差別。(受 ES5 特性限制,這也是 Vue 不支持 IE8 及以下的緣故。)

變化檢測的邊界

受 ES5 限制,Vue 無法檢測對象屬性的新增與刪除。屬性必須在 data 對象上預先聲明,才會被轉為 getter/setter:

var data = { a : 1 }
var vm = new Vue({ data : data })

// vm.a 和 data.a 現在是響應的
vm.b = 2      // vm.b 不是響應的
data.b = 2    // data.b 不是響應的

實例創建之後想加響應式屬性,Vue 實例可用 $set:

vm.$set('b', 2)  // vm.b 和 data.b 現在是響應的

普通對象則用全局方法:

Vue.set(data, 'c', 3)  // vm.c 和 data.c 現在是響應的

若用 Object.assign() 或 _.extend() 往已有對象上加屬性,新屬性不會觸發更新。此時更安全的做法是生成新對象再整體賦值:

// 不要這樣做:
// Object.assign(this.someObject, { a : 1, b : 2 })
this.someObject = Object.assign({}, this.someObject, { a : 1, b : 2 })

計算屬性為什麼要緩存

Vue 的計算屬性不是簡單的 getter,它會持續追蹤自己的響應依賴。求值時 Vue 更新依賴列表並緩存結果,只有某個依賴變化了緩存才失效。因此只要依賴不變,訪問計算屬性會直接返回緩存值,而不會重新調用 getter。

緩存的意義在於避免重複計算。假設有一個高耗的計算屬性 A,需要遍歷巨型數組做大量運算,而其他計算屬性又依賴 A;若沒有緩存,A 的 getter 會被調用遠超必要的次數。

var vm = new Vue({
  data : { msg : 'hi' },
  computed : {
    example : function () { return Date.now() + this.msg }
  }
})

此處 example 只有一個響應依賴 vm.msg;Date.now() 與 Vue 的觀測系統無關,因此不算依賴。訪問 vm.example 時時間戳不變,除非 vm.msg 改變。

如果確實希望每次訪問都重新求值,可以關閉緩存:

computed : {
  example : {
    cache : false,
    get : function () { return Date.now() + this.msg }
  }
}

此時在 JS 中訪問 vm.example 每次都拿到新時間戳,但模板中的 {{example}} 仍是依賴驅動的,只有響應依賴變化才會更新 DOM。

五、組件系統要點

組件可以擴展 HTML 元素、封裝可重用代碼。高層面上它就是自定義元素,由 Vue 編譯器賦予特殊能力;必要時也能以 is 特性的形式擴展原生元素。

創建與註冊

var MyComponent = Vue.extend({
  template : '<div>A custom component!</div>'
})

// 全局註冊
Vue.component('my-component', MyComponent)

註冊後即可在父實例模板中以 <my-component> 使用,注意要在根實例初始化之前完成註冊:

<div id="example">
  <my-component></my-component>
</div>

// 渲染結果
<div id="example">
  <div>A custom component!</div>
</div>

也可以只在特定組件內可用,通過 components 選項做局部註冊:

var Child = Vue.extend({ /* ... */ })
var Parent = Vue.extend({
  template : '...',
  components : {
    // <my-component> 只能用在父組件模板內
    'my-component': Child
  }
})

局部註冊同樣適用於指令、過濾器、過渡等資源。

組件可被多個實例共享構造器,這裡有兩個特例需要注意——data 與 el:

var data = { a : 1 }
var MyComponent = Vue.extend({ data : data })  // 危險

這樣寫會導致所有實例共享同一個 data 對象(對象是引用傳遞),顯然不是我們想要的。正確做法是傳入函數:

var MyComponent = Vue.extend({
  data : function () { return { a : 1 } }
})

el 用在 Vue.extend() 中時同理,也必須是函數。

用 props 傳遞數據

組件實例的作用域是孤立的,這意味著不能也不應該在子組件模板裡直接引用父組件數據。父組件通過 props 向子組件傳值,子組件需顯式聲明:

Vue.component('child', {
  // JavaScript 中寫 camelCase
  props : ['myMessage'],
  template : '<span>{{ myMessage }}</span>'
})
<child my-message="hello!"></child>

由於 HTML 特性不區分大小寫,camelCase 形式的 prop 用作特性時需轉為 kebab-case(短橫線分隔)。

props 也可以是動態的,用 v-bind 綁定到父組件數據表達式即可:

<div>
  <input v-model="parentMsg">
  <br/>
  <child v-bind:my-message="parentMsg"></child>
</div>

// 縮寫形式
<child :my-message="parentMsg"></child>

父子組件通信

子組件可用 this.$parent 訪問父組件,根實例的後代可用 this.$root,父組件則有 this.$children 數組。

雖然能訪問父鏈上任意實例,但子組件應避免直接依賴父組件數據,盡量顯式使用 props;在子組件中修改父組件狀態更是應避免的做法,因為:這會讓父子組件緊密耦合;並且只看父組件已無法理解其狀態——它可能被任意子組件改寫。理想狀態下,只有組件自己能修改自身狀態。

為此,每個 Vue 實例都實現了一套自定義事件接口:

  • $on() 監聽事件;
  • $emit() 觸發事件;
  • $dispatch() 派發事件,沿父鏈冒泡;
  • $broadcast() 廣播事件,向下傳導給所有後代。

與 DOM 事件不同,Vue 事件在冒泡中第一次觸發回調後就自動停止,除非回調顯式返回 true。

<!-- 子組件模板 -->
<template id="child-template">
  <input v-model="msg">
  <button v-on:click="notify">Dispatch Event</button>
</template>

<!-- 父組件模板 -->
<div id="events-example">
  <p>Messages: {{ messages | json }}</p>
  <child></child>
</div>

動態組件

多個組件可以共用同一掛載點並動態切換,做法是使用保留的 <component> 元素綁定 is 特性:

new Vue({
  el : 'body',
  data : { currentView : 'home' },
  components : {
    home : { /* ... */ },
    posts : { /* ... */ },
    archive : { /* ... */ }
  }
})
<component :is="currentView">
  <!-- 組件在 vm.currentView 變化時改變 -->
</component>

加上 keep-alive 可把切換出去的組件保留在內存中,從而保留狀態或避免重新渲染:

<component :is="currentView" keep-alive>
  <!-- 非活動組件將被緩存 -->
</component>

應用變複雜之後,動態組件會顯得笨拙,這時應改用路由。vue-router 可以理解為動態組件的升級版。

生命週期鉤子

Vue 實例創建時會經歷一系列初始化步驟——建立數據觀測、編譯模板、創建必要的數據綁定,過程中會調用若干生命週期鉤子。例如 created 在實例創建後調用:

var vm = new Vue({
  data : { a : 1 },
  created : function () {
    // this 指向 vm 實例
    console.log('a is: ' + this.a)
  }
})
// => "a is: 1"

此外還有 compiled、ready、destroyed 等鉤子,this 均指向調用它的 Vue 實例。至於「Vue 有沒有控制器概念」——沒有。組件的自定義邏輯就拆分在這些鉤子裡。

六、Vuex:把狀態收攏到一處

大型應用中,狀態常常散落在眾多組件的不同作用域裡。當我們用 vue-router 和 .vue 組件化方式構建大型 SPA 時,組件間的狀態傳遞會變得棘手。props、dispatch、broadcast 固然能跨組件傳值,但大量使用會讓耦合急劇上升——組件越多、層級越深,維護成本越高。能否有一個全局的狀態管理架構?

先說 Flux

Flux 是 Facebook 用來構建客戶端 Web 應用的應用程序體系架構,通過數據單向流動為 React 的可復用視圖組件提供補充。相對於形式化框架,它更像一種架構思想,不需要太多新代碼就能上手。

Flux 應用主要包括三部分:dispatcher、store 和 views(React components),注意不要與 MVC 混淆。Controller 在 Flux 中確實存在,但以 controller-view 的形式出現:view 處於應用頂層,從 store 取數據並傳給後代節點。另外還有 action creators——dispatcher 的輔助方法,提供描述應用所有可能變更的語義化 API,把它看作 Flux 更新閉環的第四部分有助於理解。

一句話概括:Flux 是把視圖底層的事件手動綁定到數據頂層的單向數據流架構。設計目的是不允許 UI 直接寫數據,避免同一份數據被多處同時修改。相比雙向綁定,編碼略繁瑣一些,但換來的是排錯與維護上的巨大便利。

Vuex 是什麼

Vuex 是專為 Vue.js 應用設計的集中式狀態管理架構,借鑒了 Flux 與 Redux 的思想,但簡化了概念,並針對 Vue 的響應機制做了實現上的優化。(Redux 也可以通過簡單綁定與 Vue 配合使用。)

應用很簡單時多半用不上 Vuex,也不建議過早引入。但在構建中大型 SPA 時,如何安置 Vue 之外的應用組成部分就成了必須思考的問題。

單獨使用 Vue 時,我們通常把狀態存在組件內部,整個應用的狀態分散在各個角落。而狀態往往需要跨多個組件共享,常見策略是用定製事件系統讓一個組件把狀態「發送」給其他組件——問題是大型組件樹中的事件流很快變得繁雜,出錯時難以定位。

更好的做法是區分組件本地狀態(component local state)與應用層級狀態(application level state)。後者不屬於任何特定組件,但每個組件都能監視其變化並響應式更新 DOM。把狀態管理匯總到一處,就不必到處傳遞事件;凡是牽扯一個以上組件的邏輯都寫在這裡,同時也更容易記錄與觀察狀態變更(mutation),甚至實現時間旅行式的調試效果。

最簡單的 store

import Vuex from 'vuex'

const state = { count : 0 }
const mutations = {
  INCREMENT (state) { state.count++ }
}

export default new Vuex.Store({ state, mutations })

此後可以通過 store.state 讀取狀態,通過 dispatch 某個 mutation 名稱觸發變更:

store.dispatch('INCREMENT')
console.log(store.state.count)  // -> 1

// 對象風格的分發方式,效果相同
store.dispatch({ type : 'INCREMENT' })

之所以不直接改 store.state,而是繞道 dispatch mutation,是為了讓狀態變化更明確可追蹤。這個簡單約定讓代碼意圖更清晰,也為記錄每次變更、保存狀態快照的調試工具留出了空間。

Vuex 使用單一狀態樹——一個對象包含全部應用層級狀態,作為唯一數據源(SSOT)存在,因此每個應用只有一個 store 實例。這讓定位任一狀態片段、以及取得整個應用狀態快照都變得容易。

State 與 Getters

先安裝 Vuex 並在根組件引入 store 實例:

import Vue from 'vue'
import Vuex from 'vuex'
import store from './store'
import MyComponent from './MyComponent'

// 關鍵:告訴 Vue 如何處理與 Vuex 相關的選項
Vue.use(Vuex)

var app = new Vue({
  el : '#app',
  store,  // 把 store 提供給「store」選項,會注入所有子組件
  components : { MyComponent }
})

子組件可以通過 this.$store 訪問,不過實踐中幾乎不需要直接引用它。更常用的是在組件的 vuex.getters 中聲明要讀取的狀態:

// MyComponent.js
export default {
  template : '...',
  data () { /* ... */ },
  vuex : {
    getters : {
      // 把 store.state.count 綁定為組件的 this.count
      count : (state) => state.count
    }
  }
}

getter 函數只接收整個狀態樹作為唯一參數,可以返回其中一部分,也可以返回計算值;返回結果會以該 getter 的屬性名掛到組件上,用法與組件自身的計算屬性完全一致。

切記:組件永遠不應直接修改 Vuex store 的狀態。所有變更都必須在 mutation handler 中進行,開啟嚴格模式時,若在 mutation 句柄外修改狀態,Vuex 會直接報錯。有了這條規則,組件的職能大為簡化:通過只讀 getter 綁定狀態,唯一能影響全局狀態的方式就是觸發 mutation。組件仍可處理本地狀態,但不再承擔數據請求或全局狀態變更的邏輯——這些全部集中在 Vuex 相關文件中,大型應用因此更易理解與維護。

Mutation

Mutation 本質上是個事件系統:每個 mutation 有一個事件名和一個回調函數,回調的第一個參數永遠是所屬 store 的 state 對象。

import Vuex from 'vuex'

const store = new Vuex.Store({
  state : { count : 1 },
  mutations : {
    INCREMENT (state) {
      // 改變 state
      state.count++
    }
  }
})

慣例是用全大寫命名 mutation,以便與 actions 區分。你不能直接調用 mutation handler,傳入 Store 構造器的選項更像是在註冊事件回調;觸發方式是 dispatch 對應的事件名:

store.dispatch('INCREMENT')

兩條硬性要求:

其一,mutation 必須是同步函數。當 mutation 觸發時回調尚未執行,我們不知道它實際何時被調用,回調中的任何狀態改寫都是不可追蹤的。

其二,必須遵守 Vue 的響應系統規則:盡可能在創建 store 時就初始化 state 所需的全部屬性;添加原本不存在的屬性時,使用 Vue.set(obj, 'newProp', 123),或拷貝並替換原對象,例如 state.obj = { ...state.obj, newProp : 123 }。

Actions

Actions 是負責分發 mutations 的函數,第一個參數是 store 實例,其後可接自定義參數:

// 最簡單的 action
function increment (store) {
  store.dispatch('INCREMENT')
}

// 帶附加參數的 action,使用 ES2015 參數解構
function incrementBy ({ dispatch }, amount) {
  dispatch('INCREMENT', amount)
}

乍看像是多此一舉,但別忘了 mutation 必須同步這個限制——actions 不受此約束。我們可以在 action 內部執行異步操作,例如發起 ajax 請求:

function getData ({ dispatch }) {
  ajax({
    url : "...",
    data : { ... },
    success : (data) => { dispatch("SET_DATA", data) }
  })
}

組件中可以這樣調用 actions:

// 某組件內部
import { incrementBy } from './actions'

const vm = new Vue({
  vuex : {
    getters : { ... },
    actions : { incrementBy }
  }
})

這段代碼把原生 action 綁定到組件的 store 實例上,暴露出 vm.incrementBy 方法。傳給它的參數會排在 store 變量之後一起傳給原生 action,因此 vm.incrementBy(1) 等價於 incrementBy(vm.$store, 1)。多寫的這點代碼換來的是模板中更省力的調用:

<button v-on:click="incrementBy(1)">increment by one</button>

大型应用中,action 通常需要按目的分組、模塊化管理。

完整數據流示例

用一個計數器 app 來理解 Vuex 中的數據流(僅為說明概念,這種簡單場景並不需要 Vuex):

// store.js
import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)

// 應用初始狀態
const state = { count : 0 }

// 定義所需的 mutations
const mutations = {
  INCREMENT (state) { state.count++ },
  DECREMENT (state) { state.count-- }
}

export default new Vuex.Store({ state, mutations })
// actions.js
export const increment = ({ dispatch }) => dispatch('INCREMENT')
export const decrement = ({ dispatch }) => dispatch('DECREMENT')
<!-- template -->
<div>
  Clicked: {{ count }} times
  <button v-on:click="increment">+</button>
  <button v-on:click="decrement">-</button>
</div>
// 僅需在根組件注入 store 實例一次
import store from './store'
import { increment, decrement } from './actions'

const app = new Vue({
  el : '#app',
  store,
  vuex : {
    getters: { count: state => state.count },
    actions: { increment, decrement }
  }
})

組件本身非常簡單:綁定到 state,在用戶輸入時調用 actions。整個應用的數據流是單向的:

1. 用戶在組件中的輸入觸發 action 調用。

2. Actions 通過分發 mutations 修改 store 的狀態。

3. Store 的狀態變化通過 getters 被組件獲知。

最後要強調的是,Vuex 並不要求所有狀態都放進 store。如果某些狀態不需要追蹤變化,完全可以留在 Vuex 之外(作為組件本地狀態);比如公共組件對外的接口,用 props 傳遞數據更為有效。

七、vue-devtools

vue-devtools 是一個 Chrome 開發插件,可在 Chrome 商店下載 crx 擴展包安裝,提供 Components 與 Vuex 預覽(含 state 變化跟蹤)能力,對開發調試幫助很大。

組件的 prop、計算屬性、getter,以及 Vuex 中觸發過的 mutation、state 當前值,都被直觀地呈現出來。

八、模塊化

大型項目中,使用模塊構建系統來管理代碼非常必要。推薦代碼採用 CommonJS 或 ES6 模塊,再用 Webpack 或 Browserify 打包。

兩者都不只是打包器,還提供源碼轉換 API,可接入各類預處理器;例如借助 babel-loader 或 babelify,就能使用 ES2015/2016 語法。單文件 Vue 組件可以用 Webpack + vue-loader 或 Browserify + vueify 構建。

選哪種工具取決於經驗與需求:Webpack 功能更強大,支持代碼分割、把靜態資源當模塊、將組件 CSS 提取到單獨文件等,代價是配置相對複雜;不需要這些能力時,Browserify 更簡單。最快的起步方式是使用官方腳手架工具 vue-cli。

九、活動模板設計系統的落地

這個系統只負責設計活動模板「要展示什麼內容」,具體樣式與交互由各活動 H5 頁面根據視覺與交互稿決定。活動中的每一個子項都抽象為一個組件,H5 展示端拿到每個組件的內容後套上對應的樣式與交互邏輯,最終拼成一個完整的活動頁。

每個活動組件對應三種形態:

1. 標簽組件——通過拖動創建對應類型的組件;

2. 預覽組件——展示當前組件各項的內容;

3. 編輯組件——編輯當前選中組件的各項內容。

以最簡單的節標題組件為例:

左側容器排列著常用組件的標簽。把需要的標簽拖入預覽區後,會生成對應的預覽組件與編輯組件;點擊某個預覽組件,編輯區顯示它對應的編輯組件;在編輯組件中修改各項內容,由於事先建立了數據綁定,預覽區的組件會即時更新視圖。

從標簽區開始

標簽組件是每個活動組件的入口,因此必須有一個屬性標識它代表哪個活動組件。先給它們指定類型 type:

  • 節標題 type:'sectionTitle'
  • 投票 type:'vote'
  • 正文 type:'content'
  • 用戶 type:'user'
  • 圖片 type:'image'
  • 視頻 type:'video'
  • 音頻 type:'audio'
  • 跳轉鏈接 type:'link'

每當一個標簽被拖入預覽區,就根據它的 type 生成對應的預覽與編輯組件。而預覽與編輯組件需要確定的,無非是「有哪些編輯項」以及「這些編輯項是什麼內容」。以節標題為例,它只有一個編輯項:節標題文本。也就是說預覽組件負責顯示文本,編輯組件提供一個文本域,模板中事先綁定好數據,文本域的變化便會反映到預覽組件的 DOM 上。

我們需要一個保存所有組件數據的容器,這裡用數組:

// widgetData.js
[
  { id : "100", type : "vote", ... },   // 投票
  { id : "101", type : "image", ... },  // 圖片
  { id : "102", type : "video", ... }   // 視頻
]

之所以更青睞數組而非對象:Vue 對數組的基礎方法(push、splice、shift 等)都做了封裝,通過它們改動數據結果都是響應式的;而在保持響應的前提下修改對象數據要麻煩得多,特別是複雜嵌套結構。用對象的好處是可以通過 id 直接命中數據,用數組則需要遍歷——不過有了 for...of,代碼依然簡潔,且這裡操作的不是 DOM,性能影響可忽略。

每個組件數據對象的 id 唯一,在拖入標簽時生成,是關聯預覽組件與編輯組件的關鍵。之所以不用 type 判斷,是因為同一活動中可能存在多個同類組件(比如多個節標題),type 無法確定對應關係。

這裡用 Vuex 創建 store 來存儲與修改這個數組。按照單向數據流規則,UI 不允許直接修改數據:編輯項輸入框的值變化,並不直接改寫組件數據,而是通過 DOM 事件觸發 action,action 再派發 mutation 來修改 state。如此一來,所有對組件數據的修改都經過同一個公共 action——它就是進行某項修改的唯一入口。

知道了要生成什麼組件並放入容器之後,還需要知道該組件究竟有哪些編輯項。這時引入一個 map 來管理 type 與編輯項的關係。以投票組件為例,按需求它需要:投票標題;投票項列表,每項含名稱,後續可能擴展其他屬性。

// typeDataMap.js
export default {
  vote : {
    type : "vote",
    title : "投票標題文本",
    items : [
      { name : "投票項1" },  // 每個投票項
      { name : "投票項2" },
      { name : "投票項3" }
    ]
  }
}

只要知道類型,通過 typeData[type] 就能取到初始數據存入容器。由於預覽與編輯組件的模板已事先完成數據綁定,改變容器中某項數據時更新會自動反映到 DOM。保存整個模板時,只需取出組件數據容器——也就是那個數組。H5 展示端拿到這個數組,即可獲知組件數據與排序,按約定模板渲染。像投票這類帶交互數據的組件,模板只確定要展示的固定內容;投票總數、每項票數等屬性由後端處理後插入對應組件數據,供展示端呈現。

標簽組件實現

由於標簽組件的表現與交互邏輯一致,這裡做了一個公共可復用的標簽組件,對外接收 title(標簽文本)與 type(標簽類型)兩個參數。標簽容器組件中建立一個包含所有標簽數據的數組,模板中遍歷它即可渲染出全部標簽。

// labelWrapper.vue 標簽組件容器(組件標簽區域)
<template>
  <div class="label-wrapper">
    <div class="label-title">組件標簽區域</div>
    <div class="label-box">
      <common-label
        v-for="label in labelArr"
        :title="label.title"
        :type="label.type">
      </common-label>
    </div>
  </div>
</template>

<script>
import commonLabel from './widget/commonLabel.vue'

export default {
  name : "label_wrapper",
  components : {
    commonLabel  // 註冊為子組件(ES6 同名屬性縮寫)
  },
  data () {
    return {
      labelArr : [
        { title : "節標題", type : "sectionTitle" },
        { title : "投票", type : "vote" },
        { title : "正文", type : "content" },
        { title : "用戶", type : "user" },
        { title : "圖片", type : "image" },
        { title : "視頻", type : "video" },
        { title : "音頻", type : "audio" },
        { title : "跳轉鏈接", type : "link" }
      ]
    }
  }
}
</script>

<style lang="stylus">/*...*/</style>
// commonLabel.vue 公共標簽組件
<template>
  <div class="label-item-wrapper"
       title="拖入模板設計區域"
       draggable="true"
       @dragstart="dragStart">
    <img class="label-icon" alt="{{title}}" :src="iconUrl">
    <span class="label-text">{{title}}</span>
  </div>
</template>

<script>
import labelMixin from './mixin/labelMixin'

export default {
  name : "label",
  props : {
    title : String,
    type : String
  },
  mixins : [labelMixin],
  computed : {
    iconUrl () { return this.type + '.png' }
  }
}
</script>

<style lang="stylus">/*...*/</style>

公共的屬性與方法抽到一個對象字面量中,導入後以 mixin 混入。目前只有一個公共標簽組件,mixin 的收益不明顯;但如果每種類型的標簽都是獨立的 .vue 文件,mixin 的可復用與易維護價值就體現出來了。

// labelMixin.js
import typeDataMap from './typeDataMap'

export default {
  methods : {
    dragStart (e) {
      var id = parseInt(Date.now() + "" + parseInt(Math.random() * 90))
      var widgetData = typeDataMap[this.type]
      var dt = e.dataTransfer
      widgetData['id'] = id
      dt.setData("id", id)
      dt.setData("type", this.type)
      dt.setData("widgetData", JSON.stringify(widgetData))
    }
  }
}

預覽組件實現

預覽組件相對簡單,除了數據綁定就是拖動排序。排序基於 HTML5 原生 drag 事件,而得益於 Vue 的數據驅動,拖動時無需手工調整 DOM 順序,只要改動組件數據數組中各對象的 index,視圖自然更新。

<template>
  <div class="preview-item-wrapper"
       draggable="true"
       :class="{'active': isActive}"
       @click="showEdit"
       @dragover="allowDrop"
       @dragstart="dragStart"
       @drop="dropIn">
    <span class="preview-item-del"
          :class="{'active': isActive}"
          title="刪除該組件">
      <div v-on:click="delMe">x</div>
    </span>
    <label class="preview-item-label">- 節標題 -</label>
    <div class="preview-item-input-wrapper">
      <div class="title-text">{{text}}</div>
    </div>
  </div>
</template>

<script>
import {
  addPreviewAndData, deleteWidgetPreview, changeWidgetEdit,
  changPreviewAndDataIndex
} from '../../../store/actions'
import previewMixin from './mixin/previewMixin'

export default {
  name : "sectionTitle_preview",
  mixins : [previewMixin],
  props : {
    id : Number,
    index : Number
  },
  computed : {
    // mixin 之外的私有屬性
    text () {
      for (let value of this.widgetDataArr)
        if (value.id == this.id) return value.text
    }
  },
  vuex : {
    getters : {
      widgetDataArr : (state) => state.widgetDataArr,
      currentEditWidgetId : (state) => state.currentEditWidgetId
    },
    actions : {
      addPreviewAndData, deleteWidgetPreview, changeWidgetEdit,
      changPreviewAndDataIndex
    }
  }
}
</script>

<style lang="stylus">/*...*/</style>
/**
 * previewMixin.js
 * 預覽組件的 mixin,提取同類組件間可復用的計算屬性與方法
 */
export default {
  computed : {
    // 該預覽組件是否為當前點擊的
    isActive () {
      return this.id == this.currentEditWidgetId
    }
  },
  methods : {
    // 刪除該預覽組件
    delMe () { this.deleteWidgetPreview(this.id) },
    // 顯示該預覽組件對應的編輯組件
    showEdit () { this.changeWidgetEdit(this.id) },
    // 允許向該預覽組件拖放其他組件
    allowDrop (e) { e.preventDefault() },
    // 開始拖放該預覽組件
    dragStart (e) {
      var dt = e.dataTransfer
      dt.setData("index", this.index)
    },
    // 向該預覽組件拖放其他組件(預覽組件或標簽組件)
    dropIn (e) {
      e.preventDefault()
      e.stopPropagation()
      var dt = e.dataTransfer
      var id = parseInt(dt.getData("id"))
      if (id) {
        // 有 id 表明拖入的是標簽組件
        var type = dt.getData("type")
        var widgetData = JSON.parse(dt.getData("widgetData"))
        this.changeWidgetEdit(id)
        this.addValidation(id)  // 添加組件驗證項
      } else {
        var index = parseInt(dt.getData("index"))
        this.changPreviewAndDataIndex(index, this.index)
      }
      dt.clearData()
    }
  }
}

編輯組件實現

仍以節標題組件為例:

<template>
  <div class="edit-item-wrapper">
    <label class="edit-item-label">節標題文本</label>
    <validator name="titleValidator">
      <div class="edit-item-input-wrapper">
        <textarea class="title-edit-input"
          placeholder="必填項,16字以內"
          v-model="text"
          v-validate:text="{
            required: { rule: true, message: '請填寫節標題文本' },
            maxlength: { rule: 16, message: '節標題文本限制在16字以內' }
          }"
          @input="inputValue"
          @valid="onValid"
          @invalid="onInvalid">
        </textarea>
        <div class="edit-input-err" v-if="$titleValidator.text.required">
          {{$titleValidator.text.required}}
        </div>
        <div class="edit-input-err" v-if="$titleValidator.text.maxlength">
          {{$titleValidator.text.maxlength}}
        </div>
      </div>
    </validator>
  </div>
</template>

<script>
import { changeWidgetData, changeValidation } from '../../../store/actions'
import editMixin from './mixin/editMixin'

export default {
  name : "title_edit",
  mixins : [editMixin],
  props : { id : Number },
  computed : {
    // mixin 之外的私有屬性
    text () {
      for (let value of this.widgetDataArr)
        if (value.id == this.id) return value.text
    }
  },
  methods : {
    // mixin 之外的私有方法
    inputValue (e) {
      this.changeWidgetData(this.id, 'text', e.target.value)
    }
  },
  vuex : {
    getters : {
      widgetDataArr : (state) => state.widgetDataArr
    },
    actions : { changeWidgetData, changeValidation }
  }
}
</script>

<style lang="stylus">/*...*/</style>
/**
 * editMixin.js
 * 編輯組件的 mixin
 */
export default {
  data () {
    return {
      // isValid : false
    }
  },
  methods : {
    onValid () {
      // 驗證通過
      this.isValid = true
      this.changeValidation(this.id, true)
    },
    onInvalid () {
      // 驗證失敗
      this.isValid = false
      this.changeValidation(this.id, false)
    }
  }
}

其餘公共組件與 store 的實現思路與上文一致,此處不再展開。最終成品大致如下:

整套方案的關鍵,是把「內容數據」與「展示樣式」徹底剝離:設計系統只產出一份組件數據數組,展示端再按約定渲染。這樣既擺脫了重複造輪子,也讓後續活動的接入成本降到最低。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved