Cómo usar mutations y commit en Vuex
Clase 41 de 53 • Curso Profesional de Vue.js 2
Contenido del curso
CLI y Dev Tools
- 3

Instalación de Vue.js: Node, Dev Tools y CLI
06:13 min - 4

Crear una aplicación Vue con CLI y webpack
12:49 min - 5

Cómo funciona webpack.config.js
10:38 min - 6

Babel: transpilador de JavaScript moderno
05:06 min - 7

ESLint con Standard JS: linteo automático en webpack
15:34 min - 8

Configuración de Sass y Bulma en Vue
06:18 min - 9

Cómo configurar Pug en Vue con webpack
04:23 min - 10
Diseño de Mockups: Práctica y Colaboración en Comunidad
00:20 min - 11
Creación de Vistas con Mockups y Vue.js
00:32 min
Manipulación del DOM
- 12

Expresiones en Vue: sintaxis doble llave
03:49 min - 13

Diferencia entre v-show y v-if en el DOM
06:22 min - 14

Qué es data binding en Vue.js
04:11 min - 15

Computed properties en Vue.js: cómo crearlas
04:13 min - 16

Qué son los watchers de Vue
02:25 min - 17

Eventos Vue: directiva v-on y métodos format
06:12 min - 18

Cómo construir una interfaz de búsqueda completa en Vue
19:03 min - 19
Manipulación del DOM con Vue.js: Práctica y Ejercicios
03:00 min
REST y HTTP
Sistema de Componentes
- 23

Cómo crear componentes en Vue
08:46 min - 24

Componentes Layout en Vue con Bulma
09:50 min - 25

Reactividad en Vue: $set y Object.assign
06:14 min - 26

Hooks del ciclo de vida en Vue.js
05:38 min - 27

Comunicación padre-hijo con props en Vue
23:27 min - 28

Eventos en Vue: comunicar hijo a padre
12:04 min - 29

Slots: HTML dinámico en componentes Vue
13:42 min - 30

Plugin Event Bus: comunicar componentes sin relación en Vue
19:19 min
Vue Router
Extendiendo VueJS
Clases, Animaciones y Transiciones36
Vuex
- 39

Cómo Vuex centraliza estados en Vue
03:41 min - 40

Instalación de Vuex con estado único
17:32 min - 41

Cómo usar mutations y commit en Vuex
Viendo ahora - 42

Getters de Vuex: mapGetters y store sincronizado
07:35 min - 43

Cómo dispatch ejecuta actions asincrónicas en ViewX
07:54 min - 44

Instalación de Viewex en Platzi Music
26:37 min
Nuxt.js
Deploy a Producción con Now
Conclusiones
Bonus
Actualizar el estado de forma segura y trazable en Vuex es sencillo cuando entiendes las mutations, el commit y la reactividad. Aquí verás cómo registrar cambios, depurar con confianza y reducir código con mapMutations, sin romper el flujo de datos.
¿Qué son las mutations y por qué importan para el estado global?
Las mutations son la única vía para cambiar el estado en Vuex. No se actualiza el estado directamente: se registra cada cambio para facilitar el debug y saber qué componente disparó la actualización.
- Funcionan similar a eventos: el store define el handler y el componente hace commit para notificar el cambio.
- Soportan múltiples componentes cambiando el estado simultáneamente sin perder trazabilidad.
- Integran con Vue DevTools: se ve una línea de tiempo de commits y valores en cada momento.
- Son reactivas: cuando cambia el estado, todos los componentes que lo usan se renderizan automáticamente.
Idea clave: el estado es una “variable global reactiva”; al modificarse, la vista se refresca sola en cada componente que depende de él.
¿Cómo usar commit desde el componente para actualizar el estado?
El patrón es directo: defines las mutations en el store y las invocas con this.$store.commit(...) desde el componente. Así mantienes el flujo claro: componente → estado → vista actualizada.
¿Cómo definir increment y decrement en el store?
// store.js
export default new Vuex.Store({
state: { count: 0 },
mutations: {
increment(state) {
state.count++;
},
decrement(state) {
state.count--;
}
}
});
¿Cómo invocar commit desde el componente?
// App.vue (fragmento)
export default {
methods: {
increment() {
this.$store.commit('increment');
},
decrement() {
this.$store.commit('decrement');
}
}
};
commit('increment')ocommit('decrement')registran el cambio y actualizan el estado.- La vista se refresca en automático gracias a la reactividad.
- En DevTools ves cada commit listado y puedes inspeccionar los valores a lo largo del tiempo.
¿Cómo fluye la reactividad y el render?
- El componente hace commit hacia el estado.
- El estado actualiza
county propaga el cambio. - El componente se vuelve a renderizar con el valor actualizado.
¿Cómo pasar payload y reutilizar con mapMutations?
Puedes extender una mutation con un payload para configurar el cambio y, además, evitar duplicación de código con mapMutations.
¿Cómo agregar payload y valores por defecto?
Puedes recibir un objeto payload y definir un valor default de ES2015 para no romper si no se pasa nada.
// store.js (increment con payload y default)
export default new Vuex.Store({
state: { count: 0 },
mutations: {
increment(state, payload = {}) {
state.count += payload.number || 1; // usa 1 si no viene number
},
decrement(state) {
state.count--;
}
}
});
payload = {}evita errores cuando no se envía información extra.payload.number || 1permite incrementar por un número custom o por 1.
¿Cómo crear acciones personalizadas como increment diez?
// App.vue (fragmento)
export default {
methods: {
incrementDiez() {
this.$store.commit('increment', { number: 10 });
}
}
};
- Útil para botones como “+10”.
- No interfiere con otras mutations ya definidas.
¿Cómo extraer mutaciones con mapMutations y combinar métodos?
Usa mapMutations para “traerte” mutations del store al componente y combinar con métodos propios usando el spread operator.
// App.vue (fragmento)
import { mapState, mapMutations } from 'vuex';
export default {
computed: {
...mapState(['count'])
},
methods: {
...mapMutations(['increment', 'decrement']),
incrementDiez() {
this.$store.commit('increment', { number: 10 });
}
}
};
- Menos código repetido en componentes.
- Puedes mantener métodos custom como
incrementDiezen el componente. - Si
incrementDiezse necesita “en todos lados”, muévelo al store como mutation para hacerlo accesible globalmente.
¿Te gustaría ver variantes con diferentes payloads o atajos con botones? Deja tus preguntas y cuéntame qué caso necesitas cubrir.