How to implement vue component reuse in actual projects
This time I will bring you how to implement vue component reuse in actual projects. What are the precautions for how to implement vue component reuse in actual projects? The following is a practical case, let's take a look.
1. What is a component
Component (Component) is one of the most powerful features of Vue.js. Components can extend HTML elements, encapsulating reusable code.
2. Component usage
Components need to be registered before they can be used. There are two ways of registration: global registration and local registration.
2.1 After global registration, any V ue instance can be used. For example:
<p id="app1"> <my-component></my-component> </p> Vue.component('my-component',{ template: '<p>这里是组件的内容</p>' }); var app1 = new Vue({ el: '#app1' });
To use this component in the parent instance, you must register it before the instance is created, and then you can use the component in the form of The DOM structure of template must be contained by an element. If it is written directly as "here is the content of the component", it will not be rendered without " p >". (And the outermost layer can only have one root tag) 2.2 In a Vue instance, you can use the component option to register a component locally. The registered component is only valid within the scope of the instance. For example: 2.3 data must be a function In addition to the template option, components can also use other options like Vue instances, such as data, computed, methods, etc. But when using data, it is slightly different from the example. data must be a function, and then the data is returned. Generally, the returned object should not refer to an external object, because if the returned object refers to an external object, then this object is shared, and modifications by either party will be synchronized. So generally a new independent data object is returned to the component. Supplement: vue-router component reuse issue The component system is an important part of Vue, it can combine a complex page The abstraction is decomposed into many small, independent, reusable components, and the application is composed by combining the components. Combined with the routing function of vue-router, each component is mapped to the corresponding route, and the changes in the routing are used to tell Vue where to render. They implement jump navigation between various components and pages. Problem When using vue-router to switch routes, it will trigger the update of the component tree and render a new component tree according to the defined route. The general switching process is as follows of: - Deactivate and remove unnecessary components For specific route switching control process, please refer to the official document: Switching Control Pipeline How does vue-router determine that a certain component can be reused? Let’s take a look at the following routing configuration: This is the route that loads the corresponding article page through the article ID. When accessed for the first time, the Post.vue component will be rendered into the component tree, and the mounted component will be installed. When we obtain the article content through the article ID and display it on the page, when we access another article, the routing parameter: postId changes. According to our expectations, the content of the new article should be displayed, but it backfires. What we see is still the previous article. Although the routing parameters have changed, vue-router will think that you are accessing the Post.vue component. Since the component has been rendered before, it will be copied directly. Use the previous component and will not perform any operations in the component including life cycle functions such as mounted. So what we finally see is the content of the original component. So how can we achieve the desired effect? An effective solution is introduced below Solution We can use the watch listener to monitor routing changes. According to the routing The parameters change to respond to the corresponding data. The specific implementation process is as follows: Define the data acquisition method First define a method to obtain articles, and obtain the corresponding article information from the background according to the article ID . Listening route 接着是在路由切换的时候判断目标组件是否是Post.vue组件,这里可以根据定义的路由名称name实现,如果是,我们就可以从路由信息中获取目标文章ID来更新组件内容。 组件初始化 这里需要注意的是,当组件首次被挂载到组件树上时,对路由的监听是无效的,这时我们需要在生命周期钩子mounted对组件进行初始化工作: 写在最后 通过上面的方法就可以实现组件内容随路由参数的变化而更新了,有效解决了vue-router组件复用导致路由参数失效的问题。 相信看了本文案例你已经掌握了方法,更多精彩请关注php中文网其它相关文章! 推荐阅读: <p id="app2">
<my-component1></my-component1>
</p>
var app2 = new Vue({
el: '#app2',
components:{
'my-component1': {
template: '<p>这里是局部注册组件的内容</p>'
}
}
});
<p id="app3">
<my-component3></my-component3>
</p>
Vue.component('my-component3',{
template: '<p>{{message}}</p>',
data: function(){
return {
message: '组件内容'
}
}
});
var app3 = new Vue({
el: '#app3'
});
- Verify the feasibility of switching
- Reuse components that have not been updated
- Enable and activate new components{
path: 'post/:postId',
name: 'post',
component: resolve => require(['./components/Post.vue'],resolve)
}
methods: {
getPost(postId) {
this.$http.get(`/post/get_post/${postId}`).then((response) => {
if(response.data.code === 0){
this.post = response.data.post;
}
});
}
}
watch: {
'$route' (to, from) {
if(to.name === 'post'){
this.getPost(to.params.postId);
}
}
}
mounted() {
this.getPost(this.$route.params.postId);
}
The above is the detailed content of How to implement vue component reuse in actual projects. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











Python is more suitable for beginners, with a smooth learning curve and concise syntax; JavaScript is suitable for front-end development, with a steep learning curve and flexible syntax. 1. Python syntax is intuitive and suitable for data science and back-end development. 2. JavaScript is flexible and widely used in front-end and server-side programming.

The main uses of JavaScript in web development include client interaction, form verification and asynchronous communication. 1) Dynamic content update and user interaction through DOM operations; 2) Client verification is carried out before the user submits data to improve the user experience; 3) Refreshless communication with the server is achieved through AJAX technology.

JavaScript's application in the real world includes front-end and back-end development. 1) Display front-end applications by building a TODO list application, involving DOM operations and event processing. 2) Build RESTfulAPI through Node.js and Express to demonstrate back-end applications.

Understanding how JavaScript engine works internally is important to developers because it helps write more efficient code and understand performance bottlenecks and optimization strategies. 1) The engine's workflow includes three stages: parsing, compiling and execution; 2) During the execution process, the engine will perform dynamic optimization, such as inline cache and hidden classes; 3) Best practices include avoiding global variables, optimizing loops, using const and lets, and avoiding excessive use of closures.

Both Python and JavaScript's choices in development environments are important. 1) Python's development environment includes PyCharm, JupyterNotebook and Anaconda, which are suitable for data science and rapid prototyping. 2) The development environment of JavaScript includes Node.js, VSCode and Webpack, which are suitable for front-end and back-end development. Choosing the right tools according to project needs can improve development efficiency and project success rate.

C and C play a vital role in the JavaScript engine, mainly used to implement interpreters and JIT compilers. 1) C is used to parse JavaScript source code and generate an abstract syntax tree. 2) C is responsible for generating and executing bytecode. 3) C implements the JIT compiler, optimizes and compiles hot-spot code at runtime, and significantly improves the execution efficiency of JavaScript.

Python is more suitable for data science and automation, while JavaScript is more suitable for front-end and full-stack development. 1. Python performs well in data science and machine learning, using libraries such as NumPy and Pandas for data processing and modeling. 2. Python is concise and efficient in automation and scripting. 3. JavaScript is indispensable in front-end development and is used to build dynamic web pages and single-page applications. 4. JavaScript plays a role in back-end development through Node.js and supports full-stack development.

JavaScript is widely used in websites, mobile applications, desktop applications and server-side programming. 1) In website development, JavaScript operates DOM together with HTML and CSS to achieve dynamic effects and supports frameworks such as jQuery and React. 2) Through ReactNative and Ionic, JavaScript is used to develop cross-platform mobile applications. 3) The Electron framework enables JavaScript to build desktop applications. 4) Node.js allows JavaScript to run on the server side and supports high concurrent requests.
