<p>This article introduces an experimental Vue feature called Hooks.</p>

<h2>Before you start</h2>

<p>This post is suited for developers of all stages including beginners. Here are a few things you should already have before going through this article.</p>

<p>You will need the following in your pc:</p>

<ul>
<li><a href="https://nodejs.org/en/" target="_blank" rel="noreferrer noopener">Node.js version 10.x</a>&nbsp;and above installed. You can verify if you do by running the command below in your terminal/command prompt:</li>
</ul>

<pre class="wp-block-preformatted">node -v</pre>

<ul>
<li>A code editor: Visual Studio Code is highly recommended</li>
<li><a href="https://vuejs.org/" target="_blank" rel="noreferrer noopener">Vue&rsquo;s latest version</a>, installed globally on your machine</li>
<li><a href="https://vuejs.org/" target="_blank" rel="noreferrer noopener">Vue CLI 3.0</a>&nbsp;installed on your machine. To do this, uninstall the old CLI version first:</li>
</ul>

<pre class="wp-block-preformatted">npm uninstall -g vue-cli</pre>

<p>then install the new one:</p>

<pre class="wp-block-preformatted">npm install -g @vue/cli</pre>

<ul>
<li>Download a Vue starter project&nbsp;<a href="https://github.com/viclotana/vue-canvas" target="_blank" rel="noreferrer noopener">here</a></li>
<li>Unzip the downloaded project</li>
<li>Navigate into the unzipped file and run the command to keep all the dependencies up-to-date:</li>
</ul>

<pre class="wp-block-preformatted">npm install</pre>

<h2>Introduction: Hooks</h2>

<p>Initially, React components that contain state logic must be a class component. Even though there were already stateless functional components in React there was a need to create components that accommodate state logic without being classes. That was when Hooks was born. Hooks are a way to use state logic inside functional components, thereby eliminating the need for writing classes.</p>

<h2>What is wrong with classes?</h2>

<p>There is nothing wrong with classes, to begin with, but the React team found out that&nbsp;<a href="https://reactjs.org/docs/hooks-intro.html#classes-confuse-both-people-and-machines" target="_blank" rel="noreferrer noopener">understanding how classes work has been a drawback to React adoption</a>. It can be difficult to understand and can become ambiguous as your project increases in size and complexity.</p>

<h3>But I don&rsquo;t normally use classes in Vue JS..</h3>

<p>If you are a Vue developer, you might wonder why classes are being discussed as you do not use classes by default in your Vue projects. While this is true, Vue JS lets you use functional components that are stateless with&nbsp;<a href="https://vuejs.org/v2/guide/mixins.html" target="_blank" rel="noreferrer noopener">mixins</a>. With Vue mixins you can define logic or a functionality in a particular file and use and even re-use it in a functional component.</p>

<h2>The problem with mixins</h2>

<p>In a&nbsp;<a href="https://css-tricks.com/what-hooks-mean-for-vue/" target="_blank" rel="noreferrer noopener">blog post</a>, some months back,&nbsp;<a href="https://twitter.com/sarah_edo?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor" target="_blank" rel="noreferrer noopener">Sarah Drasner</a>&nbsp;a very popular Vue core team member wrote about her conversation with&nbsp;<a href="https://twitter.com/youyuxi?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor" target="_blank" rel="noreferrer noopener">Evan You</a>&nbsp;the creator of Vue JS. Sarah revealed that a mixin cannot consume or use state from another mixin, which makes chaining of encapsulated logic difficult to achieve. This is the mixin limitation that the Vue Hooks solves for.</p>

<h2>Introducing Vue Hooks</h2>

<p>Vue Hooks are basically an enhanced version of mixins, if you do not know what mixins are, they are a platform in Vue used to re-use logic between components (you will see a quick demo of mixins in this post). Vue Hooks lets you pass logic from one Hook to another and you can also use state in a Hook from another Hook. So just like in React, Hooks in Vue are defined in functions which can be a cleaner and more flexible way to define and share logic and can return state.</p>

<h2>Demo A: Vue mixins</h2>

<p>If you have followed this post from the start, you must have downloaded&nbsp;<a href="https://github.com/viclotana/vue-canvas" target="_blank" rel="noreferrer noopener">the starter project file</a>&nbsp;and opened it up in your VS Code application. We are going to create a mixin that contains a counter logic and then import it into any component of choice. First, create a folder called mixins in the root directory and create a new file, call it&nbsp;<code>clickMixin.js</code>&nbsp;and copy the code block below inside it:</p>

<pre class="wp-block-preformatted">export default { 
    data (){
      return{
        count: 1,
        double: 2
      }
    },
    methods: {
      clicked(){
       this.count++; 
       this.double = this.count*2;
      }
    }
  }</pre>

<p>This mixin contains counter logic and also contains a variable that returns double the count, you see the export statement because it has to be imported into your component of choice. Open your&nbsp;<code>Test.vue</code>&nbsp;component and copy the code block below inside it:</p>

<pre class="wp-block-preformatted">&lt;template&gt;
  &lt;div&gt; 
    &lt;button v-on:click="clicked()"&gt;Button 1&lt;/button&gt;
    &lt;h2&gt;{{this.count}}&lt;/h2&gt;
    &lt;h2&gt;{{this.double}}&lt;/h2&gt;
  &lt;/div&gt;
&lt;/template&gt;
&lt;script&gt;
import clickMixin from '../Mixins/clickMixin'
export default {
  name: 'Test',
  mixins: [clickMixin]
}
&lt;/script&gt;</pre>

<p>Here you see how mixins are imported and registered under the name, it is a Vue instance property just like data or methods or computed properties. You also see that inside the template that you have access to this in JavaScript as it relates to the mixins (almost like the mixin was defined right inside the component). If you run the application in your dev server it should look like this:</p>

<div class="wp-block-image">
<figure class="aligncenter"><img class="wp-image-453" src="http://ec2-13-127-91-65.ap-south-1.compute.amazonaws.com/wp-content/uploads/2019/09/vuebutton1and2-1024x394.png" alt=""></figure>
</div>

<p>When you click button 1, the counter is increased by 1 and the lower figure is double the counter figure just as the template in your code suggests.</p>

<h2>Demo B: Vue Hooks</h2>

<p>You can recreate this logic with Vue Hooks easily, the point of the Hooks is to potentially replace mixins in the future. First of all, you have to install the vue-Hooks package with the node package manager. Open a new terminal in VS Code and run:</p>

<pre class="wp-block-preformatted">npm install vue-Hooks</pre>

<p>Then open up your&nbsp;<code>main.js</code>&nbsp;file and initialize Hooks with a line of command before the new Vue statement:</p>

<pre class="wp-block-preformatted">Vue.use(Hooks);</pre>

<p>Open the components folder and create a new file inside it, call it&nbsp;<code>Modal.vue</code>&nbsp;then navigate back to the root directory and create a new folder called Hooks. Inside the Hooks folder create a new file called&nbsp;<code>Hooks.js</code>&nbsp;and copy this code block below into it:</p>

<pre class="wp-block-preformatted">import { useData, useMounted, useEffect, useComputed, useUpdated} from 'vue-Hooks'
export default function clickedHook(){
const data = useData({ count:1 })
const double = useComputed(() =&gt; data.count * 2)
useMounted(()=&gt; {console.log('mounted')});
useUpdated(()=&gt; {console.log('updated')});
useEffect(()=&gt; {
     console.log('DOM re-renders....')
 });
return {
     data, double
   }
}</pre>

<p>Just like in React, Vue Hooks borrows the use-prefix syntax and uses it in the Vue way. You also notice that the lifecycle Hooks available for every Vue instance is accessible inside Vue Hooks, some of them are:</p>

<ul>
<li><code>useData</code>: handles initialization of data inside your Hook, so the count is initialized inside it</li>
<li><code>useComputed</code>: this is more like computed properties inside your Hook, so the double computation is done inside it</li>
<li><code>useMounted</code>: acts exactly like the mounted lifecycle Hook in your Vue instance but for Hooks</li>
<li><code>useUpdated</code>: acts exactly like the updated lifecycle Hook in your Vue instance but for Hooks</li>
<li><code>useEffect</code>: this handles logic on DOM re-render</li>
</ul>

<p>There are other properties you can import, the whole list can be found&nbsp;<a href="https://github.com/yyx990803/vue-hooks" target="_blank" rel="noreferrer noopener" aria-label=" (opens in a new tab)">here</a>&nbsp;on GitHub. You will notice it is exported as a function, open the&nbsp;<code>modal.vue</code>&nbsp;file you created earlier and copy this code block below inside it:</p>

<pre class="wp-block-preformatted">&lt;template&gt;
  &lt;div&gt; 
    &lt;button v-on:click="data.count++"&gt;Button 2&lt;/button&gt;
    &lt;h2&gt;{{data.count}}&lt;/h2&gt;
    &lt;h2&gt;{{double}}&lt;/h2&gt;
  &lt;/div&gt;
&lt;/template&gt;
&lt;script&gt;
import clickedHook from '../Hooks/Hooks'
export default {
  name: 'Modal',
  Hooks(){
    return clickedHook();
  }
}
&lt;/script&gt;</pre>

<p>Notice that after importing the Hooks file, you can access the data and the double constants earlier defined in the Hook inside this component. We also see that Hooks registration has the same syntax with data registration, with the function set up and the return object inside it.</p>

<h3><br>It is important to note that&hellip;</h3>

<ul>
<li>You can go ahead and use Vue Hooks right away (your Vue version must be 2.x)</li>
<li>There is&nbsp;<a href="https://css-tricks.com/what-hooks-mean-for-vue/#article-header-id-5" target="_blank" rel="noreferrer noopener">speculation that Vue version 3.0 will ship with Vue</a>&nbsp;Hooks officially</li>
<li>It is experimental and so should not be used in production yet</li>
<li><a href="https://css-tricks.com/what-hooks-mean-for-vue/" target="_blank" rel="noreferrer noopener">Read the Sarah Drasner blog post here</a>&nbsp;which contains even more examples too</li>
</ul>

<p>You can use npm or just go to&nbsp;<a href="https://github.com/yyx990803/vue-hooks" target="_blank" rel="noreferrer noopener">GitHub with this link</a>&nbsp;to get the project repository.</p>

<h2>Conclusion</h2>

<p>This has been a quick overview of Hooks in Vue JS and how they might differ from the React Hooks that inspired it. We also highlighted mixins for readers who have not been introduced to the concept and we looked at an illustration using Hooks. Are you excited about Vue Hooks?</p>

This article introduces an experimental Vue feature called Hooks. This post is suited for developers of all stages includi...

Hooks are coming to Vue.js version 3.0 - TCMHACK

Hooks are coming to Vue.js version 3.0

<p>With the release of the&nbsp;<a href="https://github.com/vuejs/rfcs/blob/function-apis/active-rfcs/0000-function-api.md">VueJS 3 "Request for Comment" documentation</a>&nbsp;about two weeks ago, Evan You introduced the VueJS function-based API and has set the VueJS community ablaze. These new ideas are still in the "Request for Comments" stage, so they're far from set in stone, but because the RFC introduces such significant changes, I made a quick summary of what you need to know.</p>



<p><strong>NB: All this information and much more is in the RFC, so I do suggest you read that.</strong></p>



<h2>Setup</h2>



<p>VueJS 3 departs from the option-based API we've grown to love and introduces the&nbsp;<code>setup()</code>&nbsp;function, which will be where all the magic happens. This function single-handedly sets up the the logic for our component and returns data that's exposed to the template. The option-based API will continue to work even in VueJS 3, but this new function-based API will be the new standard.</p>



<p>For all the functionality we're used to from VueJS like reactive data, computed values, methods and watchers, we&nbsp;<code>import</code>&nbsp;functions from&nbsp;<code>vue</code>&nbsp;and use them in our&nbsp;<code>setup()</code>&nbsp;function. Here's a basic example from the RFC:</p>



<pre class="wp-block-code"><code>&lt;template>
  &lt;div>
    &lt;span>count is {{ count }}&lt;/span>
    &lt;span>plusOne is {{ plusOne }}&lt;/span>
    &lt;button @click="increment">count++&lt;/button>
  &lt;/div>
&lt;/template>

&lt;script>
import { value, computed, watch, onMounted } from 'vue'

export default {
  setup() {
    // reactive state
    const count = value(0)
    // computed state
    const plusOne = computed(() => count.value + 1)
    // method
    const increment = () => { count.value++ }
    // watch
    watch(() => count.value * 2, val => {
      console.log(`count * 2 is NULL`)
    })
    // lifecycle
    onMounted(() => {
      console.log(`mounted`)
    })
    // expose bindings on render context
    return {
      count,
      plusOne,
      increment
    }
  }
}
&lt;/script></code></pre>



<h2>But why?</h2>



<p>If that example doesn't make it clear why this change was introduced, or if it feels like a step back in terms of usability, I understand. I had the same initial reaction and it took me a bit of time to figure out why this change was necessary. The v2.x API is widely loved and is often the reason why people move to VueJS from other frameworks like ReactJS or AngularJS, so a change this drastic seems like a strange idea.</p>



<h3>Encapsulation is king</h3>



<p>The component API was created in part to make it easier to reuse code across your application. While VueJS is seriously modular and uses components, the current option-based API doesn't allow for an easy extraction of functionality that relates to a single piece of functionality or data. You need to define your data(/state), computed values and methods separately, while they might all be related. This gets confusing when components grow and methods deal with different pieces of data.</p>



<p>This is where the new function-based API comes in. It allows you to extract all code related to a piece of logic and put it together in what they call a "composition function", which returns reactive state. An example given in the RFC uses one of those composition functions to&nbsp;<a href="https://github.com/vuejs/rfcs/blob/function-apis/active-rfcs/0000-function-api.md#logic-composition">extract the logic of listening to the mouse position</a>:</p>



<pre class="wp-block-code"><code>function useMouse() {
  const x = value(0)
  const y = value(0)
  const update = e => {
    x.value = e.pageX
    y.value = e.pageY
  }
  onMounted(() => {
    window.addEventListener('mousemove', update)
  })
  onUnmounted(() => {
    window.removeEventListener('mousemove', update)
  })
  return { x, y }
}

// in consuming component
const Component = {
  setup() {
    const { x, y } = useMouse()
    return { x, y }
  },
  template: `&lt;div>{{ x }} {{ y }}&lt;/div>`
}</code></pre>



<p>If we compare this to how we would write this functionality in the v2.x API, we can see that the functionality related to using the mouse position is all over the place, where in the v3.x API, it's quite nicely grouped in a singular function:</p>



<pre class="wp-block-code"><code>&lt;template>
    &lt;div>
        {{ x }} {{ y }}
    &lt;/div>
&lt;/template>

&lt;script>
export default {
  data() {
    return {
      x: 0,
      y: 0,
    };
  },
  mounted() {
    window.addEventListener('mousemove', this.update);
  },
  beforeDestroy() {
    window.removeEventListener('mousemove', this.update);
  },
  methods: {
    update(e) {
      this.x = e.pageX;
      this.y = e.pageY;
    },
  },
};
&lt;/script></code></pre>



<h3>And more</h3>



<p>Encapsulation isn't the only reason why these changes are useful, so here are two other reasons why this change might be what VueJS needs.</p>



<p>The current option-based API in VueJS has an issue in that it doesn't properly support TypeScript type inference. The proposed changes fix this issue, and achieve full typing support, with TS code looking almost the same as JS code as a cherry on top of an already very useful pie.</p>



<p>VueJS is loved for its extremely small bundle size and this change shrinks that bundle even more. Since function and variable names can be shortened with standard minification (while object/class methods and properties can't), the code simply compresses better.</p>

With the release of the&nbsp;VueJS 3 "Request for Comment" documentation&nbsp;about two weeks ago, Evan You introduced the VueJS function-based A...

Hooks are coming to Vue.js version 3.0

VueJS is dead, long live VueJS!