Rewrite: A Simple and Powerful URL Rewriter for Go

Rewrite is a Go package that lets you rewrite URL paths, subdomains or hosts based on regular expressions. It is inspired by Apache’s mod_rewrite module and can be used as a middleware for?net/http-based servers.

Rewrite can help you achieve better SEO results by redirecting old or unwanted URLs to new ones, enforcing a primary subdomain, or simplifying complex URL structures.

How to Install Rewrite

To install Rewrite, you need to have Go installed on your system. Then, you can use the go get command to download and install the package:

$ go get github.com/kataras/rewrite        

How to Use Rewrite

You can load rewrite options in two ways:

1. Through code using the?New?function and?Handler?method. This way, you can handle parse errors and create rules programmatically.

2. Or through a YAML file using the?Load?function which returns a?func(http.Handler) http.Handler. This is the most common and simplest way. It panics on parse errors.

The syntax of the rewrite rules is:

REDIRECT_CODE_DIGITS PATTERN_REGEX TARGET_REPL        

Where:

-?REDIRECT_CODE_DIGITS?is the HTTP status code to use for the redirection, such as 301 (Moved Permanently) or 302 (Found).

-?PATTERN_REGEX?is the regular expression that matches the request URL path, subdomain or host.

-?TARGET_REPL?is the replacement string that contains the new URL path, subdomain or host.

For example:

301 /seo/(.*) /$1        

This rule redirects all requests from relative path?/seo/* to /*?using the 301 HTTP status code.

You can also use a special option called?PrimarySubdomain?to redirect all requests from the root domain to a specific subdomain, such as?www.

For example:

PrimarySubdomain: www        

This option redirects all requests from?example.com?to?www.example.com.

Examples

Let’s write a simple application that follows these redirect rules:

- Redirects `/seo/*` to `/*`

- Redirects `/docs/v12*` to `/docs`

- Redirects `/old (.*)` to `/`

- Redirects root domain requests to `www.`

The code would look like this:

package main

import (
  "net/http"

  "github.com/kataras/rewrite"
)

func main() {
  mux := http.NewServeMux()
  // […routes]
  // Load the redirect rules from a YAML file.
  redirects := rewrite.Load("redirects.yml")
  // Wrap the router with the rewrite middleware.
  http.ListenAndServe(":8080", redirects(mux))
}        

The YAML file would look like this:

RedirectMatch:
  # Redirects /seo/* to /*
  - 301 /seo/(.*) /$1
  # Redirects /docs/v12* to /docs
  - 301 /docs/v12(.*) /docs
  # Redirects /old (.*) to /
  - 301 /old(.*) /
# Redirects root domain requests to www.
PrimarySubdomain: www        

That’s it! Now you can test your application and see how it redirects the requests according to your rules.

You can find more examples in the `_examples` folder of the GitHub repository:?https://github.com/kataras/rewrite/tree/main/_examples

Conclusion

Rewrite is a handy package that lets you rewrite URLs in Go with ease. It is compatible with any net/http router or framework and supports regular expressions for flexible matching and replacing. It can help you improve your SEO performance by redirecting old or unwanted URLs to new ones, enforcing a primary subdomain, or simplifying complex URL structures.

If you want to learn more about Rewrite, you can check out its GitHub repository:?https://github.com/kataras/rewrite

I hope you enjoyed this article and found it useful. If you have any feedback or questions, feel free to leave a comment below. Thank you for reading! ??