04 February, 2021

Vue.js Mixins

                No comments   

 

Vue.js Mixins

In Vue.js, mixins are a set of defined logic, stored in a predefined way specified by Vue.js. We can use these mixins over and over to add functionality to our Vue.js instances and components. So, we can say that mixins are used to distribute reusable functionalities for Vue components. They provide a flexible and straightforward way to deal with Vue.js components and share reusable code among them.

A mixin object can contain any component options. When a component uses a mixin, all options within the mixin are "mixed" into the component's own options and become an integral part of the component options.

Why are Mixins important?

Following is a list of some features that make Vue.js mixins necessary:

  • js mixins ensure that you do not need to repeat yourself. You can efficiently distribute reusable functionalities for Vue.js components and use them again and again.
  • js mixins provide an excellent option for flexibility. A mixin object contains Vue components options, which means it is a mix of both mixin and component options of Vue.js.
  • js mixins provide a great safety feature. They do not affect changes outside their defined scope if you have written them well.
  • js mixins are an excellent platform for code reusability.

The problem Vue.js mixins were supposed to solve

The main reason to use Vue.js is to resolve the re-use problem in the program. Suppose, you have two components that contain a method that does exactly the same thing or performs the same functionality in the two components same as the following code:

Component 1:

  1. <template>  
  2.   <div>  
  3.     <button v-on:click="clicked('you just clicked on button  1')">  
  4.       Button 1  
  5.     </button>  
  6.   </div>  
  7. </template>;  
  8. export default {  
  9.   name: "Test",  
  10.   methods: {  
  11.     clicked(value) {  
  12.       alert(value);  
  13.     }  
  14.   }  
  15. };  

Component 2:

  1. <template>  
  2.   <div>  
  3.     <button v-on:click="clicked('you just clicked on button  2')">  
  4.       Button 2  
  5.     </button>  
  6.   </div>  
  7. </template>;  
  8. export default {  
  9.   name: "Modal",  
  10.   methods: {  
  11.     clicked(value) {  
  12.       alert(value);  
  13.     }  
  14.   }  
  15. };  

After using the both components, your App.vue file should have the both components imported and declared same as following:

  1. <template>  
  2.   <div id="app">  
  3.     <img alt="Vue logo" src="./assets/logo.png">  
  4.     <Test />  
  5.     <modal />  
  6.   </div>  
  7. </template>;  
  8. <script>  
  9. import Test from "./components/Test.vue";  
  10. import Modal from "./components/Modal.vue";  
  11. export default {  
  12.   name: "app",  
  13.   components: {  
  14.     Test,  
  15.     Modal  
  16.   }  
  17. };  
  18. </script>  

Here, you can see that we have repeated the click method code block in both components. This is not an ideal and efficient way to handle memory resources; that's why Vue.js Mixin was introduced.

Vue.js has introduced the mixins as an excellent solution to this problem. By using mixins, you can encapsulate a piece of code or functionality and then import it to use when you need it in various components.

Vue.js Mixin Syntax

The Vue.js mixin syntax would look like the following code:

  1. // define a mixin object  
  2. var myMixin = {  
  3.   created: function() {  
  4.     this.hello();  
  5.   },  
  6.   methods: {  
  7.     hello: function() {  
  8.       console.log("hello from mixin!");  
  9.     }  
  10.   }  
  11. };  
  12. // define a component that uses this mixin  
  13. var Component = Vue.extend({  
  14.   mixins: [myMixin]  
  15. });  
  16. var component = new Component(); // => "hello from mixin!"  

Let's take a simple example to understand the concept of Vue.js Mixin well.

Index.html file:

  1. <html>  
  2.    <head>  
  3.       <title>Vue.js </title>  
  4.       <link rel="stylesheet" href="index.css">  
  5.         <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>  
  6. <script src="https://unpkg.com/vue/dist/vue.js"></script>  
  7.     </head>  
  8.     <body>  
  9.       <div id = "mixin_1"></div>  
  10.       <script type = "text/javascript">  
  11.          var vm = new Vue({  
  12.             el: '#mixin_1',  
  13.             data: {  
  14.             },  
  15.             methods : {  
  16.             },  
  17.          });  
  18.          var myMixin = {  
  19.             created: function () {  
  20.                this.startmixin()  
  21.             },  
  22.             methods: {  
  23.                startmixin: function () {  
  24.                   alert("This is a Vue.js Mixin example!!");  
  25.                }  
  26.             }  
  27.          };  
  28.       </script>  
  29.       <script src="index.js"></script>  
  30.    </body>  
  31. </html>  

Index.js file:

  1. var Component = Vue.extend({  
  2.             mixins: [myMixin]  
  3.          })  
  4.          var component = new Component()  

Let's use a simple CSS file to make the output more attractive.

Index.css file:

  1. html, body {  
  2.     margin: 5px;  
  3.     padding: 0;  
  4. }  

After the execution of the program, you will see the following output:

Output:


Source by : javatpoint.com

0 comments:

Post a Comment

Thanks

Meta

Popular Posts

Categories

Social Media Links

Blog Archive

Laravel News

Loading...