Along with the UI components, Ionic Framework also provides a command line tool for creating new apps, as well as deploying to the various platforms we support.
In this guide, we will go over the basics of both Vue and Ionic Framework, including any Ionic Framework specific features. If you are familiar with Vue, enjoy the guide and learn something new about Ionic Framework. If you are not familiar with either, no worries! This guide will cover the basics and provide enough information to get an app up and running.
To begin, let's install the latest version of the Ionic CLI.
From here, the global command
ionic will allow for the creation of a Vue project with Ionic Framework and any other dependencies. To create a new project, run the following command:
From here, we run
ionic serve and have our project running in the browser.
We love TypeScript at Ionic, and have believed for quite some time now that it’s a great tool for building scalable apps. That said, we know how much the Vue community values simplicity – in their tooling, languages, and more. In fact, it’s likely what drew you to Vue in the first place. Start simple – then scale up as needed.
- Remove TypeScript dependencies:
.js. In a blank Ionic Vue app, this should only be
scripttags in any of your Vue components that have them. In a blank Ionic Vue app, this should only be
The base of our app will be in the
src directory, and the main entry point will be our
main.ts file. If we open our project in a code editor and open
main.ts, we should see the following:
So what is going on here? The first four lines are pulling in some dependencies. The
createApp function lets us initialize our Vue application, while
IonicVue is a plugin that allows us to use Ionic Framework in a Vue environment.
The third import is the root component for our app, simply named
App. This is our first Vue component and will be used in the bootstrapping process for our Vue app.
The fourth import gets our routing configuration. We will look at this more in depth later.
If we open
App.vue we should see the following:
Let's break it down, starting with the first group of imports.
To use a component in Vue, you must first import it. So for Ionic Framework, this means anytime we want to use a Button or a Card, it must be added to our imports. In the case of our
App component, we are using
IonRouterOutlet. You can also register components globally if you find yourself importing the same components repeatedly. This comes with performance tradeoffs that we cover in Optimizing Your App.
From there, let's look at the template.
All Vue components must have a
<template>. Inside of there, we place our
Finally, let's look at the component definition:
Vue 3 offers a new
defineComponent function when creating components for improved tooling support, and we are going to use that here. We first define the name of the component, and then we supply the components that we will use in our template.
There are several arguments you can supply here such as
setup and more. This is explained as part of Vue's Composition API Documentation.
Ionic Vue uses the vue-router dependency, so if you are already familiar with Vue Router, you will be able to apply what you know to navigation in Ionic Vue. Let's take a look at the router configuration we mentioned before. In
router/index.ts, you should see something similar to the following:
This example is using the Ionic Vue Blank starter application, so your actual routes may look a bit different.
The setup here is the same as if you were using
vue-router directly, but instead you need to import dependencies such as
createWebHistory from the
After importing our dependencies, we can declare our routes in the
routes array. From there, we can create a router instance and provide it with our routes and the type of history we want to use.
With Ionic Vue, lazy loading works right out of the box. Instead of importing our
Home component, we could also do:
Now, you might be wondering: Why do we use
@ when describing the path to our components? The
@ symbol is a shortcut we can use to describe paths relative to the
src directory. This is useful if we are trying to reference a component while in a file several folders deep. Instead of doing
'../../../views/Home.vue', we could simply do
App component does not really have a lot to modify here. It is a basic example of a container component. With the router logic set, all it is responsible for is to render a component that matches the given URL route. Since we already have one component/router setup, let's go ahead and modify our
Home component looks like so:
Much like the
App component we started with, we have some imports for specific Ionic Framework components, an import from Vue, the Vue component, and styles to go along with our component.
For our styles, notice that we have specified our styles to be
scoped. This means that the styles we write here will only apply to this component. This is useful for preventing styles from leaking out of a component and affecting other parts of your application. We strongly recommend using
scoped styles for Ionic Vue applications.
IonPage is the base component for all pages (a component with a route/URL), and includes some common building blocks of a full-screen component, like header, title, and content components.
When creating your own pages, do not forget to have
IonPagebe the root component for them. Having
IonPagebe the root component is important because it helps ensure transitions work properly as well as provides the base CSS the Ionic Framework components rely on.
IonHeader is a component meant to exist at the top of the page. It does not do much by itself, aside from handling some flexbox-based layout. It is meant to hold components, like
IonContent is, as its name suggests, the main content area for our page. It is responsible for providing a scrollable content that users will interact with, plus any scroll events that could be used in an app.
Our current content is relatively simple, but does not contain anything that could be used in a real app, so let's change that.
Note: For brevity, we are excluding repeating parts of our component, like the function declaration or import statements from other components.
Here in our
IonContent, we are adding an
IonList and a much more involved
IonItem component. Let's look at
IonItem as it is the centerpiece here.
Looking at our code, we have a special attribute called slot. This is key for letting the
IonItem know where to place the
IonCheckbox when it renders. This is not a Vue API, but a web standards API. Additionally, this is different from the slots API you may recall from Vue 2.
Let's look at another component from Ionic Framework, FAB. Floating Action Buttons are a nice way to provide a main action that is elevated from the rest of an app. For this FAB, we will need three components: a FAB, a FAB Button, and an Icon.
On our main
IonFab, we are setting its positioning with the vertical and horizontal attributes. We are also setting the render location to "fixed" with the slot attribute. This will tell
IonFab to render outside of the scrollable content in
Now let's wire up a click handler to this. When clicking the FAB button, we want to navigate to a new page (which we will create in a moment). To do this, we will need to get access to Vue Router's navigation API. This can be done by importing
useRouter from the
In our component file, we are importing the
useRouter function. When called, this function injects the router dependency into the component. It gives us access to the history API from Vue Router, allowing us to push a new route onto the navigation stack. On our
IonFabButton, we can add a click handler, and just call
router.push and pass in the new route. In this case, we will navigate to
Now that we have the pieces in place to navigate in our app, we need to create a new component and add the new route to our router declaration. Let's open our
router/index.ts file and add the new route.
With our router now having an entry for the route
/new, we will create the component needed,
NewItem. This will exist in
Let's fill the
NewItem.vue file with some placeholder content for the moment.
Each view must contain an
IonPagecomponent. Page transitions will not work correctly without it. See the IonPage Documentation for more information.
The content here should look similar to the
Home component. What is different here is the
IonBackButton component. This is used to navigate back to the previous route. Seems easy enough, right? Ok, but what if we reload the page?
In this case, the in-memory history is lost, so the back button disappears. To address this, we can set the
default-href attribute value to the URL we want to navigate to if there is no history.
Now, If there is no app history present, we will be able to navigate back to our home route.
In order to call a method on any of the Ionic Vue components, you will first need to get a reference to the component instance. Next, you will need to access the underlying Web Component using
$el and call the method.
In other framework integrations such as Ionic React, this is not needed as any
ref you provide is automatically forwarded to the underlying Web Component instance. We are unable to do the same thing here due to limitations in how Vue manages refs.
Ionic Vue comes with Ionicons pre-installed. There are a couple options developers have for using them in their application.
Dynamic Imports is the recommended approach to using Ionicons. This involves importing the icon of your choice from the
ionicons package and passing it to your template:
Let's break down what we are doing here. First, we are importing the
heart icon from
ionicons/icons. This will load the appropriate SVG data for our icon.
Next, we pass the
heart data to our template in the
Finally, we pass the icon data into the
ion-icon component via the
Developers also have the option of setting different icons based upon the mode:
Note that any icon names that are hyphenated should be written in camel case when importing.
The other option is to import specific icons globally. This is not typically recommended as it will force icons to be loaded every time your application starts and can increase your application's initial chunk size.
That being said, there may be use cases when it makes sense to load specific icons globally:
addIcons function lets us register icons globally and give it a string as a key. We then reference the icon by that key in our
Vue gives you several tools to fine tune your application. This section will cover the options that are most relevant to Ionic Framework.
By default, Ionic Framework components are registered locally. With local registration, these components are imported and provided to each Vue component you want to use them in. This is the recommended approach as it allows lazy loading and treeshaking to work properly with Ionic Framework components.
The one downside to this approach is that it may be tedious to re-import your Ionic Framework components multiple times. However, we feel that the performance benefits you receive in exchange are worth it.
Also note that locally registered components are not available in subcomponents. You will need to re-import the Ionic Framework components you would like to use in your subcomponent.
Let's take a look at how local component registration works:
In the example above, we are using the
IonContent components. To use them, we first import them from
@ionic/vue. Then, we provide them to our Vue component in the
components option. From there, we can use the components in our template.
Note that since we are registering these components locally, neither
IonContent will be available in
Subcomponent unless we register them there as well.
For more information, see the Local Registration Vue Documentation.
The other option for registering components is to use global registration. Global registration involves importing the components you want to use in
main.ts and calling the
component method on your Vue app instance.
Let's take a look at how global component registration works:
In the example above, we are using the
IonContent components. To use them, we first import them from
main.ts. From there, we call the
component method on our app instance and pass it the tag name as well as the component definition. After we do that, we can use the components in the rest of our application without having to import them into each Vue component.
For more information, see the Global Registration Vue Documentation.
Prefetching consumes bandwidth, so if you have a large app, you may want to disable it. You can do this by modifying or creating your
The configuration above will prevent all files from being prefetched and, instead, will be loaded when they are needed. You can also select certain chunks to prefetch. Check out the Vue CLI Docs on Prefetching for more examples.
We now have the basics of an Ionic Vue app down, including some UI components and navigation. The great thing about Ionic Framework’s components is that they work anywhere, including iOS, Android, and PWAs. To deploy to mobile, desktop, and beyond, we use Ionic’s cross-platform app runtime Capacitor. It provides a consistent, web-focused set of APIs that enable an app to stay as close to web-standards as possible while accessing rich native device features on platforms that support them.
Adding native functionality is easy. First, add Capacitor to your project:
Next, build the project, then add your platform of choice:
We use the standard native IDEs (Xcode and Android Studio) to open, build, and run the iOS and Android projects:
Additional details can be found here.
This guide covered the basics of creating an Ionic Vue app, adding some basic navigation, and introducing Capacitor as a way of building native apps. To dive deeper into building complete Ionic Framework apps with Vue and Capacitor, follow our First App guide.
Happy app building! 🎉