vue -ag捕鱼王app官网

like other frameworks, vue has many lifecycle hooks that allow us to attach code to specific events that occur when creating or using a vue application—such as when a component is loaded, when the component is added to the dom, or when something is removed.

vue has many lifecycle hooks, and it can be confusing to understand what each hook means or does. in this article, we will introduce the purpose of each lifecycle hook and how to use them.

if you are not familiar with vue, you can refer to our vue tutorial.

vue lifecycle hooks

one important point to note here is that vue has two paradigms for lifecycle hooks. one is the component api introduced in vue 3, and the other is the "options api," which defines vue components using a prototype pattern. in this article, we will start with the options api and then demonstrate how the component api works based on that.

options api example

if you're unfamiliar with the options api, this is what vue's version looks like in the following code:

export default {
    name: 'component name',
    data() {
        return {
            phonenumber: '123-123-123'
        }
    },
    mounted() {
    }
}

running lifecycle hooks

to run any lifecycle hook using the options api, we can add it to the javascript prototype. for example, if you want to use beforecreate(), the first hook triggered after a new component is detected, you can add it like this:

export default {
    name: 'component name',
    data() {
        return {
            somedata: '123-123-123'
        }
    },
    mounted() {
        // any code that should trigger immediately before the options api loads
    }
}

now that we have introduced when the different hooks happen, let’s look at what each one does and when they are triggered.

beforecreate()

called when the component is initialized. data() and computed properties are not available at this time. this is useful for calling apis that do not modify component data. if we update data() here, it will be lost once the options api is loaded.

created()

called after the instance has processed all state operations. we can access reactive data, computed properties, methods, and watchers. $el is where vue stores the component's html, but it’s not available yet because no dom elements have been created. if you want to trigger something like an api or update data(), you can do it here.

beforemount()

this hook runs immediately before the rendering process. the template has been compiled and stored in memory, but it has not yet been attached to the page. no dom elements have been created. $el is still unavailable at this stage.

this method is not called during server-side rendering.

mounted()

the component is installed and displayed on the page. $el is now available, so we can access and manipulate the dom from vue. this will only trigger after all child components have been fully mounted. it’s useful when we want to perform operations on the dom after it has loaded, like changing specific elements.

this method is not called during server-side rendering.

beforeupdate()

sometimes we change the data in a vue component by updating it in a watcher or through user interaction. when data() changes or triggers a component re-render, the update event is triggered. beforeupdate() will trigger immediately before the re-render occurs. after this event, the component will re-render and update using the latest data. you can use this hook to access the current state of the dom and even update data().

this method is not called during server-side rendering.

updated()

triggered after the update and the dom has been updated to match the latest data. updated() happens immediately after the re-render. now, if we access $el or anything related to the dom content, it will show the new, re-rendered version. if there is a parent component, the child component's updated() is called first, followed by the parent component's updated() hook.

this method is not called during server-side rendering.

beforeunmount()

if a component is removed, it will be unmounted. beforeunmount() is triggered before the component is completely deleted. this event still gives you access to the dom element and any other content related to the component. this is useful for deletion events. for example, you can use this event to notify the server that a user has deleted a node in the table. you can still access this.$el, data, watchers, and methods.

this method is not called during server-side rendering.

unmount()

triggered after the component is fully deleted. this can be used to clean up other data, event listeners, or timers, letting them know that the component is no longer on the page. you can still access this.$el, as well as data, watchers, and methods.

this method is not called during server-side rendering.

using vue lifecycle hooks with the composition api

if you are used to the options api, the above hooks will make sense. if you're primarily using vue 3, you may be more accustomed to using the composition api. the composition api is a supplement to the options api, but the way we use the hooks is a bit different. let’s take a look at how it works.

created() and beforecreated() are replaced by setup()

in the composition api, created() and beforecreated() are not available. instead, they are replaced by setup(). this makes sense because there is no "options api" to load. any code we would have put in created() or beforecreated() can now safely go inside setup().

hooks can be used with setup()

hooks can still be used with setup(), just like they were in the options api. this is very intuitive. for example:

export default {
    data() {
        return {
            msg: 1
        }
    },
    setup() {
        console.log('component setup complete')
    },
    mounted() {
        console.log(this.$el)
    },
}

however, we may see another way to do this using the composition api functions to define hooks directly in the setup() function itself. if we do this, the naming of the hooks will be slightly different:

• beforemount() becomes onbeforemount()
• mounted() becomes onmounted()
• beforeupdate() becomes onbeforeupdate()
• updated() becomes onupdated()
• beforeunmount() becomes onbeforeunmount()
• unmounted() becomes onunmounted()

these functions work exactly as described in the previous section, but the way they are called is slightly different. all of these hooks must be called inside the setup() function or setup script. for example, we must run the hooks inside the setup() function as shown below:

export default {
    setup() {
        // all hooks must be placed here
    }
}

alternatively, in a script tag with a setup attribute, as shown below:

<scriptsetup>// all hooks must be included in this setup scriptscript>

so, if we want to call the hooks using this method, the code would look like this:

export default {
    setup() {
        // all hooks must be placed here
        onbeforemount(() => {
            // code for beforemount()
        });
        onbeforeupdate(() => {
            // code for beforeupdate()
        })
    }
}

there is no fundamental performance improvement or better reason. it’s just another way—sometimes, it makes your code easier to read and maintain. in other cases, using the options api might be better, so use whichever one feels more comfortable for you.

conclusion

vue's lifecycle is quite complex, but it provides many tools for running code, updating data, and ensuring that our components display in the way we want. in this article, we’ve introduced how it works, when to use each part of the lifecycle, and how the composition api differs from the options api in terms of lifecycle hooks.