Using Go's embed package can easily embed static resources into binary, suitable for web services to package HTML, CSS, pictures and other files. 1. Declare the embedded resource to add //go:embed comments before the variable, such as embedding a single file hello.txt; 2. It can be embedded in the entire directory such as static/*, and realize multi-file packaging through embed.FS; 3. It is recommended to switch disk loading mode through build tags or environment variables to improve efficiency; 4. Pay attention to path accuracy, file size limitations and read-only characteristics of embedded resources. Rational use of embed can simplify deployment and optimize project structure.

It is actually quite convenient to embed static resources using Go's embed package, especially suitable for packaging HTML, CSS, pictures and other files into binary when doing web services. Here are a few key points and usage methods to help you get started quickly.

Basic usage: How to declare embedded resources

Go 1.16 introduces the embed package, which allows you to embed files or directories directly into programs. Just add //go:embed annotation before the variable.

For example, if you want to embed a file called hello.txt :

 package main

import (
    "embed"
    "fmt"
)

//go:embed hello.txt
var f embedded.FS

func main() {
    data, _ := f.ReadFile("hello.txt")
    fmt.Println(string(data))
}

This way, the content of hello.txt will be output when running, and no additional disk files are required.

Note that the path is relative to the path of the current source file. If the file is not in the same directory, you need to write a relative path, such as assets/config.json .

Embed the entire directory: Package multiple files

Sometimes you need to embed the entire directory, such as the static resources of the website (HTML, CSS, JS), and you can directly embed a subdirectory.

 //go:embed static/*
var staticFS embedded.FS

This code will pack all the contents in the static/ folder in the current directory. Then you can use it as an HTTP file server:

 http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS)))))

In this way, access /static/index.html can load the page you embedded.

Usage tips: Debugging and development mode switching

Although embedding is convenient, if you frequently modify files during the development stage, it is really troublesome to recompile each time. It is recommended not to use embed during development, but load it from disk and switch back to release.

You can use build tag or environment variables to control whether to enable embed mode:

 //go:build !dev
// build !dev

package main

//go:embed static/*
var staticFS embedded.FS

func getFS() http.FileSystem {
    return http.FS(staticFS)
}

And in dev mode:

 //go:build dev

package main

func getFS() http.FileSystem {
    return http.Dir("static")
}

This allows hot loading during development and embed resources during production.

Notes: Path and size issues

• The path needs to be written correctly : especially in a multi-layer directory structure, it is easy to write the wrong path and cause the file to be found.
• Files cannot be too large : Although embed can package any file, being too large will significantly increase memory usage and startup time.
• Read-only restriction : Embedded files are read-only and cannot be written or modified. They are suitable for unchanging content such as configurations, templates, and static resources.

Basically that's it. Using embed well can simplify the deployment process and make the project structure cleaner. As long as you pay attention to the path and development and debugging methods, there will be no big problem.

The above is the detailed content of Go embed package tutorial. For more information, please follow other related articles on the PHP Chinese website!