5 • Beef up your blog
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
Dynamic page routingSection titled Dynamic page routing
You can create entire sets of pages dynamically using
.astro files that export a
Create pages dynamicallySection titled Create pages dynamically
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:
getStaticPathsfunction returns an array of page routes, and all of the pages at those routes will use the same template defined in the file.
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.
Make sure that every blog post contains at least one tag, written as an array, e.g.
localhost:3000/tags/astroin 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/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.
Use props in dynamic routesSection titled Use props in dynamic routes
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.
Filter your list of posts to only include posts that contain the page’s own tag.
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
You can even refactor this to use your
<BlogPost />component instead! (Don’t forget to import this component at the top of
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.
Analyze the patternSection titled Analyze the pattern
For each of the following, state whether the code is written inside the
getStaticPath() function, or outside of it.
Astro.glob()call to receive information about all your
.mdfiles to pass to each page route.
The list of routes to be generated (returned) by
The received values of
paramsto be used in the HTML template.
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 tagsSection 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.
2. Create an array of all your existing tagsSection 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.
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
"learning in public"
3. Replace the Section titled 3. Replace the return value of the getStaticPaths function
return value of the
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
Final code sampleSection titled Final code sample
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:
Now, you should be able to visit any of your tag pages in your browser preview.
localhost:3000/tags/community and you should see a list of only your blog posts with the tag
localhost:3000/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.
Test your knowledgeSection titled Test your knowledge
Choose the term that matches the description.
A function that returns an array of page routes.
The process of creating multiple page routes from one file in Astro.
A value that defines the name of a page route generated dynamically.