Response
Send String
Use the context method Context#String(code int, s string) to respond with HTTP status code and plain text data.
func(c slim.Context) error {
return c.String(http.StatusOK, "Hello, World!")
}
Send HTML
Use the context method Context#HTML(code int, html string) to send simple HTML text. If we want to send dynamically generated HTML, refer to the Template chapter.
func(c slim.Context) error {
return c.HTML(http.StatusOK, "<strong>Hello, World!</strong>")
}
Send HTML Blob
Use the context method Context#HTMLBlob(code int, b []byte) to send HTML blob content with status.
Render Template
Refer to the Template chapter for more information.
Send JSON
Use the context method Context#JSON(code int, i any) to serialize the provided Go type data to JSON data and respond with status code.
// User
type User struct {
Name string `json:"name" xml:"name"`
Email string `json:"email" xml:"email"`
}
// Handler
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "jon@go-slim.dev",
}
return c.JSON(http.StatusOK, u)
}
Stream JSON
Since the method Context#JSON() internally uses json.Marshal to serialize data, it may not be efficient for large JSON. In this case, we can use streaming to transmit JSON, example:
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "jon@go-slim.dev",
}
c.Response().Header().Set(slim.HeaderContentType, slim.MIMEApplicationJSONCharsetUTF8)
c.Response().WriteHeader(http.StatusOK)
return json.NewEncoder(c.Response()).Encode(u)
}
Pretty JSON
Use the context method Context#JSONPretty(code int, i any, indent string) to send JSON data indented with spaces or tabs.
The example below sends JSON data indented with spaces:
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "joe@go-slim.dev",
}
return c.JSONPretty(http.StatusOK, u, " ")
}
{
"email": "joe@go-slim.dev",
"name": "Jon"
}
JSON Blob
Use the context method Context#JSONBlob(code int, b []byte) to directly send pre-encoded JSON blob from external sources, such as from a database.
func(c slim.Context) error {
encodedJSON := []byte{} // Encoded JSON from external source
return c.JSONBlob(http.StatusOK, encodedJSON)
}
Send JSONP
Use the context method Context#JSONP(code int, callback string, i any) to respond with provided JSON data in a JavaScript script callback manner.
Send XML
Use the context method Context#XML(code int, i any) to encode the provided Go type data to XML format text and send it with status code.
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "jon@go-slim.dev",
}
return c.XML(http.StatusOK, u)
}
Stream XML
The context method Context#XML uses Go's built-in xml.Marshal to encode data, which may not be efficient for large XML. In this case, we can speed up response by transmitting XML through streaming.
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "jon@go-slim.dev",
}
c.Response().Header().Set(slim.HeaderContentType, slim.MIMEApplicationXMLCharsetUTF8)
c.Response().WriteHeader(http.StatusOK)
return xml.NewEncoder(c.Response()).Encode(u)
}
Pretty XML
Use the context method Context#XMLPretty(code int, i any, indent string) to send XML data indented with spaces or tabs.
The example below sends XML data indented with spaces:
func(c slim.Context) error {
u := &User{
Name: "Jon",
Email: "joe@go-slim.dev",
}
return c.XMLPretty(http.StatusOK, u, " ")
}
Result:
<?xml version="1.0" encoding="UTF-8"?>
<User>
<Name>Jon</Name>
<Email>joe@go-slim.dev</Email>
</User>
XML Blob
Use the context method Context#XMLBlob(code int, b []byte) to directly send pre-encoded XML blob data from external sources, such as from a database.
func(c slim.Context) error {
encodedXML := []byte{} // Encoded XML from external source
return c.XMLBlob(http.StatusOK, encodedXML)
}
Send File
Use the context method Context#File(file string) to send file content based on Slim#Filesystem as response. It automatically sets the correct content type and handles caching gracefully.
func(c slim.Context) error {
return c.File("<PATH_TO_YOUR_FILE>")
}
Send Attachment
Use the context method Context#Attachment(file, name string) to send a file as an attachment. The browser will download the file to the user's device using the name we provide.
func(c slim.Context) error {
return c.Attachment("<PATH_TO_YOUR_FILE>", "<ATTACHMENT_NAME>")
}
Send Inline File
Use the context method Context#Inline(file, name string) to send a file inline (i.e., as a webpage or part of a page) to the browser.
func(c slim.Context) error {
return c.Inline("<PATH_TO_YOUR_FILE>")
}
Send Blob
Use the context method Context#Blob(code int, contentType string, b []byte) for byte slices, but we must provide the correct MIME type so clients can understand our intent.
func(c slim.Context) (err error) {
data := []byte(`0306703,0035866,NO_ACTION,06/19/2006
0086003,"0005866",UPDATED,06/19/2006`)
return c.Blob(http.StatusOK, "text/csv", data)
}
Send Stream
Use the context method Context#Stream(code int, contentType string, r io.Reader) to send data from an io.Reader interface as a streaming response. We must provide the correct MIME type so clients can understand our intent.
func(c slim.Context) error {
f, err := os.Open("<PATH_TO_IMAGE>")
if err != nil {
return err
}
return c.Stream(http.StatusOK, "image/png", f)
}
Send Nothing
Use the context method Context#NoContent(code int) to send the specified status code. This method does not respond with any content.
The commonly used status code is 204 - http.StatusNoContent.
func(c slim.Context) error {
return c.NoContent(http.StatusOK)
}
Redirect Request
Use the context method Context#Redirect(code int, url string) for request redirection.
// handler a request
func(c slim.Context) error {
return c.Redirect(http.StatusMovedPermanently, "<URL>")
}