# 所有 Context 方法
这是`iris.Context`提供的方法的完整列表。
```
type Context interface {
// ResponseWriter 会按预期返回与http.ResponseWriter兼容的响应编写器。
ResponseWriter() ResponseWriter
// ResetResponseWriter 应该更改或升级 Context 的 ResponseWriter。
ResetResponseWriter(ResponseWriter)
// Request 请求按预期返回原始的 *http.Request 。
Request() *http.Request
// ResetRequest 设置Context 的 Request,
// 这个对于保存一个标准的 *http.Request#WithContext() 创建的新请求到 Iris' Context 很有用。
// 当出于某种原因要进行完整填充覆盖 *http.Request 的时候，请使用 `ResetRequest` 。
// 注意： 当你只想更改一个字段时，可以使用 Request() 返回指向 Request 的指针，
// 所以这样的更改将会在没有完全覆盖的情况下生效。
// 使用方法: 使用本地 http 处理程序 ，该处理程序使用标准的 "context" 包
// 获取值而不是 Iris 的 Context#Values():
// r := ctx.Request()
// stdCtx := context.WithValue(r.Context(), key, val)
// ctx.ResetRequest(r.WithContext(stdCtx)) 。
ResetRequest(r *http.Request)
// SetCurrentRouteName 在内部设置路由名称，
// 为了让开发人员调用 `GetCurrentRoute()` 方法的时候，
// 能够找到正确的当前 “只读” 路由。
// 它将由路由器初始化， 如果你手动修改名称
// 实际上什么都不会发生，除非你通过 `GetCurrentRoute()`
// 方法获得其他路由。
// 相反的，在当前上下文中执行不同的路径
// 你应该使用 `Exec` 方法
// 或者通过 `SetHandlers/AddHandler` 方法改变处理程序。
SetCurrentRouteName(currentRouteName string)
// GetCurrentRoute 返回正在被注册到当前请求路径的 "只读" 路由。
GetCurrentRoute() RouteReadOnly
// 调用 SetHandlers(handlers)
// 并执行第一个处理程序，
// 处理程序不应为空。
//
// 它由路由器使用， 开发人员可以使用它
// 立即替换并执行处理程序。
Do(Handlers)
// AddHandler 以添加处理程序到
// 服务时间内的当前请求中，
// 这些处理程序不会持久化到路由器。
//
// 路由器正在调用此函数以添加路由的处理程序。
// 如果 AddHandler 被调用， 则将插入处理程序
// 至已定义路由的处理程序的末尾。
//
AddHandler(...Handler)
// SetHandlers 用新的替换所有处理程序。
SetHandlers(Handlers)
// Handlers 继续跟踪当前处理程序。
Handlers() Handlers
// HandlerIndex 设置当前上下文的处理程序链
// 的当前索引。
// 如果传递了 -1，则返回
// 当前处理程序索引，而不更改当前索引。
//
// 同时查看 Handlers(), Next() 和 StopExecution() 。
HandlerIndex(n int) (currentIndex int)
// Proceed 是一种用于检查 一个特定的处理程序
// 是否被执行并且调用 `ctx.Next` 方法的替代方法。
// 这是有用的仅仅在当你在另一个处理程序
// 内运行一个处理程序.
// 它只是检查前索引和后索引。
//
// 一个用例是当你要在控制器的 `BeginRequest`
// 里面执行一个调用 `ctx.Next`的中间件。
// 控制器将整个流程 (BeginRequest, method handler, EndRequest)
// 当作一个处理程序， 所以如果 `ctx.Next` 在 `BeginRequest` 里面调用。
// 将不会影响到 method handler
//
// 尽管 `BeginRequest` 不应该用于调用其他处理程序，
// `BeginRequest` 已经被引入以便能够去设置
// 通用数据到所有处理程序，在它们被执行前。
// 控制器能想通常那样从 MVC 的应用的路由中接受中间件。
//
// 这样说，让我们来看一个 `ctx.Proceed` 的示例：
//
// var authMiddleware = basicauth.New(basicauth.Config{
// Users: map[string]string{
// "admin": "password",
// },
// })
//
// func (c *UsersController) BeginRequest(ctx iris.Context) {
// if !ctx.Proceed(authMiddleware) {
// ctx.StopExecution()
// }
// }
// Get() 将在和 `BeginRequest` 相同的处理程序中执行,
// 内部控制器检查 `ctx.StopExecution`。
// 那么 如果 BeginRequest 调用 `StopExecution`，则它不会被触发。
// func(c *UsersController) Get() []models.User {
// return c.Service.GetAll()
//}
// 如果中间件在失败时使用`ctx.StopExecution()` ，则替代方法是 `!ctx.IsStopped()`。
Proceed(Handler) bool
// HandlerName 返回当前处理程序的名称，这有助于调试。
HandlerName() string
// HandlerFileLine 返回当前处理程序的源文件和行信息。
// 主要在调试时有用。
HandlerFileLine() (file string, line int)
// RouteName 返回处理程序运行时的路由名称。
// 注意： 它将在未找到的处理程序上返回空值。
RouteName() string
// Next 调用处理程序链中的所有下一个处理程序，
// 应该在中间件内部使用。
//
// 注意： 自定义上下文应覆盖此方法，以便能够传递其自己的context.Context实现。
Next()
// NextOr 检查链是否具有下一个处理程序，如果有，则执行它
// 否则会根据给定的处理程序设置分配给此Context的新链
// 并执行其第一个处理程序。
//
// 如果存在并执行下一个处理程序，则返回true，否则返回false。
//
// 注意，如果找不到下一个处理程序，并且缺少处理程序，则
// 它将状态未找到(404)发送到客户端，并停止执行。
NextOr(handlers ...Handler) bool
// NextOrNotFound 检查链是否具有下一个处理程序，如果有，则执行它
// 否则它将状态未找到(404)发送给客户端并停止执行。
//
// 如果存在并执行下一个处理程序，则返回true，否则返回false。
NextOrNotFound() bool
// NextHandler 返回 (不执行) 理程序链中的下一个处理程序。
//
// 使用 .Skip() 跳过此处理程，如果需要执行此返回处理程序的下一个。
NextHandler() Handler
// Skip 跳过/忽略处理程序链中的下一个处理程序，
// 应该在中间件内部使用。
Skip()
// StopExecution如果被调用，则以下 .Next 调用将被忽略，
// 因此，不会触发链中的下一个处理程序。
StopExecution()
// IsStopped 检查并返回 true ，如果Context的当前位置为255。
// 表示调用了StopExecution()。
IsStopped() bool
// OnConnectionClose 注册将被触发的 "cb" 函数 (在其自身的 goroutine 中， 不需要 end-dev 注册的 goroutine )
// 当基础连接消失时。
//
// 此机制可用于取消服务器上的长时间操作
// 如果客户端在响应准备就绪之前已断开连接。
//
// 它取决于 `http#CloseNotify`。
// CloseNotify 可能会一直等待通知，直到 Request.Body 被
// 完整阅读。
//
// 在主处理程序返回后，无法保证
// 通道接收值。
//
// 最后，它报告协议是否支持管道 (HTTP/1.1禁用管道将不被支持)。
// "cb" 将不会触发 ,如果输出值是 false,
//
// 注意， 只能注册一个回调, 对于整个请求处理程序链/每个路由。
//
//查找` `ResponseWriter#CloseNotifier` 了解更多。
OnConnectionClose(fnGoroutine func()) bool
// OnClose 使用 `Context#OnConnectionClose`将回调函数 "cb" 注册到下划线连接关闭事件
// ，并在请求处理程序的末尾使用`ResponseWriter#SetBeforeFlush`。
// 注意， 只能注册一个回调, 对于整个请求处理程序链/每个路由。
//
// 有关更多信息，请参见 `Context#OnConnectionClose` 和 `ResponseWriter#SetBeforeFlush` 。
OnClose(cb func())
// +------------------------------------------------------------+
// | 在处理程序之间，当前 "用户/请求" 储存 |
// | 和分享信息 - Values(). |
// | 保存和获取命名路径参数 - Params() |
// +------------------------------------------------------------+
// Params 返回当前URL的命名参数键值存储。
// 命名路径参数将保存在此处。
// 此存储，作为整个上下文，是每个请求的生命周期。
Params() *RequestParams
// Values 返回当前 "user" 存储。
// 命名路径参数和任何可选数据将被保存在这里。
// 此存储，作为整个上下文，是每个请求的生命周期。
//
// 你可以使用此函数设置和获取本地值
// 可用于在处理程序和中间件之间共享信息
Values() *memstore.Store
// +------------------------------------------------------------+
// | 路径, Host, 子域, IP, Headers,本地化等... |
// +------------------------------------------------------------+
// Method 返回 request.Method，(客户端的http方法) 到服务器。
Method() string
// Path 返回完整的请求路径，
// 如果 EnablePathEscape 配置字段为true，则转义。
Path() string
// RequestPath 返回基于 '转义' 的完整的请求路径。
RequestPath(escape bool) string
// Host 返回当前网址的主机部分。
Host() string
// Subdomain返回此请求的子域(如果有)。
// 请注意，这是一种快速方法，无法涵盖所有情况。
Subdomain() (subdomain string)
// IsWWW 返回 true ，如果当前子域(如果有)是 www。
IsWWW() bool
// FullRqeuestURI 返回完整的URI，
// 包括方案，主机和相对的请求路径/资源。
FullRequestURI() string
// RemoteAddr 尝试解析并返回真实客户端的请求IP。
//
// 基于可以从 Configuration.RemoteAddrHeaders 修改的允许的标头名称。
//
// 如果基于这些标头的解析失败，则它将返回请求的 `RemoteAddr` 字段，
// 那些由服务器在HTTP处理程序之前填充的。
//
// 通过查看 `Configuration.RemoteAddrHeaders`,
// `Configuration.WithRemoteAddrHeader(...)`,
// `Configuration.WithoutRemoteAddrHeader(...)` 了解更多。
RemoteAddr() string
// GetHeader根据名称返回请求标头的值。
GetHeader(name string) string
// IsAjax 返回 true ，如果请求是一个 'ajax 请求'( XMLHttpRequest)。
//
// 没有100％的方式知道通过Ajax发出请求。
// 永远不要信任来自客户端的数据， 它们可以轻易的通过欺骗的手段被发送到服务器。
//
// /注意 ， "X-Requested-With" 头可以被任何客户端修改(因为 "X-"前缀)，
// 因此，不要依赖 IsAjax 处理真正的严重问题。
// 尝试找到另一种检测类型（即内容类型)的方法，
// 有许多博客描述了这些问题并提供了不同的解决方案，
//它始终取决于你正在构建的应用程序，
//这就是为什么 `IsAjax` 对于常规用途足够简单的原因。
//
//有关更多信息，请访问：https://developer.mozilla.org/en-US/docs/AJAX
// 和 https://xhr.spec.whatwg.org/ 。
IsAjax() bool
// IsMobile 检查客户端是否正在使用移动设备(电话或平板电脑)与此服务器进行通信。
// 如果返回值为true，则表示使用移动设备的http客户端
// 与服务器通信，否则为false。
//
// 请注意，这会检查 "User-Agent" 请求头。
IsMobile() bool
// GetReferrer 按照指定的方式从 "Referer" 头中提取并返回信息
// 在 https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy 中
// o或通过URL查询参数 "referer"。
GetReferrer() Referrer
// GetLocale返回由i18n中间件找到的当前请求的 `Locale`。
// 同 `Tr` 一样。
GetLocale() Locale
// Tr根据带有可选参数的格式返回一个i18n本地化消息。
// 同 `GetLocale` 一样。
// 示例: https://github.com/kataras/iris/tree/master/_examples/i18n
Tr(format string, args ...interface{}) string
// +------------------------------------------------------------+
// | Headers 辅助方法 |
// +------------------------------------------------------------+
// Header 将头添加到响应编写器
Header(name string, value string)
// ContentType 将响应编写者头的键名 "Content-Type" 设置为 'cType' 的值。
ContentType(cType string)
// GetContentType 返回响应编写者 "Content-Type" 头的值
// 它可以用 'ContentType' 提前设置。
GetContentType() string
// GetContentType 返回请求的 "Content-Type" 头的值
GetContentTypeRequested() string
// GetContentLength 返回 请求 "Content-Length" 头的值。
// 返回 0 ，如果它的值是一个不能被找到或者不是有效数据的时候。
GetContentLength() int64
// StatusCode 设置响应的状态码头
// 同 .`GetStatusCode` 一样。
StatusCode(statusCode int)
// GetStatusCode 返回当前响应的状态码
// 同 `StatusCode` 一样。
GetStatusCode() int
// AbsoluteURI 解析“ s”并返回其绝对URI形式。
AbsoluteURI(s string) string
// Redirect 发送一个重定向响应发送到客户端
// 指向特定的网址或相对路径。
// 接受2个参数字符串和一个可选的int
// 第一个参数是要重定向的网址
// 第二个参数是应该发送的http状态，
// 默认值为302(StatusFound)，
// 你可以将其设置为301(永久重定向)
// 或303(StatusSeeOther)(如果采用POST方法)，
// 或StatusTemporaryRedirect(307)(如果需要的话)。
Redirect(urlToRedirect string, statusHeader ...int)
// +------------------------------------------------------------+
// | 各种请求和发布数据 |
// +------------------------------------------------------------+
// URLParam 如果url参数存在，则URLParam返回true，否则返回false。
URLParamExists(name string) bool
// URLParamDefault 从请求中返回get参数，
// 如果未找到，则返回 “ def”。
URLParamDefault(name string, def string) string
// URLParam 从请求中返回get参数(如果有)。
URLParam(name string) string
// URLParamTrim 返回url查询参数，并从请求中删除结尾的空格。
URLParamTrim(name string) string
// URLParamEscape 从请求中返回转义的url查询参数
URLParamEscape(name string) string
// URLParamInt 以请求中的int值形式返回url查询参数，
// 如果解析失败，则返-1和一个错误。
URLParamInt(name string) (int, error)
// URLParamIntDefault 将url查询参数作为请求中的int值返回，
// 如果未找到或解析失败，则返回 "def" 。
URLParamIntDefault(name string, def int) int
// URLParamInt32Default将url查询参数作为来自请求的int32值返回，
// 如果未找到或解析失败，则返回 "def" 。
URLParamInt32Default(name string, def int32) int32
// URLParamInt64 将url查询参数作为来自请求的int64值返回，
// 如果解析失败，则返-1和一个错误。
URLParamInt64(name string) (int64, error)
// URLParamInt64Default 从请求中返回url查询参数作为int64值，
// 如果未找到或解析失败，则返回 "def" 。
URLParamInt64Default(name string, def int64) int64
// URLParamFloat64 从请求中返回url查询参数作为float64值，
// 如果解析失败，则返-1和一个错误。
URLParamFloat64(name string) (float64, error)
// URLParamFloat64Default 从请求中返回url查询参数作为float64值，
// 如果未找到或解析失败，则返回 "def" 。
URLParamFloat64Default(name string, def float64) float64
// URLParamBool 以请求中的布尔值返回url查询参数，
// 如果解析失败，则返一个错误。
URLParamBool(name string) (bool, error)
// URLParams 返回一个GET查询参数的映射，如果有多个，则以逗号分隔
// 如果找不到任何内容，则返回一个空映射。
URLParams() map[string]string
// FormValueDefault 通过名称返回单个被解析的值，
// 包括 URL 字段的查询参数和 POST 或 PUT 表单数据。
//
// 就返回默的 "def"值，如果没有找到值
FormValueDefault(name string, def string) string
// FormValue 通过名称返回单个被解析的值，
// 包括 URL 字段的查询参数和 POST 或 PUT 表单数据。
FormValue(name string) string
// FormValues 通过名称返回被解析的值，包括 URL 字段的查询参数和 POST 或 PUT 表单数据。
//
// 默认表单的内存最大大小为32MB， 可以通过传递 `iris.WithPostMaxMemory`
// 配置到 `app.Run` 的第二个参数去修改默认值。
//
// 注意：必须检查 nil 。
FormValues() map[string][]string
// PostValueDefault 通过名称返回被解析的值，包括 URL 字段的查询参数和 POST 或 PUT 表单数据。
//
// 如果未找到，则返回 "def"。
PostValueDefault(name string, def string) string
// PostValue 通过名称返回被解析的值，包括 URL 字段的查询参数和 POST 或 PUT 表单数据。
PostValue(name string) string
// PostValueTrim 通过名称返回被解析的值，包括 URL 字段的查询参数和 POST 或 PUT 表单数据 ，而且是不带空格。
PostValueTrim(name string) string
// PostValueInt 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 int 数据。
//
// 如果未找到，则返回-1和非 nil 错误。
PostValueInt(name string) (int, error)
// PostValueIntDefault 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 int 数据。
//
// 如果未找到，则返回 "def" 。
PostValueIntDefault(name string, def int) int
// PostValueInt64 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 int64 （原文是：float64） 数据。
//
// 如果未找到，则返回 -1 和非 nil 错误。
PostValueInt64(name string) (int64, error)
// PostValueInt64Default 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 int64 数据。
//
// 如果未找到，则返回 "def" 。
PostValueInt64Default(name string, def int64) int64
//PostValueFloat64 （原文是： PostValueInt64Default） 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 float64 数据。
//
// 如果未找到，则返回 -1 和非 nil 错误。
PostValueFloat64(name string) (float64, error)
// PostValueFloat64Default （原文是： PostValueInt64Default） 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 float64 数据。
//
// 如果未找到，则返回 "def" 。
PostValueFloat64Default(name string, def float64) float64
// PostValueBool （原文是： PostValueInt64Default） 通过名称来返回解析自 POST, PATCH,
// 或者 PUT 主体参数的 bool 数据。
//
// 如果没有找到值，或者找到的值为 false, 则会返回 false ， 否则就会返回 true。
PostValueBool(name string) (bool, error)
// PostValues 通过名称来返回所有解析自 POST, PATCH,
// 或者 PUT 主体参数的 struct 数据。
//
// 默认表单的内存最大大小为32MB， 可以通过传递 `iris.WithPostMaxMemory`
// 配置到 `app.Run` 的第二个参数去修改默认值。
PostValues(name string) []string
// FormFile 返回从客户端收到的第一个上载文件。
//
// 默认表单的内存最大大小为32MB， 可以通过传递 `iris.WithPostMaxMemory`
// 配置到 `app.Run` 的第二个参数去修改默认值。
//
// 示例： https://github.com/kataras/iris/tree/master/_examples/http_request/upload-file
FormFile(key string) (multipart.File, *multipart.FileHeader, error)
// UploadFormFiles 从客户端将所有收到的文件上传到系统物理位置 "destDirectory"。
//
// 第二个可选参数 "before" 使调用者有机会在保存到磁盘之前修改
// `*miltipart.FileHeader` ，它可以根据当前请求用于更改文件名，
// 所有 FileHeader的选项都可以被改变。如果在将文件保存到磁盘之前不需要使用此功能，
// 则可以忽略它。
//
// 请注意，它不会检查请求主体是否流式传输
//
// 如果服务器未收到文件，如果是由于操作系统的权限或`net/http.ErrMissingFile`
// 而无法创建至少一个新文件，则返回复制的长度为 int64，
// 并返回一个不为零的错误。
//
// 如果要接收和接受文件并手动进行管理，
// 则可以改用`Context.FormFile`并创建适合你需要的复制功能，
// 以下内容仅用于一般情况。
//
// 默认表单的内存最大大小为32MB， 可以通过传递 `iris.WithPostMaxMemory`
// 配置到 `app.Run` 的第二个参数去修改默认值。
//
// 查看 `FormFile`，一个更容易用来接受文件的函数。
//
//
// 示例： https://github.com/kataras/iris/tree/master/_examples/http_request/upload-files
UploadFormFiles(destDirectory string, before ...func(Context, *multipart.FileHeader)) (n int64, err error)
// +------------------------------------------------------------+
// | 自定以 HTTP 错误 |
// +------------------------------------------------------------+
// NotFound 使用特定的自定义错误处理程序，向客户端发出错误 404。
// 注意， 如果你不想下一个处理程序被执行，你需要调用 ctx.StopExecution()，
// 下一个处理程序在 iris 上正在被执行，因为你可以弹出这个
// 错误代码， 并且可以把它修改为更特别的一个错误。 例如：
// users := app.Party("/users")
// users.Done(func(ctx context.Context){ if ctx.StatusCode() == 400 { /* 为 /users 路由自定义错误代码 */ }})
NotFound()
// +------------------------------------------------------------+
// | 正文阅读器 |
// +------------------------------------------------------------+
// SetMaxRequestBodySize 设置对请求正文大小的限制，它
应在从客户端读取请求正文之前被调用。
SetMaxRequestBodySize(limitOverBytes int64)
// GetBody 读取并返回这个请求的正文。
// http 请求读取器的默认行为是使用数据读取
但是，你可以通过传递 "WithoutBodyConsumptionOnUnmarshal" iris的选项来更改该行为。
//
//但是， 你可以在任何地方使用 `ctx.Request().Body` 去替代它。
GetBody() ([]byte, error)
// UnmarshalBody 读取这个请求的正文，并且绑定它到一个值或者一个任意类型的指针。
// 使用示例： context.ReadJSON, context.ReadXML.
//
// 示例： https://github.com/kataras/iris/blob/master/_examples/http_request/read-custom-via-unmarshaler/main.go
//
// UnmarshalBody 不检查 gzipped 有关的数据。
// 不要依赖传入服务器的压缩数据。主要原因是： https://en.wikipedia.org/wiki/Zip_bomb
// 但是你仍然可以手动自由的去访问 `ctx.Request().Body io.Reader`。
UnmarshalBody(outPtr interface{}, unmarshaler Unmarshaler) error
// ReadJSON 从请求的正文中读取 JSON ，并且绑定它到一个值或者一个任意类型的指针。
//
// 示例： https://github.com/kataras/iris/blob/master/_examples/http_request/read-json/main.go
ReadJSON(jsonObjectPtr interface{}) error
// ReadXML 从请求的正文中读取 XML，并且绑定它到一个 xml-valid 类型值的指针。
//
// 示例： https://github.com/kataras/iris/blob/master/_examples/http_request/read-xml/main.go
ReadXML(xmlObjectPtr interface{}) error
// ReadYAML 从请求的正文中读取 YAML ，并且绑定它到 "outPtr" 值。
//
// 示例: https://github.com/kataras/iris/blob/master/_examples/http_request/read-yaml/main.go
ReadYAML(outPtr interface{}) error
// ReadForm 绑定表单数据到 formObject 对象，
// 它支持所有类型种类，包括自定义结构体。
// 如果请求数据是空的，它不会返回任何东西。
// 结构体的字段标签是 "form"。
//
// 示例代码： https://github.com/kataras/iris/blob/master/_examples/http_request/read-form/main.go
ReadForm(formObject interface{}) error
// ReadQuery 绑定 url 请求字符串到 "指针"， 结构体的字段标签是 "url"。
//
// 示例代码: https://github.com/kataras/iris/blob/master/_examples/http_request/read-query/main.go
ReadQuery(ptr interface{}) error
// +------------------------------------------------------------+
// | 正文（原始）写入器 |
// +------------------------------------------------------------+
// Write 将数据作为 HTTP 回复的一部分写入连接。
//
// 如果 WriteHeader 还没有被调用, Write 调用
// WriteHeader(http.StatusOK) 在写入内容之前， 如果 Header
// 没有包含一个 Content-Type 行, Write 添加一个 Content-Type
// 去设置将初始 512 字节的写入数据传递到检测内容类型的结果。
//
// 根据 HTTP 协议版本和客户端，调用
// Write或 WriteHeader 可能会阻止将来在
// Request.Body。对于 HTTP/1.x 请求，处理程序应读取任何
// 编写响应之前所需的请求正文数据。一旦
// 标头已刷新（由于显式 Flusher.Flush 或写入足够的数据以触发刷新），请求正文
// 可能不可用。对于 HTTP/2 请求，Go HTTP 服务器允许
// 处理程序以继续读取请求正文，同时
// 编写响应。但是，此类行为可能不受支持
// 由所有 HTTP/2 客户端。处理程序应在写入之前读取
// 可以最大化兼容性。
Write(body []byte) (int, error)
// Writef 根据格式说明符格式化并写入响应。
//
// /返回写入的字节数以及遇到的任何写入错误
Writef(format string, args ...interface{}) (int, error)
// WriteString 将简单的字符串写入响应。
//
// 返回写入的字节数以及遇到的任何写入错误。
WriteString(body string) (int, error)
// SetLastModified 根据 "modtime" 输入设置 "Last-Modified"。
// 如果 "modtime" 为零，则不执行任何操作。
//
// 它主要在内部位于核心/路由器和上下文包中。
//
// 注意，使用的是 modtime.UTC() 而不是 modtime，因此
// 你无需了解内部原理就可以使用它们。
SetLastModified(modtime time.Time)
// CheckIfModifiedSince 检查响应是否已经被更新，自从 "modtime" 以来。
// 请注意，它与服务器端缓存无关。
// 它通过检查 "If-Modified-Since" 请求头是否被客户端发送，
// 或者以前的请求头(例如，使用 WriteWithExpiration 或者 HandleDir 或者 Favicon 等等。)仍然有效，并且这些请求头都是在 "modtime" 之前，来做这些检查。
//
// 对 !modtime && err == nil 做一个检查是有必要的，以用来确定
// 它之前没有更新过， 因为它可能返回 false，但有时候我们甚至没有机
// 会检查客户端（请求）标头由于一些错误,
// 就像 HTTP 方法不是 "GET" 或者 "HEAD" 或者 "modtime" 是 0，或者
// 从错误的头中解析时间的时候一样。
//
// 它主要在内部使用，例如： `context#WriteWithExpiration`。 `ErrPreconditionFailed` 也是一样。
//
// 注意，使用的是 modtime.UTC() 而不是 modtime，因此
// 你无需了解内部原理就可以使用它们。
CheckIfModifiedSince(modtime time.Time) (bool, error)
// WriteNotModified 发送一个 304 "Not Modified" 状态码到客户端，
// 它用来确认在响应发送前，内容类型，内容长度等请求头
// 和 任意的 "ETag" 都已经被移除。
//
// 它主要用于核心 core/router/fs.go 和上下文方法中。
WriteNotModified()
// WriteWithExpiration 像 `Write` 一样工作， 但是它会一直检查一个资源是否被更新，
// 基于 "modtime" 输入参数，
// 否则会发送一个 304 状态码来让客户端侧显示缓存内容
WriteWithExpiration(body []byte, modtime time.Time) (int, error)
// StreamWriter 注册给定的流编写器以填充响应正文。
//
// 访问写入器禁止的上下文和/或其成员。
//
// 此函数可用于以下情况：
//
// * 如果响应正文太大 (大于 iris.LimitRequestBodySize(如果设置了)).
// * 如果响应正文从缓慢的外部源流式传输。
// * 如果响应正文必须以块数流式传输到客户端。
// (aka `服务器推送`).
//
// 接收一个当响应写入器应该停止写入的时候，会接收它并返回 false 的函数，
// 否者会返回 true 以用来继续写入内容。
StreamWriter(writer func(w io.Writer) bool)
// +------------------------------------------------------------+
// | 正文压缩写入器 |
// +------------------------------------------------------------+
// ClientSupportsGzip 返回 true ，如果客户端支持 gzip 压缩、
ClientSupportsGzip() bool
// WriteGzip 接收字节，字节被使用 gzip 格式压缩，并且被发送到客户端的。
// 返回写入的字节数和一个错误 (如果客户端不支持 gzip 压缩)
// 你可以毫无问题的多次在同一处理程序中重复使用此函数
// 写更多的数据。
WriteGzip(b []byte) (int, error)
// TryWriteGzip 接收字节，字节被使用 gzip 格式压缩，并且被发送到客户端的。
// 如果客户端不支持 gzip 压缩 ，这些内容会以未压缩形式发送。
TryWriteGzip(b []byte) (int, error)
// GzipResponseWriter 当它的 .Write 调用它将数据压缩到 gzip 并将其写入客户端的时候，
//将当前响应编写器转换为响应编写器
。
//
// 也可以使用它的 .Disable 和 .ResetBody 去禁用以回滚到常用的响应写入器。
GzipResponseWriter() *GzipResponseWriter
// Gzip 启用或者禁用 (如果之前已经启用) gzip 响应写入器，如果客户端支持
// gzip 压缩，所以接下来响应数据将会被压缩承 gzip 数据发送到客户端。
Gzip(enable bool)
// +------------------------------------------------------------+
// | 丰富的正文内容编写器/呈现器 |
// +------------------------------------------------------------+
// ViewLayout 设置 "layout" 选项，当 .View
// 被调用之后，在相同通的请求中会非常有用，
// 当需要基于处理程序链中的上一个处理程序，设置或者改变一个 layout时。
//
// 注意， 'layoutTmplFile' 变量可以被设置到 iris.NoLayout 或者 view.NoLayout
// 去禁用 layout， 在一些特殊的视图渲染操作中。
// 他禁用引擎配置的layout 属性。
//
// .ViewData 和 .View 看起来是一样的。
//
// 示例： https://github.com/kataras/iris/tree/master/_examples/view/context-view-data/
ViewLayout(layoutTmplFile string)
// ViewData 在同一个请求中，当 .View
// 被调用之后，保存一个或多个键值对，以便被传递。
// 当需要基于处理程序链中的上一个处理程序，设置或者改变一个模板数据时非常有用。
//
// 如果 .View' 的 "绑定" 参数不是 nil 并且它不是一个映射类型
// 那么这些数据都会被忽略，绑定具有优先级， 因此主路由的处理程序仍然可以运行。
// 如果绑定是一个映射或者 context.Map 那么这些数据都会被添加到视图数据中
// 并被传递给模版。
//
// 调用 .View 之后， 这些数据没有被摧毁，为了能够重复利用(重复，在完全相同求情中),
// 要清除这些视图数据，开发这可以调用：
// ctx.Set(ctx.Application().ConfigurationReadOnly().GetViewDataContextKey(), nil)
//
// 如果 'key' 是空的，那么这个值可以被添加到它的(结构体或者映射)中 并且开发这不能添加其他值。
//
// .ViewLayout 和 .View 看起来是一样的。
//
// 示例: https://github.com/kataras/iris/tree/master/_examples/view/context-view-data/
ViewData(key string, value interface{})
// GetViewData 返回被 `context#ViewData`注册的值。
// 返回值是一个`map[string]interface{}`，这意味着，如果
// 一个自定义结构体被注册到 ViewData 那么这个函数
// 将会尝试将它解析到映射中， 如果失败那么返回值将会是一个 nil。
// 如果不同类型的值或者没有数据通过 `ViewData` 被注册，
// 那么对 nil 的检查一直是一个好的实践。
//
// 同理对于 `viewData := ctx.Values().Get("iris.viewData")` 或者
// `viewData := ctx.Values().Get(ctx.Application().ConfigurationReadOnly().GetViewDataContextKey())`.
GetViewData() map[string]interface{}
// 视图基于注册的视图引擎渲染一个模版。
//第一个参数接受一个相对于视图引擎的目录和扩展的文件名，
// 即: 如果目录是 "./templates" 的同时想要渲染 "./templates/users/index.html"
// 那么你使用 "users/index.html" 作为文件名参数。
//
// 第二个可选参数可以接收单个 "视图模型"，
// 它被绑定到视图模版上。如果它不是nil,
// 否则它将会在相同的请求中检查下一个被 `ViewData` 保存的视图数据
// 甚至被下一个处理程序(中间件)保存的视图数据 。
//
// .ViewData` 和 .ViewLayout 看起来是一样的。
//
// 示例: https://github.com/kataras/iris/tree/master/_examples/view
View(filename string, optionalViewModel ...interface{}) error
// Binary 将原始字节作为二进制数据写入。
Binary(data []byte) (int, error)
// Text 将字符串写成纯文本。
Text(format string, args ...interface{}) (int, error)
// HTML 将字符串写成 text/html。
HTML(format string, args ...interface{}) (int, error)
// JSON 整顿（原文：marshals）给定的接口对象并编写JSON响应。
JSON(v interface{}, options ...JSON) (int, error)
// JSONP 整顿（原文：marshals）给定的接口对象并编写 JSONP（原文：JSON） 响应。
JSONP(v interface{}, options ...JSONP) (int, error)
// XML整顿（原文：marshals）给定的接口对象并编写 XML 响应。
// 将映射渲染为 XML ，查看 `XMLMap` 包级函数。
XML(v interface{}, options ...XML) (int, error)
// Problem 编写一个 JSON 或 XML 问题响应。
// 问题字段并不是一直以相同的顺序呈现。
//
// 行为完全像 `Context.JSON`
// 但是，默认的 ProblemOptions.JSON 缩进是 " " 而且是一个
// 内容是 "application/problem+json" 类型的响应。
//
// 使用 options.RenderXML 和 XML 字段去改变这些行为并且
// 发送一个内容是 "application/problem+xml" 类型的响应。
//
// 阅读更多关于: https://github.com/kataras/iris/wiki/Routing-error-handlers 的内容。
Problem(v interface{}, opts ...ProblemOptions) (int, error)
// Markdown 解析 markdown 为 html ，并将其结果呈现给客户端。
Markdown(markdownB []byte, options ...Markdown) (int, error)
// YAML 使用 yaml 解析器解析 “v”，并将其结果呈现给客户端。
YAML(v interface{}) (int, error)
// +-----------------------------------------------------------------------+
// | 内容协议 |
// | https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation | |
// +-----------------------------------------------------------------------+
// Negotiation 创建一次并返回协议生成器，
// 为特定的 mime 类型构建服务端的可用内容
// 和字符集。
//
// `Negotiate`看起来也一样。
Negotiation() *NegotiationBuilder
// Negotiate 用于在同一个 URI 上为不同的资源形式提供服务。
//
// "v" 可以是一个单个 `N` 结构值。
// "v" 可以是任意完成了 `ContentSelector` 接口的值。
//"v" 可以是任意完成了 `ContentNegotiator` 接口的值。
// "v" 可以是任意 (JSON, JSONP, XML, YAML)结构的值或者，
// (TEXT, HTML)字符串 或者 []byte(Markdown, Binary) 或者 任何匹配的mime类型的 []byte。
//
// 如果 "v" 是 nil, 将会使用 `Context.Negotitation()` 构建器的
// 内容去替代它， 否则 "v" 会覆盖构建器的内容
// (服务器的 mime 类型一直受到它所注册和支持的 mime 列表的检索。)
//
// 通过 `Negotiation().JSON().XML().HTML()...`设置mime类型优先级。
// 通过 `Negotiation().Charset(...)` 设置字符集优先级。
// 通过 `Negotiation().Encoding(...)` 设置编码算法优先级。
// 通过
// `Negotiation().Accept./Override()/.XML().JSON().Charset(...).Encoding(...)... 修改接受的内容。
//
// 当没有匹配的 mime 类型，它会返回 `ErrContentNotSupported`。
//
// 相关资源:
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
//
// 支持以上没有特性的值。
//
// 有关更多信息，请访问： https://github.com/kataras/iris/wiki/Content-negotiation
Negotiate(v interface{}) (int, error)
// +------------------------------------------------------------+
// | 文件服务 |
// +------------------------------------------------------------+
// ServeContent 通过自动设置接收的三个参数
//来服务内容和头， 它是一个低级的函数，你可以使用 .ServeFile(string,bool)/SendFile(string,string) 来替代它
//
//
// 在这个函数调用之前，你可以使用 `context#ContentType`来定义自己的 "Content-Type"。
//
// 这个函数不支持恢复 (通过范围),
// 需要使用 ctx.SendFile 或者路由的 `HandleDir` 去替代它。
ServeContent(content io.ReadSeeker, filename string, modtime time.Time, gzipCompression bool) error
// ServeFile 发送一个文件 (用于发送一个文件，一个 zip 文件。例如：发送到客户端你应该使用`SendFile` 来替代）
// 接收两个参数
// filename/path (string)
// gzipCompression (bool)
//
// 在这个函数调用之前，你可以使用 `context#ContentType`来定义自己的 "Content-Type"。
//
// 这个函数不支持恢复 (通过范围),
// 需要使用 ctx.SendFile 或者路由的 `HandleDir` 去替代它。
//
// 当你想要服务动态文件到客户端的时候，请使用它。
ServeFile(filename string, gzipCompression bool) error
// SendFile 将文件发送到客户端进行强制下载
//
// 使用它来替代 ServeFile 用于在客户端 '强制下载' 大文件。
SendFile(filename string, destinationName string) error
// +------------------------------------------------------------+
// | Cookies |
// +------------------------------------------------------------+
// SetCookie 增加一个 cookie.
// "选项"不是必需的，它们可用于修改 "cookie" 。
//
// 例如: https://github.com/kataras/iris/tree/master/_examples/cookies/basic
SetCookie(cookie *http.Cookie, options ...CookieOption)
// SetCookieKV 增加一个 cookie，需要使用 name(字符串) 和 value(字符串)。
//
// 它的默认有效期是 2 小时并且它会被添加到根路径，
// 使用 `CookieExpires` 和 `CookiePath` 更新它们。
// 或者: ctx.SetCookie(&http.Cookie{...})
//
//如果你想要设置自定义路径：
// ctx.SetCookieKV(name, value, iris.CookiePath("/custom/path/cookie/will/be/stored"))
//
// 如果你想要它仅仅是当前请求路径可见：
// ctx.SetCookieKV(name, value, iris.CookieCleanPath/iris.CookiePath(""))
// More:
// iris.CookieExpires(time.Duration)
// iris.CookieHTTPOnly(false)
//
// 例如: https://github.com/kataras/iris/tree/master/_examples/cookies/basic
SetCookieKV(name, value string, options ...CookieOption)
// GetCookie 返回通过它的名称一个 cookie 的值。
// 如果没有找到值，将会返回一个空的字符串。
//
// 如果你想要比值更多的返回，使用：
// cookie, err := ctx.Request().Cookie("name")
//
// 例如: https://github.com/kataras/iris/tree/master/_examples/cookies/basic
GetCookie(name string, options ...CookieOption) string
// RemoveCookie 通过它的名称和路径 = "/",删除一个 cookie 。
// 小贴士： 改变当前 cookie 的路径通过: RemoveCookie("name", iris.CookieCleanPath)
//
// 例如： https://github.com/kataras/iris/tree/master/_examples/cookies/basic
RemoveCookie(name string, options ...CookieOption)
// VisitAllCookies 接受一个 visitor 函数，它在每次(请求的) cookie 的 name 和 value 上调用。
VisitAllCookies(visitor func(name string, value string))
// MaxAge 返回 "cache-control" 请求头的秒数值
// 作为 int64 类型，
// 如果头没有找到或者解析失败那么它将会返回 -1。
MaxAge() int64
// +------------------------------------------------------------+
// | 高级：响应记录器和事务 |
// +------------------------------------------------------------+
// Record 将 context 的基础和直接的 responseWriter 转化为一个 ResponseRecorder，
// 它可以被用于在任何时候去重置正文，重置头，以及获取正文，
// 获取和设置状态码和更多内容。
Record()
// Recorder 返回 context 的 ResponseRecorder。
// 如果当它开始记录但是有没有没有记录的时候返回新的 context 的 ResponseRecorder。
Recorder() *ResponseRecorder
// IsRecording 返回响应的记录器和一个 true 值，
// 当响应记录者正在记录状态码，正文，响应头等等内容时，
// 如果没有，也会返回 nil 和 false。
IsRecording() (*ResponseRecorder, bool)
// BeginTransaction 启动作用域的事务。
//
// 你可以搜索有关业务交易工作方式的第三方文章或书籍（非常简单，尤其是此处）。
//
// 请注意，这是唯一的，新的
//（*到目前为止，我从未在 Golang 中见过任何其他关于这个主题的例子或代码，就像大多数iris 功能一样)。
// 它并不涵盖所有路径，
// 例如数据库, 这应该由你用来建立数据库连接的库进行管理，,
// 此事务范围仅用于上下文的响应。
// Transactions 有自己的中间件生态系统，请看 iris.go:UseTransaction。
//
// 查看 https://github.com/kataras/iris/tree/master/_examples/ 以了解更多。
BeginTransaction(pipe func(t *Transaction))
// SkipTransactions 如果被调用，那么会跳过其余的事务
// 或者在第一个事务之前它们都已经被调用。
SkipTransactions()
// TransactionsSkipped 返回 true 如果事务被完全跳过或者取消。
TransactionsSkipped() bool
// Exec 基于上下文修改了一个方法和用户请求一样的路径调用 `context/Application#ServeCtx`，但它不是。（这句翻译的有带点蛋疼，原文：Exec calls the `context/Application#ServeCtx` based on this context but with a changed method and path like it was requested by the user, but it is not.）
//
//
// 离线意味着路由已注册到iris，并具有正常路由具有的所有功能
// 但它不能通过浏览，其他处理程序的上下文调用他，它的处理程序才会执行。
// 它可以验证路径、具有会话、路径参数等。
//
// 你可以通过 app.GetRoute("theRouteName") 找到这个路由。
// 你可以设置一个路由名称作为: myRoute := app.Get("/mypath", handler)("theRouteName")
// 它将会设置一个名称到这路由并且返回他的路由信息实例，以便进一步使用。
//
// 它不会更改全局状态，如果路由处于"脱机"状态，则它将保持脱机状态。
//
// app.None(...) 和 app.GetRoutes().Offline(route)/.Online(route, method)
//
// 例如: https://github.com/kataras/iris/tree/master/_examples/routing/route-state
//
// 用户可以通过简单使用获得响应， rec := ctx.Recorder(); rec.Body()/rec.StatusCode()/rec.Header().
//
// 保留上下文的值和会话，以便能够通过结果路由进行通信。
//
// 这是极端使用的情况，99% 的时间永远不会对你有用。
Exec(method, path string)
// RouteExists 报告是否存在特定路由
// 它将从上下文主机的当前子域（如果不是在根域内）进行搜索。
RouteExists(method, path string) bool
// Application 返回属于此上下文的 iris 应用实例。
// 值得注意的是，此函数返回一个接口
// 的应用程序，其中包含安全的方法
// 在服务时间执行。 为了开发人员的安全，
// 此处无法提供完整的应用字段和方法。
Application() Application
// String 返回此请求的字符串表示形式。
// 每个上下文都有一个唯一的字符串表示形式。
// 它可用于简单的调试方案，即将上下文打印为字符串。
//
// 它返回什么？一个数字，
// 它声明每个可执行应用程序的"String"总调用的长度，
// 然后是远程 IP（客户端），最后是 方法:url。
String() string
}
```
