Question

我的Vue.js应用程序的Vuex存储正在增长，并且其中的许多常量变得有些混乱。我想将这些常量拆分为单独的文件，然后将其导入我的Vuex存储store.js中。我是JavaScript的新手，所以我想知道：

如何将这些常量存储在单独的文件中？这些文件的语法是什么？
如何在store.js中导入这些常量？这样做的确切语法是什么？

这是我的store.js

的当前内容

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

Vue.use(Vuex);

export const store = new Vuex.Store({
    state: {
        graphqlUrl: 'https://localhost/listof/api/v1/graphql',
        errorObject: {
            flag: false,
            message: ''
        },

        // Data types queries
        queryGetAllDataTypes: `query getAllDataTypes {
            allSysDataTypes(orderBy: NAME_ASC) {
                nodes {
                    id
                    name
                }
            }
        }`,

        // Data for linked list & attributes drodpdown in attribute form
        // Response labels must be formatted according to Treeselect requirements
        queryGetLinkedLists: `query getAllLists {
            allSysLists(orderBy: NAME_ASC) {
                nodes {
                    id:nodeId
                    label:name
                    attributes:sysAttributesByListId {
                        children:nodes {
                            id
                            label:name
                        }
                    }
                }
            }
        }`,

        // Data for linked list & attributes drodpdown in value form
        // Response labels must be formatted according to Treeselect requirements
        queryGetLinkedListValues: `query getAllValues {
            all<GraphQlListName> {
                nodes {
                    id
                    label:<graphQlAttributeName>
                }
            }
        }`,

        // Lists queries and mutations
        queryGetAllLists: `query getAllLists{
            allSysLists(orderBy: NAME_ASC) {
                nodes {
                    id
                    name
                    description
                }
            }
        }`,

        queryGetList: `query getList($id: Int!) {
            sysListById(id: $id) {
                id
                name
                description
                tableName
                sysAttributesByListId {
                    nodes {
                        id
                        name
                        description
                        flagMandatory
                        flagUnique
                        dataTypeId
                        sysDataTypeByDataTypeId { name }
                        linkedAttributeId
                        sysAttributeByLinkedAttributeId {
                            name
                            columnName
                            listId
                            sysListByListId {
                                name
                                tableName
                            }
                        }
                        columnName
                    }
                }
            }
        }`,

        mutationCreateList: `mutation createList($sysList: SysListInput!) {
            createSysList(input: {sysList: $sysList}) {
                sysList {
                    id
                }
            }
        }`,

        mutationUpdateList: `mutation updateList($id: Int!, $sysListPatch: SysListPatch!) {
            updateSysListById(input: {id: $id, sysListPatch: $sysListPatch }) {
                sysList {
                    id
                }
            }
        }`,

        mutationDeleteList: `mutation deleteList($id: Int!) {
            deleteSysListById(input: {id: $id}){
                sysList {
                    id
                }
            }
        }`,

        // Attributes queries and mutations
        queryGetAttribute: `query getAttribute($id: Int!) {
            sysAttributeById(id: $id) {
                id
                name
                description
                flagMandatory
                flagUnique
                dataTypeId
                sysDataTypeByDataTypeId { name }
                linkedAttributeId
                sysAttributeByLinkedAttributeId {
                    name
                    listId
                    sysListByListId { name }
                }
                defaultValue
            }
        }`,

        mutationCreateAttribute: `mutation createAttribute($sysAttribute: SysAttributeInput!) {
            createSysAttribute(input: {sysAttribute: $sysAttribute}) {
                sysAttribute {
                    id
                }
            }
        }`,

        mutationUpdateAttribute: `mutation updateAttribute($id: Int!, $sysAttributePatch: SysAttributePatch!) {
            updateSysAttributeById(input: {id: $id, sysAttributePatch: $sysAttributePatch }) {
                sysAttribute {
                    id
                }
            }
        }`,

        mutationDeleteAttribute: `mutation deleteAttribute($id: Int!) {
            deleteSysAttributeById(input: {id: $id}){
                sysAttribute {
                    id
                }
            }
        }`,

        // Generic query used as template to fetch all values from a list
        queryGetAllValues: `query getAllValues {
            all<GraphQlListName> {
                nodes {
                    id
                    createdDate
                    updatedDate
                    <graphQlAttributeName>
                }
            }
        }`,

        // Generic query used as template to fetch one value from a list
        queryGetValue: `query getValue($id: Int!) {
            <graphQlListName>ById(id: $id) {
                id
                createdDate
                updatedDate
                <graphQlAttributeName>
            }
        }`,

        // Generic mutation used as template to create a new value in a list
        mutationCreateValue: `mutation createValue($<graphQlListName>: <GraphQlListName>Input!) {
            create<GraphQlListName>(input: {<graphQlListName>: $<graphQlListName>}) {
                <graphQlListName> {
                    id
                }
            }
        }`,

        // Generic mutation used as template to update a value in a list
        mutationUpdateValue: `mutation updateValue($id: Int!, $<graphQlListName>Patch: <GraphQlListName>Patch!) {
            update<GraphQlListName>ById(input: {id: $id, <graphQlListName>Patch: $<graphQlListName>Patch }) {
                <graphQlListName> {
                    id
                }
            }
        }`,

        // Generic mutation used as template to delete a value in a list
        mutationDeleteValue: `mutation deleteValue($id: Int!) {
            delete<GraphQlListName>ById(input: {id: $id}){
                <graphQlListName> {
                    id
                }
            }
        }`,
    }
});

Answer 1

最简单的选择是为常量（constants.js）创建一个新文件，然后在其中定义和导出它们，例如：

export const cat = 'black'
export const dog = 'brown'
export const mouse = 'grey'

然后将它们全部导入store.js中的当前名称空间：

import * as constants from './constants'

或在需要时有选择地导入它们：

import { cat, dog } from './constants'

Answer 2

VueX存储在默认情况下是不可变的，只能通过变异进行变异。 Vuex为此创建了模块。我只需创建一个模块，然后将所有常量放入其中就可以了。

从 vux 文档中： https://vuex.vuejs.org/guide/modules.html下方：

const moduleA = {
  state: { ... },
  mutations: { ... },
  actions: { ... },
  getters: { ... }
}

const moduleB = {
  state: { ... },
  mutations: { ... },
  actions: { ... }
}

const store = new Vuex.Store({
  modules: {
    a: moduleA,
    b: moduleB
  }
})

store.state.a // -> `moduleA`'s state
store.state.b // -> `moduleB`'s state

使用 nuxt.js ，您可以简单地将constants.js添加到store文件夹中：

export const state = () => ({
    example: {}
});

在Vuex商店中导入常量

2 个答案: