对 Vuejs 应用全局变量

You can use a Global Mixin to affect every Vue instance. You can add data to this mixin, making a value/values available to all vue components.

To make that value Read Only, you can use the method described in this Stack Overflow answer.

Here is an example:

// This is a global mixin, it is applied to every vue instance.
// Mixins must be instantiated *before* your call to new Vue(...)
Vue.mixin({
data: function() {
return {
get globalReadOnlyProperty() {
return "Can't change me!";
}
}
}
})


Vue.component('child', {
template: "<div>In Child: \{\{globalReadOnlyProperty}}</div>"
});


new Vue({
el: '#app',
created: function() {
this.globalReadOnlyProperty = "This won't change it";
}
});

<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.1.3/vue.js"></script>
<div id="app">
In Root: \{\{globalReadOnlyProperty}}
<child></child>
</div>

Just Adding Instance Properties

For example, all components can access a global appName, you just write one line code:

Vue.prototype.$appName = 'My App'

or in vue3 app.config.globalProperties.$http = axios.create({ /* ... */ })

$ isn't magic, it's a convention Vue uses for properties that are available to all instances.

Alternatively, you can write a plugin that includes all global methods or properties.

You can use mixin and change var in something like this.

// This is a global mixin, it is applied to every vue instance
Vue.mixin({
data: function() {
return {
globalVar:'global'
}
}
})


Vue.component('child', {
template: "<div>In Child: \{\{globalVar}}</div>"
});


new Vue({
el: '#app',
created: function() {
this.globalVar = "It's will change global var";
}
});

<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.1.3/vue.js"></script>
<div id="app">
In Root: \{\{globalVar}}
<child></child>
</div>

If the global variable should not be written to by anything, including Vuejs, you can use Object.freeze to freeze your object. Adding it to Vue's viewmodel won't unfreeze it. Another option is to provide Vuejs with a frozen copy of the object, if the object is intended to be written globally but just not by Vue: var frozenCopy = Object.freeze(Object.assign({}, globalObject))

you can use Vuex to handle all your global data

A possibility is to declare the variable at the index.html because it is really global. It can be done adding a javascript method to return the value of the variable, and it will be READ ONLY. I did like that:

Supposing that I have 2 global variables (var1 and var2). Just add to the index.html header this code:

  <script>
function getVar1() {
return 123;
}
function getVar2() {
return 456;
}
function getGlobal(varName) {
switch (varName) {
case 'var1': return 123;
case 'var2': return 456;
// ...
default: return 'unknown'
}
}
</script>

It's possible to do a method for each variable or use one single method with a parameter.

This solution works between different vuejs mixins, it a really global value.

In VueJS 3 with createApp() you can use app.config.globalProperties

Like this:

const app = createApp(App);


app.config.globalProperties.foo = 'bar';


app.use(store).use(router).mount('#app');

and call your variable like this:

app.component('child-component', {
mounted() {
console.log(this.foo) // 'bar'
}
})

doc: https://v3.vuejs.org/api/application-config.html#warnhandler

If your data is reactive, you may want to use VueX.

In your main.js file, you have to import Vue like this :

import Vue from 'vue'

Then you have to declare your global variable in the main.js file like this :

Vue.prototype.$actionButton = 'Not Approved'

If you want to change the value of the global variable from another component, you can do it like this :

Vue.prototype.$actionButton = 'approved'

https://v2.vuejs.org/v2/cookbook/adding-instance-properties.html#Base-Example

in main.js (or any other js file)

export const variale ='someting' in app.vue (or any other component)

import {key} from '../main.js' (file location) define the key to a variable in data method and use it.

If you’d like to use a variable in many components, but you don’t want to pollute the global scope. In these cases, you can make them available to each Vue instance by defining them on the Vue prototype:

Vue.prototype.$yourVariable = 'Your Variable'

Please remember to add this line before creating your Vue instance in your project entry point, most of time it's main.js

Now $yourVariable is available on all Vue instances, even before creation. If we run:

new Vue({
beforeCreate: function() {
console.log(this.$yourVariable)
}
})

Then "Your Variable" will be logged to the console!

doc: https://v2.vuejs.org/v2/cookbook/adding-instance-properties.html#Base-Example

If you want to make this variable immutable, you can use the static method Object.defineProperty():

Object.defineProperty(Vue.prototype, '$yourVariable', {
get() {
return "Your immutable variable"
}
})

This method by default will prevent your variable from being removed or replaced from the Vue prototype

If you want to take it a step further, let's say your variable is an object, and you don't want any changes applied to your object, you can use Object.freeze():

Object.defineProperty(Vue.prototype, '$yourVariable', {
get() {
return Object.freeze(yourGlobalImmutableObject)
}
})

Simply define it in vite configuration

export default defineConfig({
root:'/var/www/html/a1.biz/admin',
define: {
appSubURL: JSON.stringify('/admin')
}, ..../// your other configurations
});

Now appSubURL will be accessible everywhere