func (r *Router) Match(req *http.Request, match *RouteMatch) bool {
	for _, route := range r.routes {
		if route.Match(req, match) {
			if match.MatchErr == nil {
				for i := len(r.middlewares) - 1; i >= 0; i-- {
					match.Handler = r.middlewares[i].Middleware(match.Handler)
				}
			}
			return true
		}
	}
	if match.MatchErr == ErrMethodMismatch {
		if r.MethodNotAllowedHandler != nil {
			match.Handler = r.MethodNotAllowedHandler
			return true
		}
		return false
	}
	if r.NotFoundHandler != nil {
		match.Handler = r.NotFoundHandler
		match.MatchErr = ErrNotFound
		return true
	}
	match.MatchErr = ErrNotFound
	return false
}
Match attempts to match the given request against the router's registered routes.

If the request matches a route of this router or one of its subrouters the Route,
Handler, and Vars fields of the the match argument are filled and this function
returns true.

If the request does not match any of this router's or its subrouters' routes
then this function returns false. If available, a reason for the match failure
will be filled in the match argument's MatchErr field. If the match failure type
(eg: not found) has a registered handler, the handler is assigned to the Handler
field of the match argument.
package mux
import (
	"errors"
	"fmt"
	"net/http"
	"path"
	"regexp"
)
var (
	ErrMethodMismatch = errors.New("method is not allowed")
	ErrNotFound = errors.New("no matching route was found")
)
func NewRouter() *Router {
	return &Router{namedRoutes: make(map[string]*Route)}
}
type Router struct {
	NotFoundHandler http.Handler
	MethodNotAllowedHandler http.Handler
	routes []*Route
	namedRoutes map[string]*Route
	KeepContext bool
	middlewares []middleware
	routeConf
}
type routeConf struct {
	useEncodedPath bool
	strictSlash bool
	skipClean bool
	regexp routeRegexpGroup
	matchers []matcher
	buildScheme string
	buildVarsFunc BuildVarsFunc
}
func copyRouteConf(r routeConf) routeConf {
	c := r
	if r.regexp.path != nil {
		c.regexp.path = copyRouteRegexp(r.regexp.path)
	}
	if r.regexp.host != nil {
		c.regexp.host = copyRouteRegexp(r.regexp.host)
	}
	c.regexp.queries = make([]*routeRegexp, 0, len(r.regexp.queries))
	for _, q := range r.regexp.queries {
		c.regexp.queries = append(c.regexp.queries, copyRouteRegexp(q))
	}
	c.matchers = make([]matcher, 0, len(r.matchers))
	for _, m := range r.matchers {
		c.matchers = append(c.matchers, m)
	}
	return c
}
func copyRouteRegexp(r *routeRegexp) *routeRegexp {
	c := *r
	return &c
}