|
| 1 | +--- |
| 2 | +title: Avoiding Memory Leaks |
| 3 | +type: cookbook |
| 4 | +order: 10 |
| 5 | +--- |
| 6 | +## Introduction |
| 7 | + |
| 8 | +If you are developing applications with Vue, then you need to watch out for memory leaks. This issue is especially important in Single Page Applications (SPAs) because by design, users should not have to refresh their browser when using an SPA, so it is up to the Javascript application to clean up components and make sure that garbage collection takes place as expected. |
| 9 | + |
| 10 | +Memory leaks in Vue applications do not typically come from Vue itself, rather they can happen when incorporating other libraries into an application. |
| 11 | + |
| 12 | +## Simple Example |
| 13 | + |
| 14 | +The following example shows a memory leak caused by using the [Choices.js](https://github.com/jshjohnson/Choices) library in a Vue component and not properly cleaning it up. Later, we will show how to remove the Choices.js footprint and avoid the memory leak. |
| 15 | + |
| 16 | +In the example below, we load up a select with a lot of options and then we use a show/hide button with a [v-if](/v2/guide/conditional.html) directive to add it and remove it from the virtual DOM. The problem with this example is that the `v-if` directive removes the parent element from the DOM, but we did not clean up the additional DOM pieces created by Choices.js, causing a memory leak. |
| 17 | + |
| 18 | +```html |
| 19 | +<link rel='stylesheet prefetch' href='https://joshuajohnson.co.uk/Choices/assets/styles/css/choices.min.css?version=3.0.3'> |
| 20 | +<script src='https://joshuajohnson.co.uk/Choices/assets/scripts/dist/choices.min.js?version=3.0.3'></script> |
| 21 | + |
| 22 | +<div id="app"> |
| 23 | + <button v-if="showChoices" @click="hide">Hide</button> |
| 24 | + <button v-if="!showChoices" @click="show">Show</button> |
| 25 | + <div v-if="showChoices"> |
| 26 | + <select id="choices-single-default"></select> |
| 27 | + </div> |
| 28 | +</div> |
| 29 | +``` |
| 30 | +```js |
| 31 | +new Vue({ |
| 32 | + el: "#app", |
| 33 | + data: function () { |
| 34 | + return { |
| 35 | + showChoices: true |
| 36 | + } |
| 37 | + }, |
| 38 | + mounted: function () { |
| 39 | + this.initializeChoices() |
| 40 | + }, |
| 41 | + methods: { |
| 42 | + initializeChoices: function () { |
| 43 | + let list = [] |
| 44 | + // lets load up our select with many choices |
| 45 | + // so it will use a lot of memory |
| 46 | + for (let i = 0; i < 1000; i++) { |
| 47 | + list.push({ |
| 48 | + label: "Item " + i, |
| 49 | + value: i |
| 50 | + }) |
| 51 | + } |
| 52 | + new Choices("#choices-single-default", { |
| 53 | + searchEnabled: true, |
| 54 | + removeItemButton: true, |
| 55 | + choices: list |
| 56 | + }) |
| 57 | + }, |
| 58 | + show: function () { |
| 59 | + this.showChoices = true |
| 60 | + this.$nextTick(() => { |
| 61 | + this.initializeChoices() |
| 62 | + }) |
| 63 | + }, |
| 64 | + hide: function () { |
| 65 | + this.showChoices = false |
| 66 | + } |
| 67 | + } |
| 68 | +}) |
| 69 | +``` |
| 70 | +To see this memory leak in action, open this [CodePen example](https://codepen.io/freeman-g/pen/qobpxo) using Chrome and then open the Chrome Task Manager. To open the Chrome Task Manager on Mac, choose Chrome Top Navigation > Window > Task Manager or on Windows, use the Shift+Esc shortcut. Now, click the show/hide button 50 or so times. You should see the memory usage in the Chrome Task Manager increase and never be reclaimed. |
| 71 | + |
| 72 | + |
| 73 | + |
| 74 | +## Resolving the Memory Leak |
| 75 | + |
| 76 | +In the above example, we can use our `hide()` method to do some clean up and solve the memory leak prior to removing the select from the DOM. To accomplish this, we will keep a property in our Vue instance’s data object and we will use the [Choices API’s](https://github.com/jshjohnson/Choices) `destroy()` method to perform the clean up. |
| 77 | + |
| 78 | +Check the memory usage again with this [updated CodePen example](https://codepen.io/freeman-g/pen/mxWMor). |
| 79 | + |
| 80 | +```js |
| 81 | +new Vue({ |
| 82 | + el: "#app", |
| 83 | + data: function () { |
| 84 | + return { |
| 85 | + showChoices: true, |
| 86 | + choicesSelect: null |
| 87 | + } |
| 88 | + }, |
| 89 | + mounted: function () { |
| 90 | + this.initializeChoices() |
| 91 | + }, |
| 92 | + methods: { |
| 93 | + initializeChoices: function () { |
| 94 | + let list = [] |
| 95 | + for (let i = 0; i < 1000; i++) { |
| 96 | + list.push({ |
| 97 | + label: "Item " + i, |
| 98 | + value: i |
| 99 | + }) |
| 100 | + } |
| 101 | + // Set a reference to our choicesSelect in our Vue instance's data object |
| 102 | + this.choicesSelect = new Choices("#choices-single-default", { |
| 103 | + searchEnabled: true, |
| 104 | + removeItemButton: true, |
| 105 | + choices: list |
| 106 | + }) |
| 107 | + }, |
| 108 | + show: function () { |
| 109 | + this.showChoices = true |
| 110 | + this.$nextTick(() => { |
| 111 | + this.initializeChoices() |
| 112 | + }) |
| 113 | + }, |
| 114 | + hide: function () { |
| 115 | + // now we can use the reference to Choices to perform clean up here |
| 116 | + // prior to removing the elements from the DOM |
| 117 | + this.choicesSelect.destroy() |
| 118 | + this.showChoices = false |
| 119 | + } |
| 120 | + } |
| 121 | +}) |
| 122 | +``` |
| 123 | + |
| 124 | +## Details about the Value |
| 125 | + |
| 126 | +Memory management and performance testing can easily be neglected in the excitement of shipping quickly, however, keeping a small memory footprint is still important to your overall user experience. |
| 127 | + |
| 128 | +Consider the types of devices your users may be using and what their normal flow will be. Could they use memory constrained laptops or mobile devices? Do your users typically do lots of in-application navigation? If either of these are true, then good memory management practices can help you avoid the worst case scenario of crashing a user’s browser. Even if neither of these are true, you can still potentially have degradation of performance over extended usage of your app if you are not careful. |
| 129 | + |
| 130 | +## Real-World Example |
| 131 | + |
| 132 | +In the above example, we used a `v-if` directive to illustrate the memory leak, but a more common real-world scenario happens when using [vue-router](https://router.vuejs.org/en/) to route to components in a Single Page Application. |
| 133 | + |
| 134 | +Just like the `v-if` directive, `vue-router` removes elements from the virtual DOM and replaces those with new elements when a user navigates around your application. The Vue `beforeDestroy()` [lifecycle hook](/v2/guide/instance.html#Lifecycle-Diagram) is a good place to solve the same sort of issue in a `vue-router` based application. |
| 135 | + |
| 136 | +We could move our clean up into the `beforeDestroy()` hook like this: |
| 137 | + |
| 138 | +```js |
| 139 | +beforeDestroy: function () { |
| 140 | + this.choicesSelect.destroy() |
| 141 | +} |
| 142 | +``` |
| 143 | + |
| 144 | +## Alternative Patterns |
| 145 | + |
| 146 | +We have discussed managing memory when removing elements, but what if you intentionally want to preserve state and keep elements in memory? In this case, you can use the built-in component [keep-alive](/v2/api/#keep-alive). |
| 147 | + |
| 148 | +When you wrap a component with `keep-alive`, its state will be preserved and therefore kept in memory. |
| 149 | + |
| 150 | +```html |
| 151 | +<button @click="show = false">Hide</button> |
| 152 | +<keep-alive> |
| 153 | + <!-- my-component will be intentionally kept in memory even when removed --> |
| 154 | + <my-component v-if="show"></my-component> |
| 155 | +</keep-alive> |
| 156 | +``` |
| 157 | +This technique can be useful to improve user experience. For example, imagine a user starts entering comments into a text input and then decides to navigate away. If the user then navigated back, their comments would still be preserved. |
| 158 | + |
| 159 | +Once you use keep-alive, then you have access to two more lifecycle hooks: `activated` and `deactivated`. If you do want to clean up or change data when a keep-alive component is removed, you can do so in the `deactivated` hook. |
| 160 | + |
| 161 | +```js |
| 162 | +deactivated: function () { |
| 163 | + // remove any data you do not want to keep alive |
| 164 | +} |
| 165 | +``` |
| 166 | + |
| 167 | +## Wrapping Up |
| 168 | + |
| 169 | +Vue makes it very easy to develop amazing, reactive Javascript applications, but you still need to be careful about memory leaks. These leaks will often occur when using additional 3rd Party libraries that manipulate the DOM outside of Vue. Make sure to test your application for memory leaks and take appropriate steps to clean up components where necessary. |
0 commit comments