API Reference
API Reference
github.com/labstack/echo/v5
github.com/labstack/echo/v5
Root
github.com/labstack/echo/v5
Package echo implements high performance, minimalist Go web framework.
import "github.com/labstack/echo/v5"
Package echo implements high performance, minimalist Go web framework.
+Example:
+
+
+
+
+
+package main
+
+import (
+ "log/slog"
+ "net/http"
+
+ "github.com/labstack/echo/v5"
+ "github.com/labstack/echo/v5/middleware"
+)
+
+// Handler
+func hello(c *echo.Context) error {
+ return c.String(http.StatusOK, "Hello, World!")
+}
+
+func main() {
+ // Echo instance
+ e := echo.New()
+
+ // Middleware
+ e.Use(middleware.RequestLogger())
+ e.Use(middleware.Recover())
+
+ // Routes
+ e.GET("/", hello)
+
+ // Start server
+ if err := e.Start(":8080"); err != nil {
+ slog.Error("failed to start server", "error", err)
+ }
+}Learn more at https://echo.labstack.com
Constants
+TimeLayout constants for parsing Unix timestamps in different precisions.
+
+
+
+
+const (
+ TimeLayoutUnixTime = TimeLayout("UnixTime") // Unix timestamp in seconds
+ TimeLayoutUnixTimeMilli = TimeLayout("UnixTimeMilli") // Unix timestamp in milliseconds
+ TimeLayoutUnixTimeNano = TimeLayout("UnixTimeNano") // Unix timestamp in nanoseconds
+)MIME types
+
+
+
+
+const (
+ // MIMEApplicationJSON JavaScript Object Notation (JSON) https://www.rfc-editor.org/rfc/rfc8259
+ MIMEApplicationJSON = "application/json"
+ // Deprecated: Please use MIMEApplicationJSON instead. JSON should be encoded using UTF-8 by default.
+ // No "charset" parameter is defined for this registration.
+ // Adding one really has no effect on compliant recipients.
+ // See RFC 8259, section 8.1. https://datatracker.ietf.org/doc/html/rfc8259#section-8.1n"
+ MIMEApplicationJSONCharsetUTF8 = MIMEApplicationJSON + "; " + charsetUTF8
+ MIMEApplicationJavaScript = "application/javascript"
+ MIMEApplicationJavaScriptCharsetUTF8 = MIMEApplicationJavaScript + "; " + charsetUTF8
+ MIMEApplicationXML = "application/xml"
+ MIMEApplicationXMLCharsetUTF8 = MIMEApplicationXML + "; " + charsetUTF8
+ MIMETextXML = "text/xml"
+ MIMETextXMLCharsetUTF8 = MIMETextXML + "; " + charsetUTF8
+ MIMEApplicationForm = "application/x-www-form-urlencoded"
+ MIMEApplicationProtobuf = "application/protobuf"
+ MIMEApplicationMsgpack = "application/msgpack"
+ MIMETextHTML = "text/html"
+ MIMETextHTMLCharsetUTF8 = MIMETextHTML + "; " + charsetUTF8
+ MIMETextPlain = "text/plain"
+ MIMETextPlainCharsetUTF8 = MIMETextPlain + "; " + charsetUTF8
+ MIMEMultipartForm = "multipart/form-data"
+ MIMEOctetStream = "application/octet-stream"
+)
+
+
+
+
+const (
+
+ // PROPFIND Method can be used on collection and property resources.
+ PROPFIND = "PROPFIND"
+ // REPORT Method can be used to get information about a resource, see rfc 3253
+ REPORT = "REPORT"
+ // QUERY Method is a safe, idempotent request method carrying request content (a query) in its body, see rfc 10008.
+ // It is not (yet) part of the `net/http` standard library, so Echo defines it here.
+ QUERY = "QUERY"
+ // RouteNotFound is special method type for routes handling "route not found" (404) cases
+ RouteNotFound = "echo_route_not_found"
+ // RouteAny is special method type that matches any HTTP method in request. Any has lower
+ // priority that other methods that have been registered with Router to that path.
+ RouteAny = "echo_route_any"
+)Headers
+
+
+
+
+const (
+ HeaderAccept = "Accept"
+ HeaderAcceptEncoding = "Accept-Encoding"
+ // HeaderAllow is the name of the "Allow" header field used to list the set of methods
+ // advertised as supported by the target resource. Returning an Allow header is mandatory
+ // for status 405 (method not found) and useful for the OPTIONS method in responses.
+ // See RFC 7231: https://datatracker.ietf.org/doc/html/rfc7231#section-7.4.1
+ HeaderAllow = "Allow"
+ HeaderAuthorization = "Authorization"
+ HeaderContentDisposition = "Content-Disposition"
+ HeaderContentEncoding = "Content-Encoding"
+ HeaderContentLength = "Content-Length"
+ HeaderContentType = "Content-Type"
+ HeaderCookie = "Cookie"
+ HeaderSetCookie = "Set-Cookie"
+ HeaderIfModifiedSince = "If-Modified-Since"
+ HeaderLastModified = "Last-Modified"
+ HeaderLocation = "Location"
+ HeaderRetryAfter = "Retry-After"
+ HeaderUpgrade = "Upgrade"
+ HeaderVary = "Vary"
+ HeaderWWWAuthenticate = "WWW-Authenticate"
+ HeaderXForwardedFor = "X-Forwarded-For"
+ HeaderXForwardedProto = "X-Forwarded-Proto"
+ HeaderXForwardedProtocol = "X-Forwarded-Protocol"
+ HeaderXForwardedSsl = "X-Forwarded-Ssl"
+ HeaderXUrlScheme = "X-Url-Scheme"
+ HeaderXHTTPMethodOverride = "X-HTTP-Method-Override"
+ HeaderXRealIP = "X-Real-Ip"
+ HeaderXRequestID = "X-Request-Id"
+ HeaderXCorrelationID = "X-Correlation-Id"
+ HeaderXRequestedWith = "X-Requested-With"
+ HeaderServer = "Server"
+
+ // HeaderOrigin request header indicates the origin (scheme, hostname, and port) that caused the request.
+ // See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Origin
+ HeaderOrigin = "Origin"
+ HeaderCacheControl = "Cache-Control"
+ HeaderConnection = "Connection"
+
+ // Access control
+ HeaderAccessControlRequestMethod = "Access-Control-Request-Method"
+ HeaderAccessControlRequestHeaders = "Access-Control-Request-Headers"
+ HeaderAccessControlAllowOrigin = "Access-Control-Allow-Origin"
+ HeaderAccessControlAllowMethods = "Access-Control-Allow-Methods"
+ HeaderAccessControlAllowHeaders = "Access-Control-Allow-Headers"
+ HeaderAccessControlAllowCredentials = "Access-Control-Allow-Credentials"
+ HeaderAccessControlExposeHeaders = "Access-Control-Expose-Headers"
+ HeaderAccessControlMaxAge = "Access-Control-Max-Age"
+
+ // Security
+ HeaderStrictTransportSecurity = "Strict-Transport-Security"
+ HeaderXContentTypeOptions = "X-Content-Type-Options"
+ HeaderXXSSProtection = "X-XSS-Protection"
+ HeaderXFrameOptions = "X-Frame-Options"
+ HeaderContentSecurityPolicy = "Content-Security-Policy"
+ HeaderContentSecurityPolicyReportOnly = "Content-Security-Policy-Report-Only"
+ HeaderXCSRFToken = "X-CSRF-Token" // #nosec G101
+ HeaderReferrerPolicy = "Referrer-Policy"
+
+ // HeaderSecFetchSite fetch metadata request header indicates the relationship between a request initiator's
+ // origin and the origin of the requested resource.
+ // See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Sec-Fetch-Site
+ HeaderSecFetchSite = "Sec-Fetch-Site"
+)
+
+
+
+
+const (
+ // NotFoundRouteName is name of RouteInfo returned when router did not find matching route (404: not found).
+ NotFoundRouteName = "echo_route_not_found_name"
+ // MethodNotAllowedRouteName is name of RouteInfo returned when router did not find matching method for route (405: method not allowed).
+ MethodNotAllowedRouteName = "echo_route_method_not_allowed_name"
+)
+
+
+
+
+const (
+ // ContextKeyHeaderAllow is set by Router for getting value for `Allow` header in later stages of handler call chain.
+ // Allow header is mandatory for status 405 (method not found) and useful for OPTIONS method requests.
+ // It is added to context only when Router does not find matching method handler for request.
+ ContextKeyHeaderAllow = "echo_header_allow"
+)
+
+
+
+
+const (
+ // Version of Echo
+ Version = "5.3.0"
+)Variables
+The following errors can produce HTTP status code by implementing HTTPStatusCoder interface
+
+
+
+
+var (
+ ErrBadRequest = &httpError{http.StatusBadRequest} // 400
+ ErrUnauthorized = &httpError{http.StatusUnauthorized} // 401
+ ErrForbidden = &httpError{http.StatusForbidden} // 403
+ ErrNotFound = &httpError{http.StatusNotFound} // 404
+ ErrMethodNotAllowed = &httpError{http.StatusMethodNotAllowed} // 405
+ ErrRequestTimeout = &httpError{http.StatusRequestTimeout} // 408
+ ErrStatusRequestEntityTooLarge = &httpError{http.StatusRequestEntityTooLarge} // 413
+ ErrUnsupportedMediaType = &httpError{http.StatusUnsupportedMediaType} // 415
+ ErrTooManyRequests = &httpError{http.StatusTooManyRequests} // 429
+ ErrInternalServerError = &httpError{http.StatusInternalServerError} // 500
+ ErrBadGateway = &httpError{http.StatusBadGateway} // 502
+ ErrServiceUnavailable = &httpError{http.StatusServiceUnavailable} // 503
+)The following errors fall into 500 (InternalServerError) category
+
+
+
+
+var (
+ ErrValidatorNotRegistered = errors.New("validator not registered")
+ ErrRendererNotRegistered = errors.New("renderer not registered")
+ ErrInvalidRedirectCode = errors.New("invalid redirect status code")
+ ErrCookieNotFound = errors.New("cookie not found")
+ ErrInvalidCertOrKeyType = errors.New("invalid cert or key type, must be string or []byte")
+ ErrInvalidListenerNetwork = errors.New("invalid listener network")
+)ErrInvalidKeyType is error that is returned when the value is not castable to expected type.
+
+
+
+
+var ErrInvalidKeyType = errors.New("invalid key type")ErrNonExistentKey is error that is returned when key does not exist
+
+
+
+
+var ErrNonExistentKey = errors.New("non existent key")Functions
+func BindBody(c *Context, target any) (err error)
+ +BindBody binds request body contents to bindable object +NB: then binding forms take note that this implementation uses standard library form parsing +which parses form data from BOTH URL and BODY if content type is not MIMEMultipartForm +See non-MIMEMultipartForm: https://golang.org/pkg/net/http/#Request.ParseForm +See MIMEMultipartForm: https://golang.org/pkg/net/http/#Request.ParseMultipartForm
func BindHeaders(c *Context, target any) error
+ +BindHeaders binds HTTP headers to a bindable object
func BindPathValues(c *Context, target any) error
+ +BindPathValues binds path parameter values to bindable object
func BindQueryParams(c *Context, target any) error
+ +BindQueryParams binds query params to bindable object
func ContextGet[T any](c *Context, key string) (T, error)
+ +ContextGet retrieves a value from the context store or ErrNonExistentKey error the key is missing. +Returns ErrInvalidKeyType error if the value is not castable to type T.
func ContextGetOr[T any](c *Context, key string, defaultValue T) (T, error)
+ +ContextGetOr retrieves a value from the context store or returns a default value when the key +is missing. Returns ErrInvalidKeyType error if the value is not castable to type T.
func DefaultHTTPErrorHandler(exposeError bool) HTTPErrorHandler
+ +DefaultHTTPErrorHandler creates new default HTTP error handler implementation. It sends a JSON response
+with status code. exposeError parameter decides if returned message will contain also error message or not
Note: DefaultHTTPErrorHandler does not log errors. Use middleware for it if errors need to be logged (separately) +Note: In case errors happens in middleware call-chain that is returning from handler (which did not return an error). +When handler has already sent response (ala c.JSON()) and there is error in middleware that is returning from +handler. Then the error that global error handler received will be ignored because we have already "committed" the +response and status code header has been sent to the client.
Example
+
+
+
+
+
+
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: © 2015 LabStack LLC and Echo contributors
+
+// run tests as external package to get real feel for API
+package echo_test
+
+import (
+ "encoding/json"
+ "fmt"
+ "github.com/labstack/echo/v5"
+ "net/http"
+ "net/http/httptest"
+)
+
+func ExampleDefaultHTTPErrorHandler() {
+ e := echo.New()
+ e.GET("/api/endpoint", func(c *echo.Context) error {
+ return &apiError{
+ Code: http.StatusBadRequest,
+ Body: map[string]any{"message": "custom error"},
+ }
+ })
+
+ req := httptest.NewRequest(http.MethodGet, "/api/endpoint?err=1", nil)
+ resp := httptest.NewRecorder()
+
+ e.ServeHTTP(resp, req)
+
+ fmt.Printf("%d %s", resp.Code, resp.Body.String())
+
+ // Output: 400 {"error":{"message":"custom error"}}
+}
+
+type apiError struct {
+ Code int
+ Body any
+}
+
+func (e *apiError) StatusCode() int {
+ return e.Code
+}
+
+func (e *apiError) MarshalJSON() ([]byte, error) {
+ type body struct {
+ Error any `json:"error"`
+ }
+ return json.Marshal(body{Error: e.Body})
+}
+
+func (e *apiError) Error() string {
+ return http.StatusText(e.Code)
+}
+Output:
+
+
+
+
+
+
+400 {"error":{"message":"custom error"}}func ExtractIPDirect() IPExtractor
+ +ExtractIPDirect extracts an IP address using an actual IP address. +Use this if your server faces to internet directly (i.e.: uses no proxy).
func ExtractIPFromRealIPHeader(options ...TrustOption) IPExtractor
+ +ExtractIPFromRealIPHeader extracts IP address using x-real-ip header.
+Use this if you put proxy which uses this header.
func ExtractIPFromXFFHeader(options ...TrustOption) IPExtractor
+ +ExtractIPFromXFFHeader extracts IP address using x-forwarded-for header.
+Use this if you put proxy which uses this header.
+This returns nearest untrustable IP. If all IPs are trustable, returns furthest one (i.e.: XFF[0]).
func FormFieldBinder(c *Context) *ValueBinder
+ +FormFieldBinder creates form field value binder +For all requests, FormFieldBinder parses the raw query from the URL and uses query params as form fields
+For POST, PUT, and PATCH requests, it also reads the request body, parses it +as a form and uses query params as form fields. Request body parameters take precedence over URL query +string values in r.Form.
+NB: when binding forms take note that this implementation uses standard library form parsing +which parses form data from BOTH URL and BODY if content type is not MIMEMultipartForm +See https://golang.org/pkg/net/http/#Request.ParseForm
func FormValue[T any](c *Context, key string, opts ...any) (T, error)
+ +FormValue extracts and parses a single form value from the request by key. +It returns the typed value and an error if binding fails. Returns ErrNonExistentKey if parameter not found.
+Empty String Handling:
+
+
+
+
+
+If the form field exists but has an empty value, the zero value of type T is returned
+with no error. For example, an empty form field returns (0, nil) for int types.
+This differs from standard library behavior where parsing empty strings returns errors.
+To treat empty values as errors, validate the result separately or check the raw value.See ParseValue for supported types and options
func FormValueOr[T any](c *Context, key string, defaultValue T, opts ...any) (T, error)
+ +FormValueOr extracts and parses a single form value from the request by key. +Returns defaultValue if the parameter is not found or has an empty value. +Returns an error only if parsing fails or form parsing errors occur.
+Example:
+
+
+
+
+
+limit, err := echo.FormValueOr[int](c, "limit", 100)
+// If "limit" is missing: returns (100, nil)
+// If "limit" is "50": returns (50, nil)
+// If "limit" is "abc": returns (100, BindingError)See ParseValue for supported types and options
func FormValues[T any](c *Context, key string, opts ...any) ([]T, error)
+ +FormValues extracts and parses all values for a form values key as a slice. +It returns the typed slice and an error if binding any value fails. Returns ErrNonExistentKey if parameter not found.
+See ParseValues for supported types and options
func FormValuesOr[T any](c *Context, key string, defaultValue []T, opts ...any) ([]T, error)
+ +FormValuesOr extracts and parses all values for a form values key as a slice. +Returns defaultValue if the parameter is not found. +Returns an error only if parsing any value fails or form parsing errors occur.
+Example:
+
+
+
+
+
+tags, err := echo.FormValuesOr[string](c, "tags", []string{})
+// If "tags" is missing: returns ([], nil)
+// If form parsing fails: returns (nil, error)See ParseValues for supported types and options
func HandlerName(h HandlerFunc) string
+ +HandlerName returns string name for given function.
func LegacyIPExtractor() IPExtractor
+ +LegacyIPExtractor returns an IPExtractor that derives the client IP address +from common proxy headers, falling back to the request's remote address.
+Resolution order:
+-
+
- X-Forwarded-For: returns the first IP in the comma-separated list. +If multiple values are present, only the left-most (original client) +is used. Surrounding brackets (for IPv6) are stripped. +
- X-Real-IP: used if X-Forwarded-For is absent. Surrounding brackets +(for IPv6) are stripped. +
- req.RemoteAddr: used as a fallback; the host portion is extracted +via net.SplitHostPort. +
Notes:
+-
+
- No validation is performed on header values. +
- This function trusts headers as-is and is therefore not safe against +spoofing unless the application is behind a trusted proxy that is +configured to strip/replace/modify headers correctly. +
Use ExtractIPFromXFFHeader or ExtractIPFromRealIPHeader instead of LegacyIPExtractor.
func MustSubFS(currentFs fs.FS, fsRoot string) fs.FS
+ +MustSubFS creates sub FS from current filesystem or panic on failure.
+Panic happens when fsRoot contains invalid path according to fs.ValidPath rules.
MustSubFS is helpful when dealing with embed.FS because for example //go:embed assets/images embeds files with
+paths including assets/images as their prefix. In that case use `fs := echo.MustSubFS(fs, "rootDirectory") to
+create sub fs which uses necessary prefix for directory path.
func New() *Echo
+ +New creates an instance of Echo.
func NewBindingError(sourceParam string, values []string, message string, err error) error
+ +NewBindingError creates new instance of binding error
func NewConcurrentRouter(r Router) Router
+Source: router_concurrent.go:9
+NewConcurrentRouter creates concurrency safe Router which routes can be added/removed safely +even after http.Server has been started.
func NewContext(r *http.Request, w http.ResponseWriter, opts ...any) *Context
+ +NewContext returns a new Context instance.
+Note: request,response and e can be left to nil as Echo.ServeHTTP will call c.Reset(req,resp) anyway +these arguments are useful when creating context for tests and cases like that.
func NewDefaultFS(dir string) fs.FS
+ +NewDefaultFS returns a new defaultFS instance which allows fs.FS.Open to have absolute paths as input if it matches
+then given dir as prefix.
func NewHTTPError(code int, message string) *HTTPError
+ +NewHTTPError creates a new instance of HTTPError
func NewResponse(w http.ResponseWriter, logger *slog.Logger) (r *Response)
+ +NewResponse creates a new instance of Response.
func NewRouter(config RouterConfig) *DefaultRouter
+ +NewRouter returns a new Router instance.
func NewVirtualHostHandler(vhosts map[string]*Echo) *Echo
+ +NewVirtualHostHandler creates instance of Echo that routes requests to given virtual hosts +when hosts in request does not exist in given map the request is served by returned Echo instance.
func NewWithConfig(config Config) *Echo
+ +NewWithConfig creates an instance of Echo with given configuration.
func ParseValue[T any](value string, opts ...any) (T, error)
+ +ParseValue parses value to generic type
+Types that are supported:
+-
+
- bool +
- float32 +
- float64 +
- int +
- int8 +
- int16 +
- int32 +
- int64 +
- uint +
- uint8/byte +
- uint16 +
- uint32 +
- uint64 +
- string +
- echo.BindUnmarshaler interface +
- encoding.TextUnmarshaler interface +
- json.Unmarshaler interface +
- time.Duration +
- time.Time use echo.TimeOpts or echo.TimeLayout to set time parsing configuration +
func ParseValueOr[T any](value string, defaultValue T, opts ...any) (T, error)
+ +ParseValueOr parses value to generic type, when value is empty defaultValue is returned.
+Types that are supported:
+-
+
- bool +
- float32 +
- float64 +
- int +
- int8 +
- int16 +
- int32 +
- int64 +
- uint +
- uint8/byte +
- uint16 +
- uint32 +
- uint64 +
- string +
- echo.BindUnmarshaler interface +
- encoding.TextUnmarshaler interface +
- json.Unmarshaler interface +
- time.Duration +
- time.Time use echo.TimeOpts or echo.TimeLayout to set time parsing configuration +
func ParseValues[T any](values []string, opts ...any) ([]T, error)
+ +ParseValues parses value to generic type slice. Same types are supported as ParseValue +function but the result type is slice instead of scalar value.
+See ParseValue for supported types and options
func ParseValuesOr[T any](values []string, defaultValue []T, opts ...any) ([]T, error)
+ +ParseValuesOr parses value to generic type slice, when value is empty defaultValue is returned. +Same types are supported as ParseValue function but the result type is slice instead of scalar value.
+See ParseValue for supported types and options
func PathParam[T any](c *Context, paramName string, opts ...any) (T, error)
+ +PathParam extracts and parses a path parameter from the context by name. +It returns the typed value and an error if binding fails. Returns ErrNonExistentKey if parameter not found.
+Empty String Handling:
+
+
+
+
+
+If the parameter exists but has an empty value, the zero value of type T is returned
+with no error. For example, a path parameter with value "" returns (0, nil) for int types.
+This differs from standard library behavior where parsing empty strings returns errors.
+To treat empty values as errors, validate the result separately or check the raw value.See ParseValue for supported types and options
func PathParamOr[T any](c *Context, paramName string, defaultValue T, opts ...any) (T, error)
+ +PathParamOr extracts and parses a path parameter from the context by name. +Returns defaultValue if the parameter is not found or has an empty value. +Returns an error only if parsing fails (e.g., "abc" for int type).
+Example:
+
+
+
+
+
+id, err := echo.PathParamOr[int](c, "id", 0)
+// If "id" is missing: returns (0, nil)
+// If "id" is "123": returns (123, nil)
+// If "id" is "abc": returns (0, BindingError)See ParseValue for supported types and options
func PathValuesBinder(c *Context) *ValueBinder
+ +PathValuesBinder creates path parameter value binder
func QueryParam[T any](c *Context, key string, opts ...any) (T, error)
+ +QueryParam extracts and parses a single query parameter from the request by key. +It returns the typed value and an error if binding fails. Returns ErrNonExistentKey if parameter not found.
+Empty String Handling:
+
+
+
+
+
+If the parameter exists but has an empty value (?key=), the zero value of type T is returned
+with no error. For example, "?count=" returns (0, nil) for int types.
+This differs from standard library behavior where parsing empty strings returns errors.
+To treat empty values as errors, validate the result separately or check the raw value.Behavior Summary:
+-
+
- Missing key (?other=value): returns (zero, ErrNonExistentKey) +
- Empty value (?key=): returns (zero, nil) +
- Invalid value (?key=abc for int): returns (zero, BindingError) +
See ParseValue for supported types and options
func QueryParamOr[T any](c *Context, key string, defaultValue T, opts ...any) (T, error)
+ +QueryParamOr extracts and parses a single query parameter from the request by key. +Returns defaultValue if the parameter is not found or has an empty value. +Returns an error only if parsing fails (e.g., "abc" for int type).
+Example:
+
+
+
+
+
+page, err := echo.QueryParamOr[int](c, "page", 1)
+// If "page" is missing: returns (1, nil)
+// If "page" is "5": returns (5, nil)
+// If "page" is "abc": returns (1, BindingError)See ParseValue for supported types and options
func QueryParams[T any](c *Context, key string, opts ...any) ([]T, error)
+ +QueryParams extracts and parses all values for a query parameter key as a slice. +It returns the typed slice and an error if binding any value fails. Returns ErrNonExistentKey if parameter not found.
+See ParseValues for supported types and options
func QueryParamsBinder(c *Context) *ValueBinder
+ +QueryParamsBinder creates query parameter value binder
func QueryParamsOr[T any](c *Context, key string, defaultValue []T, opts ...any) ([]T, error)
+ +QueryParamsOr extracts and parses all values for a query parameter key as a slice. +Returns defaultValue if the parameter is not found. +Returns an error only if parsing any value fails.
+Example:
+
+
+
+
+
+ids, err := echo.QueryParamsOr[int](c, "ids", []int{})
+// If "ids" is missing: returns ([], nil)
+// If "ids" is "1&ids=2": returns ([1, 2], nil)
+// If "ids" contains "abc": returns ([], BindingError)See ParseValues for supported types and options
func ResolveResponseStatus(rw http.ResponseWriter, err error) (resp *Response, status int)
+ +ResolveResponseStatus returns the Response and HTTP status code that should be (or has been) sent for rw, +given an optional error.
+This function is useful for middleware and handlers that need to figure out the HTTP status +code to return based on the error that occurred or what was set in the response.
+Precedence rules:
+-
+
- If the response has already been committed, the committed status wins (err is ignored). +
- Otherwise, start with 200 OK (net/http default if WriteHeader is never called). +
- If the response has a non-zero suggested status, use it. +
- If err != nil, it overrides the suggested status:
-
+
- StatusCode(err) if non-zero +
- otherwise 500 Internal Server Error. +
+
func StaticDirectoryHandler(fileSystem fs.FS, disablePathUnescaping bool) HandlerFunc
+ +StaticDirectoryHandler creates handler function to serve files from provided file system +When disablePathUnescaping is set then file name from path is not unescaped and is served as is.
+Note: when disablePathUnescaping=false, the handler decodes the wildcard param before serving. +If route guards (e.g. e.GET("/admin/*", forbidden)) are used to restrict parts of the +filesystem, an encoded separator (%2F) or encoded dot-dot (%2E%2E) in the URL can resolve to +a path that the router never matched against the guard route. Enabling +RouterConfig.UseEscapedPathForMatching does NOT fix this — it changes which path the router +uses for matching but still lets path.Clean resolve ".." segments into a guarded directory. +Do not rely on route guards alone to restrict a filesystem served by this handler. +See https://github.com/labstack/echo/security/advisories/GHSA-vfp3-v2gw-7wfq
func StaticFileHandler(file string, filesystem fs.FS) HandlerFunc
+ +StaticFileHandler creates handler function to serve file from provided file system.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func StatusCode(err error) int
+ +StatusCode returns status code from err if it implements HTTPStatusCoder interface. +If err does not implement the interface, it returns 0.
func TrustIPRange(ipRange *net.IPNet) TrustOption
+ +TrustIPRange add trustable IP ranges using CIDR notation.
func TrustLinkLocal(v bool) TrustOption
+ +TrustLinkLocal configures if you trust link-local address (default: true).
func TrustLoopback(v bool) TrustOption
+ +TrustLoopback configures if you trust loopback address (default: true).
func TrustPrivateNet(v bool) TrustOption
+ +TrustPrivateNet configures if you trust private network address (default: true).
func UnwrapResponse(rw http.ResponseWriter) (*Response, error)
+ +UnwrapResponse unwraps given ResponseWriter to return contexts original Echo Response. rw has to implement
+following method Unwrap() http.ResponseWriter
func WrapHandler(h http.Handler) HandlerFunc
+ +WrapHandler wraps http.Handler into echo.HandlerFunc.
func WrapMiddleware(m func(http.Handler) http.Handler) MiddlewareFunc
+ +WrapMiddleware wraps func(http.Handler) http.Handler into echo.MiddlewareFunc
Types
+type AddRouteError
+ +AddRouteError is error returned by Router.Add containing information what actual route adding failed. Useful for +mass adding (i.e. Any() routes)
+
+
+
+
+
+type AddRouteError struct {
+ Err error
+ Method string
+ Path string
+}Fields
Err errorMethod stringPath string
func Error) Error() string
+ +func Unwrap() error
+ +type BindUnmarshaler
+ +BindUnmarshaler is the interface used to wrap the UnmarshalParam method. +Types that don't implement this, but do implement encoding.TextUnmarshaler +will use that interface instead.
+
+
+
+
+
+type BindUnmarshaler interface {
+ // UnmarshalParam decodes and assigns a value from an form or query param.
+ UnmarshalParam(param string) error
+}Methods
UnmarshalParam func(param string) errorUnmarshalParam decodes and assigns a value from an form or query param.
type Binder
+ +Binder is the interface that wraps the Bind method.
+
+
+
+
+
+type Binder interface {
+ Bind(c *Context, target any) error
+}Methods
Bind func(c *Context, target any) error
type BindingError
+ +BindingError represents an error that occurred while binding request data.
+Note: JSON serialization is handled by the MarshalJSON method below, not by the +struct tags (which are kept for documentation). MarshalJSON emits {"field","message"}.
+
+
+
+
+
+type BindingError struct {
+ // Field is the field name where value binding failed
+ Field string `json:"field"`
+ *HTTPError
+ // Values of parameter that failed to bind.
+ Values []string `json:"-"`
+}Fields
Field string`json:"field"`Field is the field name where value binding failed
*HTTPErrorValues []string`json:"-"`Values of parameter that failed to bind.
func Error) Error() string
+ +Error returns error message
func MarshalJSON() ([]byte, error)
+ +MarshalJSON implements json.Marshaler so that binding errors are serialized into +a structured response (e.g. {"field":"id","message":"..."}) rather than being +flattened to a generic message. DefaultHTTPErrorHandler routes errors that +implement json.Marshaler through their own encoding.
type Config
+ +Config is configuration for NewWithConfig function
+
+
+
+
+
+type Config struct {
+ // Logger is the slog logger instance used for application-wide structured logging.
+ // If not set, a default TextHandler writing to stdout is created.
+ Logger *slog.Logger
+
+ // HTTPErrorHandler is the centralized error handler that processes errors returned
+ // by handlers and middleware, converting them to appropriate HTTP responses.
+ // If not set, DefaultHTTPErrorHandler(false) is used.
+ HTTPErrorHandler HTTPErrorHandler
+
+ // Router is the HTTP request router responsible for matching URLs to handlers
+ // using a radix tree-based algorithm.
+ // If not set, NewRouter(RouterConfig{}) is used.
+ Router Router
+
+ // OnAddRoute is an optional callback hook executed when routes are registered.
+ // Useful for route validation, logging, or custom route processing.
+ // If not set, no callback is executed.
+ OnAddRoute func(route Route) error
+
+ // Filesystem is the fs.FS implementation used for serving static files.
+ // Supports os.DirFS, embed.FS, and custom implementations.
+ // If not set, defaults to current working directory.
+ Filesystem fs.FS
+
+ // Binder handles automatic data binding from HTTP requests to Go structs.
+ // Supports JSON, XML, form data, query parameters, and path parameters.
+ // If not set, DefaultBinder is used.
+ Binder Binder
+
+ // Validator provides optional struct validation after data binding.
+ // Commonly used with third-party validation libraries.
+ // If not set, Context.Validate() returns ErrValidatorNotRegistered.
+ Validator Validator
+
+ // Renderer provides template rendering for generating HTML responses.
+ // Requires integration with a template engine like html/template.
+ // If not set, Context.Render() returns ErrRendererNotRegistered.
+ Renderer Renderer
+
+ // JSONSerializer handles JSON encoding and decoding for HTTP requests/responses.
+ // Can be replaced with faster alternatives like jsoniter or sonic.
+ // If not set, DefaultJSONSerializer using encoding/json is used.
+ JSONSerializer JSONSerializer
+
+ // IPExtractor defines the strategy for extracting the real client IP address
+ // from requests, particularly important when behind proxies or load balancers.
+ // Used for rate limiting, access control, and logging.
+ // If not set, falls back to checking X-Forwarded-For and X-Real-IP headers.
+ IPExtractor IPExtractor
+
+ // FormParseMaxMemory is default value for memory limit that is used
+ // when parsing multipart forms (See (*http.Request).ParseMultipartForm)
+ FormParseMaxMemory int64
+
+ // EnablePathUnescapingStaticFiles enables path parameter (param: *) unescaping for static file methods.
+ // Default false (safe): encoded slashes (%2f) in the wildcard param are NOT decoded,
+ // preventing ACL bypass where /admin%2fprivate.txt bypasses a /admin/* route guard by
+ // not matching that route but having its wildcard param decoded to admin/private.txt.
+ // Set to true only when serving files whose names contain URL-encoded characters
+ // (e.g. "hello world.txt" via /hello%20world.txt) and you are not relying on
+ // route-based ACL guards to restrict access.
+ // If you are enabling this option, make sure you understand the security implications.
+ // See: https://github.com/labstack/echo/security/advisories/GHSA-vfp3-v2gw-7wfq
+ //
+ // Enabling RouterConfig.UseEscapedPathForMatching makes this field irrelevant and can lead to security issues when
+ // using different Routes to exclude some of the files from being served.
+ // e.g. if you serve files from directory as such and use different route to exclude some of the files from being served.
+ // 0. given folder structure:
+ // public/
+ // public/index.html
+ // public/admin/private.txt
+ // 1. share `public/` folder contents from the server root with `e.Static("/", "public")`
+ // 2. naively assume that everything under /admin folder is now forbidden
+ // e.GET("/admin/*", func(c *Context) error { return echo.ErrForbidden })
+ // Then request to `/assets/../admin%2fprivate.txt` will be served as router does not match it to guarded route.
+ //
+ // Applies to methods: Echo.Static, Echo.StaticFS, Group.Static, Group.StaticFS.
+ EnablePathUnescapingStaticFiles bool
+
+ // NoGroupAutoRegister404Routes bool is a flag that indicates whether echo.Group should NOT register 404 routes automatically
+ // when there are middlewares registered with the group.
+ // Note: if you decide not to register 404 routes automatically, make sure to check if all your middlewares are executed
+ // as expected. For example - CORS middleware.
+ NoGroupAutoRegister404Routes bool
+}Fields
Logger *slog.LoggerLogger is the slog logger instance used for application-wide structured logging. +If not set, a default TextHandler writing to stdout is created.
HTTPErrorHandler HTTPErrorHandlerHTTPErrorHandler is the centralized error handler that processes errors returned +by handlers and middleware, converting them to appropriate HTTP responses. +If not set, DefaultHTTPErrorHandler(false) is used.
Router RouterRouter is the HTTP request router responsible for matching URLs to handlers +using a radix tree-based algorithm. +If not set, NewRouter(RouterConfig{}) is used.
OnAddRoute func(route Route) errorOnAddRoute is an optional callback hook executed when routes are registered. +Useful for route validation, logging, or custom route processing. +If not set, no callback is executed.
Filesystem fs.FSFilesystem is the fs.FS implementation used for serving static files. +Supports os.DirFS, embed.FS, and custom implementations. +If not set, defaults to current working directory.
Binder BinderBinder handles automatic data binding from HTTP requests to Go structs. +Supports JSON, XML, form data, query parameters, and path parameters. +If not set, DefaultBinder is used.
Validator ValidatorValidator provides optional struct validation after data binding. +Commonly used with third-party validation libraries. +If not set, Context.Validate() returns ErrValidatorNotRegistered.
Renderer RendererRenderer provides template rendering for generating HTML responses. +Requires integration with a template engine like html/template. +If not set, Context.Render() returns ErrRendererNotRegistered.
JSONSerializer JSONSerializerJSONSerializer handles JSON encoding and decoding for HTTP requests/responses. +Can be replaced with faster alternatives like jsoniter or sonic. +If not set, DefaultJSONSerializer using encoding/json is used.
IPExtractor IPExtractorIPExtractor defines the strategy for extracting the real client IP address +from requests, particularly important when behind proxies or load balancers. +Used for rate limiting, access control, and logging. +If not set, falls back to checking X-Forwarded-For and X-Real-IP headers.
FormParseMaxMemory int64FormParseMaxMemory is default value for memory limit that is used +when parsing multipart forms (See (*http.Request).ParseMultipartForm)
EnablePathUnescapingStaticFiles boolEnablePathUnescapingStaticFiles enables path parameter (param: ) unescaping for static file methods. +Default false (safe): encoded slashes (%2f) in the wildcard param are NOT decoded, +preventing ACL bypass where /admin%2fprivate.txt bypasses a /admin/ route guard by +not matching that route but having its wildcard param decoded to admin/private.txt. +Set to true only when serving files whose names contain URL-encoded characters +(e.g. "hello world.txt" via /hello%20world.txt) and you are not relying on +route-based ACL guards to restrict access. +If you are enabling this option, make sure you understand the security implications. +See: https://github.com/labstack/echo/security/advisories/GHSA-vfp3-v2gw-7wfq
+Enabling RouterConfig.UseEscapedPathForMatching makes this field irrelevant and can lead to security issues when +using different Routes to exclude some of the files from being served. +e.g. if you serve files from directory as such and use different route to exclude some of the files from being served. +0. given folder structure: + public/ + public/index.html + public/admin/private.txt
+-
+
- share
public/folder contents from the server root withe.Static("/", "public")
+ - naively assume that everything under /admin folder is now forbidden
+ e.GET("/admin/*", func(c *Context) error { return echo.ErrForbidden })
+Then request to
/assets/../admin%2fprivate.txtwill be served as router does not match it to guarded route.
+
Applies to methods: Echo.Static, Echo.StaticFS, Group.Static, Group.StaticFS.
- share
NoGroupAutoRegister404Routes boolNoGroupAutoRegister404Routes bool is a flag that indicates whether echo.Group should NOT register 404 routes automatically +when there are middlewares registered with the group. +Note: if you decide not to register 404 routes automatically, make sure to check if all your middlewares are executed +as expected. For example - CORS middleware.
type Context
+ +Context represents the context of the current HTTP request. It holds request and +response objects, path, path parameters, data and registered handler.
+
+
+
+
+
+type Context struct {
+ // contains filtered or unexported fields
+}func Attachment(file, name string) error
+ +Attachment sends a response as attachment, prompting client to save the file.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func Bind(i any) error
+ +Bind binds path params, query params and the request body into provided type i. The default binder
+binds body based on Content-Type header.
func Blob(code int, contentType string, b []byte) (err error)
+ +Blob sends a blob response with status code and content type.
func Cookie(name string) (*http.Cookie, error)
+ +Cookie returns the named cookie provided in the request.
func Cookies() []*http.Cookie
+ +Cookies returns the HTTP cookies sent with the request.
func Echo() *Echo
+ +Echo returns the Echo instance.
func File(file string) error
+ +File sends a response with the content of the file.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func FileFS(file string, filesystem fs.FS) error
+ +FileFS serves file from given file system.
+When dealing with embed.FS use fs := echo.MustSubFS(fs, "rootDirectory") to create sub fs which uses necessary prefix for directory path. This is necessary as //go:embed assets/imagesembeds files with paths includingassets/images` as their prefix.
func FormFile(name string) (*multipart.FileHeader, error)
+ +FormFile returns the multipart form file for the provided name.
func FormValue(name string) string
+ +FormValue returns the form field value for the provided name.
func FormValueOr(name, defaultValue string) string
+ +FormValueOr returns the form field value or default value for the provided name. +Note: FormValueOr does not distinguish if form had no value by that name or value was empty string
func FormValues() (url.Values, error)
+ +FormValues returns the form field values as url.Values.
func Get(key string) any
+ +Get retrieves data from the context. +Method returns any(nil) when key does not exist which is different from typed nil (eg. []byte(nil)).
func HTML(code int, html string) (err error)
+ +HTML sends an HTTP response with status code.
func HTMLBlob(code int, b []byte) (err error)
+ +HTMLBlob sends an HTTP blob response with status code.
func InitializeRoute(ri *RouteInfo, pathValues *PathValues)
+ +InitializeRoute sets the route related variables of this request to the context.
func Inline(file, name string) error
+ +Inline sends a response as inline, opening the file in the browser.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func IsTLS() bool
+ +IsTLS returns true if HTTP connection is TLS otherwise false.
func IsWebSocket() bool
+ +IsWebSocket returns true if HTTP connection is WebSocket otherwise false.
func JSON(code int, i any) (err error)
+ +JSON sends a JSON response with status code.
func JSONBlob(code int, b []byte) (err error)
+ +JSONBlob sends a JSON blob response with status code.
func JSONP(code int, callback string, i any) (err error)
+ +JSONP sends a JSONP response with status code. It uses callback to construct
+the JSONP payload.
func JSONPBlob(code int, callback string, b []byte) (err error)
+ +JSONPBlob sends a JSONP blob response with status code. It uses callback
+to construct the JSONP payload.
func JSONPretty(code int, i any, indent string) (err error)
+ +JSONPretty sends a pretty-print JSON with status code.
func Logger() *slog.Logger
+ +Logger returns logger in Context
func MultipartForm() (*multipart.Form, error)
+ +MultipartForm returns the multipart form.
func NoContent(code int) error
+ +NoContent sends a response with no body and a status code.
func Param(name string) string
+ +Param returns path parameter by name.
func ParamOr(name, defaultValue string) string
+ +ParamOr returns the path parameter or default value for the provided name.
+Notes for DefaultRouter implementation: +Path parameter could be empty for cases like that:
+-
+
- route
/release-:version/binand request URL is/release-/bin
+ - route
/api/:version/image.jpgand request URL is/api//image.jpg+but not when path parameter is last part of route path
+ - route
/download/file.:extwill not match request/download/file.
+
func Path() string
+ +Path returns the registered path for the handler.
func PathValues() PathValues
+ +PathValues returns path parameter values.
func QueryParam(name string) string
+ +QueryParam returns the query param for the provided name.
func QueryParamOr(name, defaultValue string) string
+ +QueryParamOr returns the query param or default value for the provided name.
+Note: QueryParamOr does not distinguish if query had no value by that name or value was empty string
+This means URLs /test?search= and /test would both return 1 for c.QueryParamOr("search", "1")
func QueryParams() url.Values
+ +QueryParams returns the query parameters as url.Values.
func QueryString() string
+ +QueryString returns the URL query string.
func RealIP() string
+ +RealIP returns the client IP address using the configured extraction strategy.
+If Echo#IPExtractor is set, it is used to resolve the client IP from the incoming request (typically via proxy
+headers such as X-Forwarded-For or X-Real-IP).
+Look into the ip.go file for comments and examples.
See:
+-
+
- Echo#ExtractIPFromXFFHeader for
X-Forwarded-Forhandling with trust checks
+ - Echo#ExtractIPFromRealIPHeader for
X-Real-IPhandling with trust checks
+ - Echo#LegacyIPExtractor for
v4compatibility (spoofable, no trust checks built in)
+
If no extractor is configured, RealIP falls back to the request RemoteAddr, returning only the host portion.
+Notes:
+-
+
- No validation or trust enforcement is performed unless implemented by the configured IPExtractor. +
- When relying on proxy headers, ensure the application is deployed behind trusted intermediaries to avoid spoofing. +
func Redirect(code int, url string) error
+ +Redirect redirects the request to a provided URL with status code.
func Render(code int, name string, data any) (err error)
+ +Render renders a template with data and sends a text/html response with status
+code. Renderer must be registered using Echo.Renderer.
func Request() *http.Request
+ +Request returns *http.Request.
func Reset(r *http.Request, w http.ResponseWriter)
+ +Reset resets the context after request completes. It must be called along
+with Echo#AcquireContext() and Echo#ReleaseContext().
+See Echo#ServeHTTP()
func Response() http.ResponseWriter
+ +Response returns *Response.
func RouteInfo() RouteInfo
+ +RouteInfo returns current request route information. Method, Path, Name and params if they exist for matched route.
+RouteInfo returns generic "empty" struct for these cases:
+-
+
- Context is accessed before Routing is done. For example inside Pre middlewares (
e.Pre())
+ - Router did not find matching route - 404 (route not found) +
- Router did not find matching route with same method - 405 (method not allowed) +
func Scheme() string
+ +Scheme returns the HTTP protocol scheme, http or https.
func Set(key string, val any)
+ +Set saves data in the context.
func SetCookie(cookie *http.Cookie)
+ +SetCookie adds a Set-Cookie header in HTTP response.
func SetLogger(logger *slog.Logger)
+ +SetLogger sets logger in Context
func SetPath(p string)
+ +SetPath sets the registered path for the handler.
func SetPathValues(pathValues PathValues)
+ +SetPathValues sets path parameters for current request.
func SetRequest(r *http.Request)
+ +SetRequest sets *http.Request.
func SetResponse(r http.ResponseWriter)
+ +SetResponse sets *http.ResponseWriter. Some context methods and/or middleware require that given ResponseWriter implements following
+method Unwrap() http.ResponseWriter which eventually should return *echo.Response instance.
func Stream(code int, contentType string, r io.Reader) (err error)
+ +Stream sends a streaming response with status code and content type.
func String(code int, s string) (err error)
+ +String sends a string response with status code.
func Validate(i any) error
+ +Validate validates provided i. It is usually called after Context#Bind().
+Validator must be registered using Echo#Validator.
func XML(code int, i any) (err error)
+ +XML sends an XML response with status code.
func XMLBlob(code int, b []byte) (err error)
+ +XMLBlob sends an XML blob response with status code.
func XMLPretty(code int, i any, indent string) (err error)
+ +XMLPretty sends a pretty-print XML with status code.
type DefaultBinder
+ +DefaultBinder is the default implementation of the Binder interface.
+
+
+
+
+
+type DefaultBinder struct{}func Binder) Bind(c *Context, target any) error
+ +Bind implements the Binder#Bind function.
+Binding is done in following order: 1) path params; 2) query params; 3) request body. Each step COULD override previous
+step bound values. For single source binding use their own methods BindBody, BindQueryParams, BindPathValues.
type DefaultJSONSerializer
+ +DefaultJSONSerializer implements JSON encoding using encoding/json.
+
+
+
+
+
+type DefaultJSONSerializer struct{}func Deserialize(c *Context, target any) error
+ +Deserialize reads a JSON from a request body and converts it into an interface.
+The body is read into a pooled buffer and decoded with json.Unmarshal rather +than streaming through json.NewDecoder. This avoids allocating a decoder and +its internal read buffer on every request. json.Unmarshal does not retain a +reference to the input slice, so the buffer is safe to reuse afterwards.
+Note: the full request body is read into memory before decoding. As with any +JSON parser, decoding untrusted input can allocate large amounts of memory; +guard such endpoints with middleware.BodyLimit (or http.MaxBytesReader), +which makes the body read here fail fast once the limit is exceeded.
func Serializer) Serialize(c *Context, target any, indent string) error
+ +Serialize converts an interface into a json and writes it to the response. +You can optionally use the indent parameter to produce pretty JSONs.
type DefaultRouter
+ +DefaultRouter is the registry of all registered routes for an Echo instance for
+request matching and URL path parameter parsing.
+Note: DefaultRouter is not coroutine-safe. Do not Add/Remove routes after HTTP server has been started with Echo.
+
+
+
+
+
+type DefaultRouter struct {
+ // contains filtered or unexported fields
+}func Add(route Route) (RouteInfo, error)
+ +Add registers a new route for method and path with matching handler.
func Remove(method string, path string) error
+ +Remove unregisters registered route
func Router) Route(c *Context) HandlerFunc
+ +Route looks up a handler registered for method and path. It also parses URL for path parameters and loads them +into context.
+For performance:
+-
+
- Get context from
Echo#AcquireContext()
+ - Reset it
Context#Reset()
+ - Return it
Echo#ReleaseContext().
+
func Routes() Routes
+ +Routes returns all registered routes
type Echo
+ +Echo is the top-level framework instance.
+Goroutine safety: Do not mutate Echo instance fields after server has started. Accessing these +fields from handlers/middlewares and changing field values at the same time leads to data-races. +Same rule applies to adding new routes after server has been started - Adding a route is not Goroutine safe action.
+
+
+
+
+
+type Echo struct {
+ Binder Binder
+
+ // Filesystem is the file system used for serving static files. Defaults to the current working directory (os.Getwd()).
+ //
+ // Note: fs.FS.Open() already assumes that file names are relative to FS root path and considers name with prefix `/` as invalid
+ // so if you have `fs := os.DirFS("/tmp")` and you try to `fs.Open("/tmp/file.txt")` it will fail, but "file.txt"
+ // would succeed. `echo.NewDefaultFS("/tmp")` overwrites this behavior and allows you to use Open with a matching
+ // absolute path prefix.
+ Filesystem fs.FS
+
+ Renderer Renderer
+ Validator Validator
+ JSONSerializer JSONSerializer
+ IPExtractor IPExtractor
+ OnAddRoute func(route Route) error
+ HTTPErrorHandler HTTPErrorHandler
+ Logger *slog.Logger
+ // contains filtered or unexported fields
+}Fields
Binder BinderFilesystem fs.FSFilesystem is the file system used for serving static files. Defaults to the current working directory (os.Getwd()).
+Note: fs.FS.Open() already assumes that file names are relative to FS root path and considers name with prefix
/as invalid +so if you havefs := os.DirFS("/tmp")and you try tofs.Open("/tmp/file.txt")it will fail, but "file.txt" +would succeed.echo.NewDefaultFS("/tmp")overwrites this behavior and allows you to use Open with a matching +absolute path prefix.Renderer RendererValidator ValidatorJSONSerializer JSONSerializerIPExtractor IPExtractorOnAddRoute func(route Route) errorHTTPErrorHandler HTTPErrorHandlerLogger *slog.Logger
func AcquireContext() *Context
+ +AcquireContext returns an empty Context instance from the pool.
+You must return the context by calling ReleaseContext().
func Add(method, path string, handler HandlerFunc, middleware ...MiddlewareFunc) RouteInfo
+ +Add registers a new route for an HTTP method and path with matching handler +in the router with optional route-level middleware.
func AddRoute(route Route) (RouteInfo, error)
+ +AddRoute registers a new Route with default host Router
func Any(path string, handler HandlerFunc, middleware ...MiddlewareFunc) RouteInfo
+ +Any registers a new route for all HTTP methods (supported by Echo) and path with matching handler +in the router with optional route-level middleware.
+Note: this method only adds specific set of supported HTTP methods as handler and is not true +"catch-any-arbitrary-method" way of matching requests.
func CONNECT(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +CONNECT registers a new CONNECT route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func DELETE(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +DELETE registers a new DELETE route for a path with matching handler in the router +with optional route-level middleware. Panics on error.
func File(path, file string, middleware ...MiddlewareFunc) RouteInfo
+ +File registers a new route with path to serve a static file with optional route-level middleware. Panics on error.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func FileFS(path, file string, filesystem fs.FS, m ...MiddlewareFunc) RouteInfo
+ +FileFS registers a new route with path to serve file from the provided file system.
+Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func GET(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +GET registers a new GET route for a path with matching handler in the router +with optional route-level middleware. Panics on error.
func Group(prefix string, m ...MiddlewareFunc) (g *Group)
+ +Group creates a new router group with prefix and optional group-level middleware.
func HEAD(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +HEAD registers a new HEAD route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func Match(methods []string, path string, handler HandlerFunc, middleware ...MiddlewareFunc) Routes
+ +Match registers a new route for multiple HTTP methods and path with matching +handler in the router with optional route-level middleware. Panics on error.
func Middlewares() []MiddlewareFunc
+ +Middlewares returns registered route level middlewares. Does not contain any group level +middlewares. Use this method to build your own ServeHTTP method.
+NOTE: returned slice is not a copy. Do not mutate.
func NewContext(r *http.Request, w http.ResponseWriter) *Context
+ +NewContext returns a new Context instance.
+Note: both request and response can be left to nil as Echo.ServeHTTP will call c.Reset(req,resp) anyway +these arguments are useful when creating context for tests and cases like that.
func OPTIONS(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +OPTIONS registers a new OPTIONS route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func PATCH(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +PATCH registers a new PATCH route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func POST(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +POST registers a new POST route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func PUT(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +PUT registers a new PUT route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func Pre(middleware ...MiddlewareFunc)
+ +Pre adds middleware to the chain which is run before router tries to find matching route. +Meaning middleware is executed even for 404 (not found) cases.
func PreMiddlewares() []MiddlewareFunc
+ +PreMiddlewares returns registered pre middlewares. These are middleware to the chain +which are run before router tries to find matching route. +Use this method to build your own ServeHTTP method.
+NOTE: returned slice is not a copy. Do not mutate.
func QUERY(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +QUERY registers a new QUERY route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func ReleaseContext(c *Context)
+ +ReleaseContext returns the Context instance back to the pool.
+You must call it after AcquireContext().
func RouteNotFound(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +RouteNotFound registers a special-case route which is executed when no other route is found (i.e. HTTP 404 cases)
+for current request URL.
+Path supports static and named/any parameters just like other http method is defined. Generally path is ended with
+wildcard/match-any character (/*, /download/* etc).
Example: e.RouteNotFound("/*", func(c *echo.Context) error { return c.NoContent(http.StatusNotFound) })
func Router() Router
+ +Router returns the default router.
func ServeHTTP(w http.ResponseWriter, r *http.Request)
+ +ServeHTTP implements http.Handler interface, which serves HTTP requests.
func Start(address string) error
+ +Start stars HTTP server on given address with Echo as a handler serving requests. The server can be shutdown by
+sending os.Interrupt signal with ctrl+c. Method returns only errors that are not http.ErrServerClosed.
Note: this method is created for use in examples/demos and is deliberately simple without providing configuration +options.
+In need of customization use:
+
+
+
+
+
+ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+defer cancel()
+sc := echo.StartConfig{Address: ":8080"}
+if err := sc.Start(ctx, e); err != nil && !errors.Is(err, http.ErrServerClosed) {
+ slog.Error(err.Error())
+}// or standard library http.Server
+
+
+
+
+s := http.Server{Addr: ":8080", Handler: e}
+if err := s.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+ slog.Error(err.Error())
+}func Static(pathPrefix, fsRoot string, middleware ...MiddlewareFunc) RouteInfo
+ +Static registers a new route with path prefix to serve static files from the provided root directory.
func StaticFS(pathPrefix string, filesystem fs.FS, middleware ...MiddlewareFunc) RouteInfo
+ +StaticFS registers a new route with path prefix to serve static files from the provided file system.
+When dealing with embed.FS use fs := echo.MustSubFS(fs, "rootDirectory") to create sub fs which uses necessary prefix for directory path. This is necessary as //go:embed assets/imagesembeds files with paths includingassets/images` as their prefix.
func TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +TRACE registers a new TRACE route for a path with matching handler in the +router with optional route-level middleware. Panics on error.
func Use(middleware ...MiddlewareFunc)
+ +Use adds middleware to the chain which is run after router has found matching route and before route/request handler method is executed.
type Group
+ +Group is a set of sub-routes for a specified route. It can be used for inner +routes that share a common middleware or functionality that should be separate +from the parent echo instance while still inheriting from it.
+
+
+
+
+
+type Group struct {
+ // contains filtered or unexported fields
+}func Add(method, path string, handler HandlerFunc, middleware ...MiddlewareFunc) RouteInfo
+ +Add implements Echo#Add() for sub-routes within the Group. Panics on error.
func AddRoute(route Route) (RouteInfo, error)
+ +AddRoute registers a new Routable with Router
func Any(path string, handler HandlerFunc, middleware ...MiddlewareFunc) RouteInfo
+ +Any implements Echo#Any() for sub-routes within the Group. Panics on error.
func CONNECT(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +CONNECT implements Echo#CONNECT() for sub-routes within the Group. Panics on error.
func DELETE(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +DELETE implements Echo#DELETE() for sub-routes within the Group. Panics on error.
func File(path, file string, middleware ...MiddlewareFunc) RouteInfo
+ +File implements Echo#File() for sub-routes within the Group. Panics on error.
Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func FileFS(path, file string, filesystem fs.FS, m ...MiddlewareFunc) RouteInfo
+ +FileFS implements Echo#FileFS() for sub-routes within the Group.
Avoid using the leading / slash as most of the Go standard library fs.FS implementations require relative paths for
+file operations.
func GET(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +GET implements Echo#GET() for sub-routes within the Group. Panics on error.
func Group) Group(prefix string, middleware ...MiddlewareFunc) (sg *Group)
+ +Group creates a new sub-group with prefix and optional sub-group-level middleware.
+Important! Group middlewares are executed in case there was no exact route match as by default Group registers
+/* NotFound routes for itself. If this kind of behavior is not needed, then create an Echo instance with the noAutoRegisterRoutes
+flag set to true. Example echo.NewWithConfig(echo.Config{NoGroupAutoRegister404Routes: true}).
func HEAD(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +HEAD implements Echo#HEAD() for sub-routes within the Group. Panics on error.
func Match(methods []string, path string, handler HandlerFunc, middleware ...MiddlewareFunc) Routes
+ +Match implements Echo#Match() for sub-routes within the Group. Panics on error.
func OPTIONS(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +OPTIONS implements Echo#OPTIONS() for sub-routes within the Group. Panics on error.
func PATCH(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +PATCH implements Echo#PATCH() for sub-routes within the Group. Panics on error.
func POST(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +POST implements Echo#POST() for sub-routes within the Group. Panics on error.
func PUT(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +PUT implements Echo#PUT() for sub-routes within the Group. Panics on error.
func QUERY(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +QUERY implements Echo#QUERY() for sub-routes within the Group. Panics on error.
func RouteNotFound(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +RouteNotFound implements Echo#RouteNotFound() for sub-routes within the Group.
Example: g.RouteNotFound("/*", func(c *echo.Context) error { return c.NoContent(http.StatusNotFound) })
func Static(pathPrefix, fsRoot string, middleware ...MiddlewareFunc) RouteInfo
+ +Static implements Echo#Static() for sub-routes within the Group.
func StaticFS(pathPrefix string, filesystem fs.FS, middleware ...MiddlewareFunc) RouteInfo
+ +StaticFS implements Echo#StaticFS() for sub-routes within the Group.
When dealing with embed.FS use fs := echo.MustSubFS(fs, "rootDirectory") to create sub fs which uses necessary prefix for directory path. This is necessary as //go:embed assets/imagesembeds files with paths includingassets/images` as their prefix.
func TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) RouteInfo
+ +TRACE implements Echo#TRACE() for sub-routes within the Group. Panics on error.
func Use(middleware ...MiddlewareFunc)
+ +Use implements Echo#Use() for sub-routes within the Group.
Important! Group middlewares are executed in case there was no exact route match as by default Group registers
+/* NotFound routes for itself. If this kind of behavior is not needed, then create an Echo instance with the noAutoRegisterRoutes
+flag set to true. Example echo.NewWithConfig(echo.Config{NoGroupAutoRegister404Routes: true}).
type HTTPError
+ +HTTPError represents an error that occurred while handling a request.
+
+
+
+
+
+type HTTPError struct {
+ // Code is status code for HTTP response
+ Code int `json:"-"`
+ Message string `json:"message"`
+ // contains filtered or unexported fields
+}Fields
Code int`json:"-"`Code is status code for HTTP response
Message string`json:"message"`
func Error) Error() string
+ +Error makes it compatible with the error interface.
func StatusCode() int
+ +StatusCode returns status code for HTTP response
func Unwrap() error
+ +func Wrap(err error) error
+ +Wrap returns a new HTTPError with given errors wrapped inside
type HTTPErrorHandler
+ +HTTPErrorHandler is a centralized HTTP error handler.
+
+
+
+
+
+type HTTPErrorHandler func(c *Context, err error)type HTTPStatusCoder
+ +HTTPStatusCoder is an interface that errors can implement to produce status code for HTTP response
+
+
+
+
+
+type HTTPStatusCoder interface {
+ StatusCode() int
+}Methods
StatusCode func() int
type HandlerFunc
+ +HandlerFunc defines a function to serve HTTP requests.
+
+
+
+
+
+type HandlerFunc func(c *Context) errortype IPExtractor
+ +IPExtractor is a function to extract IP addr from http.Request. +Set appropriate one to Echo#IPExtractor. +See https://echo.labstack.com/guide/ip-address for more details.
+
+
+
+
+
+type IPExtractor func(*http.Request) stringtype JSONSerializer
+ +JSONSerializer is the interface that encodes and decodes JSON to and from interfaces.
+
+
+
+
+
+type JSONSerializer interface {
+ Serialize(c *Context, target any, indent string) error
+ Deserialize(c *Context, target any) error
+}Methods
Serialize func(c *Context, target any, indent string) errorDeserialize func(c *Context, target any) error
type MiddlewareConfigurator
+ +MiddlewareConfigurator defines interface for creating middleware handlers with possibility to return configuration errors instead of panicking.
+
+
+
+
+
+type MiddlewareConfigurator interface {
+ ToMiddleware() (MiddlewareFunc, error)
+}Methods
ToMiddleware func() (MiddlewareFunc, error)
type MiddlewareFunc
+ +MiddlewareFunc defines a function to process middleware.
+
+
+
+
+
+type MiddlewareFunc func(next HandlerFunc) HandlerFunctype PathValue
+ +PathValue is tuple pf path parameter name and its value in request path
+
+
+
+
+
+type PathValue struct {
+ Name string
+ Value string
+}Fields
Name stringValue string
type PathValues
+ +PathValues is collections of PathValue instances with various helper methods
+
+
+
+
+
+type PathValues []PathValuefunc Get(name string) (string, bool)
+ +Get returns path parameter value for given name or false.
func GetOr(name string, defaultValue string) string
+ +GetOr returns path parameter value for given name or default value if the name does not exist.
type Renderer
+ +Renderer is the interface that wraps the Render function.
+
+
+
+
+
+type Renderer interface {
+ Render(c *Context, w io.Writer, templateName string, data any) error
+}Methods
Render func(c *Context, w io.Writer, templateName string, data any) error
type Response
+ +Response wraps an http.ResponseWriter and implements its interface to be used +by an HTTP handler to construct an HTTP response. +See: https://golang.org/pkg/net/http/#ResponseWriter
+
+
+
+
+
+type Response struct {
+ http.ResponseWriter
+
+ Status int
+ Size int64
+ Committed bool
+ // contains filtered or unexported fields
+}Fields
http.ResponseWriterStatus intSize int64Committed bool
func After(fn func())
+ +After registers a function which is called just after the response is written.
func Before(fn func())
+ +Before registers a function which is called just before the response (status) is written.
func Flush()
+ +Flush implements the http.Flusher interface to allow an HTTP handler to flush +buffered data to the client. +See http.Flusher
func Hijack() (net.Conn, *bufio.ReadWriter, error)
+ +Hijack implements the http.Hijacker interface to allow an HTTP handler to +take over the connection. +This method is relevant to Websocket connection upgrades, proxis, and other advanced use cases. +See http.Hijacker
func Unwrap() http.ResponseWriter
+ +Unwrap returns the original http.ResponseWriter. +ResponseController can be used to access the original http.ResponseWriter. +See [https://go.dev/blog/go1.20]
func Write(b []byte) (n int, err error)
+ +Write writes the data to the connection as part of an HTTP reply.
func WriteHeader(code int)
+ +WriteHeader sends an HTTP response header with status code. If WriteHeader is +not called explicitly, the first call to Write will trigger an implicit +WriteHeader(http.StatusOK). Thus explicit calls to WriteHeader are mainly +used to send error codes.
type Route
+ +Route contains information to adding/registering new route with the router. +Method+Path pair uniquely identifies the Route. It is mandatory to provide Method+Path fields.
+
+
+
+
+
+type Route struct {
+ Method string
+ Path string
+ Name string
+
+ // HandlerFunc is a function that handles HTTP requests. This could be left nil when the Router implementation allows
+ // fallback to default/global handlers in certain situations.
+ Handler HandlerFunc
+ Middlewares []MiddlewareFunc
+}Fields
Method stringPath stringName stringHandler HandlerFuncHandlerFunc is a function that handles HTTP requests. This could be left nil when the Router implementation allows +fallback to default/global handlers in certain situations.
Middlewares []MiddlewareFunc
func ToRouteInfo(params []string) RouteInfo
+ +ToRouteInfo converts Route to RouteInfo
func WithPrefix(pathPrefix string, middlewares []MiddlewareFunc) Route
+ +WithPrefix recreates Route with added group prefix and group middlewares it is grouped to.
type RouteInfo
+ +RouteInfo contains information about registered Route.
+
+
+
+
+
+type RouteInfo struct {
+ Name string
+ Method string
+ Path string
+ Parameters []string
+}Fields
Name stringMethod stringPath stringParameters []string
func Clone() RouteInfo
+ +Clone creates copy of RouteInfo
func Reverse(pathValues ...any) string
+ +Reverse reverses route to URL string by replacing path parameters with given params values.
type Router
+ +Router is interface for routing request contexts to registered routes.
+Contract between Echo/Context instance and the router:
+-
+
- all routes must be added through methods on echo.Echo instance.
+Reason: Echo instance uses RouteInfo.Params() length to allocate slice for paths parameters (see
Echo.contextPathParamAllocSize).
+ - Router must populate Context during Router.Route call with: +
- Context.InitializeRoute (IMPORTANT! to reduce allocations use same slice that c.PathValues() returns) +
- Optionally can set additional information to Context with Context.Set +
+
+
+
+
+
+type Router interface {
+ // Add registers Routable with the Router and returns registered RouteInfo.
+ //
+ // Router may change Route.Path value in returned RouteInfo.Path.
+ // Router generates RouteInfo.Parameters values from Route.Path.
+ // Router generates RouteInfo.Name value if it is not provided.
+ Add(routable Route) (RouteInfo, error)
+
+ // Remove removes route from the Router.
+ //
+ // Router may choose not to implement this method.
+ Remove(method string, path string) error
+
+ // Routes returns information about all registered routes
+ Routes() Routes
+
+ // Route searches Router for matching route and applies it to the given context. In case when no matching method
+ // was not found (405) or no matching route exists for path (404), router will return its implementation of 405/404
+ // handler function.
+ //
+ // Router must populate Context during Router.Route call with:
+ // - Context.InitializeRoute() (IMPORTANT! to reduce allocations use same slice that c.PathValues() returns)
+ // - optionally can set additional information to Context with Context.Set()
+ Route(c *Context) HandlerFunc
+}Methods
Add func(routable Route) (RouteInfo, error)Add registers Routable with the Router and returns registered RouteInfo.
+Router may change Route.Path value in returned RouteInfo.Path. +Router generates RouteInfo.Parameters values from Route.Path. +Router generates RouteInfo.Name value if it is not provided.
Remove func(method string, path string) errorRemove removes route from the Router.
+Router may choose not to implement this method.
Routes func() RoutesRoutes returns information about all registered routes
Route func(c *Context) HandlerFuncRoute searches Router for matching route and applies it to the given context. In case when no matching method +was not found (405) or no matching route exists for path (404), router will return its implementation of 405/404 +handler function.
+Router must populate Context during Router.Route call with:
+-
+
- Context.InitializeRoute() (IMPORTANT! to reduce allocations use same slice that c.PathValues() returns) +
- optionally can set additional information to Context with Context.Set() +
type RouterConfig
+ +RouterConfig is configuration options for (default) router
+
+
+
+
+
+type RouterConfig struct {
+ // NotFoundHandler is a handler that is executed when no route matches the request.
+ NotFoundHandler HandlerFunc
+
+ // MethodNotAllowedHandler is a handler that is executed when no route with exact METHOD matches the request but
+ // there is a route with same path but different method.
+ MethodNotAllowedHandler HandlerFunc
+
+ // OptionsMethodHandler is a handler that is executed when an OPTIONS request is made.
+ OptionsMethodHandler HandlerFunc
+
+ // AllowOverwritingRoute allows overwriting existing routes. If false, then adding a route with the same method
+ // and path will return an error.
+ AllowOverwritingRoute bool
+
+ // UnescapePathParamValues forces router to unescape path parameter values before setting them in context.
+ UnescapePathParamValues bool
+
+ // UseEscapedPathForMatching forces router to use an escaped path (req.URL.RawPath instead of req.URL.Path) for matching.
+ // Difference between URL.RawPath and URL.Path is:
+ // * URL.Path is where request path is stored. Value is stored in decoded form: /%47%6f%2f becomes /Go/.
+ // * URL.RawPath is an optional field which only gets set if the default encoding is different from Path.
+ UseEscapedPathForMatching bool
+
+ // AutoHandleHEAD enables automatic handling of HTTP HEAD requests by
+ // falling back to the corresponding GET route.
+ //
+ // When enabled, a HEAD request will match the same handler as GET for
+ // the route, but the response body is suppressed in accordance with
+ // HTTP semantics. Headers (e.g., Content-Length, Content-Type) are
+ // preserved as if a GET request was made.
+ //
+ // Security considerations: the GET handler is fully executed for every
+ // HEAD request, including all side effects:
+ // - State-mutating operations (DB writes, audit logs, counters) run.
+ // - Rate-limiting middleware consumes quota, enabling low-cost exhaustion.
+ // - Expensive computations run with no response body returned to the
+ // caller, making HEAD cheaper to abuse for DoS than GET.
+ // - All GET routes become enumerable via HEAD probing (200 = route
+ // exists, 405 = route absent).
+ //
+ // If route confidentiality/state-mutation is a concern, leave AutoHandleHEAD disabled
+ // and register explicit HEAD handlers only for routes that are safe to
+ // expose (e.g. e.HEAD("/public", handler)).
+ // You can leverage Echo.OnAddRoute callback to add HEAD routes explicitly from a single place.
+ //
+ // Disabled by default.
+ AutoHandleHEAD bool
+}Fields
NotFoundHandler HandlerFuncNotFoundHandler is a handler that is executed when no route matches the request.
MethodNotAllowedHandler HandlerFuncMethodNotAllowedHandler is a handler that is executed when no route with exact METHOD matches the request but +there is a route with same path but different method.
OptionsMethodHandler HandlerFuncOptionsMethodHandler is a handler that is executed when an OPTIONS request is made.
AllowOverwritingRoute boolAllowOverwritingRoute allows overwriting existing routes. If false, then adding a route with the same method +and path will return an error.
UnescapePathParamValues boolUnescapePathParamValues forces router to unescape path parameter values before setting them in context.
UseEscapedPathForMatching boolUseEscapedPathForMatching forces router to use an escaped path (req.URL.RawPath instead of req.URL.Path) for matching. +Difference between URL.RawPath and URL.Path is:
+-
+
- URL.Path is where request path is stored. Value is stored in decoded form: /%47%6f%2f becomes /Go/. +
- URL.RawPath is an optional field which only gets set if the default encoding is different from Path. +
AutoHandleHEAD boolAutoHandleHEAD enables automatic handling of HTTP HEAD requests by +falling back to the corresponding GET route.
+When enabled, a HEAD request will match the same handler as GET for +the route, but the response body is suppressed in accordance with +HTTP semantics. Headers (e.g., Content-Length, Content-Type) are +preserved as if a GET request was made.
+Security considerations: the GET handler is fully executed for every +HEAD request, including all side effects:
+-
+
- State-mutating operations (DB writes, audit logs, counters) run. +
- Rate-limiting middleware consumes quota, enabling low-cost exhaustion. +
- Expensive computations run with no response body returned to the +caller, making HEAD cheaper to abuse for DoS than GET. +
- All GET routes become enumerable via HEAD probing (200 = route +exists, 405 = route absent). +
If route confidentiality/state-mutation is a concern, leave AutoHandleHEAD disabled +and register explicit HEAD handlers only for routes that are safe to +expose (e.g. e.HEAD("/public", handler)). +You can leverage Echo.OnAddRoute callback to add HEAD routes explicitly from a single place.
+Disabled by default.
type Routes
+ +Routes is collection of RouteInfo instances with various helper methods.
+
+
+
+
+
+type Routes []RouteInfofunc Clone() Routes
+ +Clone creates copy of Routes
func FilterByMethod(method string) (Routes, error)
+ +FilterByMethod searched for matching route info by method
func FilterByName(name string) (Routes, error)
+ +FilterByName searched for matching route info by name
func FilterByPath(path string) (Routes, error)
+ +FilterByPath searched for matching route info by path
func FindByMethodPath(method string, path string) (RouteInfo, error)
+ +FindByMethodPath searched for matching route info by method and path
func Reverse(routeName string, pathValues ...any) (string, error)
+ +Reverse reverses route to URL string by replacing path parameters with given params values.
type StartConfig
+ +StartConfig is for creating configured http.Server instance to start serve http(s) requests with given Echo instance
+
+
+
+
+
+type StartConfig struct {
+ // Address specifies the address where listener will start listening on to serve HTTP(s) requests
+ Address string
+
+ // HideBanner instructs Start* method not to print banner when starting the Server.
+ HideBanner bool
+ // HidePort instructs Start* method not to print port when starting the Server.
+ HidePort bool
+
+ // CertFilesystem is filesystem is used to read `certFile` and `keyFile` when StartTLS method is called.
+ CertFilesystem fs.FS
+
+ // TLSConfig is used to configure TLS. If Listener is set, TLSConfig is not used to create the listener.
+ TLSConfig *tls.Config
+
+ // Listener is used to start server with the custom listener.
+ Listener net.Listener
+ // ListenerNetwork is used configure on which Network listener will use.
+ // If Listener is set, ListenerNetwork is not used.
+ ListenerNetwork string
+ // ListenerAddrFunc will be called after listener is created and started to listen for connections. This is useful in
+ // testing situations when server is started on random port `address = ":0"` in that case you can get actual port where
+ // listener is listening on.
+ ListenerAddrFunc func(addr net.Addr)
+
+ // GracefulTimeout is timeout value (defaults to 10sec) graceful shutdown will wait for server to handle ongoing requests
+ // before shutting down the server.
+ GracefulTimeout time.Duration
+ // OnShutdownError is called when graceful shutdown results an error. for example when listeners are not shut down within
+ // given timeout
+ OnShutdownError func(err error)
+
+ // BeforeServeFunc is callback that is called just before server starts to serve HTTP request.
+ // Use this callback when you want to configure http.Server different timeouts/limits/etc
+ BeforeServeFunc func(s *http.Server) error
+}Fields
Address stringAddress specifies the address where listener will start listening on to serve HTTP(s) requests
HideBanner boolHideBanner instructs Start* method not to print banner when starting the Server.
HidePort boolHidePort instructs Start* method not to print port when starting the Server.
CertFilesystem fs.FSCertFilesystem is filesystem is used to read
certFileandkeyFilewhen StartTLS method is called.TLSConfig *tls.ConfigTLSConfig is used to configure TLS. If Listener is set, TLSConfig is not used to create the listener.
Listener net.ListenerListener is used to start server with the custom listener.
ListenerNetwork stringListenerNetwork is used configure on which Network listener will use. +If Listener is set, ListenerNetwork is not used.
ListenerAddrFunc func(addr net.Addr)ListenerAddrFunc will be called after listener is created and started to listen for connections. This is useful in +testing situations when server is started on random port
address = ":0"in that case you can get actual port where +listener is listening on.GracefulTimeout time.DurationGracefulTimeout is timeout value (defaults to 10sec) graceful shutdown will wait for server to handle ongoing requests +before shutting down the server.
OnShutdownError func(err error)OnShutdownError is called when graceful shutdown results an error. for example when listeners are not shut down within +given timeout
BeforeServeFunc func(s *http.Server) errorBeforeServeFunc is callback that is called just before server starts to serve HTTP request. +Use this callback when you want to configure http.Server different timeouts/limits/etc
func StartConfig) Start(ctx stdContext.Context, h http.Handler) error
+ +Start starts given Handler with HTTP(s) server.
func StartTLS(ctx stdContext.Context, h http.Handler, certFile, keyFile any) error
+ +StartTLS starts given Handler with HTTPS server.
+If certFile or keyFile is string the values are treated as file paths.
+If certFile or keyFile is []byte the values are treated as the certificate or key as-is.
type TemplateRenderer
+ +TemplateRenderer is helper to ease creating renderers for html/template and text/template packages.
+Example usage:
+
+
+
+
+ e.Renderer = &echo.TemplateRenderer{
+ Template: template.Must(template.ParseGlob("templates/*.html")),
+ }
+
+ e.Renderer = &echo.TemplateRenderer{
+ Template: template.Must(template.New("hello").Parse("Hello, {{.}}!")),
+ }
+
+
+
+
+
+type TemplateRenderer struct {
+ Template interface {
+ ExecuteTemplate(wr io.Writer, name string, data any) error
+ }
+}Fields
Template interface { + ExecuteTemplate(wr io.Writer, name string, data any) error +}
func Renderer) Render(c *Context, w io.Writer, name string, data any) error
+ +Render renders the template with given data.
type TimeLayout
+ +TimeLayout specifies the format for parsing time values in request parameters. +It can be a standard Go time layout string or one of the special Unix time layouts.
+
+
+
+
+
+type TimeLayout stringtype TimeOpts
+ +TimeOpts is options for parsing time.Time values
+
+
+
+
+
+type TimeOpts struct {
+ // Layout specifies the format for parsing time values in request parameters.
+ // It can be a standard Go time layout string or one of the special Unix time layouts.
+ //
+ // Parsing layout defaults to: echo.TimeLayout(time.RFC3339Nano)
+ // - To convert to custom layout use `echo.TimeLayout("2006-01-02")`
+ // - To convert unix timestamp (integer) to time.Time use `echo.TimeLayoutUnixTime`
+ // - To convert unix timestamp in milliseconds to time.Time use `echo.TimeLayoutUnixTimeMilli`
+ // - To convert unix timestamp in nanoseconds to time.Time use `echo.TimeLayoutUnixTimeNano`
+ Layout TimeLayout
+
+ // ParseInLocation is location used with time.ParseInLocation for layout that do not contain
+ // timezone information to set output time in given location.
+ // Defaults to time.UTC
+ ParseInLocation *time.Location
+
+ // ToInLocation is location to which parsed time is converted to after parsing.
+ // The parsed time will be converted using time.In(ToInLocation).
+ // Defaults to time.UTC
+ ToInLocation *time.Location
+}Fields
Layout TimeLayoutLayout specifies the format for parsing time values in request parameters. +It can be a standard Go time layout string or one of the special Unix time layouts.
+Parsing layout defaults to: echo.TimeLayout(time.RFC3339Nano)
+-
+
- To convert to custom layout use
echo.TimeLayout("2006-01-02")
+ - To convert unix timestamp (integer) to time.Time use
echo.TimeLayoutUnixTime
+ - To convert unix timestamp in milliseconds to time.Time use
echo.TimeLayoutUnixTimeMilli
+ - To convert unix timestamp in nanoseconds to time.Time use
echo.TimeLayoutUnixTimeNano
+
- To convert to custom layout use
ParseInLocation *time.LocationParseInLocation is location used with time.ParseInLocation for layout that do not contain +timezone information to set output time in given location. +Defaults to time.UTC
ToInLocation *time.LocationToInLocation is location to which parsed time is converted to after parsing. +The parsed time will be converted using time.In(ToInLocation). +Defaults to time.UTC
type TrustOption
+ +TrustOption is config for which IP address to trust
+
+
+
+
+
+type TrustOption func(*ipChecker)type Validator
+ +Validator is the interface that wraps the Validate function.
+
+
+
+
+
+type Validator interface {
+ Validate(i any) error
+}Methods
Validate func(i any) error
type ValueBinder
+ +ValueBinder provides utility methods for binding query or path parameter to various Go built-in types
+
+
+
+
+
+type ValueBinder struct {
+ // ValueFunc is used to get single parameter (first) value from request
+ ValueFunc func(sourceParam string) string
+ // ValuesFunc is used to get all values for parameter from request. i.e. `/api/search?ids=1&ids=2`
+ ValuesFunc func(sourceParam string) []string
+ // ErrorFunc is used to create errors. Allows you to use your own error type, that for example marshals to your specific json response
+ ErrorFunc func(sourceParam string, values []string, message string, internalError error) error
+ // contains filtered or unexported fields
+}Fields
ValueFunc func(sourceParam string) stringValueFunc is used to get single parameter (first) value from request
ValuesFunc func(sourceParam string) []stringValuesFunc is used to get all values for parameter from request. i.e.
/api/search?ids=1&ids=2ErrorFunc func(sourceParam string, values []string, message string, internalError error) errorErrorFunc is used to create errors. Allows you to use your own error type, that for example marshals to your specific json response
func BindError() error
+ +BindError returns first seen bind error and resets/empties binder errors for further calls
Example
+
+
+
+
+
+
+{
+
+ failFastRouteFunc := func(c *echo.Context) error {
+ var opts struct {
+ IDs []int64
+ Active bool
+ }
+ length := int64(50)
+
+ b := echo.QueryParamsBinder(c)
+
+ err := b.Int64("length", &length).
+ Int64s("ids", &opts.IDs).
+ Bool("active", &opts.Active).
+ BindError()
+ if err != nil {
+ bErr := err.(*echo.BindingError)
+ return fmt.Errorf("my own custom error for field: %s values: %v", bErr.Field, bErr.Values)
+ }
+ fmt.Printf("active = %v, length = %v, ids = %v\n", opts.Active, length, opts.IDs)
+
+ return c.JSON(http.StatusOK, opts)
+ }
+
+ e := echo.New()
+ c := e.NewContext(
+ httptest.NewRequest(http.MethodGet, "/api/endpoint?active=true&length=25&ids=1&ids=2&ids=3", nil),
+ httptest.NewRecorder(),
+ )
+
+ _ = failFastRouteFunc(c)
+
+}Output:
+
+
+
+
+
+
+active = true, length = 25, ids = [1 2 3]func BindErrors() []error
+ +BindErrors returns all bind errors and resets/empties binder errors for further calls
Example
+
+
+
+
+
+
+{
+
+ routeFunc := func(c *echo.Context) error {
+ var opts struct {
+ IDs []int64
+ Active bool
+ }
+ length := int64(50)
+
+ b := echo.QueryParamsBinder(c)
+
+ errs := b.Int64("length", &length).
+ Int64s("ids", &opts.IDs).
+ Bool("active", &opts.Active).
+ BindErrors()
+ if errs != nil {
+ for _, err := range errs {
+ bErr := err.(*echo.BindingError)
+ log.Printf("in case you want to access what field: %s values: %v failed", bErr.Field, bErr.Values)
+ }
+ return fmt.Errorf("%v fields failed to bind", len(errs))
+ }
+ fmt.Printf("active = %v, length = %v, ids = %v", opts.Active, length, opts.IDs)
+
+ return c.JSON(http.StatusOK, opts)
+ }
+
+ e := echo.New()
+ c := e.NewContext(
+ httptest.NewRequest(http.MethodGet, "/api/endpoint?active=true&length=25&ids=1&ids=2&ids=3", nil),
+ httptest.NewRecorder(),
+ )
+
+ _ = routeFunc(c)
+
+}Output:
+
+
+
+
+
+
+active = true, length = 25, ids = [1 2 3]func BindUnmarshaler(sourceParam string, dest BindUnmarshaler) *ValueBinder
+ +BindUnmarshaler binds parameter to destination implementing BindUnmarshaler interface
func BindWithDelimiter(sourceParam string, dest any, delimiter string) *ValueBinder
+ +BindWithDelimiter binds parameter to destination by suitable conversion function. +Delimiter is used before conversion to split parameter value to separate values
func Bool(sourceParam string, dest *bool) *ValueBinder
+ +Bool binds parameter to bool variable
func Bools(sourceParam string, dest *[]bool) *ValueBinder
+ +Bools binds parameter values to slice of bool variables
func Byte(sourceParam string, dest *byte) *ValueBinder
+ +Byte binds parameter to byte variable
func CustomFunc(sourceParam string, customFunc func(values []string) []error) *ValueBinder
+ +CustomFunc binds parameter values with Func. Func is called only when parameter values exist.
Example
+
+
+
+
+
+
+{
+
+ routeFunc := func(c *echo.Context) error {
+ length := int64(50)
+ var binary []byte
+
+ b := echo.QueryParamsBinder(c)
+ errs := b.Int64("length", &length).
+ CustomFunc("base64", func(values []string) []error {
+ if len(values) == 0 {
+ return nil
+ }
+ decoded, err := base64.URLEncoding.DecodeString(values[0])
+ if err != nil {
+
+ return []error{echo.NewBindingError("base64", values[0:1], "failed to decode base64", err)}
+ }
+ binary = decoded
+ return nil
+ }).
+ BindErrors()
+
+ if errs != nil {
+ for _, err := range errs {
+ bErr := err.(*echo.BindingError)
+ log.Printf("in case you want to access what field: %s values: %v failed", bErr.Field, bErr.Values)
+ }
+ return fmt.Errorf("%v fields failed to bind", len(errs))
+ }
+ fmt.Printf("length = %v, base64 = %s", length, binary)
+
+ return c.JSON(http.StatusOK, "ok")
+ }
+
+ e := echo.New()
+ c := e.NewContext(
+ httptest.NewRequest(http.MethodGet, "/api/endpoint?length=25&base64=SGVsbG8gV29ybGQ%3D", nil),
+ httptest.NewRecorder(),
+ )
+ _ = routeFunc(c)
+
+}Output:
+
+
+
+
+
+
+length = 25, base64 = Hello Worldfunc Duration(sourceParam string, dest *time.Duration) *ValueBinder
+ +Duration binds parameter to time.Duration variable
func Durations(sourceParam string, dest *[]time.Duration) *ValueBinder
+ +Durations binds parameter values to slice of time.Duration variables
func FailFast(value bool) *ValueBinder
+ +FailFast set internal flag to indicate if binding methods will return early (without binding) when previous bind failed +NB: call this method before any other binding methods as it modifies binding methods behaviour
func Float32(sourceParam string, dest *float32) *ValueBinder
+ +Float32 binds parameter to float32 variable
func Float32s(sourceParam string, dest *[]float32) *ValueBinder
+ +Float32s binds parameter values to slice of float32 variables
func Float64(sourceParam string, dest *float64) *ValueBinder
+ +Float64 binds parameter to float64 variable
func Float64s(sourceParam string, dest *[]float64) *ValueBinder
+ +Float64s binds parameter values to slice of float64 variables
func Int(sourceParam string, dest *int) *ValueBinder
+ +Int binds parameter to int variable
func Int16(sourceParam string, dest *int16) *ValueBinder
+ +Int16 binds parameter to int16 variable
func Int16s(sourceParam string, dest *[]int16) *ValueBinder
+ +Int16s binds parameter to slice of int16
func Int32(sourceParam string, dest *int32) *ValueBinder
+ +Int32 binds parameter to int32 variable
func Int32s(sourceParam string, dest *[]int32) *ValueBinder
+ +Int32s binds parameter to slice of int32
func Int64(sourceParam string, dest *int64) *ValueBinder
+ +Int64 binds parameter to int64 variable
func Int64s(sourceParam string, dest *[]int64) *ValueBinder
+ +Int64s binds parameter to slice of int64
func Int8(sourceParam string, dest *int8) *ValueBinder
+ +Int8 binds parameter to int8 variable
func Int8s(sourceParam string, dest *[]int8) *ValueBinder
+ +Int8s binds parameter to slice of int8
func Ints(sourceParam string, dest *[]int) *ValueBinder
+ +Ints binds parameter to slice of int
func JSONUnmarshaler(sourceParam string, dest json.Unmarshaler) *ValueBinder
+ +JSONUnmarshaler binds parameter to destination implementing json.Unmarshaler interface
func MustBindUnmarshaler(sourceParam string, dest BindUnmarshaler) *ValueBinder
+ +MustBindUnmarshaler requires parameter value to exist to bind to destination implementing BindUnmarshaler interface. +Returns error when value does not exist
func MustBindWithDelimiter(sourceParam string, dest any, delimiter string) *ValueBinder
+ +MustBindWithDelimiter requires parameter value to exist to bind destination by suitable conversion function. +Delimiter is used before conversion to split parameter value to separate values
func MustBool(sourceParam string, dest *bool) *ValueBinder
+ +MustBool requires parameter value to exist to bind to bool variable. Returns error when value does not exist
func MustBools(sourceParam string, dest *[]bool) *ValueBinder
+ +MustBools requires parameter values to exist to bind to slice of bool variables. Returns error when values does not exist
func MustByte(sourceParam string, dest *byte) *ValueBinder
+ +MustByte requires parameter value to exist to bind to byte variable. Returns error when value does not exist
func MustCustomFunc(sourceParam string, customFunc func(values []string) []error) *ValueBinder
+ +MustCustomFunc requires parameter values to exist to bind with Func. Returns error when value does not exist.
func MustDuration(sourceParam string, dest *time.Duration) *ValueBinder
+ +MustDuration requires parameter value to exist to bind to time.Duration variable. Returns error when value does not exist
func MustDurations(sourceParam string, dest *[]time.Duration) *ValueBinder
+ +MustDurations requires parameter values to exist to bind to slice of time.Duration variables. Returns error when values does not exist
func MustFloat32(sourceParam string, dest *float32) *ValueBinder
+ +MustFloat32 requires parameter value to exist to bind to float32 variable. Returns error when value does not exist
func MustFloat32s(sourceParam string, dest *[]float32) *ValueBinder
+ +MustFloat32s requires parameter values to exist to bind to slice of float32 variables. Returns error when values does not exist
func MustFloat64(sourceParam string, dest *float64) *ValueBinder
+ +MustFloat64 requires parameter value to exist to bind to float64 variable. Returns error when value does not exist
func MustFloat64s(sourceParam string, dest *[]float64) *ValueBinder
+ +MustFloat64s requires parameter values to exist to bind to slice of float64 variables. Returns error when values does not exist
func MustInt(sourceParam string, dest *int) *ValueBinder
+ +MustInt requires parameter value to exist to bind to int variable. Returns error when value does not exist
func MustInt16(sourceParam string, dest *int16) *ValueBinder
+ +MustInt16 requires parameter value to exist to bind to int16 variable. Returns error when value does not exist
func MustInt16s(sourceParam string, dest *[]int16) *ValueBinder
+ +MustInt16s requires parameter value to exist to bind to int16 slice variable. Returns error when value does not exist
func MustInt32(sourceParam string, dest *int32) *ValueBinder
+ +MustInt32 requires parameter value to exist to bind to int32 variable. Returns error when value does not exist
func MustInt32s(sourceParam string, dest *[]int32) *ValueBinder
+ +MustInt32s requires parameter value to exist to bind to int32 slice variable. Returns error when value does not exist
func MustInt64(sourceParam string, dest *int64) *ValueBinder
+ +MustInt64 requires parameter value to exist to bind to int64 variable. Returns error when value does not exist
func MustInt64s(sourceParam string, dest *[]int64) *ValueBinder
+ +MustInt64s requires parameter value to exist to bind to int64 slice variable. Returns error when value does not exist
func MustInt8(sourceParam string, dest *int8) *ValueBinder
+ +MustInt8 requires parameter value to exist to bind to int8 variable. Returns error when value does not exist
func MustInt8s(sourceParam string, dest *[]int8) *ValueBinder
+ +MustInt8s requires parameter value to exist to bind to int8 slice variable. Returns error when value does not exist
func MustInts(sourceParam string, dest *[]int) *ValueBinder
+ +MustInts requires parameter value to exist to bind to int slice variable. Returns error when value does not exist
func MustJSONUnmarshaler(sourceParam string, dest json.Unmarshaler) *ValueBinder
+ +MustJSONUnmarshaler requires parameter value to exist to bind to destination implementing json.Unmarshaler interface. +Returns error when value does not exist
func MustString(sourceParam string, dest *string) *ValueBinder
+ +MustString requires parameter value to exist to bind to string variable. Returns error when value does not exist
func MustStrings(sourceParam string, dest *[]string) *ValueBinder
+ +MustStrings requires parameter values to exist to bind to slice of string variables. Returns error when value does not exist
func MustTextUnmarshaler(sourceParam string, dest encoding.TextUnmarshaler) *ValueBinder
+ +MustTextUnmarshaler requires parameter value to exist to bind to destination implementing encoding.TextUnmarshaler interface. +Returns error when value does not exist
func MustTime(sourceParam string, dest *time.Time, layout string) *ValueBinder
+ +MustTime requires parameter value to exist to bind to time.Time variable. Returns error when value does not exist
func MustTimes(sourceParam string, dest *[]time.Time, layout string) *ValueBinder
+ +MustTimes requires parameter values to exist to bind to slice of time.Time variables. Returns error when values does not exist
func MustUint(sourceParam string, dest *uint) *ValueBinder
+ +MustUint requires parameter value to exist to bind to uint variable. Returns error when value does not exist
func MustUint16(sourceParam string, dest *uint16) *ValueBinder
+ +MustUint16 requires parameter value to exist to bind to uint16 variable. Returns error when value does not exist
func MustUint16s(sourceParam string, dest *[]uint16) *ValueBinder
+ +MustUint16s requires parameter value to exist to bind to uint16 slice variable. Returns error when value does not exist
func MustUint32(sourceParam string, dest *uint32) *ValueBinder
+ +MustUint32 requires parameter value to exist to bind to uint32 variable. Returns error when value does not exist
func MustUint32s(sourceParam string, dest *[]uint32) *ValueBinder
+ +MustUint32s requires parameter value to exist to bind to uint32 slice variable. Returns error when value does not exist
func MustUint64(sourceParam string, dest *uint64) *ValueBinder
+ +MustUint64 requires parameter value to exist to bind to uint64 variable. Returns error when value does not exist
func MustUint64s(sourceParam string, dest *[]uint64) *ValueBinder
+ +MustUint64s requires parameter value to exist to bind to uint64 slice variable. Returns error when value does not exist
func MustUint8(sourceParam string, dest *uint8) *ValueBinder
+ +MustUint8 requires parameter value to exist to bind to uint8 variable. Returns error when value does not exist
func MustUint8s(sourceParam string, dest *[]uint8) *ValueBinder
+ +MustUint8s requires parameter value to exist to bind to uint8 slice variable. Returns error when value does not exist
func MustUints(sourceParam string, dest *[]uint) *ValueBinder
+ +MustUints requires parameter value to exist to bind to uint slice variable. Returns error when value does not exist
func MustUnixTime(sourceParam string, dest *time.Time) *ValueBinder
+ +MustUnixTime requires parameter value to exist to bind to time.Time variable (in local time corresponding +to the given Unix time). Returns error when value does not exist.
+Example: 1609180603 bind to 2020-12-28T18:36:43.000000000+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
func MustUnixTimeMilli(sourceParam string, dest *time.Time) *ValueBinder
+ +MustUnixTimeMilli requires parameter value to exist to bind to time.Time variable (in local time corresponding +to the given Unix time in millisecond precision). Returns error when value does not exist.
+Example: 1647184410140 bind to 2022-03-13T15:13:30.140000000+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
func MustUnixTimeNano(sourceParam string, dest *time.Time) *ValueBinder
+ +MustUnixTimeNano requires parameter value to exist to bind to time.Time variable (in local time corresponding +to the given Unix time value in nanosecond precision). Returns error when value does not exist.
+Example: 1609180603123456789 binds to 2020-12-28T18:36:43.123456789+00:00 +Example: 1000000000 binds to 1970-01-01T00:00:01.000000000+00:00 +Example: 999999999 binds to 1970-01-01T00:00:00.999999999+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
- Javascript's Number type only has about 53 bits of precision (Number.MAX_SAFE_INTEGER = 9007199254740991). Compare it to 1609180603123456789 in example. +
func String(sourceParam string, dest *string) *ValueBinder
+ +String binds parameter to string variable
func Strings(sourceParam string, dest *[]string) *ValueBinder
+ +Strings binds parameter values to slice of string
func TextUnmarshaler(sourceParam string, dest encoding.TextUnmarshaler) *ValueBinder
+ +TextUnmarshaler binds parameter to destination implementing encoding.TextUnmarshaler interface
func Time(sourceParam string, dest *time.Time, layout string) *ValueBinder
+ +Time binds parameter to time.Time variable
func Times(sourceParam string, dest *[]time.Time, layout string) *ValueBinder
+ +Times binds parameter values to slice of time.Time variables
func Uint(sourceParam string, dest *uint) *ValueBinder
+ +Uint binds parameter to uint variable
func Uint16(sourceParam string, dest *uint16) *ValueBinder
+ +Uint16 binds parameter to uint16 variable
func Uint16s(sourceParam string, dest *[]uint16) *ValueBinder
+ +Uint16s binds parameter to slice of uint16
func Uint32(sourceParam string, dest *uint32) *ValueBinder
+ +Uint32 binds parameter to uint32 variable
func Uint32s(sourceParam string, dest *[]uint32) *ValueBinder
+ +Uint32s binds parameter to slice of uint32
func Uint64(sourceParam string, dest *uint64) *ValueBinder
+ +Uint64 binds parameter to uint64 variable
func Uint64s(sourceParam string, dest *[]uint64) *ValueBinder
+ +Uint64s binds parameter to slice of uint64
func Uint8(sourceParam string, dest *uint8) *ValueBinder
+ +Uint8 binds parameter to uint8 variable
func Uint8s(sourceParam string, dest *[]uint8) *ValueBinder
+ +Uint8s binds parameter to slice of uint8
func Uints(sourceParam string, dest *[]uint) *ValueBinder
+ +Uints binds parameter to slice of uint
func UnixTime(sourceParam string, dest *time.Time) *ValueBinder
+ +UnixTime binds parameter to time.Time variable (in local Time corresponding to the given Unix time).
+Example: 1609180603 bind to 2020-12-28T18:36:43.000000000+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
func UnixTimeMilli(sourceParam string, dest *time.Time) *ValueBinder
+ +UnixTimeMilli binds parameter to time.Time variable (in local time corresponding to the given Unix time in millisecond precision).
+Example: 1647184410140 bind to 2022-03-13T15:13:30.140000000+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
func UnixTimeNano(sourceParam string, dest *time.Time) *ValueBinder
+ +UnixTimeNano binds parameter to time.Time variable (in local time corresponding to the given Unix time in nanosecond precision).
+Example: 1609180603123456789 binds to 2020-12-28T18:36:43.123456789+00:00 +Example: 1000000000 binds to 1970-01-01T00:00:01.000000000+00:00 +Example: 999999999 binds to 1970-01-01T00:00:00.999999999+00:00
+Note:
+-
+
- time.Time{} (param is empty) and time.Unix(0,0) (param = "0") are not equal +
- Javascript's Number type only has about 53 bits of precision (Number.MAX_SAFE_INTEGER = 9007199254740991). Compare it to 1609180603123456789 in example. +