自治区新闻出版广电局2017年01月行政审批统计

Use the template.ParseFS and embed package to compile HTML templates into binary files. 1. Import the embed package and embed the template file into the embed.FS variable with //go:embed templates/.html; 2. Call template.Must(template.ParseFS(templateFS, "templates/.html"))) to parse all matching template files; 3. Render the specified template in the HTTP processor through tmpl.ExecuteTemplate(w, "home.html", nil). This method does not require the runtime to rely on external files, generates a self-contained executable file, and the path and extension must be exactly matched to ensure the correct case and wildcard patterns.

Starting with Go 1.16, you can use the embed package along with template.ParseFS to load HTML templates (or any text-based templates) directly from the filesystem at compile time. This is especially useful for web applications where you want to bundle templates into the binary.

Here's how to use template.ParseFS with //go:embed .

? Step 1: Embed Files Using embed

First, import the embed package and use the //go:embed directive to include your template files.

 package main

import (
    "embed"
    "html/template"
    "net/http"
)

Suppose you have a directory called templates/ with files like:

 templates/
  home.html
  layout.html
  footer.html

You can embed the entire directory:

 //go:embed templates/*.html
var templateFS embedded.FS

Note: You can also use templates/ to include subdirectories, or be more specific with patterns.

? Step 2: Parse Templates Using template.ParseFS

Now use template.ParseFS to parse the embedded files:

 tmpl := template.Must(template.ParseFS(templateFS, "templates/*.html"))

This reads all .html files in the templates/ directory and parses them into a *template.Template .

If you have nested directories:

 //go:embed templates/*
var templateFS embedded.FS

tmpl := template.Must(template.ParseFS(templateFS, "templates/**/*.html"))

The ** allows recursive matching.

? Step 3: Use the Template in an HTTP Handler

 func handler(w http.ResponseWriter, r *http.Request) {
    err := tmpl.ExecuteTemplate(w, "home.html", nil)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

Then register it:

 func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

? Example Directory Structure

 project/
├── main.go
├── templates/
│ ├── home.html
│ ├── layout.html
│ └── footer.html

main.go :

 package main

import (
    "embed"
    "html/template"
    "net/http"
)

//go:embed templates/*.html
var templateFS embedded.FS

func main() {
    tmpl := template.Must(template.ParseFS(templateFS, "templates/*.html"))

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        err := tmpl.ExecuteTemplate(w, "home.html", nil)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    })

    http.ListenAndServe(":8080", nil)
}

?? Common Pitfalls

• File extension matters : Make sure the template filenames match what you pass to ExecuteTemplate .
• Glob pattern must match : If your files aren't being picked up, double-check the glob pattern in ParseFS .
• Case sensitivity : Embedded paths are case-sensitive.
• Don't forget the embed import — even if you don't use it directly, it's required for //go:embed to work.

? Summary

To use template.ParseFS with embed :

1. Use //go:embed to embed template files into an embed.FS variable.
2. Call template.ParseFS(fs, "pattern") to parse matching files.
3. Execute the desired template by name.

This approach avoids relying on external files at runtime and creates a fully self-contained binary.

Basically, that's it — clean, efficient, and idiomatic Go.

The above is the detailed content of How to use template.ParseFS with go embed?. For more information, please follow other related articles on the PHP Chinese website!