vue.js 2 vuex से स्टोर वैल्यू कैसे देखें


168

मैं उपयोग कर रहा हूं vuexऔर vuejs 2एक साथ।

मैं नया vuexहूं, मैं एक storeपरिवर्तनशील परिवर्तन देखना चाहता हूं ।

मैं watchअपने में फंक्शन जोड़ना चाहता हूंvue component

अभी तक मेरे पास इतना ही है:

import Vue from 'vue';
import {
  MY_STATE,
} from './../../mutation-types';

export default {
  [MY_STATE](state, token) {
    state.my_state = token;
  },
};

मैं जानना चाहता हूं कि क्या इसमें कोई बदलाव हैं my_state

मैं store.my_stateअपने vuejs घटक को कैसे देख सकता हूँ ?


Vuejs प्लगइन का उपयोग करें जो क्रोम के साथ आता है यह काम आएगा
AKASH PANDEY

जवाबों:


206

उदाहरण के लिए, मान लीजिए कि आपके पास फलों की एक टोकरी है, और हर बार जब आप टोकरी से कोई फल जोड़ते या हटाते हैं, तो आप (1) फलों की गिनती के बारे में जानकारी प्रदर्शित करना चाहते हैं, लेकिन आप (2) को भी सूचित करना चाहते हैं। कुछ फैंसी फैशन में फलों की गिनती ...

फल-गिनती-component.vue

<template>
  <!-- We meet our first objective (1) by simply -->
  <!-- binding to the count property. -->
  <p>Fruits: {{ count }}</p>
</template>

<script>
import basket from '../resources/fruit-basket'

export default () {
  computed: {
    count () {
      return basket.state.fruits.length
      // Or return basket.getters.fruitsCount
      // (depends on your design decisions).
    }
  },
  watch: {
    count (newCount, oldCount) {
      // Our fancy notification (2).
      console.log(`We have ${newCount} fruits now, yay!`)
    }
  }
}
</script>

कृपया ध्यान दें, कि watchऑब्जेक्ट में फ़ंक्शन का नाम, computedऑब्जेक्ट में फ़ंक्शन के नाम से मेल खाना चाहिए । नाम के ऊपर के उदाहरण में है count

एक देखे गए संपत्ति के नए और पुराने मूल्यों को पैरामीटर के रूप में वॉच कॉलबैक (गिनती फ़ंक्शन) में पारित किया जाएगा।

टोकरी स्टोर इस तरह दिख सकता है:

फल-basket.js

import Vue from 'vue'
import Vuex from 'vuex'

Vue.use(Vuex)

const basket = new Vuex.Store({
  state: {
    fruits: []
  },
  getters: {
    fruitsCount (state) {
      return state.fruits.length
    }
  }
  // Obviously you would need some mutations and actions,
  // but to make example cleaner I'll skip this part.
})

export default basket

आप निम्नलिखित संसाधनों में अधिक पढ़ सकते हैं:


मैं सोच रहा हूं कि जब watchकार्रवाई दो चरणों में विभाजित हो जाए, तो मैं क्या कर सकता हूं : 1) सबसे पहले, यह जांचना कि क्या इच्छा डेटा कैश है और यदि यह कैश्ड डेटा को वापस करता है; 2) यदि कैश विफल हो गया, तो मुझे डेटा लाने के लिए एक async ajax कार्रवाई की आवश्यकता है, लेकिन यह काम प्रतीत होता है action। मेरे प्रश्न की उम्मीद करना, धन्यवाद!
189

माइकह 5 के जवाब से, इसका क्या फायदा है, जो स्टोर वैल्यू पर कंपोनेंट में वॉचर्स सेट करता है? इसे बनाए रखने के लिए कम कोड है।
शाम

@ बाहरी जब मैंने उत्तर लिखा था, तो मेरे लिए प्रश्न स्पष्ट नहीं था। संपत्तियों को देखने की आवश्यकता क्यों है इसका कोई संदर्भ नहीं है। इसे ऐसे समझें: "मैं चर X देखना चाहता हूं, इसलिए मैं Y कर सकता हूं।" संभवतः इसीलिए अधिकांश उत्तर इतने भिन्न दृष्टिकोणों का प्रस्ताव देते हैं। किसी को नहीं पता कि इरादा क्या है। यही कारण है कि मैंने अपने उत्तर में "उद्देश्य" शामिल किए। यदि आपके अलग-अलग उद्देश्य हैं, तो अलग-अलग उत्तर उन्हें फिट कर सकते हैं। मेरा उदाहरण प्रयोग के लिए सिर्फ एक प्रारंभिक बिंदु है। इसका मतलब प्लग एंड प्ले सॉल्यूशन होना नहीं है। कोई "लाभ" नहीं है, क्योंकि लाभ आपकी स्थिति पर निर्भर करता है।
अनास्तासी

@ 1Cr18Ni9 मुझे लगता है कि कैशिंग घटक कोड में नहीं है। आप ओवर-इंजीनियरिंग को कुछ समाप्त कर देंगे जो वास्तव में सरल होना चाहिए (डेटा को प्राप्त करना और इसे देखने के लिए बाध्य करना)। ब्राउज़र में कैशिंग पहले से ही लागू है। आप सर्वर से सही हेडर भेजकर इसका लाभ उठा सकते हैं। यहाँ सरल विवरण: csswizardry.com/2019/03/cache-control-for-civilians । आप ServiceWorkers पर भी नज़र डाल सकते हैं जो वेबसाइट को इंटरनेट कनेक्शन के बिना भी काम करने की अनुमति देते हैं।
अनास्तासी

61

राज्य परिवर्तन को सुनने के लिए आपको घटक के पहरेदारों का उपयोग नहीं करना चाहिए। मैं आपको गेट्स फ़ंक्शन का उपयोग करने की सलाह देता हूं और फिर उन्हें आपके घटक के अंदर मैप करता हूं।

import { mapGetters } from 'vuex'

export default {
  computed: {
    ...mapGetters({
      myState: 'getMyState'
    })
  }
}

आपके स्टोर में:

const getters = {
  getMyState: state => state.my_state
}

आपको this.myStateअपने घटक का उपयोग करके अपने स्टोर में किए गए किसी भी बदलाव को सुनने में सक्षम होना चाहिए ।

https://vuex.vuejs.org/en/getters.html#the-mapgetters-helper


1
मैं नहीं जानता कि मैपगेटर्स को कैसे लागू किया जाए। क्या आप मुझे एक उदाहरण दे सकते हैं। यह एक बड़ी मदद होगी। मैं फिलहाल GONG जवाब को लागू करता हूं। स्व
Rbex

1
@ रेबेक्स "मैपगेटर्स" 'वीएक्सएक्स' लाइब्रेरी का हिस्सा है। आपको इसे लागू करने की आवश्यकता नहीं है।
गेब्रियल रॉबर्ट

69
यह उत्तर गलत है। उसे वास्तव में गणना किए गए गुणों को देखने की जरूरत है।
जुआन

15
एक बार कॉल करने वाला गेट केवल उस समय की स्थिति प्राप्त करेगा। यदि आप चाहते हैं कि संपत्ति दूसरे घटक से राज्य परिवर्तन को प्रतिबिंबित करे तो आपको इसे देखना होगा।
C Tierney

3
"आपको राज्य परिवर्तन को सुनने के लिए घटक के पहरेदारों का उपयोग क्यों नहीं करना चाहिए"? यहाँ उदाहरण है कि आप ऐसा नहीं सोच सकते हैं, अगर मैं राज्य से टोकन देखना चाहता हूं, और जब यह दूसरे पृष्ठ पर रीडायरेक्ट होता है। इसलिए, कुछ मामलों में आपको ऐसा करने की आवश्यकता है। शायद आपको यह जानने के लिए अधिक अनुभव की आवश्यकता है।
श्लोमी लेवी

46

यह उतना ही सरल है:

watch: {
  '$store.state.drawer': function() {
    console.log(this.$store.state.drawer)
  }
}

6
यह यहाँ किसी भी उत्तर की तुलना में अधिक सरल है ... क्या ऐसा करने के खिलाफ कोई तर्क है ..?
Inigo

19
यह बहुत आसान है इसलिए js जैसा नहीं दिखता है, js को अधिक जटिल होना चाहिए।
28:19

1
और भी सरल होगा अगर यह थाfunction(n) { console.log(n); }
WofWca

2
बेहद कूल। इस दृष्टिकोण के किसी भी दोष में रुचि रखते हैं। अभी तक यह अच्छी तरह से काम करने लगता है।
namero999

1
गंभीरता से। यह स्वीकृत उत्तर की तुलना में बहुत अच्छा लगता है, जिसके लिए घड़ी और गणना में डुप्लिकेट फ़ंक्शन नामों की आवश्यकता होती है। क्या कोई विशेषज्ञ इस तरह से टिप्पणी कर सकता है या क्यों नहीं?
निर्वासित

42

जैसा कि ऊपर उल्लेख किया गया है कि स्टोर में सीधे परिवर्तन देखना अच्छा नहीं है

लेकिन कुछ बहुत ही दुर्लभ मामलों में यह किसी के लिए उपयोगी हो सकता है, इसलिए मैं इस उत्तर को छोड़ दूंगा। अन्य मामलों के लिए, कृपया @ gabriel-robert उत्तर देखें

आप इसके माध्यम से कर सकते हैं state.$watchcreatedघटक में इसे अपने (या जहां u निष्पादित करने की आवश्यकता है) विधि में इसे जोड़ें

this.$store.watch(
    function (state) {
        return state.my_state;
    },
    function () {
        //do something on data change
    },
    {
        deep: true //add this if u need to watch object properties change etc.
    }
);

अधिक जानकारी: https://vuex.vuejs.org/api/#watch


3
मुझे नहीं लगता कि सीधे राज्य देखना एक अच्छा विचार है। हमें गेटर्स का इस्तेमाल करना चाहिए। vuex.vuejs.org/en/getters.html#the-mapgetters-helper
गेब्रियल रॉबर्ट

14
@GabrielRobert मुझे लगता है कि दोनों के लिए एक जगह है। यदि आपको प्रतिक्रियात्मक रूप से टेम्प्लेट शर्तों को बदलने की आवश्यकता है, तो mapState के साथ गणना मूल्य का उपयोग करना, आदि समझ में आता है। लेकिन अन्यथा, एक घटक में भी प्रवाह नियंत्रण के लिए, आपको एक पूर्ण घड़ी की आवश्यकता है। आप सही हैं, आपको सादे घटक दर्शकों का उपयोग नहीं करना चाहिए, लेकिन राज्य। $ घड़ी इन उपयोग के मामलों के लिए डिज़ाइन की गई है
रॉबर्टो टॉमु

14
हर कोई इसका उल्लेख करता है, लेकिन कोई भी क्यों नहीं कहता है! मैं एक vuex स्टोर बनाने की कोशिश कर रहा हूं जो परिवर्तनों पर DB के साथ ऑटो-सिंक्रनाइज़ है। मुझे लगता है कि स्टोर पर नजर रखने वाला सबसे घर्षणहीन तरीका है! तुम क्या सोचते हो? अभी भी एक अच्छा विचार नहीं है?
मेसकाइब

16

मुझे लगता है कि पूछने वाला Vuex के साथ घड़ी का उपयोग करना चाहता है।

this.$store.watch(
      (state)=>{
        return this.$store.getters.your_getter
      },
      (val)=>{
       //something changed do something

      },
      {
        deep:true
      }
      );

13

यह उन सभी लोगों के लिए है जो गेटर्स के साथ अपनी समस्या को हल नहीं कर सकते हैं और वास्तव में वास्तव में एक वॉचर की आवश्यकता होती है, उदाहरण के लिए नॉन-वीयू थर्ड पार्टी सामान पर बात करना (देखें वॉच वॉचर्स ऑन द वॉचर्स का उपयोग करने के लिए)।

Vue घटक के द्रष्टा और संगणित मूल्य दोनों ही संगणित मूल्यों पर काम करते हैं। तो यह vuex के साथ अलग नहीं है:

import { mapState } from 'vuex';

export default {
    computed: {
        ...mapState(['somestate']),
        someComputedLocalState() {
            // is triggered whenever the store state changes
            return this.somestate + ' works too';
        }
    },
    watch: {
        somestate(val, oldVal) {
            // is triggered whenever the store state changes
            console.log('do stuff', val, oldVal);
        }
    }
}

यदि यह केवल स्थानीय और वैश्विक राज्य के संयोजन के बारे में है, तो मैपस्टैट का डॉक भी एक उदाहरण प्रदान करता है:

computed: {
    ...mapState({
        // to access local state with `this`, a normal function must be used
        countPlusLocalState (state) {
          return state.count + this.localCount
        }
    }
})

अच्छा हैक, लेकिन अभी भी थकाऊ, आपको नहीं लगता?
Martian2049

2
डॉक्स में अगर यह हैक नहीं है तो क्या यह है? लेकिन फिर, यह vue / vuex के लिए एक समर्थक-तर्क नहीं है
dube

8

यदि आप टाइपस्क्रिप्ट का उपयोग करते हैं तो आप कर सकते हैं:

import { Watch } from "vue-property-decorator";

..

@Watch("$store.state.something")
private watchSomething() {
   // use this.$store.state.something for access
   ...
}


क्यों वास्तव में इसे डाउनवोट किया गया था? सिर्फ इसलिए कि समाधान vue-class- घटक के लिए है और TO पुराने vue-class शैलियों के लिए पूछ रहा है? मैं पूर्व बेहतर लगता है। शायद @Zhang सोल परिचय में उल्लेख कर सकता है, कि यह स्पष्ट रूप से vue-class- घटक के लिए है?
जैकलीमेमरदेउर

ध्यान दें कि एक टाइप डेकोरेटर
डेकोरेटिव सॉल्यूशन के

6

मान परिवर्तन पर देखने और सेटिंग करके अपने स्टोर चर का एक स्थानीय राज्य बनाएं । ऐसा है कि फॉर्म-इनपुट वी-मॉडल के लिए स्थानीय चर परिवर्तन सीधे स्टोर चर को म्यूट नहीं करता है ।

data() {
  return {
    localState: null
  };
 },
 computed: {
  ...mapGetters({
    computedGlobalStateVariable: 'state/globalStateVariable'
  })
 },
 watch: {
  computedGlobalStateVariable: 'setLocalState'
 },
 methods: {
  setLocalState(value) {
   this.localState = Object.assign({}, value);
  }
 }

5

स्टोर परिवर्तन देखने का सबसे अच्छा तरीका यह है mapGettersकि गैब्रियल ने कहा। लेकिन एक ऐसा मामला है जब आप ऐसा नहीं कर सकते हैं mapGettersजैसे कि आप पैरामीटर का उपयोग करके स्टोर से कुछ प्राप्त करना चाहते हैं:

getters: {
  getTodoById: (state, getters) => (id) => {
    return state.todos.find(todo => todo.id === id)
  }
}

उस स्थिति में आप उपयोग नहीं कर सकते mapGetters। आप इसके बजाय ऐसा कुछ करने की कोशिश कर सकते हैं:

computed: {
    todoById() {
        return this.$store.getters.getTodoById(this.id)
    }
}

लेकिन दुर्भाग्य todoById से अद्यतन किया जाएगा केवल अगर this.idबदल गया है

यदि आप चाहते हैं कि आप ऐसे मामले में घटक अद्यतन करें, this.$store.watch जो गोंग द्वारा प्रदान किया गया समाधान है । या अपने घटक को होशपूर्वक संभालें और this.idजब आपको अपडेट करने की आवश्यकता हो तो अपडेट करें todoById


धन्यवाद। यह वास्तव में मेरा उपयोग मामला है, और वास्तव में
गेट्टर को

5

यदि आप केवल एक राज्य संपत्ति देखना चाहते हैं और फिर उस संपत्ति के परिवर्तनों के अनुसार घटक के भीतर कार्य करते हैं तो नीचे दिए गए उदाहरण देखें।

इन store.js:

export const state = () => ({
 isClosed: false
})
export const mutations = {
 closeWindow(state, payload) {
  state.isClosed = payload
 }
}

इस परिदृश्य में, मैं एक booleanराज्य संपत्ति बना रहा हूं जिसे मैं आवेदन में विभिन्न स्थानों पर बदलने जा रहा हूं:

this.$store.commit('closeWindow', true)

अब, अगर मुझे उस राज्य संपत्ति को किसी अन्य घटक में देखने की आवश्यकता है और फिर स्थानीय संपत्ति को मैं mountedहुक में निम्नलिखित लिखूंगा :

mounted() {
 this.$store.watch(
  state => state.isClosed,
  (value) => {
   if (value) { this.localProperty = 'edit' }
  }
 )
}

सबसे पहले, मैं राज्य की संपत्ति पर एक चौकीदार स्थापित कर रहा हूं और फिर कॉलबैक फ़ंक्शन में मैं valueउस संपत्ति का उपयोग बदलने के लिए करता हूं localProperty

मुझे उम्मीद है यह मदद करेगा!


3

जब आप राज्य स्तर पर देखना चाहते हैं, तो यह इस तरह से किया जा सकता है:

let App = new Vue({
    //...
    store,
    watch: {
        '$store.state.myState': function (newVal) {
            console.log(newVal);
            store.dispatch('handleMyStateChange');
        }
    },
    //...
});

घटक से राज्य कार्रवाई store.stateद्वारा परिवर्तन को संभालना अच्छा नहीं है dispatchक्योंकि यह व्यवहार तभी काम करता है जब आप उस घटक का उपयोग करते हैं। इसके अलावा आप अनंत लूप के साथ समाप्त हो सकते हैं। store.stateउदाहरण के लिए, शायद ही कभी उपयोग करने के लिए देखें , यदि आपके पास एक घटक या एक पृष्ठ है जो store.stateपरिवर्तित के आधार पर कुछ कार्रवाई करना चाहिए जो केवल कम्प्यूट किए गए मैपस्टेट का उपयोग करके नियंत्रित नहीं किया जा सकता है जहां आप newValueबनाम की तुलना नहीं कर सकतेoldValue
Januartha

@ जानुर्था इस समस्या के बारे में आपका क्या सुझाव है?
बिलाल बेगुएरजज

@ और हां, अपने काम के लिए हाँ। मैं सिर्फ यह नोट करना चाहता हूं कि आप फोन क्यों करते हैं store.dispatch? यदि आप store.mutations` के store.stateलिए परिवर्तन को संभालना चाहते हैं store' why not handle it inside ?
Januartha

@BillalBEGUERADJ I प्रीवर डब सॉल्यूशन अधिक क्लीनर है
Januartha

@ जानुर्था, क्योंकि म्यूटेशन करने से पहले एक अजाक्स कॉल हो सकता है, इसीलिए मैं store.dispatchपहले इस्तेमाल करता हूं । उदाहरण के लिए, मैं चाहता हूं कि जब भी कोई देश $store.state.countryबदलता है, तो मैं सभी शहरों को वहां से हटाऊं। तब मैं एक अजाक्स कॉल store.dispatch('fetchCities')लिखूंगा: i में लिखूंगा:axios.get('cities',{params:{country: state.country }}).then(response => store.commit('receiveCities',response) )
एंडी

2

आप Vuex के संयोजन का उपयोग कर सकते हैं कार्यों , टिककर खेल , गणना गुण और पर नजर रखने वालों के लिए एक Vuex राज्य मूल्य पर परिवर्तन को सुनने के लिए।

HTML कोड:

<div id="app" :style='style'>
  <input v-model='computedColor' type="text" placeholder='Background Color'>
</div>

जावास्क्रिप्ट कोड:

'use strict'

Vue.use(Vuex)

const { mapGetters, mapActions, Store } = Vuex

new Vue({
    el: '#app',
  store: new Store({
    state: {
      color: 'red'
    },
    getters: {
      color({color}) {
        return color
      }
    },
    mutations: {
      setColor(state, payload) {
        state.color = payload
      }
    },
    actions: {
      setColor({commit}, payload) {
        commit('setColor', payload)
      }
    }
  }),
  methods: {
    ...mapGetters([
        'color'
    ]),
    ...mapActions([
        'setColor'
    ])
  },
  computed: {
    computedColor: {
        set(value) {
        this.setColor(value)
      },
      get() {
        return this.color()
      }
    },
    style() {
        return `background-color: ${this.computedColor};`
    }
  },
  watch: {
    computedColor() {
        console.log(`Watcher in use @${new Date().getTime()}`)
    }
  }
})

JSFiddle डेमो देखें


1

आप स्टोर म्यूटेशन की सदस्यता भी ले सकते हैं:

store.subscribe((mutation, state) => {
  console.log(mutation.type)
  console.log(mutation.payload)
})

https://vuex.vuejs.org/api/#subscribe


आप इसे अपने घटक के पहले () हुक में आग लगा सकते हैं और उसके बाद आने वाले म्यूटेशन को एक स्टेटमेंट के साथ फ़िल्टर कर सकते हैं। जैसे अगर (उत्परिवर्तन। टाइप == "नाम / SET_NAMES") {... कुछ करें}
एलेजांद्रो

1

घटक के अंदर, एक कम्प्यूटेड फ़ंक्शन बनाएं

computed:{
  myState:function(){
    return this.$store.state.my_state; // return the state value in `my_state`
  }
}

अब गणना किए गए फ़ंक्शन नाम को देखा जा सकता है, जैसे

watch:{
  myState:function(newVal,oldVal){
    // this function will trigger when ever the value of `my_state` changes
  }
}

vuexराज्य में किए गए परिवर्तन my_stateपरिकलित फ़ंक्शन में प्रतिबिंबित होंगे myStateऔर वॉच फ़ंक्शन को ट्रिगर करेंगे।

यदि राज्य my_stateमें नेस्टेड डेटा है, तो handlerविकल्प अधिक मदद करेगा

watch:{
  myState:{
    handler:function(newVal,oldVal){
      // this function will trigger when ever the value of `my_state` changes
    },
    deep:true
  }
}

यह स्टोर में सभी नेस्टेड मानों को देखेगा my_state


0

आप दुकान से राज्य प्राप्त करने के लिए अपने पुए घटक में मैपस्टेट का उपयोग कर सकते हैं।

आपके घटक में:

computed: mapState([
  'my_state'
])

my_stateस्टोर से एक चर कहां है।


0

====== store =====
import Vue from 'vue'
import Vuex from 'vuex'
import axios from 'axios'

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
    showRegisterLoginPage: true,
    user: null,
    allitem: null,
    productShow: null,
    userCart: null
  },
  mutations: {
    SET_USERS(state, payload) {
      state.user = payload
    },
    HIDE_LOGIN(state) {
      state.showRegisterLoginPage = false
    },
    SHOW_LOGIN(state) {
      state.showRegisterLoginPage = true
    },
    SET_ALLITEM(state, payload) {
      state.allitem = payload
    },
    SET_PRODUCTSHOW(state, payload) {
      state.productShow = payload
    },
    SET_USERCART(state, payload) {
      state.userCart = payload
    }
  },
  actions: {
    getUserLogin({ commit }) {
      axios({
        method: 'get',
        url: 'http://localhost:3000/users',
        headers: {
          token: localStorage.getItem('token')
        }
      })
        .then(({ data }) => {
          // console.log(data)
          commit('SET_USERS', data)
        })
        .catch(err => {
          console.log(err)
        })
    },
    addItem({ dispatch }, payload) {
      let formData = new FormData()
      formData.append('name', payload.name)
      formData.append('file', payload.file)
      formData.append('category', payload.category)
      formData.append('price', payload.price)
      formData.append('stock', payload.stock)
      formData.append('description', payload.description)
      axios({
        method: 'post',
        url: 'http://localhost:3000/products',
        data: formData,
        headers: {
          token: localStorage.getItem('token')
        }
      })
        .then(({ data }) => {
          // console.log('data hasbeen created ', data)
          dispatch('getAllItem')
        })
        .catch(err => {
          console.log(err)
        })
    },
    getAllItem({ commit }) {
      axios({
        method: 'get',
        url: 'http://localhost:3000/products'
      })
        .then(({ data }) => {
          // console.log(data)
          commit('SET_ALLITEM', data)
        })
        .catch(err => {
          console.log(err)
        })
    },
    addUserCart({ dispatch }, { payload, productId }) {
      let newCart = {
        count: payload
      }
      // console.log('ini dari store nya', productId)

      axios({
        method: 'post',
        url: `http://localhost:3000/transactions/${productId}`,
        data: newCart,
        headers: {
          token: localStorage.getItem('token')
        }
      })
        .then(({ data }) => {
          dispatch('getUserCart')
          // console.log('cart hasbeen added ', data)
        })
        .catch(err => {
          console.log(err)
        })
    },
    getUserCart({ commit }) {
      axios({
        method: 'get',
        url: 'http://localhost:3000/transactions/user',
        headers: {
          token: localStorage.getItem('token')
        }
      })
        .then(({ data }) => {
          // console.log(data)
          commit('SET_USERCART', data)
        })
        .catch(err => {
          console.log(err)
        })
    },
    cartCheckout({ commit, dispatch }, transactionId) {
      let count = null
      axios({
        method: 'post',
        url: `http://localhost:3000/transactions/checkout/${transactionId}`,
        headers: {
          token: localStorage.getItem('token')
        },
        data: {
          sesuatu: 'sesuatu'
        }
      })
        .then(({ data }) => {
          count = data.count
          console.log(count, data)

          dispatch('getUserCart')
        })
        .catch(err => {
          console.log(err)
        })
    },
    deleteTransactions({ dispatch }, transactionId) {
      axios({
        method: 'delete',
        url: `http://localhost:3000/transactions/${transactionId}`,
        headers: {
          token: localStorage.getItem('token')
        }
      })
        .then(({ data }) => {
          console.log('success delete')

          dispatch('getUserCart')
        })
        .catch(err => {
          console.log(err)
        })
    }
  },
  modules: {}
})


1
साइट पर आपका स्वागत है। केवल एक कोड स्निपेट डालना पर्याप्त नहीं है। कृपया अपने कोड के बारे में कुछ स्पष्टीकरण प्रदान करें।
PGK

0

मैंने इस तरह से इस्तेमाल किया और यह काम करता है:

store.js:

const state = {
  createSuccess: false
};

mutations.js

[mutations.CREATE_SUCCESS](state, payload) {
    state.createSuccess = payload;
}

actions.js

async [mutations.STORE]({ commit }, payload) {
  try {
    let result = await axios.post('/api/admin/users', payload);
    commit(mutations.CREATE_SUCCESS, user);
  } catch (err) {
    console.log(err);
  }
}

getters.js

isSuccess: state => {
    return state.createSuccess
}

और आपके घटक में जहां आप स्टोर से राज्य का उपयोग करते हैं:

watch: {
    isSuccess(value) {
      if (value) {
        this.$notify({
          title: "Success",
          message: "Create user success",
          type: "success"
        });
      }
    }
  }

जब उपयोगकर्ता फ़ॉर्म सबमिट करता है, तो कार्रवाई STORE को कॉल किया जाएगा, बनाई गई सफलता के बाद, CREATE_SUCCESS म्यूटेशन उसके बाद प्रतिबद्ध है। मुड़ें createSuccess सच है, और घटक में, द्रष्टा मूल्य बदल गया है और ट्रिगर अधिसूचना दिखाई देगी।

isSuccess को आपके द्वारा getters.js में घोषित नाम के साथ मेल खाना चाहिए

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.