<!--more--> at the appropriate place in the content page, or the summary can be written independent of the page text. See [Content Summaries](/content-management/summaries/) for more details.
.TableOfContents
: The rendered [table of contents](/content-management/toc/) for the page.
.Title
: The title for this page.
.Translations
: A list of translated versions of the current page. See [Multilingual Mode](/content-management/multilingual/) for more information.
.TranslationKey
: The key used to map language translations of the current page. See [Multilingual Mode](/content-management/multilingual/) for more information.
.Truncated
: A boolean, `true` if the `.Summary` is truncated. Useful for showing a "Read more..." link only when necessary. See [Summaries](/content-management/summaries/) for more information.
.Type
: The [content type](/content-management/types/) of the content (e.g., `posts`).
.Weight
: Assigned weight (in the front matter) to this content, used in sorting.
.WordCount
: The number of words in the content.
## Page collections
List pages receive the following page collections in [context](/getting-started/glossary/#context):
.Pages
: Regular pages within the current section (not recursive), and section pages for immediate descendant sections (not recursive).
.RegularPages
: Regular pages within the current section (not recursive).
.RegularPagesRecursive
: Regular pages within the current section, and regular pages within all descendant sections.
## Writable page-scoped variables
[.Scratch][scratch]
: Returns a Scratch to store and manipulate data. In contrast to the [`.Store`][store] method, this scratch is reset on server rebuilds.
[.Store][store]
: Returns a Scratch to store and manipulate data. In contrast to the [`.Scratch`][scratch] method, this scratch is not reset on server rebuilds.
## Section variables and methods
Also see [Sections](/content-management/sections/).
{{< readfile file="/content/en/readfiles/sectionvars.md" markdown="true" >}}
## Page fragments
{{< new-in "0.111.0" >}}
The `.Fragments` method returns a list of fragments for the current page.
.Headings
: A recursive list of headings for the current page. Can be used to generate a table of contents.
{{< todo >}}add .Headings toc example{{< /todo >}}
.Identifiers
: A sorted list of identifiers for the current page. Can be used to check if a page contains a specific identifier or if a page contains duplicate identifiers:
```go-html-template
{{ if .Fragments.Identifiers.Contains "my-identifier" }}
Page contains identifier "my-identifier"
{{ end }} {{ if gt (.Fragments.Identifiers.Count "my-identifier") 1 }}Page contains duplicate "my-identifier" fragments
{{ end }} ``` .HeadingsMap : Holds a map of headings for the current page. Can be used to start the table of contents from a specific heading. Also see the [Go Doc](https://pkg.go.dev/github.com/gohugoio/hugo@v0.111.0/markup/tableofcontents#Fragments) for the return type. ### Fragments in hooks and shortcodes `.Fragments` are safe to call from render hooks, even on the page you're on (`.Page.Fragments`). For shortcodes we recommend that all `.Fragments` usage is nested inside the `{{}}` shortcode delimiter (`{{%/**/%}}` takes part in the ToC creation so it's easy to end up in a situation where you bite yourself in the tail). ## The global page function {{< new-in "0.111.1" >}} Hugo almost always passes a `Page` as the data context into the top level template (e.g. `single.html`) (the one exception is the multihost sitemap template). This means that you can access the current page with the `.` variable in the template. But when you're deeply nested inside `.Render`, partial etc., accessing that `Page` object isn't always practical or possible. For this reason, Hugo provides a global `page` function that you can use to access the current page from anywhere in any template. ```go-html-template {{ page.Title }} ``` There are one caveat with this, and this isn't new, but it's worth mentioning here: There are situations in Hugo where you may see a cached value, e.g. when using `partialCached` or in a shortcode. ## The `.RenderShortcodes` method {#rendershortcodes} {{< new-in "0.117.0" >}} This renders all the shortcodes in the content, preserving the surrounding markup (e.g. Markdown) as is. The common use case this is to composing a page from multiple content files while preserving a global context for table of contents and foot notes. This method is most often used in shortcode templates. A simple example of shortcode template including content from another page would look like: ```go-html-template {{ $p := site.GetPage (.Get 0) }} {{ $p.RenderShortcodes }} ``` In the above it's important to understand and the difference between the two delimiters used when including a shortcode: * `{{}}` tells Hugo that the rendered shortcode does not need further processing (e.g. it's HTML). * `{{%/* myshortcode */%}}` tells Hugo that the rendered shortcode needs further processing (e.g. it's Markdown). The latter is what you want to use for the include shortcode outlined above: ```md ## Mypage {{%/* include "mypage" */%}} `````` Also see [Use Shortcodes](/content-management/shortcodes/#use-shortcodes). ## Page-level params Any other value defined in the front matter in a content file, including taxonomies, will be made available as part of the `.Params` variable. {{< code-toggle file="content/example.md" fm=true copy=false >}} title: Example categories: [one] tags: [two,three,four] {{< /code-toggle >}} With the above front matter, the `tags` and `categories` taxonomies are accessible via the following: * `.Params.tags` * `.Params.categories` The `.Params` variable is particularly useful for the introduction of user-defined front matter fields in content files. For example, a Hugo website on book reviews could have the following front matter: {{< code-toggle file="content/example.md" fm=true copy=false >}} title: Example affiliatelink: "http://www.my-book-link.here" recommendedby: "My Mother" {{< /code-toggle >}} These fields would then be accessible to via `.Params.affiliatelink` and `.Params.recommendedby`. ```go-html-templateIt was recommended by {{ .Params.recommendedby }}.
``` This template would render as follows: ```htmlIt was recommended by my Mother.
``` {{% note %}} See [Archetypes](/content-management/archetypes/) for consistency of `Params` across pieces of content. {{% /note %}} ### The `.Param` method In Hugo, you can declare parameters in individual pages and globally for your entire website. A common use case is to have a general value for the site parameter and a more specific value for some of the pages (i.e., a header image): ```go-html-template {{ $.Param "header_image" }} ``` The `.Param` method provides a way to resolve a single value according to it's definition in a page parameter (i.e. in the content's front matter) or a site parameter (i.e., in your site configuration). ### Access nested fields in front matter When front matter contains nested fields like the following: {{< code-toggle file="content/example.md" fm=true copy=false >}} title: Example author: given_name: John family_name: Feminella display_name: John Feminella {{< /code-toggle >}} `.Param` can access these fields by concatenating the field names together with a dot: ```go-html-template {{ $.Param "author.display_name" }} ``` [configuring dates]: /getting-started/configuration/#configure-dates [gitinfo]: /variables/git/ [File Variables]: /variables/files/ [bundle]: /content-management/page-bundles [scratch]: /functions/scratch [store]: /functions/store