Skip to content

Generate tag pages

Get ready to…

  • Create a page to generate multiple pages
  • Specify which page routes to build, and pass each page its own props

You can create entire sets of pages dynamically using .astro files that export a getStaticPaths() function.

  1. Create a new file at src/pages/tags/[tag].astro. (You will have to create a new folder.) Notice that the file name ([tag].astro) uses square brackets. Paste the following code into the file:

    src/pages/tags/[tag].astro
    ---
    import BaseLayout from '../../layouts/BaseLayout.astro';
    export async function getStaticPaths() {
    return [
    { params: { tag: "astro" } },
    { params: { tag: "successes" } },
    { params: { tag: "community" } },
    { params: { tag: "blogging" } },
    { params: { tag: "setbacks" } },
    { params: { tag: "learning in public" } },
    ];
    }
    const { tag } = Astro.params;
    ---
    <BaseLayout pageTitle={tag}>
    <p>Posts tagged with {tag}</p>
    </BaseLayout>

    The getStaticPaths function returns an array of page routes, and all of the pages at those routes will use the same template defined in the file.

  2. If you have customized your blog posts, then replace the individual tag values (e.g. “astro”, “successes”, “community”, etc.) with the tags used in your own posts.

  3. Make sure that every blog post contains at least one tag, written as an array, e.g. tags: ["blogging"].

  4. Visit http://localhost:4321/tags/astro in your browser preview and you should see a page, generated dynamically from [tag].astro. Check that you also have pages created for each of your tags at /tags/successes, /tags/community, and /tags/learning%20in%20public, etc., or at each of your custom tags. You may need to first quit and restart the dev server to see these new pages.

  1. Add the following props to your getStaticPaths() function in order to make data from all your blog posts available to each page route.

    Be sure to give each route in your array the new props, and then make those props available to your component template outside of your function.

    src/pages/tags/[tag].astro
    ---
    import BaseLayout from '../../layouts/BaseLayout.astro';
    export async function getStaticPaths() {
    const allPosts = await Astro.glob('../posts/*.md');
    return [
    {params: {tag: "astro"}, props: {posts: allPosts}},
    {params: {tag: "successes"}, props: {posts: allPosts}},
    {params: {tag: "community"}, props: {posts: allPosts}},
    {params: {tag: "blogging"}, props: {posts: allPosts}},
    {params: {tag: "setbacks"}, props: {posts: allPosts}},
    {params: {tag: "learning in public"}, props: {posts: allPosts}}
    ]
    }
    const { tag } = Astro.params;
    const { posts } = Astro.props;
    ---
  2. Filter your list of posts to only include posts that contain the page’s own tag.

    /src/pages/tags/[tag].astro
    ---
    const { tag } = Astro.params;
    const { posts } = Astro.props;
    const filteredPosts = posts.filter((post) => post.frontmatter.tags?.includes(tag));
    ---
  3. Now you can update your HTML template to show a list of each blog post containing the page’s own tag. Add the following code to [tag].astro:

    src/pages/tags/[tag].astro
    <BaseLayout pageTitle={tag}>
    <p>Posts tagged with {tag}</p>
    <ul>
    {filteredPosts.map((post) => <li><a href={post.url}>{post.frontmatter.title}</a></li>)}
    </ul>
    </BaseLayout>
  4. You can even refactor this to use your <BlogPost /> component instead! (Don’t forget to import this component at the top of [tag].astro.)

    src/pages/tags/[tag].astro
    <BaseLayout pageTitle={tag}>
    <p>Posts tagged with {tag}</p>
    <ul>
    {filteredPosts.map((post) => <li><a href={post.url}>{post.frontmatter.title}</a></li>)}
    {filteredPosts.map((post) => <BlogPost url={post.url} title={post.frontmatter.title}/>)}
    </ul>
    </BaseLayout>
  5. Check your browser preview for your individual tag pages, and you should now see a list of all of your blog posts containing that particular tag.

For each of the following, state whether the code is written inside the getStaticPaths() function, or outside of it.

  1. The Astro.glob() call to receive information about all your .md files to pass to each page route.

  2. The list of routes to be generated (returned) by getStaticPaths()

  3. The received values of props and params to be used in the HTML template.

Advanced JavaScript: Generate pages from existing tags

Section titled Advanced JavaScript: Generate pages from existing tags

Your tag pages are now defined statically in [tag].astro. If you add a new tag to a blog post, you will also have to revisit this page and update your page routes.

The following example shows how to replace your code on this page with code that will automatically look for, and generate pages for, each tag used on your blog pages.

1. Check that all your blog posts contain tags

Section titled 1. Check that all your blog posts contain tags

Revisit each of your existing Markdown pages and ensure that every post contains a tags array in its frontmatter. Even if you only have one tag, it should still be written as an array, e.g. tags: ["blogging"].

2. Create an array of all your existing tags

Section titled 2. Create an array of all your existing tags

Add the following code to provide you with a list of every tag used in your blog posts.

src/pages/tags/[tag].astro
---
import BaseLayout from '../../layouts/BaseLayout.astro';
export async function getStaticPaths() {
const allPosts = await Astro.glob('../posts/*.md');
const uniqueTags = [...new Set(allPosts.map((post) => post.frontmatter.tags).flat())];
Tell me what this line of code is doing in more detail!

It’s OK if this isn’t something you would have written yourself yet!

It goes through each Markdown post, one by one, and combines each array of tags into one single larger array. Then, it makes a new Set from all the individual tags it found (to ignore repeated values). Finally, it turns that set into an array (with no duplications), that you can use to show a list of tags on your page.

You now have an array uniqueTags with element items "astro", "successes", "community", "blogging", "setbacks", "learning in public"

3. Replace the return value of the getStaticPaths function

Section titled 3. Replace the return value of the getStaticPaths function
src/pages/tags/[tag].astro
return [
{params: {tag: "astro"}, props: {posts: allPosts}},
{params: {tag: "successes"}, props: {posts: allPosts}},
{params: {tag: "community"}, props: {posts: allPosts}},
{params: {tag: "blogging"}, props: {posts: allPosts}},
{params: {tag: "setbacks"}, props: {posts: allPosts}},
{params: {tag: "learning in public"}, props: {posts: allPosts}}
]
return uniqueTags.map((tag) => {
const filteredPosts = allPosts.filter((post) => post.frontmatter.tags.includes(tag));
return {
params: { tag },
props: { posts: filteredPosts },
};
});

A getStaticPaths function should always return a list of objects containing params (what to call each page route) and optionally any props (data that you want to pass to those pages). Earlier, you defined each tag name that you knew was used in your blog and passed the entire list of posts as props to each page.

Now, you generate this list of objects automatically using your uniqueTags array to define each parameter.

And, now the list of all blog posts is filtered before it is sent to each page as props. Be sure to remove the previous line of code filtering the posts, and update your HTML template to use posts instead of filteredPosts.

src/pages/tags/[tag].astro
const { tag } = Astro.params;
const { posts } = Astro.props;
const filteredPosts = posts.filter((post) => post.frontmatter.tags?.includes(tag));
---
<!-- -->
<ul>
{filteredPosts.map((post) => <BlogPost url={post.url} title={post.frontmatter.title}/>)}
{posts.map((post) => <BlogPost url={post.url} title={post.frontmatter.title}/>)}
</ul>

To check your work, or if you just want complete, correct code to copy into [tag].astro, here is what your Astro component should look like:

src/pages/tags/[tag].astro
---
import BaseLayout from '../../layouts/BaseLayout.astro';
import BlogPost from '../../components/BlogPost.astro';
export async function getStaticPaths() {
const allPosts = await Astro.glob('../posts/*.md');
const uniqueTags = [...new Set(allPosts.map((post) => post.frontmatter.tags).flat())];
return uniqueTags.map((tag) => {
const filteredPosts = allPosts.filter((post) => post.frontmatter.tags.includes(tag));
return {
params: { tag },
props: { posts: filteredPosts },
};
});
}
const { tag } = Astro.params;
const { posts } = Astro.props;
---
<BaseLayout pageTitle={tag}>
<p>Posts tagged with {tag}</p>
<ul>
{posts.map((post) => <BlogPost url={post.url} title={post.frontmatter.title}/>)}
</ul>
</BaseLayout>

Now, you should be able to visit any of your tag pages in your browser preview.

Navigate to http://localhost:4321/tags/community and you should see a list of only your blog posts with the tag community. Similarly http://localhost:4321/tags/learning%20in%20public should display a list of the blog posts tagged learning in public.

In the next section, you will create navigation links to these pages.

Choose the term that matches the description.

  1. A function that returns an array of page routes.

  2. The process of creating multiple page routes from one file in Astro.

  3. A value that defines the name of a page route generated dynamically.