# 状态管理vuex
# Vuex基本概念
Vuex 是一个专为 Vue.js 应用程序开发的状态管理插件。它采用集中式存储管理应用的所有组件的状态，并支持通过命名空间组织和管理状态树。一般状态要配合存储实现持久化。
每一个 Vuex 应用的核心就是 store（仓库）。store包含应用中大部分的状态 (state)。Vuex 和单纯的全局对象有以下两点不同：
1. Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候，若 store 中的状态发生变化，那么相应的组件也会相应地得到高效更新。
2. store 中的状态是只读的，改变 store 中的状态的唯一途径就是显式地提交修改器mutation。
uni-app中集成了Vuex，整个应用只允许定义一个store，uni-app建议使用注入的方式使用vuex，然后我们需要做的是定义store的逻辑，然后在main.js文件中引用这个store就可以了。一个标准的store的定义如下，包含状态（state）、修改器（mutations）、动作（actions）和读取器（getters）四个部分。
如果一个项目比较复杂，可以通过模块来进行管理。
```
import Vue from 'vue'
import Vuex from 'vuex'
import createLogger from 'vuex/dist/logger'
Vue.use(Vuex)
const debug = true;
Vue.use(Vuex)
export default new Vuex.Store({
modules: {
},
state,
actions,
getters,
mutations,
strict: debug, //设置运行模式
plugin: debug ? [createLogger()] : [] //调试模式加入日志插件
})
```
详细官方文档可以参考：[https://vuex.vuejs.org/zh/
](https://vuex.vuejs.org/zh/)
完整的定义可能还包含日志输出
# 简单的计数器
首先看下最简单的版本，这个store只包含一个状态count，由于Vuex只能通过mutuations修改状态，因此定义increament和decrement两个修改器改变count的值。
## store的定义
在单独的文件中定义store，然后在main.js中导入定义好的store。
store/index.js
```
import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)
const store = new Vuex.Store({
state: {
count:0
},
mutations: {
increment(state) {
state.count++
},
decrement(state) {
state.count--
}
}
})
export default store
```
将定义的store文件通过import语句导入
```
import store from './store'
```
上述语句实际是导入默认的文件index.js
```
import store from './store/index'
```
然后修改Vue的原型prototype，使得store全局可用
```
Vue.prototype.$store = store
```
最后生成Vue的实例的时候将定义的store传给构造函数
```
const app = new Vue({
store,
...App
})
```
完整的main.js文件：
```
import Vue from 'vue'
import App from './App'
import store from './store/index.js'
Vue.config.productionTip = false
Vue.prototype.$store = store
App.mpType = 'app'
const app = new Vue({
store,
...App
})
app.$mount()
```
由于store挂在app实例的原型上，因此全局可用。在页面文件中可以通过this.$store访问store。例如访问state中的count状态变量
```
this.$store.state.count
```
## 页面中使用store
下面看看页面文件如何使用vuex。在页面文件中为方便访问，通过计算属性简单的封装状态变量的访问（后面会介绍通过mapState简单的实现映射）。
现在，你可以通过 this.$store.state 来获取状态对象，
```
computed: {
counter() {
return this.$store.state.count;
}
},
```
通过 this.$store.commit 方法触发状态变更：
```
methods: {
increment(){
this.$store.commit('increment')
},
decrement(){
this.$store.commit('decrement')
}
}
```
完整的示例代码：
pages/index/about.vue
```
<template>
<view class="content">
<text class="title">{{ counter }}</text>
<view class="">
<button @tap="doIncrement">+</button>
<button @tap="doDecrement">-</button>
</view>
</view>
</template>
<script>
export default {
computed: {
counter () {
return this.$store.state.count;
}
},
methods: {
doIncrement() {
this.$store.commit('increment');
},
doDecrement() {
this.$store.commit('decrement');
}
},
}
</script>
<style>
.content {
flex: 1;
justify-content: center;
align-items: center;
}
.title {
font-size: 36upx;
color: #8f8f94;
}
</style>
```
运行效果：
> 再次强调，我们通过提交 mutation 的方式，而非直接改变 store.state.count，是因为我们想要更明确地追踪到状态的变化。这个简单的约定能够让你的意图更加明显，这样你在阅读代码的时候能更容易地解读应用内部的状态改变。
由于 store 中的状态是响应式的，在组件中调用 store 中的状态简单到仅需要在计算属性中返回即可。触发变化也仅仅是在组件的 methods 中提交 mutation。
# State
Vuex 使用单一状态树，用一个对象就包含了全部的应用层级状态，作为一个“唯一数据源”而存在。这也意味着，每个应用将仅仅包含一个 store 实例。单一状态树让我们能够直接地定位任一特定的状态片段，在调试的过程中也能轻易地取得整个当前应用状态的快照。
那么我们如何在 Vue 组件中展示状态呢？由于 Vuex 的状态存储是响应式的，从 store 实例中读取状态最简单的方法就是在计算属性中返回某个状态：
```
<script>
export default {
computed: {
counter {
return this.$store.state.count;
}
},
methods: {
increment(){
return this.$store.commit('increment')
},
decrement(){
return this.$store.commit('decrement')
}
}
}
</script>
```
每当 store.state.count 变化的时候, 都会重新求取计算属性，并且触发更新相关联的文档对象模型 (Document Object Model : DOM)。然而，这种模式导致组件依赖全局状态单例。uni-app将状态从根组件“注入”到每一个子组件中（需调用 `Vue.use(Vuex)`），通过在根实例中注册 store 选项，该 store 实例会注入到根组件下的所有子组件中，且子组件能通过`this.$store` 访问到。
当一个组件需要获取多个状态时候，将这些状态都声明为计算属性会有些重复和冗余。为了解决这个问题，我们可以使用 mapState 辅助函数帮助我们生成计算属性，mapState 函数返回的是一个对象。使用对象展开运算符`…`，我们可以极大地简化写法：
```
<script>
import {
mapState,
mapMutations,
mapActions
} from 'vuex'
export default {
computed: {
...mapState(['count']),
},
}
</script>
```
如果你不想使用store中定义的名字，或者说命名有冲突，可以取个别名：
```
computed: {
// ...mapState(['count']),
...mapState({
counter: state => state.count,
}),
},
```
使用 Vuex 并不意味着你需要将所有的状态放入 Vuex。虽然将所有的状态放到 Vuex 会使状态变化更显式和易调试，但也会使代码变得冗长和不直观。如果有些状态严格属于单个组件，最好还是作为组件的局部状态。你应该根据你的应用开发需要进行权衡和确定。
# Getter
有时候我们需要从 store 中的 state 中派生出一些状态，例如对列表进行过滤并计数：
```
computed: {
doneTodosCount () {
return this.$store.state.todos.filter(todo => todo.done).length
}
}
```
如果有多个组件需要用到此属性，我们要么复制这个函数，或者抽取到一个共享函数然后在多处导入它——无论哪种方式都不是很理想。
Vuex 允许我们在 store 中定义“getter”（可以认为是 store 的计算属性）。就像计算属性一样，getter 的返回值会根据它的依赖被缓存起来，且只有当它的依赖值发生了改变才会被重新计算。
Getter 接受 state 作为其第一个参数：
```
const store = new Vuex.Store({
state: {
todos: [
{ id: 1, text: '...', done: true },
{ id: 2, text: '...', done: false }
]
},
getters: {
doneTodos: state => {
return state.todos.filter(todo => todo.done)
}
}
})
```
Getter 会暴露为 store.getters 对象，你可以以属性的形式访问这些值：
```
store.getters.doneTodos // -> [{ id: 1, text: '...', done: true }]
this.$store.getters.doneTodos;
```
Getter 也可以接受其他 getter 作为第二个参数，通过这种机制可以访问其他的Getter：
```
getters: {
// ...
doneTodosCount: (state, getters) => {
return getters.doneTodos.length
}
}
```
我们可以很容易地在任何组件中使用它：
```
computed: {
doneTodosCount () {
return this.$store.getters.doneTodosCount
}
}
```
注意，getter 在通过属性访问时是作为 Vue 的响应式系统的一部分缓存其中的。
你也可以通过让 getter 返回一个函数，来实现给 getter 传参。在你对 store 里的数组进行查询时非常有用。
```
getters: {
// ...
getTodoById: (state) => (id) => {
return state.todos.find(todo => todo.id === id)
}
}
```
用法：
```
store.getters.getTodoById(2) // -> { id: 2, text: '...', done: false }
```
注意，getter 在通过方法访问时，每次都会去进行调用，而不会缓存结果。
mapGetters 辅助函数仅仅是将 store 中的 getter 映射到局部计算属性：
```
import { mapGetters } from 'vuex'
export default {
// ...
computed: {
// 使用对象展开运算符将 getter 混入 computed 对象中
...mapGetters([
'doneTodosCount',
'anotherGetter',
// ...
])
}
}
```
如果你想将一个 getter 属性另取一个名字，使用对象形式：
```
mapGetters({
// 把 `this.doneCount` 映射为 `this.$store.getters.doneTodosCount`
doneCount: 'doneTodosCount'
})
```
# Mutation
更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutation 非常类似于事件：每个 mutation 都有一个字符串的事件类型 (type) 和 一个 回调函数 (handler)。这个回调函数就是我们实际进行状态更改的地方，并且它会接受 state 作为第一个参数：
```
const store = new Vuex.Store({
state: {
count: 1
},
mutations: {
increment (state) {
// 变更状态
state.count++
}
}
})
```
你不能直接调用一个 mutation handler。这个选项更像是事件注册：“当触发一个类型为 increment 的 mutation 时，调用此函数。”要唤醒一个 mutation handler，你需要以相应的 type 调用 store.commit 方法：
store.commit('increment')
```
提交载荷（Payload）
```
你可以向 store.commit 传入额外的参数，即 mutation 的 载荷（payload）：
```
mutations: {
increment (state, n=1) {
state.count += n
}
}
store.commit('increment', 10)
```
在大多数情况下，载荷应该是一个对象，这样可以包含多个字段并且记录的 mutation 会更易读：
```
mutations: {
increment (state, payload) {
state.count += payload.amount
}
}
```
如果你要传递多个参数，必须得把这些参数封装为一个对象的形式传递。
```
store.commit('increment', {
amount: 10
})
```
## 对象风格的提交方式
提交 mutation 的另一种方式是直接使用包含 type 属性的对象：
```
store.commit({
type: 'increment',
amount: 10
})
```
当使用对象风格的提交方式，整个对象都作为载荷传给 mutation 函数，因此 handler 保持不变：
```
mutations: {
increment (state, payload) {
state.count += payload.amount
}
}
```
## Mutation 需遵守 Vue 的响应规则
既然 Vuex 的 store 中的状态是响应式的，那么当我们变更状态时，监视状态的 Vue 组件也会自动更新。这也意味着 Vuex 中的 mutation 也需要与使用 Vue 一样遵守一些注意事项：
1. 提前在你的 store 中初始化所有所需属性。
2. 当需要在对象上添加新属性时，你应该使用 Vue.set(obj, 'newProp', 123), 或者以新对象替换老对象。例如，利用对象展开运算符我们可以这样写：
```
state.obj = { ...state.obj, newProp: 123 }
```
## Mutation 必须是同步函数
一条重要的原则就是要记住 mutation 必须是同步函数。为什么？请参考下面的例子：
```
mutations: {
someMutation (state) {
api.callAsyncMethod(() => {
state.count++
})
}
}
```
现在想象，我们正在 debug 一个 app 并且观察 devtool 中的 mutation 日志。每一条 mutation 被记录，devtools 都需要捕捉到前一状态和后一状态的快照。然而，在上面的例子中 mutation 中的异步函数中的回调让这不可能完成：因为当 mutation 触发的时候，回调函数还没有被调用，devtools 不知道什么时候回调函数实际上被调用——实质上任何在回调函数中进行的状态的改变都是不可追踪的。
## 在组件中提交 Mutation
你可以在组件中使用`this.$store.commit('xxx')` 提交 mutation，或者使用 mapMutations 辅助函数将组件中的 methods 映射为 store.commit 调用（需要在根节点注入 store）。
```
import {
mapMutations
} from 'vuex'
export default {
// ...
methods: {
...mapMutations([
// 将this.increment()映射为 `this.$store.commit('increment')
'increment',
// 将this.incrementBy(amount)映射为this.$store.commit('incrementBy', amount)
'incrementBy'
]),
...mapMutations({
// 将this.add()映射为 this.$store.commit('increment')
add: 'increment'
})
}
}
```
# Action
Action 类似于 Mutation，不同在于：
1. Action 提交的是 Mutation，而不是直接变更状态。
2. Action 可以包含任意异步操作。
让我们来注册一个简单的 action：
```
const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment (state) {
state.count++
}
},
actions: {
increment (context) {
context.commit('increment')
}
}
})
```
Action 函数接受一个与 store 实例具有相同方法和属性的 context 对象，因此你可以调用 context.commit 提交一个 mutation，或者通过 context.state 和 context.getters 来获取 state 和 getters。
实践中，我们会经常用到 ES2015 的 参数解构 来简化代码（特别是我们需要调用 commit 很多次的时候）：
```
actions: {
increment ({ commit }) {
commit('increment')
}
}
```
`{commit}`意思是从context中提取commit对象方法。
## 分发 Action
Action 通过 store.dispatch 方法触发：
```
store.dispatch('increment')
```
乍一眼看上去感觉多此一举，我们直接分发 mutation 岂不更方便？实际上并非如此，还记得 mutation 必须同步执行这个限制么？Action 就不受约束！我们可以在 action 内部执行异步操作：
```
actions: {
incrementAsync ({ commit }) {
setTimeout(() => {
commit('increment')
}, 1000)
}
}
```
Actions 支持同样的载荷方式和对象方式进行分发：
```
// 以载荷形式分发
store.dispatch('incrementAsync', {
amount: 10
})
```
或者以对象的形式分发
```
// 以对象形式分发
store.dispatch({
type: 'incrementAsync',
amount: 10
})
```
## 在组件中分发 Action
你在组件中使用`this.$store.dispatch('xxx')`分发 action，或者使用 mapActions 辅助函数将组件的 methods 映射为 store.dispatch 调用：
```
import {
mapActions
} from 'vuex'
export default {
// ...
methods: {
...mapActions([
// 将this.increment()映射为this.$store.dispatch('increment')
'increment',
// 将`this.incrementBy(amount) 映射为`this.$store.dispatch('incrementBy', amount)
'incrementBy'
]),
...mapActions({
// 将this.add()映射为this.$store.dispatch('increment')
add: 'increment'
})
}
}
```
> 使用mapActions, mapMutations要注意不能有重名的方法，否则需要在使用mapActions, mapMutations时候重命名映射方法名称，例如
```
methods:{
increment() {
},
...mapActions({
// 将this.add()映射为this.$store.dispatch('increment')
add: 'increment'
})
}
```
## 组合 Action
Action 通常是异步的，那么如何知道 action 什么时候结束呢？更重要的是，我们如何才能组合多个 action，以处理更加复杂的异步流程？
首先，你需要明白 store.dispatch 可以处理被触发的 action 的处理函数返回的 Promise，并且 store.dispatch 仍旧返回 Promise：
```
actions: {
actionA ({ commit }) {
return new Promise((resolve, reject) => {
setTimeout(() => {
commit('someMutation')
resolve()
}, 1000)
})
}
}
```
现在你可以：
```
store.dispatch('actionA').then(() => {
// ...
})
```
在另外一个 action 中也可以：
```
actions: {
// ...
actionB ({ dispatch, commit }) {
return dispatch('actionA').then(() => {
commit('someOtherMutation')
})
}
}
```
最后，如果我们利用 async / await，我们可以如下组合 action：
```
// 假设 getData() 和 getOtherData() 返回的是 Promise
actions: {
async actionA ({ commit }) {
commit('gotData', await getData())
},
async actionB ({ dispatch, commit }) {
await dispatch('actionA') // 等待 actionA 完成
commit('gotOtherData', await getOtherData())
}
}
```
一个 store.dispatch 在不同模块中可以触发多个 action 函数。在这种情况下，只有当所有触发函数完成后，返回的 Promise 才会执行。
完整的代码清单
store/index.js
```
import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)
const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment(state, n = 1) {
state.count += n;
},
decrement(state, n = 1) {
state.count -= n;
}
},
actions: {
incrementIfOdd(context) {
if ((context.state.count + 1) % 2 === 0) {
context.commit('increment')
}
},
incrementAsync(context) {
// console.log(context);
setTimeout(() => {
context.commit('increment')
}, 1000)
}
},
getters: {
total(state) {
return state.count;
}
}
})
export default store
pages/index/index.vue
<template>
<view>
<view>Clicked: {{ count }} times use state</view>
<view>Clicked: {{ total }} times use getter</view>
<button @click="increment()">+</button>
<button @click="decrement()">-</button>
<button @click="incrementIfOdd()">Increment if odd</button>
<button @click="incrementAsync()">Increment async</button>
</view>
</template>
<script>
import {
mapState,
mapMutations,
mapActions
} from 'vuex'
export default {
computed: {
// ...mapState(['count']),
...mapState({
count: state => state.count,
}),
total() {
return this.$store.getters.total;
}
},
methods: {
// ...mapMutations(['increment', 'decrement']),
...mapMutations({
increment: 'increment',
decrement: 'decrement'
}),
// ...mapActions(['incrementIfOdd', 'incrementAsync'])
...mapActions({
incrementIfOdd: 'incrementIfOdd',
incrementAsync: 'incrementAsync'
})
}
}
</script>
```
# Module与子状态
由于使用单一状态树，应用的所有状态会集中到一个比较大的对象。当应用变得非常复杂时，store 对象就有可能变得相当臃肿。
为了解决以上问题，Vuex 允许我们将 store 分割成模块（module）。每个模块拥有自己的 state、mutations、actions、getters，并通过namespaced属性支持命名空间访问相应的对象：
```
const moduleA = {
namespaced: true,
state: { ... },
mutations: { ... },
actions: { ... },
getters: { ... }
}
const moduleB = {
namespaced: true,
state: { ... },
mutations: { ... },
actions: { ... }
}
const store = new Vuex.Store({
modules: {
a: moduleA,
b: moduleB
}
})
store.state.a // -> moduleA 的状态
store.state.b // -> moduleB 的状态
```
## 模块的局部状态
对于模块内部的 mutation 和 getter，接收的第一个参数是模块的局部状态对象。
```
const moduleA = {
namespaced: true,
state: { count: 0 },
mutations: {
increment (state) {
// 这里的 `state` 对象是模块的局部状态
state.count++
}
},
getters: {
doubleCount (state) {
return state.count * 2
}
}
}
```
同样，对于模块内部的 action，局部状态通过 context.state 暴露出来，根节点状态则为 context.rootState：
```
const moduleA = {
// ...
actions: {
incrementIfOddOnRootSum ({ state, commit, rootState }) {
if ((state.count + rootState.count) % 2 === 1) {
commit('increment')
}
}
}
}
```
对于模块内部的 getter，根节点状态会作为第三个参数暴露出来：
```
const moduleA = {
// ...
getters: {
sumWithRootCount (state, getters, rootState) {
return state.count + rootState.count
}
}
}
```
命名空间
默认情况下，模块内部的 action、mutation 和 getter 是注册在全局命名空间的——这样使得多个模块能够对同一 mutation 或 action 作出响应。
如果希望你的模块具有更高的封装度和复用性，你可以通过添加 namespaced: true 的方式使其成为带命名空间的模块。当模块被注册后，它的所有 getter、action 及 mutation 都会自动根据模块注册的路径调整命名。例如：
```
const store = new Vuex.Store({
modules: {
account: {
namespaced: true,
// 模块内容（module assets）
state: { ... }, // 模块内的状态已经是嵌套的了，使用 `namespaced` 属性不会对其产生影响
getters: {
isAdmin () { ... } // -> getters['account/isAdmin']
},
actions: {
login () { ... } // -> dispatch('account/login')
},
mutations: {
login () { ... } // -> commit('account/login')
},
// 嵌套模块
modules: {
// 继承父模块的命名空间
myPage: {
state: { ... },
getters: {
profile () { ... } // -> getters['account/profile']
}
},
// 进一步嵌套命名空间
posts: {
namespaced: true,
state: { ... },
getters: {
popular () { ... } // -> getters['account/posts/popular']
}
}
}
}
}
})
```
启用了命名空间的 getter 和 action 会收到局部化的 getter，dispatch 和 commit。换言之，你在使用模块内容（module assets）时不需要在同一模块内额外添加空间名前缀。更改 namespaced 属性后不需要修改模块内的代码。
在带命名空间的模块内访问全局内容（Global Assets）
如果你希望使用全局 state 和 getter，rootState 和 rootGetter 会作为第三和第四参数传入 getter，也会通过 context 对象的属性传入 action。
若需要在全局命名空间内分发 action 或提交 mutation，将`{ root: true }` 作为第三参数传给 dispatch 或 commit 即可。
```
modules: {
foo: {
namespaced: true,
getters: {
// 在这个模块的 getter 中，`getters` 被局部化了
// 你可以使用 getter 的第四个参数来调用 `rootGetters`
someGetter (state, getters, rootState, rootGetters) {
getters.someOtherGetter // -> 'foo/someOtherGetter'
rootGetters.someOtherGetter // -> 'someOtherGetter'
},
someOtherGetter: state => { ... }
},
actions: {
// 在这个模块中， dispatch 和 commit 也被局部化了
// 他们可以接受 `root` 属性以访问根 dispatch 或 commit
someAction ({ dispatch, commit, getters, rootGetters }) {
getters.someGetter // -> 'foo/someGetter'
rootGetters.someGetter // -> 'someGetter'
dispatch('someOtherAction') // -> 'foo/someOtherAction'
dispatch('someOtherAction', null, { root: true }) // -> 'someOtherAction'
commit('someMutation') // -> 'foo/someMutation'
commit('someMutation', null, { root: true }) // -> 'someMutation'
},
someOtherAction (ctx, payload) { ... }
}
}
}
```
## 在带命名空间的模块注册全局 action
若需要在带命名空间的模块注册全局 action，你可添加 root: true，并将这个 action 的定义放在函数 handler 中。例如：
```
{
actions: {
someOtherAction ({dispatch}) {
dispatch('someAction')
}
},
modules: {
foo: {
namespaced: true,
actions: {
someAction: {
root: true,
handler (namespacedContext, payload) { ... } // -> 'someAction'
}
}
}
}
}
```
带命名空间的绑定函数
当使用 mapState, mapGetters, mapActions 和 mapMutations 这些函数来绑定带命名空间的模块时，写起来可能比较繁琐：
```
computed: {
...mapState({
a: state => state.some.nested.module.a,
b: state => state.some.nested.module.b
})
},
methods: {
...mapActions([
'some/nested/module/foo', // -> this['some/nested/module/foo']()
'some/nested/module/bar' // -> this['some/nested/module/bar']()
])
}
```
对于这种情况，你可以将模块的空间名称字符串作为第一个参数传递给上述函数，这样所有绑定都会自动将该模块作为上下文。于是上面的例子可以简化为：
```
computed: {
...mapState('some/nested/module', {
a: state => state.a,
b: state => state.b
})
},
methods: {
...mapActions('some/nested/module', [
'foo', // -> this.foo()
'bar' // -> this.bar()
])
}
```
而且，你可以通过使用 createNamespacedHelpers 创建基于某个命名空间辅助函数。它返回一个对象，对象里有新的绑定在给定命名空间值上的组件绑定辅助函数：
```
import { createNamespacedHelpers } from 'vuex'
const { mapState, mapActions } = createNamespacedHelpers('some/nested/module')
export default {
computed: {
// 在 `some/nested/module` 中查找
...mapState({
a: state => state.a,
b: state => state.b
})
},
methods: {
// 在 `some/nested/module` 中查找
...mapActions([
'foo',
'bar'
])
}
}
```
- 内容介绍
- EcmaScript基础
- 快速入门
- 常量与变量
- 字符串
- 函数的基本概念
- 条件判断
- 数组
- 循环
- while循环
- for循环
- 函数基础
- 对象
- 对象的方法
- 函数
- 变量作用域
- 箭头函数
- 闭包
- 高阶函数
- map/reduce
- filter
- sort
- Promise
- 基本对象
- Arguments 对象
- 剩余参数
- Map和Set
- Json基础
- RegExp
- Date
- async
- callback
- promise基础
- promise-api
- promise链
- async-await
- 项目实践
- 标签系统
- 远程API请求
- 面向对象编程
- 创建对象
- 原型继承
- 项目实践
- Classes
- 构造函数
- extends
- static
- 项目实践
- 模块
- import
- export
- 项目实践
- 第三方扩展库
- immutable
- Vue快速入门
- 理解MVVM
- Vue中的MVVM模型
- Webpack+Vue快速入门
- 模板语法
- 计算属性和侦听器
- Class 与 Style 绑定
- 条件渲染
- 列表渲染
- 事件处理
- 表单输入绑定
- 组件基础
- 组件注册
- Prop
- 自定义事件
- 插槽
- 混入
- 过滤器
- 项目实践
- 标签编辑
- 移动客户端开发
- uni-app基础
- 快速入门程序
- 单页程序
- 底部Tab导航
- Vue语法基础
- 模版语法
- 计算属性与侦听器
- Class与Style绑定
- 样式与布局
- Box模型
- Flex布局
- 内置指令
- 基本指令
- v-model与表单
- 条件渲染指令
- 列表渲染指令v-for
- 事件与自定义属性
- 生命周期
- 项目实践
- 学生实验
- 贝店商品列表
- 加载更多数据
- 详情页面
- 自定义组件
- 内置组件
- 表单组件
- 技术专题
- 状态管理vuex
- Flyio
- Mockjs
- SCSS
- 条件编译
- 常用功能实现
- 上拉加载更多数据
- 数据加载综合案例
- Teaset UI组件库
- Teaset设计
- Teaset使用基础
- ts-tag
- ts-badge
- ts-button
- ta-banner
- ts-list
- ts-icon
- ts-load-more
- ts-segmented-control
- 代码模版
- 项目实践
- 标签组件
- 失物招领客户端原型
- 发布页面
- 检索页面
- 详情页面
- 服务端开发技术
- 服务端开发环境配置
- Koajs快速入门
- 快速入门
- 常用Koa中间件介绍
- 文件上传
- RestfulApi
- 一个复杂的RESTful例子
- 使用Mockjs生成模拟数据
- Thinkjs快速入门
- MVC模式
- Thinkjs介绍
- 快速入门
- RESTful服务
- RBAC案例
- 关联模型
- 应用开发框架
- 服务端开发
- PC端管理界面开发
- 移动端开发
- 项目实践
- 失物招领项目
- 移动客户端UI设计
- 服务端设计
- 数据库设计
- Event（事件）
- 客户端设计
- 事件列表页面
- 发布页面
- 事件详情页面
- API设计
- image
- event
- 微信公众号开发
- ui设计规范