httprouter

Named parameters use the :name syntax in the routing pattern. They match exactly one path segment. You can retrieve the value using the ByName(name string) method on the httprouter.Params object.

Example behavior for pattern /user/:user:

• /user/gordon -> match
• /user/you -> match
• /user/gordon/profile -> no match
• /user/ -> no match

Catch-all parameters use the *name syntax. They match everything from that point forward in the path and must always be at the end of the pattern.

Example behavior for pattern /src/*filepath:

• /src/ -> match
• /src/somefile.go -> match
• /src/subdir/somefile.go -> match

To use HttpRouter in your Go project, install it using the following command:

$ go get github.com/julienschmidt/httprouter

To serve different content based on the request host (domain or sub-domain), you can create a custom http.Handler that acts as a switch. This handler maps hostnames to specific http.Handler instances (such as different httprouter.Router instances).

type HostSwitch map[string]http.Handler

func (hs HostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if handler := hs[r.Host]; handler != nil {
		handler.ServeHTTP(w, r)
	} else {
		http.Error(w, "Forbidden", 403)
	}
}

func main() {
	router := httprouter.New()
	router.GET("/", Index)

	hs := make(HostSwitch)
	hs["example.com:12345"] = router

	http.ListenAndServe(":12345", hs)
}

You can use the Router.NotFound field to delegate requests that don't match any registered routes to another http.Handler. This is useful for chaining multiple routers or serving static files as a fallback.

Note: You may need to set Router.HandleMethodNotAllowed = false to avoid conflicts when chaining handlers.

// Serve static files from the ./public directory when no route matches
router.NotFound = http.FileServer(http.Dir("public"))

Use httprouter.New() to create a new router instance. By default, the router has the following features enabled:

• RedirectTrailingSlash: Automatically redirects requests with or without a trailing slash.
• RedirectFixedPath: Automatically redirects requests with superfluous path elements (like // or ..) or incorrect casing to the cleaned, correct path.
• HandleMethodNotAllowed: Returns a 405 Method Not Allowed if the path exists but the HTTP method is incorrect.
• HandleOPTIONS: Automatically responds to OPTIONS requests with the appropriate Allow header.

router := httprouter.New()

You can create a middleware wrapper for httprouter.Handle to enforce Basic Authentication (RFC 2617). The wrapper checks the Authorization header and only delegates to the original handler if the credentials match the required user and password.

func BasicAuth(h httprouter.Handle, requiredUser, requiredPassword string) httprouter.Handle {
	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
		user, password, hasAuth := r.BasicAuth()

		if hasAuth && user == requiredUser && password == requiredPassword {
			h(w, r, ps)
		} else {
			w.Header().Set("WWW-Authenticate", "Basic realm=Restricted")
			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
		}
	}
}

// Usage:
// router.GET("/protected/", BasicAuth(Protected, "user", "pass"))

If you are using standard http.Handler or http.HandlerFunc (via router.Handler or router.HandlerFunc), the named parameters are not passed as a third argument. Instead, they are stored in the request's context. You can retrieve them using httprouter.ParamsFromContext(r.Context()).

func Hello(w http.ResponseWriter, r *http.Request) {
    params := httprouter.ParamsFromContext(r.Context())

    fmt.Fprintf(w, "hello, %s!\n", params.ByName("name"))
}

You can customize how the router responds to OPTIONS requests (useful for CORS preflight) by assigning an http.HandlerFunc to the Router.GlobalOPTIONS field.

router.GlobalOPTIONS = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("Access-Control-Request-Method") != "" {
        // Set CORS headers
        header := w.Header()
        header.Set("Access-Control-Allow-Methods", header.Get("Allow"))
        header.Set("Access-Control-Allow-Origin", "*")
    }

    // Adjust status code to 204
    w.WriteHeader(http.StatusNoContent)
})