Does the vue project only have one vue instance?-Front-end Q&A-php.cn

Home

Web Front-end

Front-end Q&A

Does the vue project only have one vue instance?

青灯夜游

Dec 19, 2022 pm 03:25 PM

vuevue3

No, a vue project can contain multiple vue instances. In a vue project, generally there is only one VUE instance defined in main.js, and the others are vue component instances. Vue is built from instances. A component is an instance of Vue. Properties can be written inside each component, so each component is an instance of Vue.

Does the vue project only have one vue instance?

The operating environment of this tutorial: windows7 system, vue3 version, DELL G3 computer.

No, a vue project can contain multiple vue instances.

Vue is built from instances. A component is an instance of Vue. Properties can be written inside each component, so each component is an instance of Vue. In a vue project, generally there is only one VUE instance defined in main.js, and the others are vue component instances.

Vue instance

When using Vue to write a project, the most important thing is the Vue instance, which provides a direction for learning Vue and gradually mastering it. Vue instance-related "features" are our ultimate goal.

First, load vue.js in an html file. You can load the vue.js file directly through the script tag:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vue实例</title>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
</head>
<body>
<body>

Open this page with a browser and enter in the console Vue, you will find that Vue is essentially a function:

Does the vue project only have one vue instance?

In fact, Vue is a constructor, which can be regarded as a "class", created through new its instance. So how many instances can be created in a page?

Usually only one Vue instance is created in a page:

<body>
    <div id="app">Hello {{ msg }}</div>
    <script>
        const vm = new Vue({
            el: &#39;#app&#39;,
            data: function () {
                return {
                    msg: &#39;前端小课&#39;
                }
            }
        });
</script>
</body>

When creating a Vue instance, a "customized" object is passed in. We can change the above object to another Writing method:

<body>
    <div id="app">Hello {{ msg }}</div>
    <script>
        const obj = {
            el: &#39;#app&#39;,
            data: function () {
                return {
                    msg: &#39;前端小课&#39;
                }
            }
        }
        const vm = new Vue(obj);
</script>
</body>

In the obj object, there is an attribute el, which represents the "template" provided for the Vue instance. That is to say, when you create an instance, you need to tell Vue that the HTML to be rendered is What, how to establish some kind of connection between the things to be done in HTML and obj. For example, how to associate the data to be displayed in the HTML template with the data of the Vue instance, and how to respond to the events to be triggered in the HTML template. To establish an association, a contract must be made between the template and the Vue instance.

el can be a selector or an HTMLElement (design architecture that opens up the DOM) instance. You can write el as:

el: document.getElementById(&#39;app&#39;),

or it can be any selector:

 el: &#39;div&#39;,

What is the displayed result below?

Does the vue project only have one vue instance?

Finally found that the value of title "Good morning, check in!" was not rendered to HTML. This is because the div where title is located is not within the scope of the Vue instance. Within, that is to say, the Vue instance can only affect the template where the instance is created (such as the template pointed to by el):

Does the vue project only have one vue instance?

In fact, one page can create multiple Vue Instances, for example, the following code creates 3 Vue instances and finds that they can work normally:

<body>
    <div id="app">
        <h1 id="nbsp-msg-nbsp">{{ msg }}</h1>
    </div>
    <div id="app-body">
        <h4 id="nbsp-title-nbsp">{{ title }}</h4>
    </div>
    <div class="app-footer">
        <h4 id="nbsp-footer-nbsp">{{ footer }}</h4>
    </div>
    <script>
        const vm = new Vue({
            el: &#39;#app&#39;,
            data: function () {
                return {
                    msg: "欢迎来到前端小课",
                }
            }
        });
</script>
    <script>
        const vmBody = new Vue({
            el: &#39;#app-body&#39;,
            data: function () {
                return {
                    title: "Vue 实例讲解"
                }
            }
        });
</script>
    <script>
        const vmFooter = new Vue({
            el: &#39;.app-footer&#39;,
            data: function () {
                return {
                    footer: "感谢阅读",
                }
            }
        });
</script>
</body>

Open it with a browser and the result is as follows:

Does the vue project only have one vue instance?

This example reminds me of components. "Components are reusable Vue instances." This way of writing is a bit like components. Each Vue instance is regarded as a component.

Let's look at another example - a Vue instance nested within the Vue instance:

<body>
    <div id="app">
        <h1 id="nbsp-msg-nbsp">{{ msg }}</h1>
        <!-- 这里不能声明一个新的 Vue 实例 -->
        <div id="app-body">
            <h4 id="会渲染吗-nbsp-title-nbsp">会渲染吗？{{ title }}</h4>
        </div>
    </div>
    <script>
        const vm = new Vue({
            el: &#39;#app&#39;,
            data: function () {
                return {
                    msg: "欢迎来到前端小课",
                    title: "#app - Vue 实例讲解"
                }
            }
        });
</script>
    <script>
        const vmBody = new Vue({
            el: &#39;#app-body&#39;,
            data: function () {
                return {
                    title: "#app-body - Vue 实例讲解"
                }
            }
        });
</script>
</body>

The rendering result is, and it is found that the result uses the data in the #app instance:

Does the vue project only have one vue instance?

There are many APIs in the Vue instance, and each API requires us to learn step by step. For example, life cycle functions, calculated properties, definition methods, filters:

Does the vue project only have one vue instance?

##[Related recommendations:

vuejs video tutorial、web front-end development】

The above is the detailed content of Does the vue project only have one vue instance?. For more information, please follow other related articles on the PHP Chinese website!

Statement

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

HTML and React's Integration: A Practical GuideApr 21, 2025 am 12:16 AM

HTML and React can be seamlessly integrated through JSX to build an efficient user interface. 1) Embed HTML elements using JSX, 2) Optimize rendering performance using virtual DOM, 3) Manage and render HTML structures through componentization. This integration method is not only intuitive, but also improves application performance.

React and HTML: Rendering Data and Handling EventsApr 20, 2025 am 12:21 AM

React efficiently renders data through state and props, and handles user events through the synthesis event system. 1) Use useState to manage state, such as the counter example. 2) Event processing is implemented by adding functions in JSX, such as button clicks. 3) The key attribute is required to render the list, such as the TodoList component. 4) For form processing, useState and e.preventDefault(), such as Form components.

The Backend Connection: How React Interacts with ServersApr 20, 2025 am 12:19 AM

React interacts with the server through HTTP requests to obtain, send, update and delete data. 1) User operation triggers events, 2) Initiate HTTP requests, 3) Process server responses, 4) Update component status and re-render.

React: Focusing on the User Interface (Frontend)Apr 20, 2025 am 12:18 AM

React is a JavaScript library for building user interfaces that improves efficiency through component development and virtual DOM. 1. Components and JSX: Use JSX syntax to define components to enhance code intuitiveness and quality. 2. Virtual DOM and Rendering: Optimize rendering performance through virtual DOM and diff algorithms. 3. State management and Hooks: Hooks such as useState and useEffect simplify state management and side effects handling. 4. Example of usage: From basic forms to advanced global state management, use the ContextAPI. 5. Common errors and debugging: Avoid improper state management and component update problems, and use ReactDevTools to debug. 6. Performance optimization and optimality

React's Role: Frontend or Backend? Clarifying the DistinctionApr 20, 2025 am 12:15 AM

Reactisafrontendlibrary,focusedonbuildinguserinterfaces.ItmanagesUIstateandupdatesefficientlyusingavirtualDOM,andinteractswithbackendservicesviaAPIsfordatahandling,butdoesnotprocessorstoredataitself.

React in the HTML: Building Interactive User InterfacesApr 20, 2025 am 12:05 AM

React can be embedded in HTML to enhance or completely rewrite traditional HTML pages. 1) The basic steps to using React include adding a root div in HTML and rendering the React component via ReactDOM.render(). 2) More advanced applications include using useState to manage state and implement complex UI interactions such as counters and to-do lists. 3) Optimization and best practices include code segmentation, lazy loading and using React.memo and useMemo to improve performance. Through these methods, developers can leverage the power of React to build dynamic and responsive user interfaces.

React: The Foundation for Modern Frontend DevelopmentApr 19, 2025 am 12:23 AM

React is a JavaScript library for building modern front-end applications. 1. It uses componentized and virtual DOM to optimize performance. 2. Components use JSX to define, state and attributes to manage data. 3. Hooks simplify life cycle management. 4. Use ContextAPI to manage global status. 5. Common errors require debugging status updates and life cycles. 6. Optimization techniques include Memoization, code splitting and virtual scrolling.

The Future of React: Trends and Innovations in Web DevelopmentApr 19, 2025 am 12:22 AM

React's future will focus on the ultimate in component development, performance optimization and deep integration with other technology stacks. 1) React will further simplify the creation and management of components and promote the ultimate in component development. 2) Performance optimization will become the focus, especially in large applications. 3) React will be deeply integrated with technologies such as GraphQL and TypeScript to improve the development experience.

See all articles