http

Documentation

Overview

httpパッケージは HTTP クライアントとサーバーの実装を提供します。

Get、Head、Post、PostForm は HTTP (または HTTPS) リクエストを行います:

resp, err := http.Get("http://example.com/")
...
resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
...
resp, err := http.PostForm("http://example.com/form",
	url.Values{"key": {"Value"}, "id": {"123"}})

関数を呼び出した後、レスポンスボディを閉じる必要があります。

resp, err := http.Get("http://example.com/")
if err != nil {
	// handle error
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
// ...

Clients and Transports

HTTP クライアントヘッダー、リダイレクトポリシー、その他の設定を制御するには、Client を作成してください。

client := &http.Client{
	CheckRedirect: redirectPolicyFunc,
}

resp, err := client.Get("http://example.com")
// ...

req, err := http.NewRequest("GET", "http://example.com", nil)
// ...
req.Header.Add("If-None-Match", `W/"wyzzy"`)
resp, err := client.Do(req)
// ...

プロキシ、TLS 設定、Keep-Alive、圧縮、その他の設定を制御するには、Transport を作成してください。

tr := &http.Transport{
	MaxIdleConns:       10,
	IdleConnTimeout:    30 * time.Second,
	DisableCompression: true,
}
client := &http.Client{Transport: tr}
resp, err := client.Get("https://example.com")

クライアントとトランスポートは、複数のゴルーチンによる同時使用に対して安全であり、効率的に使用するためには、1度だけ作成して再利用する必要があります。

Servers

ListenAndServe は、指定されたアドレスとハンドラーで HTTP サーバーを開始します。 ハンドラーは通常 nil で、DefaultServeMux を使用することを意味します。 Handle と HandleFunc は、DefaultServeMux にハンドラーを追加します。

http.Handle("/foo", fooHandler)

http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})

log.Fatal(http.ListenAndServe(":8080", nil))

サーバーの動作に関するより詳細な制御は、カスタムサーバーを作成することで利用できます。

s := &http.Server{
	Addr:           ":8080",
	Handler:        myHandler,
	ReadTimeout:    10 * time.Second,
	WriteTimeout:   10 * time.Second,
	MaxHeaderBytes: 1 << 20,
}
log.Fatal(s.ListenAndServe())

HTTP/2

Go 1.6 以降、HTTPS を使用する場合、http パッケージは HTTP/2 プロトコルの透過的なサポートを提供します。HTTP/2 を無効にする必要があるプログラムは、[Transport.TLSNextProto] (クライアント用) または [Server.TLSNextProto] (サーバー用) を nil でない空のマップに設定することで行えます。また、次の GODEBUG 設定が現在サポートされています。

GODEBUG=http2client=0  # HTTP/2 クライアントサポートを無効にする
GODEBUG=http2server=0  # HTTP/2 サーバーサポートを無効にする
GODEBUG=http2debug=1   # 詳細な HTTP/2 デバッグログを有効にする
GODEBUG=http2debug=2   # ... フレームダンプを含めて、より詳細なログを有効にする

HTTP/2 サポートを無効にする前に、問題がある場合は報告してください: https://golang.org/s/http2bug

http パッケージの Transport と Server は、単純な構成に対して自動的に HTTP/2 サポートを有効にします。より複雑な構成で HTTP/2 を有効にする、より低レベルの HTTP/2 機能を使用する、またはより新しいバージョンの Go の http2 パッケージを使用するには、直接 "golang.org/x/net/http2" をインポートし、その ConfigureTransport および/または ConfigureServer 関数を使用します。golang.org/x/net/http2 パッケージを使用して HTTP/2 を手動で設定する場合、net/http パッケージの組み込みの HTTP/2 サポートよりも優先されます。

Index

• Constants
• Variables
• func CanonicalHeaderKey(s string) string
• func DetectContentType(data []byte) string
• func Error(w ResponseWriter, error string, code int)
• func Handle(pattern string, handler Handler)
• func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
• func ListenAndServe(addr string, handler Handler) error
• func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error
• func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser
• func NotFound(w ResponseWriter, r *Request)
• func ParseHTTPVersion(vers string) (major, minor int, ok bool)
• func ParseTime(text string) (t time.Time, err error)
• func ProxyFromEnvironment(req *Request) (*url.URL, error)
• func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)
• func Redirect(w ResponseWriter, r *Request, url string, code int)
• func Serve(l net.Listener, handler Handler) error
• func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, ...)
• func ServeFile(w ResponseWriter, r *Request, name string)
• func ServeFileFS(w ResponseWriter, r *Request, fsys fs.FS, name string)
• func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error
• func SetCookie(w ResponseWriter, cookie *Cookie)
• func StatusText(code int) string
• type Client
  • func (c *Client) CloseIdleConnections()
  • func (c *Client) Do(req *Request) (*Response, error)
  • func (c *Client) Get(url string) (resp *Response, err error)
  • func (c *Client) Head(url string) (resp *Response, err error)
  • func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error)
  • func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error)
• type CloseNotifier
• type ConnState
  • func (c ConnState) String() string
• type Cookie
  • func ParseCookie(line string) ([]*Cookie, error)
  • func ParseSetCookie(line string) (*Cookie, error)
  • func (c *Cookie) String() string
  • func (c *Cookie) Valid() error
• type CookieJar
• type Dir
  • func (d Dir) Open(name string) (File, error)
• type File
• type FileSystem
  • func FS(fsys fs.FS) FileSystem
• type Flusher
• type Handler
  • func AllowQuerySemicolons(h Handler) Handler
  • func FileServer(root FileSystem) Handler
  • func FileServerFS(root fs.FS) Handler
  • func MaxBytesHandler(h Handler, n int64) Handler
  • func NotFoundHandler() Handler
  • func RedirectHandler(url string, code int) Handler
  • func StripPrefix(prefix string, h Handler) Handler
  • func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler
• type HandlerFunc
  • func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)
• type Header
  • func (h Header) Add(key, value string)
  • func (h Header) Clone() Header
  • func (h Header) Del(key string)
  • func (h Header) Get(key string) string
  • func (h Header) Set(key, value string)
  • func (h Header) Values(key string) []string
  • func (h Header) Write(w io.Writer) error
  • func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error
• type Hijacker
• type MaxBytesError
  • func (e *MaxBytesError) Error() string
• type ProtocolError
  • func (pe *ProtocolError) Error() string
  • func (pe *ProtocolError) Is(err error) bool
• type PushOptions
• type Pusher
• type Request
  • func NewRequest(method, url string, body io.Reader) (*Request, error)
  • func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error)
  • func ReadRequest(b *bufio.Reader) (*Request, error)
  • func (r *Request) AddCookie(c *Cookie)
  • func (r *Request) BasicAuth() (username, password string, ok bool)
  • func (r *Request) Clone(ctx context.Context) *Request
  • func (r *Request) Context() context.Context
  • func (r *Request) Cookie(name string) (*Cookie, error)
  • func (r *Request) Cookies() []*Cookie
  • func (r *Request) CookiesNamed(name string) []*Cookie
  • func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)
  • func (r *Request) FormValue(key string) string
  • func (r *Request) MultipartReader() (*multipart.Reader, error)
  • func (r *Request) ParseForm() error
  • func (r *Request) ParseMultipartForm(maxMemory int64) error
  • func (r *Request) PathValue(name string) string
  • func (r *Request) PostFormValue(key string) string
  • func (r *Request) ProtoAtLeast(major, minor int) bool
  • func (r *Request) Referer() string
  • func (r *Request) SetBasicAuth(username, password string)
  • func (r *Request) SetPathValue(name, value string)
  • func (r *Request) UserAgent() string
  • func (r *Request) WithContext(ctx context.Context) *Request
  • func (r *Request) Write(w io.Writer) error
  • func (r *Request) WriteProxy(w io.Writer) error
• type Response
  • func Get(url string) (resp *Response, err error)
  • func Head(url string) (resp *Response, err error)
  • func Post(url, contentType string, body io.Reader) (resp *Response, err error)
  • func PostForm(url string, data url.Values) (resp *Response, err error)
  • func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)
  • func (r *Response) Cookies() []*Cookie
  • func (r *Response) Location() (*url.URL, error)
  • func (r *Response) ProtoAtLeast(major, minor int) bool
  • func (r *Response) Write(w io.Writer) error
• type ResponseController
  • func NewResponseController(rw ResponseWriter) *ResponseController
  • func (c *ResponseController) EnableFullDuplex() error
  • func (c *ResponseController) Flush() error
  • func (c *ResponseController) Hijack() (net.Conn, *bufio.ReadWriter, error)
  • func (c *ResponseController) SetReadDeadline(deadline time.Time) error
  • func (c *ResponseController) SetWriteDeadline(deadline time.Time) error
• type ResponseWriter
• type RoundTripper
  • func NewFileTransport(fs FileSystem) RoundTripper
  • func NewFileTransportFS(fsys fs.FS) RoundTripper
• type SameSite
• type ServeMux
  • func NewServeMux() *ServeMux
  • func (mux *ServeMux) Handle(pattern string, handler Handler)
  • func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))
  • func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
  • func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)
• type Server
  • func (s *Server) Close() error
  • func (s *Server) ListenAndServe() error
  • func (s *Server) ListenAndServeTLS(certFile, keyFile string) error
  • func (s *Server) RegisterOnShutdown(f func())
  • func (s *Server) Serve(l net.Listener) error
  • func (s *Server) ServeTLS(l net.Listener, certFile, keyFile string) error
  • func (s *Server) SetKeepAlivesEnabled(v bool)
  • func (s *Server) Shutdown(ctx context.Context) error
• type Transport
  • func (t *Transport) CancelRequest(req *Request)
  • func (t *Transport) Clone() *Transport
  • func (t *Transport) CloseIdleConnections()
  • func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper)
  • func (t *Transport) RoundTrip(req *Request) (*Response, error)

Examples

• FileServer
• FileServer (DotFileHiding)
• FileServer (StripPrefix)
• Get
• Handle
• HandleFunc
• Hijacker
• ListenAndServe
• ListenAndServeTLS
• NotFoundHandler
• ResponseWriter (Trailers)
• ServeMux.Handle
• Server.Shutdown
• StripPrefix

Constants

const (
	MethodGet     = "GET"
	MethodHead    = "HEAD"
	MethodPost    = "POST"
	MethodPut     = "PUT"
	MethodPatch   = "PATCH"
	MethodDelete  = "DELETE"
	MethodConnect = "CONNECT"
	MethodOptions = "OPTIONS"
	MethodTrace   = "TRACE"
)

一般的なHTTPメソッド。

特に注記がない限り、これらはRFC 7231 Section 4.3 で定義されています。

const (
	StatusContinue           = 100
	StatusSwitchingProtocols = 101
	StatusProcessing         = 102
	StatusEarlyHints         = 103

	StatusOK                   = 200
	StatusCreated              = 201
	StatusAccepted             = 202
	StatusNonAuthoritativeInfo = 203
	StatusNoContent            = 204
	StatusResetContent         = 205
	StatusPartialContent       = 206
	StatusMultiStatus          = 207
	StatusAlreadyReported      = 208
	StatusIMUsed               = 226

	StatusMultipleChoices  = 300
	StatusMovedPermanently = 301
	StatusFound            = 302
	StatusSeeOther         = 303
	StatusNotModified      = 304
	StatusUseProxy         = 305

	StatusTemporaryRedirect = 307
	StatusPermanentRedirect = 308

	StatusBadRequest                   = 400
	StatusUnauthorized                 = 401
	StatusPaymentRequired              = 402
	StatusForbidden                    = 403
	StatusNotFound                     = 404
	StatusMethodNotAllowed             = 405
	StatusNotAcceptable                = 406
	StatusProxyAuthRequired            = 407
	StatusRequestTimeout               = 408
	StatusConflict                     = 409
	StatusGone                         = 410
	StatusLengthRequired               = 411
	StatusPreconditionFailed           = 412
	StatusRequestEntityTooLarge        = 413
	StatusRequestURITooLong            = 414
	StatusUnsupportedMediaType         = 415
	StatusRequestedRangeNotSatisfiable = 416
	StatusExpectationFailed            = 417
	StatusTeapot                       = 418
	StatusMisdirectedRequest           = 421
	StatusUnprocessableEntity          = 422
	StatusLocked                       = 423
	StatusFailedDependency             = 424
	StatusTooEarly                     = 425
	StatusUpgradeRequired              = 426
	StatusPreconditionRequired         = 428
	StatusTooManyRequests              = 429
	StatusRequestHeaderFieldsTooLarge  = 431
	StatusUnavailableForLegalReasons   = 451

	StatusInternalServerError           = 500
	StatusNotImplemented                = 501
	StatusBadGateway                    = 502
	StatusServiceUnavailable            = 503
	StatusGatewayTimeout                = 504
	StatusHTTPVersionNotSupported       = 505
	StatusVariantAlsoNegotiates         = 506
	StatusInsufficientStorage           = 507
	StatusLoopDetected                  = 508
	StatusNotExtended                   = 510
	StatusNetworkAuthenticationRequired = 511
)

IANAに登録されたHTTPステータスコード。 詳細はこちらを参照してください：https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

const DefaultMaxHeaderBytes = 1 << 20

DefaultMaxHeaderBytesは、HTTPリクエストのヘッダーの許容される最大サイズです。 これは、[Server.MaxHeaderBytes] を設定することで上書きできます。

const DefaultMaxIdleConnsPerHost = 2

DefaultMaxIdleConnsPerHostは、Transport のMaxIdleConnsPerHostのデフォルト値です。

const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

TimeFormatは、HTTPヘッダーで時間を生成するときに使用する時間形式です。 time.RFC1123 のようですが、タイムゾーンとしてGMTがハードコードされています。 フォーマットされる時間はUTCである必要があります。

この時間形式を解析するには、ParseTime を参照してください。

const TrailerPrefix = "Trailer:"

TrailerPrefixは、[ResponseWriter.Header] マップのキーに対するマジックプレフィックスで、 存在する場合は、マップエントリが実際にはレスポンストレーラーであることを示します。 プレフィックスは、ServeHTTP呼び出しが終了し、値がトレーラーに送信された後に削除されます。

このメカニズムは、ヘッダーが書き込まれる前には不明なトレーラーにのみ使用することができます。 トレーラーのセットが固定されている場合、またはヘッダーが書き込まれる前に既知の場合、通常のGoトレーラーメカニズムが推奨されます。

https://pkg.go.dev/net/http#ResponseWriter
https://pkg.go.dev/net/http#example-ResponseWriter-Trailers

Variables

var (
	// ErrNotSupportedは、機能がサポートされていないことを示します。
	//
	// ResponseControllerメソッドによって、ハンドラがメソッドをサポートしていないことを示すために返され、
	// Pusher実装のPushメソッドによって、HTTP/2 Pushサポートが利用できないことを示すために返されます。
	ErrNotSupported = &ProtocolError{"feature not supported"}

	// Deprecated: ErrUnexpectedTrailerは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrUnexpectedTrailer = &ProtocolError{"trailer header without chunked transfer encoding"}

	// ErrMissingBoundaryは、リクエストのContent-Typeに「boundary」パラメータが含まれていない場合に、Request.MultipartReaderによって返されます。
	ErrMissingBoundary = &ProtocolError{"no multipart boundary param in Content-Type"}

	/// ErrNotMultipartは、リクエストのContent-Typeがmultipart/form-dataでない場合、Request.MultipartReaderによって返されます。
	ErrNotMultipart = &ProtocolError{"request Content-Type isn't multipart/form-data"}

	// Deprecated: ErrHeaderTooLongは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrHeaderTooLong = &ProtocolError{"header too long"}

	// Deprecated: ErrShortBodyは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrShortBody = &ProtocolError{"entity body too short"}

	// Deprecated: ErrMissingContentLengthは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
)

var (
	// ErrBodyNotAllowedは、HTTPメソッドまたはレスポンスコードがボディを許可しない場合に、ResponseWriter.Write呼び出しによって返されます。
	ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")

	// ErrHijackedは、Hijackerインターフェースを使用して基礎となる接続がハイジャックされた場合に、ResponseWriter.Write呼び出しによって返されます。
	// ハイジャックされた接続でのゼロバイト書き込みは、他の副作用なしにErrHijackedを返します。
	ErrHijacked = errors.New("http: connection has been hijacked")

	// ErrContentLengthは、Handlerが宣言されたサイズを持つContent-Lengthレスポンスヘッダーを設定し、宣言されたバイト数よりも多くのバイトを書き込もうとした場合に、ResponseWriter.Write呼び出しによって返されます。
	ErrContentLength = errors.New("http: wrote more than the declared Content-Length")

	// Deprecated: ErrWriteAfterFlushは、net/httpパッケージの何も返さなくなったため、もはや返されません。
	// 呼び出し元は、この変数に対してエラーを比較するべきではありません。
	ErrWriteAfterFlush = errors.New("unused")
)

HTTPサーバーで使用されるエラー。

var (
	// ServerContextKeyは、コンテキストキーです。
	// HTTPハンドラーでContext.Valueと一緒に使用して、ハンドラーを開始したサーバーにアクセスできます。
	// 関連する値の型は*Serverです。
	ServerContextKey = &contextKey{"http-server"}

	// LocalAddrContextKeyは、コンテキストキーです。
	// HTTPハンドラーでContext.Valueと一緒に使用して、接続が到着したローカルアドレスにアクセスできます。
	// 関連する値の型はnet.Addrです。
	LocalAddrContextKey = &contextKey{"local-addr"}
)

var DefaultClient = &Client{}

DefaultClientはデフォルトの Client であり、Get、Head、および Post に使用されます。

var DefaultServeMux = &defaultServeMux

DefaultServeMuxは、Serve によって使用されるデフォルトの ServeMux です。

var ErrAbortHandler = errors.New("net/http: abort Handler")

ErrAbortHandlerは、ハンドラーを中止するためのセンチネルパニック値です。 ServeHTTPからのパニックはすべて、クライアントへの応答を中止しますが、 ErrAbortHandlerでパニックすると、サーバーのエラーログにスタックトレースを記録しないようにすることができます。

var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")

ErrBodyReadAfterCloseは、ボディが閉じられた後に Request または Response のボディを読み取る場合に返されます。 これは通常、HTTP Handler が ResponseWriter のWriteHeaderまたはWriteを呼び出した後にボディが読み取られた場合に発生します。

var ErrHandlerTimeout = errors.New("http: Handler timeout")

ErrHandlerTimeout is returned on ResponseWriter Write calls in handlers which have timed out.

var ErrLineTooLong = internal.ErrLineTooLong

ErrLineTooLongは、不正なチャンクエンコーディングでリクエストまたはレスポンスボディを読み取る場合に返されます。

var ErrMissingFile = errors.New("http: no such file")

ErrMissingFileは、FormFileが提供されたファイルフィールド名がリクエストに存在しないか、ファイルフィールドではない場合に返されます。

var ErrNoCookie = errors.New("http: named cookie not present")

ErrNoCookieは、Cookieメソッドがクッキーを見つけられなかった場合にRequestによって返されます。

var ErrNoLocation = errors.New("http: no Location header in response")

ErrNoLocationは、Response.Location メソッドがLocationヘッダーが存在しない場合に返されます。

var ErrSchemeMismatch = errors.New("http: server gave HTTP response to HTTPS client")

ErrSchemeMismatchは、サーバーがHTTPSクライアントにHTTPレスポンスを返した場合に返されます。

var ErrServerClosed = errors.New("http: Server closed")

ErrServerClosedは、Server.Shutdown または Server.Close の呼び出し後、Server.Serve、ServeTLS、ListenAndServe、および ListenAndServeTLS メソッドによって返されます。

var ErrSkipAltProtocol = errors.New("net/http: skip alternate protocol")

ErrSkipAltProtocolは、Transport.RegisterProtocolによって定義されたセンチネルエラー値です。

var ErrUseLastResponse = errors.New("net/http: use last response")

ErrUseLastResponseは、Client.CheckRedirectフックによって返され、リダイレクトの処理方法を制御するために使用できます。 これが返されると、次のリクエストは送信されず、最も最近のレスポンスがそのボディが閉じられていない状態で返されます。

var NoBody = noBody{}

NoBodyはバイトを持たない io.ReadCloser です。Readは常にEOFを返し、 Closeは常にnilを返します。これは、リクエストがゼロバイトであることを 明示的に示すために、送信元クライアントのリクエストで使用することができます。 ただし、代わりに [Request.Body] をnilに設定することもできます。

Functions

func CanonicalHeaderKey

func CanonicalHeaderKey(s string) string

CanonicalHeaderKeyは、ヘッダーキーsの正規形式を返します。 正規化により、最初の文字とハイフンに続く任意の文字が大文字に変換されます。 それ以外の文字は小文字に変換されます。 たとえば、「accept-encoding」の正規キーは「Accept-Encoding」です。 sにスペースまたは無効なヘッダーフィールドバイトが含まれている場合、変更せずに返されます。

func DetectContentType

func DetectContentType(data []byte) string

DetectContentTypeは、指定されたデータのContent-Typeを決定するために https://mimesniff.spec.whatwg.org/ で説明されているアルゴリズムを実装します。 データの最初の512バイトまでしか考慮しません。 DetectContentTypeは常に有効なMIMEタイプを返します。 より具体的なMIMEタイプを決定できない場合は、"application/octet-stream"を返します。

func Error

func Error(w ResponseWriter, error string, code int)

Errorは、指定されたエラーメッセージとHTTPコードでリクエストに応答します。 それ以外に、リクエストを終了しません。呼び出し元は、wに対してさらに書き込みが行われないようにする必要があります。 エラーメッセージはプレーンテキストである必要があります。

ErrorはContent-Lengthヘッダーを削除し、 Content-Typeを"text/plain; charset=utf-8"に設定し、 X-Content-Type-Optionsを"nosniff"に設定します。 これにより、呼び出し元が成功した出力を期待して設定していた場合でも、 エラーメッセージ用にヘッダーが適切に設定されます。

func Handle

func Handle(pattern string, handler Handler)

Handleは、[DefaultServeMux]に指定されたパターンのハンドラを登録します。 [ServeMux]のドキュメントには、パターンの一致方法が説明されています。

Example

http.Handle("/count", new(countHandler))
log.Fatal(http.ListenAndServe(":8080", nil))

func HandleFunc

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

HandleFuncは、[DefaultServeMux]に指定されたパターンのハンドラ関数を登録します。 [ServeMux]のドキュメントには、パターンの一致方法が説明されています。

Example

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	h1 := func(w http.ResponseWriter, _ *http.Request) {
		io.WriteString(w, "Hello from a HandleFunc #1!\n")
	}
	h2 := func(w http.ResponseWriter, _ *http.Request) {
		io.WriteString(w, "Hello from a HandleFunc #2!\n")
	}

	http.HandleFunc("/", h1)
	http.HandleFunc("/endpoint", h2)

	log.Fatal(http.ListenAndServe(":8080", nil))
}

func ListenAndServe

func ListenAndServe(addr string, handler Handler) error

ListenAndServeは、TCPネットワークアドレスaddrでリッスンし、 Serve を呼び出して着信接続のリクエストを処理します。 受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

ハンドラは通常nilであり、その場合は DefaultServeMux が使用されます。

ListenAndServeは常に非nilのエラーを返します。

Example

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	// Hello world, the web server

	helloHandler := func(w http.ResponseWriter, req *http.Request) {
		io.WriteString(w, "Hello, world!\n")
	}

	http.HandleFunc("/hello", helloHandler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func ListenAndServeTLS

func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error

ListenAndServeTLSは、ListenAndServe と同じように動作しますが、HTTPS接続を想定しています。 さらに、サーバーの証明書と一致する秘密鍵を含むファイルを提供する必要があります。 証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

Example

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		io.WriteString(w, "Hello, TLS!\n")
	})

	// crypto/tls の generate_cert.go を使用して、cert.pem と key.pem を生成できます。
	log.Printf("About to listen on 8443. Go to https://127.0.0.1:8443/")
	err := http.ListenAndServeTLS(":8443", "cert.pem", "key.pem", nil)
	log.Fatal(err)
}

func MaxBytesReader

func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser

MaxBytesReaderは、io.LimitReader に似ていますが、着信リクエストボディのサイズを制限するために使用されます。 io.LimitReaderとは異なり、MaxBytesReaderの結果はReadCloserであり、制限を超えたReadに対して *MaxBytesError 型の非nilエラーを返し、Closeメソッドが呼び出されたときに基になるリーダーを閉じます。

MaxBytesReaderは、クライアントが誤ってまたは悪意を持って大きなリクエストを送信してサーバーのリソースを浪費することを防止します。可能であれば、ResponseWriter に制限に達した後に接続を閉じるように指示します。

func NotFound

func NotFound(w ResponseWriter, r *Request)

NotFoundは、HTTP 404 not foundエラーでリクエストに応答します。

func ParseHTTPVersion

func ParseHTTPVersion(vers string) (major, minor int, ok bool)

ParseHTTPVersionは、RFC 7230 Section 2.6 に従ってHTTPバージョン文字列を解析します。 "HTTP/1.0"は(1, 0, true)を返します。注意："HTTP/2"のようにマイナーバージョンがない文字列は無効です。

func ParseTime

func ParseTime(text string) (t time.Time, err error)

ParseTimeは、HTTP/1.1で許可されている3つのフォーマットのうちの1つ、TimeFormat、time.RFC850、および time.ANSIC をそれぞれ試して、時間ヘッダー（Date：ヘッダーなど）を解析します。

func ProxyFromEnvironment

func ProxyFromEnvironment(req *Request) (*url.URL, error)

ProxyFromEnvironmentは、環境変数HTTP_PROXY、HTTPS_PROXY、およびNO_PROXY（またはそれらの小文字バージョン）によって示されるように、 指定されたリクエストに使用するプロキシのURLを返します。 リクエストは、NO_PROXYによって除外されていない限り、スキームに一致する環境変数からプロキシを使用します。

環境値は、完全なURLまたは"host[:port]"のいずれかである場合があります。この場合、"http"スキームが想定されます。 値が異なる形式の場合は、エラーが返されます。

環境変数でプロキシが定義されていない場合、またはNO_PROXYによって指定されたリクエストにプロキシを使用しない場合、 nilのURLとnilのエラーが返されます。

特別な場合として、req.URL.Hostが"localhost"（ポート番号ありまたはなし）の場合、nilのURLとnilのエラーが返されます。

func ProxyURL

func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)

ProxyURLは、常に同じURLを返すプロキシ関数（Transport で使用するため）を返します。

func Redirect

func Redirect(w ResponseWriter, r *Request, url string, code int)

Redirectは、リクエストに対してurlにリダイレクトする応答を返します。 urlは、リクエストパスに対する相対パスである場合があります。

提供されたコードは通常、StatusMovedPermanently、StatusFound、または StatusSeeOther の3xx範囲にあります。

Content-Typeヘッダーが設定されていない場合、Redirect はそれを"text/html; charset=utf-8"に設定し、小さなHTML本文を書き込みます。 Content-Typeヘッダーを任意の値、nilを含む任意の値に設定すると、その動作が無効になります。

func Serve

func Serve(l net.Listener, handler Handler) error

Serveは、リスナーlに対して着信HTTP接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。 サービスgoroutineはリクエストを読み取り、その後handlerを呼び出して応答します。

ハンドラは通常nilであり、その場合は DefaultServeMux が使用されます。

TLS Config.NextProtosで"h2"が設定された *tls.Conn 接続を返すリスナーがある場合、HTTP/2サポートが有効になります。

Serveは常にnilでないエラーを返します。

func ServeContent

func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)

ServeContentは、提供されたReadSeekerの内容を使用してリクエストに応答します。 ServeContentの io.Copy に対する主な利点は、Rangeリクエストを適切に処理し、 MIMEタイプを設定し、If-Match、If-Unmodified-Since、If-None-Match、 If-Modified-Since、およびIf-Rangeリクエストを処理することです。

レスポンスのContent-Typeヘッダーが設定されていない場合、ServeContentは 最初にnameのファイル拡張子からタイプを推測し、それが失敗した場合は、 コンテンツの最初のブロックを読み取り、それを DetectContentType に渡すようにフォールバックします。 それ以外の場合、nameは使用されません。特に、nameは空にでき、レスポンスで送信されることはありません。

modtimeがゼロ時またはUnixエポックでない場合、ServeContentは応答のLast-Modifiedヘッダーに含めます。 リクエストにIf-Modified-Sinceヘッダーが含まれている場合、ServeContentはmodtimeを使用して、コンテンツを送信する必要があるかどうかを決定します。

コンテンツのSeekメソッドは動作する必要があります。ServeContentは、コンテンツのサイズを決定するために、コンテンツの末尾にシークを使用します。 *os.File は io.ReadSeeker インターフェースを実装していることに注意してください。

呼び出し元がRFC 7232、セクション2.3に従ってフォーマットされたwのETagヘッダーを設定している場合、ServeContentはそれを使用して、If-Match、If-None-Match、またはIf-Rangeを使用するリクエストを処理します。

リクエストの処理中にエラーが発生した場合（例えば、無効な範囲リクエストを処理する際など）、 ServeContentはエラーメッセージで応答します。デフォルトでは、ServeContentはエラーレスポンスから Cache-Control、Content-Encoding、ETag、およびLast-Modifiedヘッダーを削除します。 GODEBUG設定httpservecontentkeepheaders=1を使用すると、ServeContentはこれらのヘッダーを保持します。

func ServeFile

func ServeFile(w ResponseWriter, r *Request, name string)

ServeFileは、指定された名前の ファイルまたはディレクトリの内容でリクエストに応答します。

提供されたファイル名またはディレクトリ名が相対パスの場合、それは 現在のディレクトリに対して相対的に解釈され、親ディレクトリに昇格することができます。 提供された名前がユーザー入力から構築されている場合、ServeFile を呼び出す前に サニタイズする必要があります。

予防措置として、ServeFileはr.URL.Pathに".."パス要素が含まれているリクエストを拒否します。 これは、r.URL.Pathをサニタイズせずに [filepath.Join] で安全でなく使用し、 その結果をname引数として使用する可能性のある呼び出し元に対する保護です。

別の特殊なケースとして、ServeFileはr.URL.Pathが "/index.html"で終わる任意のリクエストを、最後の "index.html"なしで同じパスにリダイレクトします。そのようなリダイレクトを避けるためには、 パスを変更するか、ServeContent を使用します。

それらの2つの特殊なケースの外では、ServeFileは r.URL.Pathを使用して提供するファイルやディレクトリを選択しません。 名前引数で提供されたファイルやディレクトリのみが使用されます。

func ServeFileFS

func ServeFileFS(w ResponseWriter, r *Request, fsys fs.FS, name string)

ServeFileFSは、ファイルシステムfsysから指定されたファイルまたはディレクトリの内容でリクエストに応答します。 fsysによって提供されるファイルは io.Seeker を実装している必要があります。

提供された名前がユーザー入力から構築されている場合、 ServeFileFS を呼び出す前にサニタイズする必要があります。

予防措置として、ServeFileFSはr.URL.Pathに".."パス要素が含まれているリクエストを拒否します。 これにより、r.URL.Pathに [filepath.Join] を安全に使用せずにサニタイズせずに使用し、そのfilepath.Joinの結果を名前引数として使用する可能性がある呼び出し元を保護します。

もう1つの特別な場合として、ServeFileFSはr.URL.Pathが"/index.html"で終わるリクエストを、最後の"index.html"を除いた同じパスにリダイレクトします。 そのようなリダイレクトを回避するには、パスを変更するか、ServeContentを使用してください。

これら2つの特別な場合以外では、ServeFileFSはファイルまたはディレクトリを選択するためにr.URL.Pathを使用しません。 名前引数で提供されたファイルまたはディレクトリのみが使用されます。

func ServeTLS

func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error

ServeTLSは、リスナーlに対して着信HTTPS接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。 サービスgoroutineはリクエストを読み取り、その後handlerを呼び出して応答します。

ハンドラは通常nilであり、その場合は DefaultServeMux が使用されます。

さらに、サーバーの証明書と対応する秘密鍵を含むファイルを提供する必要があります。 証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

ServeTLSは常にnilでないエラーを返します。

func SetCookie

func SetCookie(w ResponseWriter, cookie *Cookie)

SetCookieは、提供された ResponseWriter のヘッダーにSet-Cookieヘッダーを追加します。 提供されたクッキーには有効な名前が必要です。無効なクッキーは黙って破棄される場合があります。

func StatusText

func StatusText(code int) string

StatusText は、HTTP ステータスコードのテキストを返します。 コードが不明な場合は、空の文字列を返します。

Types

type Client

type Client struct {
	// Transportは個別のHTTPリクエストが行われるメカニズムを指定します。
	// nilの場合、DefaultTransportが使用されます。
	Transport RoundTripper

	// CheckRedirectはリダイレクトの処理ポリシーを指定します。
	// CheckRedirectがnilでない場合、クライアントはHTTPリダイレクトに従う前にそれを呼び出します。
	// 引数のreqとviaは、直前のリクエストとこれまでに行われたリクエストです。最も古いものから順に渡されます。
	// CheckRedirectがエラーを返す場合、ClientのGetメソッドはリクエストreqを発行せずに、
	// 前のResponse（そのBodyが閉じられている）とCheckRedirectのエラー（url.Errorでラップされたもの）の両方を返します。
	// 特別な場合として、CheckRedirectがErrUseLastResponseを返す場合、
	// 最新のレスポンスがそのBodyが閉じていない状態で返され、エラーはnilです。
	//
	// CheckRedirectがnilの場合、Clientはデフォルトのポリシーを使用します。
	// デフォルトのポリシーは、連続した10個のリクエストの後に停止することです。
	CheckRedirect func(req *Request, via []*Request) error

	// Jarはクッキージャーを指定します。
	//
	// Jarは、出力リクエストに関連するクッキーを挿入するために使用され、
	// すべての入力レスポンスのクッキー値で更新されます。
	// Jarは、クライアントがフォローするすべてのリダイレクトで参照されます。
	//
	// Jarがnilの場合、リクエストに明示的に設定されていない場合にのみクッキーが送信されます。
	Jar CookieJar

	// Timeoutは、このClientによって行われるリクエストのタイムアウト時間を指定します。
	// タイムアウトには、接続時間、リダイレクト、レスポンスボディの読み取りなどが含まれます。
	// Get、Head、Post、またはDoが返却された後でも、タイマーは実行し続け、
	// Response.Bodyの読み取りを中断します。
	//
	// Timeoutがゼロの場合は、タイムアウトはありません。
	//
	// Clientは、RequestのContextが終了した場合と同様に、
	// ベースとなるTransportへのリクエストをキャンセルします。
	//
	// 互換性のために、ClientはTransportにCancelRequestメソッドも使用しますが、
	// 新しいRoundTripperの実装はCancelRequestではなく、
	// リクエストのContextを使用してキャンセルするべきです。
	Timeout time.Duration
}

ClientはHTTPクライアントです。ゼロ値(DefaultClient)は、DefaultTransport を使用する使用可能なクライアントです。

[Client.Transport] には通常、内部状態(キャッシュされたTCP接続など)があるため、必要に応じて作成するのではなく、再利用する必要があります。 Clientsは、複数のゴルーチンによる同時使用に対して安全です。

Clientは、RoundTripper(Transport など)よりも高レベルであり、クッキーやリダイレクトなどのHTTPの詳細も処理します。

リダイレクトに従う場合、Clientは、初期 Request に設定されたすべてのヘッダーを転送しますが、以下の場合は除外されます。

• "Authorization"、"WWW-Authenticate"、および"Cookie"などの機密ヘッダーを、信頼できないターゲットに転送する場合。 これらのヘッダーは、初期ドメインのサブドメインマッチまたは完全一致でないドメインにリダイレクトする場合は無視されます。 たとえば、"foo.com"から"foo.com"または"sub.foo.com"にリダイレクトする場合は、機密ヘッダーが転送されますが、 "bar.com"にリダイレクトする場合は転送されません。
• 非nilのCookie Jarで"Cookie"ヘッダーを転送する場合。 各リダイレクトはCookie Jarの状態を変更する可能性があるため、初期リクエストで設定されたCookieを変更する可能性があります。 "Cookie"ヘッダーを転送する場合、変更されたCookieは省略され、Jarが更新された値で変更されたCookieを挿入することが期待されます（元のドメインが一致する場合）。 Jarがnilの場合、初期Cookieは変更せずに転送されます。

func (*Client) CloseIdleConnections

func (c *Client) CloseIdleConnections()

CloseIdleConnectionsは、以前は接続されていたが現在は"keep-alive"状態、つまりアイドル状態にある Transport 上のアイドル接続を閉じます。 これは現在アクティブな接続を中断しません。

[Client.Transport] に Client.CloseIdleConnections メソッドがない場合、このメソッドは何もしません。

func (*Client) Do

func (c *Client) Do(req *Request) (*Response, error)

DoはHTTPリクエストを送信し、クライアントの設定したポリシー（リダイレクト、クッキー、認証など）に従ってHTTPレスポンスを返します。

クライアントポリシー（CheckRedirectなど）によってトリガーされた場合、またはHTTP転送が失敗した場合（ネットワーク接続の問題など）、エラーが返されます。2xx以外のステータスコードはエラーを引き起こしません。

返されるエラーがnilの場合、Response にはユーザーが閉じなければならない非nilのBodyが含まれます。 BodyがEOFまで完全に読み取られずに閉じられない場合、Client の基本となる RoundTripper（通常は Transport）は、 次の「keep-alive」リクエストのためにサーバーへの永続的なTCP接続を再利用できないかもしれません。

リクエストのBodyがnilでない場合、それは基本となるTransportによって閉じられます。エラーが発生した場合も同様です。

エラーが発生した場合、任意のResponseは無視できます。非nilのResponseと非nilのエラーは、CheckRedirectが失敗した場合にのみ返されます。その場合でも、返された [Response.Body] はすでに閉じられています。

通常、Doの代わりに Get、Post、または PostForm が使用されます。

サーバーがリダイレクトを返すと、Clientは最初にCheckRedirect関数を使用してリダイレクトをフォローするかどうかを決定します。許可されると、301、302、または303のリダイレクトは、メソッドがGET（元のリクエストがHEADだった場合はHEAD）でボディがない後続のリクエストを引き起こします。307または308のリダイレクトは、[Request.GetBody] 関数が定義されている場合、元のHTTPメソッドとボディを保持します。NewRequest 関数は、一般的な標準ライブラリボディタイプのGetBodyを自動的に設定します。

すべての返されるエラーは *url.Error 型です。url.ErrorのTimeoutメソッドは、リクエストがタイムアウトした場合にtrueを報告します。

func (*Client) Get

func (c *Client) Get(url string) (resp *Response, err error)

Getは指定されたURLにGETを発行します。レスポンスが以下のリダイレクトコードのいずれかである場合、 Getは [Client.CheckRedirect] 関数を呼び出した後にリダイレクトを追跡します：

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

[Client.CheckRedirect] 関数が失敗した場合、またはHTTPプロトコルエラーがあった場合、エラーが返されます。 非2xxのレスポンスはエラーを引き起こしません。返される任意のエラーは *url.Error 型になります。 url.Error値のTimeoutメソッドは、リクエストがタイムアウトした場合にtrueを報告します。

errがnilの場合、respは常に非nilのresp.Bodyを含みます。 読み取りが完了したら、呼び出し元はresp.Bodyを閉じる必要があります。

カスタムヘッダーを使用してリクエストを行うには、NewRequest と Client.Do を使用します。

カスタムヘッダーでリクエストを行うには、NewRequest と Client.Do を使用します。

指定したcontext.Contextでリクエストを作成するには、NewRequestWithContext と Client.Do を使用します。

func (*Client) Head

func (c *Client) Head(url string) (resp *Response, err error)

指定されたURLにHEADリクエストを送信します。もしレスポンスが以下のいずれかのリダイレクトコードである場合、 Headメソッドはリダイレクトに従う前に [Client.CheckRedirect] 関数を呼び出すことがあります。

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

指定された context.Context を使用してリクエストを送信する場合は、NewRequestWithContext と Client.Do を使用してください。

func (*Client) Post

func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error)

Postは、指定されたURLにPOSTリクエストを送信します。

呼び出し元は、resp.Bodyの読み込みが完了したらresp.Bodyを閉じる必要があります。

提供されたBodyが io.Closer インターフェースを実装している場合、リクエストの後に閉じられます。

カスタムヘッダーを設定するには、NewRequest と Client.Do を使用します。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContext と Client.Do を使用します。

リダイレクトの処理方法については、Client.Doメソッドのドキュメントを参照してください。

func (*Client) PostForm

func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error)

PostForm関数は、指定されたデータのキーと値のペアをリクエストボディにエンコードして、URLにPOSTリクエストを送信します。

Content-Typeヘッダーはapplication/x-www-form-urlencodedに設定されます。 他のヘッダーを設定するには、NewRequest と Client.Do を使用します。

errがnilの場合、respは常に非nilのresp.Bodyを含みます。 読み取り後、呼び出し元はresp.Bodyを閉じなければなりません。

リダイレクトの処理については、Client.Doメソッドのドキュメンテーションを参照してください。

指定したcontext.Contextでリクエストを作成するには、NewRequestWithContext とClient.Doを使用します。

type CloseNotifier

type CloseNotifier interface {
	CloseNotify() <-chan bool
}

CloseNotifierインターフェースは、基礎となる接続が切断されたときに検出できるResponseWriterによって実装されます。

このメカニズムは、レスポンスが準備される前にクライアントが切断された場合、サーバー上の長時間の操作をキャンセルするために使用できます。

Deprecated: CloseNotifierインターフェースは、Goのコンテキストパッケージより前に実装されました。 新しいコードでは、Request.Context を使用する必要があります。

type ConnState

type ConnState int

ConnStateは、サーバーへのクライアント接続の状態を表します。 これは、オプションの [Server.ConnState] フックによって使用されます。

const (
	// StateNewは、すぐにリクエストを送信することが期待される新しい接続を表します。
	// 接続はこの状態で開始し、StateActiveまたはStateClosedに移行します。
	StateNew ConnState = iota

	// StateActiveは、1バイト以上のリクエストを読み取った接続を表します。
	// StateActiveのServer.ConnStateフックは、リクエストがハンドラに入る前に発生し、
	// リクエストが処理されるまで再び発生しません。
	// リクエストが処理された後、状態はStateClosed、StateHijacked、またはStateIdleに移行します。
	// HTTP/2の場合、StateActiveはゼロから1つのアクティブなリクエストに移行するときに発生し、
	// すべてのアクティブなリクエストが完了するまでにしか移行しません。
	// つまり、ConnStateはリクエストごとの作業に使用できません。
	// ConnStateは接続の全体的な状態のみを示します。
	StateActive

	// StateIdleは、リクエストの処理が完了し、新しいリクエストを待機しているkeep-alive状態の接続を表します。
	// 接続はStateIdleからStateActiveまたはStateClosedに移行します。
	StateIdle

	// StateHijackedは、ハイジャックされた接続を表します。
	// これは終端状態です。StateClosedに移行しません。
	StateHijacked

	// StateClosedは、閉じられた接続を表します。
	// これは終端状態です。ハイジャックされた接続はStateClosedに移行しません。
	StateClosed
)

func (ConnState) String

func (c ConnState) String() string

type Cookie

type Cookie struct {
	Name   string
	Value  string
	Quoted bool

	Path       string
	Domain     string
	Expires    time.Time
	RawExpires string

	// MaxAge=0は 'Max-Age'属性が指定されていないことを意味します。
	// MaxAge<0は今すぐクッキーを削除することを意味し、'Max-Age: 0'と同等です。
	// MaxAge>0はMax-Age属性が存在し、秒で指定されていることを意味します。
	MaxAge      int
	Secure      bool
	HttpOnly    bool
	SameSite    SameSite
	Partitioned bool
	Raw         string
	Unparsed    []string
}

Cookieは、HTTP応答のSet-CookieヘッダーまたはHTTPリクエストのCookieヘッダーで送信されるHTTPクッキーを表します。

詳細については、https://tools.ietf.org/html/rfc6265 を参照してください。

func ParseCookie

func ParseCookie(line string) ([]*Cookie, error)

ParseCookieはCookieヘッダーの値を解析し、それに設定されていたすべてのクッキーを返します。 同じクッキー名が複数回現れることがあるため、返されるValuesには、特定のキーに対して複数の値が含まれることがあります。

func ParseSetCookie

func ParseSetCookie(line string) (*Cookie, error)

ParseSetCookieはSet-Cookieヘッダーの値を解析し、クッキーを返します。 構文エラーがある場合はエラーを返します。

func (*Cookie) String

func (c *Cookie) String() string

Stringは、Cookie ヘッダー（NameとValueのみが設定されている場合）またはSet-Cookie応答ヘッダー（他のフィールドが設定されている場合）で使用するためのクッキーのシリアル化を返します。 cがnilであるか、c.Nameが無効な場合、空の文字列が返されます。

func (*Cookie) Valid

func (c *Cookie) Valid() error

Validは、クッキーが有効かどうかを報告します。

type CookieJar

type CookieJar interface {
	SetCookies(u *url.URL, cookies []*Cookie)

	Cookies(u *url.URL) []*Cookie
}

CookieJarは、HTTPリクエストでのCookieのストレージと使用を管理します。

CookieJarの実装は、複数のゴルーチンによる同時使用に対して安全である必要があります。

net/http/cookiejarパッケージはCookieJarの実装を提供します。

type Dir

type Dir string

Dirは、特定のディレクトリツリーに制限されたネイティブファイルシステムを使用して FileSystem を実装します。

[FileSystem.Open] メソッドは'/'で区切られたパスを取りますが、Dirの文字列値はURLではなくネイティブファイルシステム上のディレクトリーパスであるため、[filepath.Separator] で区切られます。これは必ずしも'/'ではありません。

Dirは、機密ファイルやディレクトリを公開する可能性があります。Dirは、ディレクトリツリーから外部を指すシンボリックリンクを追跡します。これは、ユーザーが任意のシンボリックリンクを作成できるディレクトリからサービスを提供する場合に特に危険です。Dirは、ピリオドで始まるファイルやディレクトリにもアクセスを許可します。これには、.gitのような機密ディレクトリや.htpasswdのような機密ファイルが含まれます。ピリオドで始まるファイルを除外するには、ファイル/ディレクトリをサーバーから削除するか、カスタムFileSystem実装を作成してください。

空のDirは"."として扱われます。

func (Dir) Open

func (d Dir) Open(name string) (File, error)

Openは、os.Open を使用して、ディレクトリdにルートされ、相対的なファイルを読み取るために FileSystem を実装します。

type File

type File interface {
	io.Closer
	io.Reader
	io.Seeker
	Readdir(count int) ([]fs.FileInfo, error)
	Stat() (fs.FileInfo, error)
}

FileSystem のOpenメソッドによって返され、FileServer 実装によって提供されるファイルです。

メソッドは、 *os.File と同じ動作をする必要があります。

type FileSystem

type FileSystem interface {
	Open(name string) (File, error)
}

FileSystemは、名前付きファイルのコレクションへのアクセスを実装します。 ファイルパスの要素は、ホストオペレーティングシステムの規約に関係なく、スラッシュ（'/'、U+002F）で区切られます。 FileSystemを Handler に変換するには、FileServer 関数を参照してください。

このインターフェースは、fs.FS インターフェースより前に存在しており、代わりに使用できます。 FS アダプター関数は、fs.FSをFileSystemに変換します。

func FS

func FS(fsys fs.FS) FileSystem

FSはfsysを FileSystem の実装に変換します。 これは FileServer と NewFileTransport で使用するためのものです。 fsysによって提供されるファイルは io.Seeker を実装しなければなりません。

type Flusher

type Flusher interface {
	Flush()
}

Flusherインターフェースは、HTTPハンドラーがバッファリングされたデータをクライアントにフラッシュすることを許可するResponseWriterによって実装されます。

デフォルトのHTTP/1.xおよびHTTP/2 ResponseWriter 実装は Flusher をサポートしていますが、ResponseWriterラッパーはサポートしていない場合があります。 ハンドラーは常にランタイムでこの機能をテストする必要があります。

FlushをサポートするResponseWriterであっても、クライアントがHTTPプロキシを介して接続されている場合、 バッファリングされたデータがレスポンスが完了するまでクライアントに到達しない場合があります。

type Handler

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

Handlerは、HTTPリクエストに応答します。

[Handler.ServeHTTP] は、応答ヘッダーとデータを ResponseWriter に書き込んでから返す必要があります。 返すことで、リクエストが完了したことを示します。 ServeHTTPの呼び出しの完了後または同時に、 ResponseWriter を使用するか、[Request.Body]から読み取ることはできません。

HTTPクライアントソフトウェア、HTTPプロトコルバージョン、およびクライアントとGoサーバーの間の中間者によっては、 [ResponseWriter]に書き込んだ後に [Request.Body] から読み取ることができない場合があります。 注意深いハンドラーは、最初に [Request.Body] を読み取り、その後に応答する必要があります。

ボディを読み取る以外の場合、ハンドラーは提供されたRequestを変更してはいけません。

ServeHTTPがパニックを起こすと、サーバー（ServeHTTPの呼び出し元）は、パニックの影響がアクティブなリクエストに限定されたものであると仮定します。 サーバーはパニックを回復し、サーバーエラーログにスタックトレースを記録し、ネットワーク接続を閉じるか、HTTP/2 RST_STREAMを送信します。 クライアントが中断された応答を見るが、サーバーがエラーをログに記録しないように、 ErrAbortHandler の値でパニックを発生させることで、ハンドラーを中止できます。

func AllowQuerySemicolons

func AllowQuerySemicolons(h Handler) Handler

AllowQuerySemicolonsは、URLクエリ内のエスケープされていないセミコロンをアンパサンドに変換し、ハンドラhを呼び出すハンドラを返します。

これにより、Go 1.17以前のクエリパラメータをセミコロンとアンパサンドの両方で分割する動作が復元されます（golang.org/issue/25192 を参照）。 ただし、この動作は多くのプロキシと一致せず、不一致がセキュリティ上の問題を引き起こす可能性があります。

AllowQuerySemicolonsは、Request.ParseForm が呼び出される前に呼び出す必要があります。

func FileServer

func FileServer(root FileSystem) Handler

FileServerは、ルートでルートされたファイルシステムの内容でHTTPリクエストを処理するハンドラーを返します。

特別な場合として、返されたファイルサーバーは、"/index.html"で終わるリクエストを、最後の"index.html"を除いた同じパスにリダイレクトします。

オペレーティングシステムのファイルシステム実装を使用するには、http.Dir を使用してください。

http.Handle("/", http.FileServer(http.Dir("/tmp")))

fs.FS の実装を使用するには、代わりに http.FileServerFS を使用します。

Example

package main

import (
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	// シンプルな静的 Web サーバー:
	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))
}

Example (DotFileHiding)

fsys := dotFileHidingFileSystem{http.Dir(".")}
http.Handle("/", http.FileServer(fsys))
log.Fatal(http.ListenAndServe(":8080", nil))

Example (StripPrefix)

package main

import (
	"github.com/shogo82148/std/net/http"
)

func main() {
	// ディスク上のディレクトリ (/tmp) を別の URL パス (/tmpfiles/) の下で提供するには、
	// StripPrefix を使用して、FileServer がそれを見る前に
	// リクエスト URL のパスを変更します。
	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
}

func FileServerFS

func FileServerFS(root fs.FS) Handler

FileServerFSは、ファイルシステムfsysの内容でHTTPリクエストを処理するハンドラを返します。 fsysによって提供されるファイルは io.Seeker を実装している必要があります。

特別なケースとして、返されたファイルサーバーは、"/index.html"で終わる任意のリクエストを、 最後の"index.html"なしの同じパスにリダイレクトします。

http.Handle("/", http.FileServerFS(fsys))

func MaxBytesHandler

func MaxBytesHandler(h Handler, n int64) Handler

MaxBytesHandlerは、ResponseWriter と [Request.Body] をMaxBytesReaderでラップしてhを実行する Handler を返します。

func NotFoundHandler

func NotFoundHandler() Handler

NotFoundHandlerは、各リクエストに「404ページが見つかりません」という応答を返す単純なリクエストハンドラーを返します。

Example

mux := http.NewServeMux()

// Create sample handler to returns 404
mux.Handle("/resources", http.NotFoundHandler())

// Create sample handler that returns 200
mux.Handle("/resources/people/", newPeopleHandler())

log.Fatal(http.ListenAndServe(":8080", mux))

func RedirectHandler

func RedirectHandler(url string, code int) Handler

RedirectHandlerは、受信した各リクエストを、指定されたステータスコードを使用して、指定されたURLにリダイレクトするリクエストハンドラーを返します。

提供されたコードは通常、StatusMovedPermanently、StatusFound、または StatusSeeOther の3xx範囲にあります。

func StripPrefix

func StripPrefix(prefix string, h Handler) Handler

StripPrefixは、リクエストURLのPath（および設定されている場合はRawPath）から指定された接頭辞を削除し、ハンドラーhを呼び出してHTTPリクエストを処理するハンドラーを返します。 prefixで始まらないパスのリクエストには、HTTP 404 not foundエラーで応答します。 接頭辞は完全に一致する必要があります。リクエストの接頭辞にエスケープされた文字が含まれている場合、応答もHTTP 404 not foundエラーになります。

Example

package main

import (
	"github.com/shogo82148/std/net/http"
)

func main() {
	// ディスク上のディレクトリ (/tmp) を別の URL パス (/tmpfiles/) の下で提供するには、
	// StripPrefix を使用して、FileServer がそれを見る前に
	// リクエスト URL のパスを変更します。
	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
}

func TimeoutHandler

func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

TimeoutHandlerは、指定された時間制限でhを実行する Handler を返します。

新しいHandlerは、各リクエストを処理するためにh.ServeHTTPを呼び出しますが、 呼び出しがその時間制限を超えて実行されると、ハンドラは503 Service Unavailableエラーと そのボディ内の指定されたメッセージで応答します。 （もしmsgが空であれば、適切なデフォルトメッセージが送信されます。） そのようなタイムアウトの後、hによるその ResponseWriter への書き込みは ErrHandlerTimeout を返します。

TimeoutHandlerは Pusher インターフェースをサポートしますが、 Hijacker または Flusher インターフェースはサポートしません。

type HandlerFunc

type HandlerFunc func(ResponseWriter, *Request)

HandlerFunc型は、HTTPハンドラーとして通常の関数を使用できるようにするためのアダプタです。 fが適切なシグネチャを持つ関数である場合、HandlerFunc(f)はfを呼び出す Handler です。

func (HandlerFunc) ServeHTTP

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)

ServeHTTPは、f(w, r) を呼び出します。

type Header

type Header map[string][]string

Headerは、HTTPヘッダー内のキーと値のペアを表します。

キーは、CanonicalHeaderKey が返すように正規化された形式である必要があります。

func (Header) Add

func (h Header) Add(key, value string)

Addは、ヘッダーにキーと値のペアを追加します。 キーに関連付けられた既存の値に追加します。 キーは大文字小文字を区別せず、CanonicalHeaderKey によって正規化されます。

func (Header) Clone

func (h Header) Clone() Header

Cloneは、hのコピーを返します。hがnilの場合はnilを返します。

func (Header) Del

func (h Header) Del(key string)

Delは、キーに関連付けられた値を削除します。 キーは大文字小文字を区別せず、CanonicalHeaderKey によって正規化されます。

func (Header) Get

func (h Header) Get(key string) string

Getは、指定されたキーに関連付けられた最初の値を取得します。 キーに関連付けられた値がない場合、Getは""を返します。 大文字小文字を区別せず、[textproto.CanonicalMIMEHeaderKey] が提供されたキーを正規化することに注意してください。 Getは、すべてのキーが正規形式で格納されていると想定しています。非正規のキーを使用するには、直接マップにアクセスしてください。

func (Header) Set

func (h Header) Set(key, value string)

Setは、キーに関連付けられたヘッダーエントリを単一の要素値に設定します。 キーに関連付けられた既存の値を置き換えます。 キーは大文字小文字を区別せず、[textproto.CanonicalMIMEHeaderKey] によって正規化されます。 非正規のキーを使用するには、直接マップに割り当ててください。

func (Header) Values

func (h Header) Values(key string) []string

Valuesは、指定されたキーに関連付けられたすべての値を返します。 大文字小文字を区別せず、[textproto.CanonicalMIMEHeaderKey] が提供されたキーを正規化することに注意してください。 非正規のキーを使用するには、直接マップにアクセスしてください。 返されるスライスはコピーではありません。

func (Header) Write

func (h Header) Write(w io.Writer) error

Writeは、ワイヤーフォーマットでヘッダーを書き込みます。

func (Header) WriteSubset

func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error

WriteSubsetはワイヤーフォーマットでヘッダーを書き込みます。 excludeがnilでない場合、exclude[key] == trueのキーは書き込まれません。 excludeマップをチェックする前にキーは正規化されません。

type Hijacker

type Hijacker interface {
	Hijack() (net.Conn, *bufio.ReadWriter, error)
}

Hijackerインターフェースは、HTTPハンドラーが接続を引き継ぐことを許可するResponseWriterによって実装されます。

HTTP/1.x接続のデフォルト ResponseWriter はHijackerをサポートしていますが、HTTP/2接続は意図的にサポートしていません。 ResponseWriterラッパーもHijackerをサポートしていない場合があります。 ハンドラーは常にランタイムでこの機能をテストする必要があります。

Example

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	http.HandleFunc("/hijack", func(w http.ResponseWriter, r *http.Request) {
		hj, ok := w.(http.Hijacker)
		if !ok {
			http.Error(w, "webserver doesn't support hijacking", http.StatusInternalServerError)
			return
		}
		conn, bufrw, err := hj.Hijack()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		// 接続を閉じることを忘れないでください:
		defer conn.Close()
		bufrw.WriteString("Now we're speaking raw TCP. Say hi: ")
		bufrw.Flush()
		s, err := bufrw.ReadString('\n')
		if err != nil {
			log.Printf("error reading string: %v", err)
			return
		}
		fmt.Fprintf(bufrw, "You said: %q\nBye.\n", s)
		bufrw.Flush()
	})
}

type MaxBytesError

type MaxBytesError struct {
	Limit int64
}

MaxBytesErrorは、MaxBytesReader の読み取り制限を超えた場合に MaxBytesReader によって返されます。

func (*MaxBytesError) Error

func (e *MaxBytesError) Error() string

type ProtocolError

type ProtocolError struct {
	ErrorString string
}

ProtocolErrorは、HTTPプロトコルエラーを表します。

Deprecated: httpパッケージのすべてのプロトコルエラーに関連するエラーがProtocolError型ではありません。

func (*ProtocolError) Error

func (pe *ProtocolError) Error() string

func (*ProtocolError) Is

func (pe *ProtocolError) Is(err error) bool

Isは、http.ErrNotSupportedがerrors.ErrUnsupportedに一致するようにします。

type PushOptions

type PushOptions struct {

	// Methodは要求されたリクエストのHTTPメソッドを指定します。
	// 設定する場合、"GET"または"HEAD"でなければなりません。空は"GET"を意味します。
	Method string

	// Headerは追加の約束されたリクエストヘッダーを指定します。これには":path"や":scheme"などのHTTP/2疑似ヘッダーフィールドは含めることができませんが、これらは自動的に追加されます。
	Header Header
}

PushOptionsは、[Pusher.Push] のオプションを記述します。

type Pusher

type Pusher interface {
	Push(target string, opts *PushOptions) error
}

Pusherは、HTTP/2サーバープッシュをサポートするResponseWritersによって実装されるインターフェースです。 詳細については、 https://tools.ietf.org/html/rfc7540#section-8.2 を参照してください。

type Request

type Request struct {
	// Methodは、HTTPメソッド（GET、POST、PUTなど）を指定します。
	// クライアントリクエストの場合、空の文字列はGETを意味します。
	Method string

	// URLは、サーバーリクエストの場合に要求されるURI（URI）を指定するか、
	// クライアントリクエストの場合にアクセスするURLを指定します。
	//
	// サーバーリクエストの場合、URLはRequestURIに格納されたRequest-Lineで指定されたURIから解析されます。
	// ほとんどのリクエストでは、PathとRawQuery以外のフィールドは空になります。 （RFC 7230、セクション5.3を参照）
	//
	// クライアントリクエストの場合、URLのHostは接続するサーバーを指定し、
	// RequestのHostフィールドはHTTPリクエストで送信するHostヘッダー値をオプションで指定します。
	URL *url.URL

	// サーバーリクエストのプロトコルバージョン。
	//
	// クライアントリクエストの場合、これらのフィールドは無視されます。
	// HTTPクライアントコードは常にHTTP/1.1またはHTTP/2を使用します。
	// 詳細については、Transportのドキュメントを参照してください。
	Proto      string
	ProtoMajor int
	ProtoMinor int

	// Headerは、サーバーによって受信されたリクエストヘッダーフィールドまたはクライアントによって送信されるリクエストヘッダーフィールドを含みます。
	//
	// サーバーがヘッダーラインを含むリクエストを受信した場合、
	//
	//	Host: example.com
	//	accept-encoding: gzip, deflate
	//	Accept-Language: en-us
	//	fOO: Bar
	//	foo: two
	//
	// その場合、
	//
	//	Header = map[string][]string{
	//		"Accept-Encoding": {"gzip, deflate"},
	//		"Accept-Language": {"en-us"},
	//		"Foo": {"Bar", "two"},
	//	}
	//
	// 入力リクエストの場合、HostヘッダーはRequest.Hostフィールドに昇格し、Headerマップから削除されます。
	//
	// HTTPは、ヘッダー名が大文字小文字を区別しないことを定義しています。リクエストパーサーは、CanonicalHeaderKeyを使用してこれを実装し、ハイフンの後に続く最初の文字と任意の文字を大文字にし、残りを小文字にします。
	//
	// クライアントリクエストの場合、Content-LengthやConnectionなどの特定のヘッダーは必要に応じて自動的に書き込まれ、Headerの値は無視される場合があります。Request.Writeメソッドのドキュメントを参照してください。
	Header Header

	// Bodyは、リクエストの本文です。
	//
	// クライアントリクエストの場合、nilのBodyは、GETリクエストなど、リクエストに本文がないことを意味します。
	// HTTPクライアントのTransportは、Closeメソッドを呼び出す責任があります。
	//
	// サーバーリクエストの場合、Request Bodyは常にnilではありませんが、本文が存在しない場合はすぐにEOFが返されます。
	// サーバーはリクエストボディを閉じます。ServeHTTPハンドラーは閉じる必要はありません。
	//
	// Bodyは、ReadがCloseと同時に呼び出されることを許可する必要があります。
	// 特に、Closeを呼び出すと、入力を待機しているReadがブロックされている場合は、それを解除する必要があります。
	Body io.ReadCloser

	// GetBodyは、Bodyの新しいコピーを返すオプションの関数を定義します。
	// リダイレクトにより、Bodyを複数回読み取る必要がある場合にクライアントリクエストで使用されます。
	// GetBodyの使用には、Bodyを設定する必要があります。
	//
	// サーバーリクエストの場合、使用されません。
	GetBody func() (io.ReadCloser, error)

	// ContentLengthは、関連するコンテンツの長さを記録します。
	// 値-1は、長さが不明であることを示します。
	// 値が0以上の場合、Bodyから指定されたバイト数を読み取ることができます。
	//
	// クライアントリクエストの場合、Bodyがnilでない場合、値0は不明として扱われます。
	ContentLength int64

	// TransferEncodingは、最も外側から最も内側までの転送エンコーディングをリストします。
	// 空のリストは「identity」エンコーディングを示します。
	// TransferEncodingは通常無視できます。チャンクエンコーディングは、
	// リクエストの送信と受信時に必要に応じて自動的に追加および削除されます。
	TransferEncoding []string

	// Closeは、このリクエストに応答した後（サーバーの場合）またはこのリクエストを送信してその応答を読み取った後（クライアントの場合）に接続を閉じるかどうかを示します。
	//
	// サーバーリクエストの場合、HTTPサーバーがこれを自動的に処理し、このフィールドはHandlersによって必要ではありません。
	//
	// クライアントリクエストの場合、このフィールドを設定すると、 Transport.DisableKeepAlives が設定された場合と同様に、同じホストへのリクエスト間でTCP接続の再利用が防止されます。
	Close bool

	// サーバーリクエストの場合、HostはURLが要求されるホストを指定します。
	// HTTP/1（RFC 7230 Section 5.4 による）の場合、これは「Host」ヘッダーの値またはURL自体で指定されたホスト名のいずれかです。
	// HTTP/2の場合、これは「:authority」疑似ヘッダーフィールドの値です。
	// 形式は「host:port」にすることができます。
	// 国際ドメイン名の場合、HostはPunycodeまたはUnicode形式である場合があります。
	// 必要に応じて、golang.org/x/net/idna を使用してどちらの形式にも変換できます。
	// DNSリバインディング攻撃を防ぐために、サーバーハンドラーは、Hostヘッダーがハンドラー自身が権限を持つ値であることを検証する必要があります。
	// 含まれるServeMuxは、特定のホスト名に登録されたパターンをサポートし、その登録されたハンドラーを保護します。
	//
	// クライアントリクエストの場合、HostはオプションでHostヘッダーを上書きして送信します。
	// 空の場合、Request.Write メソッドは URL.Host の値を使用します。
	// Hostには国際ドメイン名が含まれる場合があります。
	Host string

	// Formには、URLフィールドのクエリパラメータとPATCH、POST、またはPUTフォームデータを含む解析されたフォームデータが含まれます。
	// ParseFormが呼び出された後にのみこのフィールドが使用可能です。
	// HTTPクライアントはFormを無視し、代わりにBodyを使用します。
	Form url.Values

	// PostFormには、PATCH、POST、またはPUTボディパラメータから解析されたフォームデータが含まれます。
	//
	// ParseFormが呼び出された後にのみこのフィールドが使用可能です。
	// HTTPクライアントはPostFormを無視し、代わりにBodyを使用します。
	PostForm url.Values

	// MultipartFormは、ファイルのアップロードを含む解析されたマルチパートフォームです。
	// ParseMultipartFormが呼び出された後にのみこのフィールドが使用可能です。
	// HTTPクライアントはMultipartFormを無視し、代わりにBodyを使用します。
	MultipartForm *multipart.Form

	// Trailerは、リクエスト本文の後に送信される追加のヘッダーを指定します。
	//
	// サーバーリクエストの場合、Trailerマップには最初にトレーラーキーのみが含まれ、nil値が含まれます。
	// （クライアントは、後で送信するトレーラーを宣言します。）
	// ハンドラーがBodyから読み取っている間、Trailerに参照しないでください。
	// Bodyからの読み取りがEOFを返した後、Trailerを再度読み取ると、クライアントが送信した場合は非nil値が含まれます。
	//
	// クライアントリクエストの場合、Trailerは、後で送信するトレーラーキーを含むマップで初期化する必要があります。
	// 値はnilまたは最終値である場合があります。ContentLengthは0または-1である必要があります。
	// HTTPリクエストが送信された後、マップの値は、リクエストボディが読み取られている間に更新できます。
	// ボディがEOFを返した後、呼び出し元はTrailerを変更してはいけません。
	//
	// 少数のHTTPクライアント、サーバー、またはプロキシがHTTPトレーラーをサポートしています。
	Trailer Header

	// RemoteAddrは、HTTPサーバーやその他のソフトウェアが、通常はログ記録のためにリクエストを送信したネットワークアドレスを記録できるようにします。
	// このフィールドはReadRequestによって入力されず、定義された形式はありません。
	// このパッケージのHTTPサーバーは、ハンドラーを呼び出す前にRemoteAddrを「IP:port」アドレスに設定します。
	// このフィールドはHTTPクライアントによって無視されます。
	RemoteAddr string

	// RequestURIは、クライアントがサーバーに送信したRequest-Line（RFC 7230 Section 3.1.1）の変更されていないリクエストターゲットです。
	// 通常、URLフィールドを代わりに使用する必要があります。
	// HTTPクライアントリクエストでこのフィールドを設定することはエラーです。
	RequestURI string

	// TLSは、HTTPサーバーやその他のソフトウェアが、リクエストを受信したTLS接続に関する情報を記録できるようにします。
	// このフィールドはReadRequestによって入力されず、定義された形式はありません。
	// このパッケージのHTTPサーバーは、ハンドラーを呼び出す前にTLS有効な接続のためにこのフィールドを設定します。
	// それ以外の場合は、このフィールドをnilのままにします。
	// このフィールドはHTTPクライアントによって無視されます。
	TLS *tls.ConnectionState

	// Cancelは、クライアントリクエストがキャンセルされたと見なす必要があることを示すチャネルのオプションです。
	// RoundTripperのすべての実装がCancelをサポートしているわけではありません。
	//
	// サーバーリクエストの場合、このフィールドは適用されません。
	//
	// Deprecated: NewRequestWithContextでRequestのコンテキストを設定してください。
	// RequestのCancelフィールドとコンテキストの両方が設定されている場合、Cancelが尊重されるかどうかは未定義です。
	Cancel <-chan struct{}

	// Responseは、このリクエストが作成されたクライアントリダイレクト中にのみ設定されるリダイレクトレスポンスです。
	Response *Response

	// Pattern is the [ServeMux] pattern that matched the request.
	// It is empty if the request was not matched against a pattern.
	Pattern string
	// contains filtered or unexported fields
}

Requestは、サーバーによって受信されたHTTPリクエストまたはクライアントによって送信されるHTTPリクエストを表します。

フィールドの意味は、クライアントとサーバーの使用方法でわずかに異なります。 以下のフィールドに関する注意事項に加えて、Request.Write および RoundTripper のドキュメントを参照してください。

func NewRequest

func NewRequest(method, url string, body io.Reader) (*Request, error)

NewRequestは、context.Background を使用して NewRequestWithContext をラップします。

func NewRequestWithContext

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error)

NewRequestWithContextは、メソッド、URL、およびオプションのボディが与えられた場合に新しい Request を返します。

提供されたbodyが io.Closer でも、返された [Request.Body] はbodyに設定され、ClientのDo、Post、PostForm、および Transport.RoundTrip によって（非同期に）閉じられます。

NewRequestWithContextは、Client.Do または Transport.RoundTrip で使用するためのRequestを返します。 Server Handlerをテストするためのリクエストを作成するには、net/http/httptestパッケージの NewRequest 関数を使用するか、 ReadRequest を使用するか、またはRequestフィールドを手動で更新します。送信元のクライアントリクエストの場合、 コンテキストはリクエストとその応答の全寿命を制御します：接続の取得、リクエストの送信、および応答ヘッダーとボディの読み取り。 入力リクエストフィールドと出力リクエストフィールドの違いについては、Requestタイプのドキュメントを参照してください。

bodyが *bytes.Buffer、 *bytes.Reader、または *strings.Reader の場合、返されたリクエストのContentLengthはその正確な値に設定されます（-1の代わりに）、 GetBodyが作成されます（307および308のリダイレクトがボディを再生できるように）、およびContentLengthが0の場合はBodyが NoBody に設定されます。

func ReadRequest

func ReadRequest(b *bufio.Reader) (*Request, error)

ReadRequestは、bから受信したリクエストを読み取り、解析します。

ReadRequestは、低レベルの関数であり、特殊なアプリケーションにのみ使用する必要があります。 ほとんどのコードは、Server を使用してリクエストを読み取り、Handler インターフェイスを介して処理する必要があります。 ReadRequestは、HTTP/1.xリクエストのみをサポートしています。 HTTP/2の場合は、golang.org/x/net/http2 を使用してください。

func (*Request) AddCookie

func (r *Request) AddCookie(c *Cookie)

AddCookieは、リクエストにクッキーを追加します。RFC 6265 Section 5.4 に従い、 AddCookieは1つ以上の Cookie ヘッダーフィールドを添付しません。つまり、すべてのクッキーが、 セミコロンで区切られた同じ行に書き込まれます。 AddCookieは、cの名前と値をサニタイズするだけで、すでにリクエストに存在するCookieヘッダーをサニタイズしません。

func (*Request) BasicAuth

func (r *Request) BasicAuth() (username, password string, ok bool)

BasicAuthは、リクエストがHTTP Basic認証を使用する場合、リクエストのAuthorizationヘッダーで提供されるユーザー名とパスワードを返します。 RFC 2617 Section 2 を参照してください。

func (*Request) Clone

func (r *Request) Clone(ctx context.Context) *Request

Cloneは、そのコンテキストをctxに変更したrのディープコピーを返します。提供されたctxはnilであってはなりません。

出力クライアントリクエストの場合、コンテキストはリクエストとそのレスポンスのライフタイム全体を制御します：接続の取得、リクエストの送信、レスポンスヘッダーとボディの読み取り。

CloneはBodyフィールドの浅いコピーのみを作成します。

新しいコンテキストを持つリクエストを作成するには、NewRequestWithContextを使用します。 コンテキストを変更せずに新しいリクエストを作成するには、Request.WithContextを使用します。

func (*Request) Context

func (r *Request) Context() context.Context

Contextは、リクエストのコンテキストを返します。コンテキストを変更するには、Request.Clone または Request.WithContext を使用してください。

返されるコンテキストは常にnilではありません。デフォルトでは、バックグラウンドコンテキストになります。

出力クライアントリクエストの場合、コンテキストはキャンセルを制御します。

入力サーバーリクエストの場合、クライアントの接続が閉じられたとき、リクエストがキャンセルされたとき（HTTP/2で）、またはServeHTTPメソッドが返されたときに、コンテキストがキャンセルされます。

func (*Request) Cookie

func (r *Request) Cookie(name string) (*Cookie, error)

Cookieは、リクエストで提供された名前付きクッキーを返します。クッキーが見つからない場合は ErrNoCookie を返します。 複数のクッキーが指定された名前に一致する場合、1つのクッキーのみが返されます。

func (*Request) Cookies

func (r *Request) Cookies() []*Cookie

Cookiesは、リクエストで送信されたHTTPクッキーを解析して返します。

func (*Request) CookiesNamed

func (r *Request) CookiesNamed(name string) []*Cookie

CookiesNamedは、リクエストとともに送信された名前付きHTTPクッキーを解析し、 マッチするものがなければ空のスライスを返します。

func (*Request) FormFile

func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)

FormFileは、指定されたフォームキーの最初のファイルを返します。 必要に応じて、FormFileは Request.ParseMultipartForm および Request.ParseForm を呼び出します。

func (*Request) FormValue

func (r *Request) FormValue(key string) string

FormValueは、クエリの名前付きコンポーネントの最初の値を返します。 優先順位は以下の通りです：

1. application/x-www-form-urlencoded形式のフォームボディ（POST、PUT、PATCHのみ）
2. クエリパラメータ（常に）
3. multipart/form-data形式のフォームボディ（常に）

FormValueは必要に応じて Request.ParseMultipartForm と Request.ParseForm を呼び出し、 これらの関数が返すエラーは無視します。 キーが存在しない場合、FormValueは空文字列を返します。 同じキーの複数の値にアクセスするには、ParseFormを呼び出し、 その後で [Request.Form] を直接調べます。

func (*Request) MultipartReader

func (r *Request) MultipartReader() (*multipart.Reader, error)

MultipartReaderは、これがmultipart/form-dataまたはmultipart/mixed POSTリクエストである場合、MIMEマルチパートリーダーを返します。 それ以外の場合はnilとエラーを返します。 リクエストボディをストリームとして処理するために、Request.ParseMultipartForm の代わりにこの関数を使用してください。

func (*Request) ParseForm

func (r *Request) ParseForm() error

ParseFormはr.Formとr.PostFormを埋めます。

すべてのリクエストに対して、ParseFormはURLから生のクエリを解析し、r.Formを更新します。

POST、PUT、およびPATCHリクエストの場合、それはまた、リクエストボディを読み取り、フォームとして解析し、その結果をr.PostFormとr.Formの両方に入れます。リクエストボディのパラメータは、r.FormのURLクエリ文字列値より優先されます。

リクエストボディのサイズがすでに MaxBytesReader によって制限されていない場合、サイズは10MBに制限されます。

他のHTTPメソッド、またはContent-Typeがapplication/x-www-form-urlencodedでない場合、リクエストボディは読み取られず、r.PostFormはnilでない空の値に初期化されます。

Request.ParseMultipartForm は自動的にParseFormを呼び出します。 ParseFormは冪等です。

func (*Request) ParseMultipartForm

func (r *Request) ParseMultipartForm(maxMemory int64) error

ParseMultipartFormは、リクエストボディをmultipart/form-dataとして解析します。 リクエストボディ全体が解析され、そのファイルパーツの最大maxMemoryバイトがメモリに格納され、残りは一時ファイルに格納されます。 ParseMultipartFormは必要に応じて Request.ParseForm を呼び出します。 ParseFormがエラーを返した場合、ParseMultipartFormはそれを返しますが、リクエストボディの解析を続けます。 ParseMultipartFormを1回呼び出した後、以降の呼び出しは効果がありません。

func (*Request) PathValue

func (r *Request) PathValue(name string) string

PathValueは、リクエストに一致した ServeMux パターンの名前付きパスワイルドカードの値を返します。 リクエストがパターンに一致しなかった場合、またはパターンにそのようなワイルドカードがない場合、空の文字列を返します。

func (*Request) PostFormValue

func (r *Request) PostFormValue(key string) string

PostFormValueは、POST、PUT、またはPATCHリクエストボディの名前付きコンポーネントの最初の値を返します。 URLクエリパラメータは無視されます。 必要に応じて、PostFormValueは Request.ParseMultipartForm および Request.ParseForm を呼び出し、 これらの関数によって返されるエラーを無視します。 キーが存在しない場合、PostFormValueは空の文字列を返します。

func (*Request) ProtoAtLeast

func (r *Request) ProtoAtLeast(major, minor int) bool

ProtoAtLeastは、リクエストで使用されるHTTPプロトコルがmajor.minor以上であるかどうかを報告します。

func (*Request) Referer

func (r *Request) Referer() string

Refererは、リクエストで送信された場合に参照元のURLを返します。

Refererは、HTTPの初期の日々からの誤りで、リクエスト自体で誤ってスペルがされています。 この値はHeader["Referer"]として Header マップから取得することもできますが、 メソッドとして利用可能にすることの利点は、代替の（正しい英語の）スペルreq.Referrer()を使用するプログラムをコンパイラが診断できるが、 Header["Referrer"]を使用するプログラムを診断できないことです。

func (*Request) SetBasicAuth

func (r *Request) SetBasicAuth(username, password string)

SetBasicAuthは、提供されたユーザー名とパスワードを使用して、HTTP Basic認証を使用するようにリクエストのAuthorizationヘッダーを設定します。

HTTP Basic認証では、提供されたユーザー名とパスワードは暗号化されません。 HTTPSリクエストでのみ使用することが一般的です。

ユーザー名にはコロンを含めることはできません。一部のプロトコルでは、ユーザー名とパスワードを事前にエスケープする追加の要件がある場合があります。たとえば、OAuth2と一緒に使用する場合、両方の引数を最初に url.QueryEscape でURLエンコードする必要があります。

func (*Request) SetPathValue

func (r *Request) SetPathValue(name, value string)

SetPathValue sets name to value, so that subsequent calls to r.PathValue(name) return value.

func (*Request) UserAgent

func (r *Request) UserAgent() string

UserAgentは、リクエストで送信された場合にクライアントのUser-Agentを返します。

func (*Request) WithContext

func (r *Request) WithContext(ctx context.Context) *Request

WithContextは、そのコンテキストをctxに変更したrの浅いコピーを返します。提供されたctxはnilであってはなりません。

出力クライアントリクエストの場合、コンテキストはリクエストとそのレスポンスのライフタイム全体を制御します：接続の取得、リクエストの送信、レスポンスヘッダーとボディの読み取り。

コンテキストを持つ新しいリクエストを作成するには、NewRequestWithContext を使用します。 新しいコンテキストを持つリクエストのディープコピーを作成するには、Request.Clone を使用します。

func (*Request) Write

func (r *Request) Write(w io.Writer) error

Writeは、ワイヤフォーマットでHTTP/1.1リクエスト（ヘッダーとボディ）を書き込みます。 このメソッドは、リクエストの以下のフィールドを参照します。

Host
URL
Method（デフォルトは "GET"）
Header
ContentLength
TransferEncoding
Body

Bodyが存在し、Content-Lengthが0以下であり、[Request.TransferEncoding] が "identity"に設定されていない場合、 Writeはヘッダーに "Transfer-Encoding: chunked"を追加します。Bodyは送信後に閉じられます。

func (*Request) WriteProxy

func (r *Request) WriteProxy(w io.Writer) error

WriteProxyは、Request.Write と似ていますが、HTTPプロキシが期待する形式でリクエストを書き込みます。 特に、Request.WriteProxy は、RFC 7230のセクション5.3に従って、スキームとホストを含む絶対URIでリクエストの最初のRequest-URI行を書き込みます。 WriteProxyは、r.Host または r.URL.Host を使用して、Hostヘッダーも書き込みます。

type Response

type Response struct {
	Status     string
	StatusCode int
	Proto      string
	ProtoMajor int
	ProtoMinor int

	// Headerは、ヘッダーキーを値にマップします。
	// レスポンスに同じキーを持つ複数のヘッダーがある場合、それらはカンマ区切りで連結される場合があります。
	// (RFC 7230 Section 3.2.2 では、複数のヘッダーがカンマ区切りのシーケンスとして意味的に等価である必要があります。)
	// Headerの値がこの構造体の他のフィールド(ContentLength、TransferEncoding、Trailerなど)によって重複する場合、フィールド値が優先されます。
	//
	// マップ内のキーは正準化されます(CanonicalHeaderKeyを参照)。
	Header Header

	// Bodyは、レスポンスボディを表します。
	//
	// レスポンスボディは、Bodyフィールドが読み取られるたびにオンデマンドでストリーミングされます。
	// ネットワーク接続が失敗した場合や、サーバーがレスポンスを終了した場合、Body.Read呼び出しはエラーを返します。
	//
	// http ClientおよびTransportは、Bodyが常にnilでないことを保証します。
	// これは、ボディのないレスポンスまたは長さがゼロのボディを持つレスポンスでも同様です。
	// Bodyを閉じるのは呼び出し側の責任です。
	// デフォルトのHTTPクライアントのTransportは、Bodyが完全に読み取られて閉じられていない場合、
	// HTTP/1.xの「keep-alive」TCP接続を再利用しない場合があります。
	//
	// サーバーが「chunked」Transfer-Encodingで返答した場合、Bodyは自動的にデチャンクされます。
	//
	// Go 1.12以降、Bodyは、WebSocketsおよびHTTP/2の「h2c」モードで使用される「101 Switching Protocols」レスポンスに成功した場合、io.Writerも実装します。
	Body io.ReadCloser

	// ContentLengthは、関連するコンテンツの長さを記録します。
	// 値-1は、長さが不明であることを示します。
	// Request.Methodが"HEAD"でない限り、0以上の値は、Bodyから指定されたバイト数を読み取ることができることを示します。
	ContentLength int64

	// TransferEncodingは、最も外側から最も内側の転送エンコーディングを含みます。
	// 値がnilの場合、"identity"エンコーディングが使用されます。
	TransferEncoding []string

	// Closeは、ヘッダーがBodyの読み取り後に接続を閉じるよう指示したかどうかを記録します。
	// この値はクライアントに対するアドバイスです。
	// ReadResponseまたはResponse.Writeは、接続を閉じません。
	Close bool

	// Uncompressedは、レスポンスが圧縮されて送信されたが、httpパッケージによって解凍されたかどうかを報告します。
	// trueの場合、Bodyから読み取ると、サーバーから実際に設定された圧縮されたコンテンツの代わりに、解凍されたコンテンツが返されます。
	// ContentLengthは-1に設定され、"Content-Length"および"Content-Encoding"フィールドはresponseHeaderから削除されます。
	// サーバーからの元のレスポンスを取得するには、Transport.DisableCompressionをtrueに設定します。
	Uncompressed bool

	// Trailerは、トレーラーキーをHeaderと同じ形式の値にマップします。
	//
	// Trailerには最初に、サーバーの"Trailer"ヘッダー値で指定されたキーごとに1つのnil値のみが含まれます。
	// これらの値はHeaderに追加されません。
	//
	// BodyのRead呼び出しと同時にTrailerにアクセスしないでください。
	//
	// Body.Readがio.EOFを返した後、Trailerにはサーバーから送信されたトレーラー値が含まれます。
	Trailer Header

	// Requestは、このResponseを取得するために送信されたリクエストです。
	// RequestのBodyはnilです(すでに消費されています)。
	// これは、クライアントリクエストに対してのみ設定されます。
	Request *Request

	// TLSは、レスポンスを受信したTLS接続に関する情報を含みます。
	// 非暗号化のレスポンスの場合、nilです。
	// このポインタはレスポンス間で共有され、変更してはいけません。
	TLS *tls.ConnectionState
}

Responseは、HTTPリクエストからのレスポンスを表します。

Client と Transport は、レスポンスヘッダが受信された後、サーバーからResponsesを返します。 レスポンスボディは、Bodyフィールドが読み取られるたびにオンデマンドでストリーミングされます。

func Get

func Get(url string) (resp *Response, err error)

Getは、指定されたURLにGETを発行します。レスポンスが次のリダイレクトコードの1つである場合、 Getはリダイレクトに従います。最大10回のリダイレクトまで:

301（Moved Permanently）
302（Found）
303（See Other）
307（Temporary Redirect）
308（Permanent Redirect）

リダイレクトが多すぎる場合や、HTTPプロトコルエラーがあった場合はエラーが返されます。 非2xxレスポンスはエラーを引き起こしません。 任意の返されたエラーは *url.Error 型です。url.ErrorのTimeoutメソッドは、 リクエストがタイムアウトした場合にtrueを報告します。

errがnilの場合、respには常に非nilのresp.Bodyが含まれます。 呼び出し元は、resp.Bodyの読み取りが完了したらresp.Bodyを閉じる必要があります。

Getは、DefaultClient.Getのラッパーです。

カスタムヘッダーでリクエストを作成するには、NewRequest とDefaultClient.Doを使用します。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContext とDefaultClient.Doを使用します。

Example

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	res, err := http.Get("http://www.google.com/robots.txt")
	if err != nil {
		log.Fatal(err)
	}
	body, err := io.ReadAll(res.Body)
	res.Body.Close()
	if res.StatusCode > 299 {
		log.Fatalf("Response failed with status code: %d and\nbody: %s\n", res.StatusCode, body)
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s", body)
}

func Head

func Head(url string) (resp *Response, err error)

Headは、指定されたURLに対してHEADリクエストを発行します。レスポンスが以下のリダイレクトコードのいずれかである場合、 Headはリダイレクションをフォローします。最大10回のリダイレクトが許可されます：

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

HeadはDefaultClient.Headのラッパーです。

指定した context.Context でリクエストを作成するには、NewRequestWithContext と DefaultClient.Do を使用します。

func Post

func Post(url, contentType string, body io.Reader) (resp *Response, err error)

Postは、指定されたURLに対してPOSTメソッドを送信します。

呼び出し元は、resp.Bodyの読み込みが完了したらresp.Bodyを閉じる必要があります。

もし提供されたBodyが io.Closer を実装している場合は、リクエストの後で閉じられます。

Postは、DefaultClient.Postのラッパーです。

カスタムヘッダーを設定するには、NewRequest と DefaultClient.Doを使用します。

リダイレクトの処理方法については、Client.Do メソッドのドキュメントを参照してください。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContext とDefaultClient.Doを使用します。

func PostForm

func PostForm(url string, data url.Values) (resp *Response, err error)

PostFormは、データのキーと値がURLエンコードされたリクエストボディとして指定されたURLにPOSTを発行します。

Content-Typeヘッダーはapplication/x-www-form-urlencodedに設定されます。 他のヘッダーを設定するには、NewRequest とDefaultClient.Doを使用します。

errがnilの場合、respには常に非nilのresp.Bodyが含まれます。 呼び出し元は、resp.Bodyの読み取りが完了したらresp.Bodyを閉じる必要があります。

PostFormは、DefaultClient.PostFormのラッパーです。

リダイレクトの処理方法については、Client.Do メソッドのドキュメントを参照してください。

指定された context.Context でリクエストを作成するには、NewRequestWithContext とDefaultClient.Doを使用します。

func ReadResponse

func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)

ReadResponseは、rからHTTPレスポンスを読み取り、返します。 reqパラメータは、この Response に対応する Request をオプションで指定します。 nilの場合、GETリクエストが想定されます。 クライアントは、resp.Bodyを読み取り終えたらresp.Body.Closeを呼び出す必要があります。 その呼び出しの後、クライアントはresp.Trailerを調べて、レスポンストレーラーに含まれるキー/値ペアを見つけることができます。

func (*Response) Cookies

func (r *Response) Cookies() []*Cookie

Cookiesは、Set-Cookieヘッダーで設定されたCookieを解析して返します。

func (*Response) Location

func (r *Response) Location() (*url.URL, error)

Locationは、レスポンスの「Location」ヘッダーのURLを返します。 存在する場合、相対リダイレクトは [Response.Request] に対して相対的に解決されます。 Locationヘッダーが存在しない場合、ErrNoLocation が返されます。

func (*Response) ProtoAtLeast

func (r *Response) ProtoAtLeast(major, minor int) bool

ProtoAtLeastは、レスポンスで使用されるHTTPプロトコルが少なくともmajor.minorであるかどうかを報告します。

func (*Response) Write

func (r *Response) Write(w io.Writer) error

Writeは、HTTP/1.xサーバーレスポンス形式でrをwに書き込みます。 ステータス行、ヘッダー、ボディ、およびオプションのトレーラーを含みます。

このメソッドは、レスポンスrの以下のフィールドを参照します。

StatusCode
ProtoMajor
ProtoMinor
Request.Method
TransferEncoding
Trailer
Body
ContentLength
Header, 非正準化キーの値は予測不可能な動作をします

レスポンスボディは送信後に閉じられます。

type ResponseController

type ResponseController struct {
	// contains filtered or unexported fields
}

ResponseControllerは、HTTPハンドラーがレスポンスを制御するために使用されます。

[Handler.ServeHTTP] メソッドが返された後にResponseControllerを使用することはできません。

func NewResponseController

func NewResponseController(rw ResponseWriter) *ResponseController

NewResponseControllerは、リクエスト用の ResponseController を作成します。

ResponseWriterは、[Handler.ServeHTTP] メソッドに渡された元の値である必要があります。 または、元のResponseWriterを返すUnwrapメソッドを持っている必要があります。

ResponseWriterが次のいずれかのメソッドを実装している場合、ResponseControllerは 適切に呼び出します。

Flush()
FlushError() error // エラーを返す代替Flush
Hijack() (net.Conn、*bufio.ReadWriter、error)
SetReadDeadline(deadline time.Time) error
SetWriteDeadline(deadline time.Time) error
EnableFullDuplex() error

ResponseWriterがメソッドをサポートしていない場合、ResponseControllerは ErrNotSupported に一致するエラーを返します。

func (*ResponseController) EnableFullDuplex

func (c *ResponseController) EnableFullDuplex() error

EnableFullDuplexは、リクエストハンドラが [Request.Body] からの読み取りを交互に行い、 ResponseWriter への書き込みと交互に行うことを示します。

HTTP/1リクエストの場合、Go HTTPサーバーはデフォルトで、レスポンスの書き込みを開始する前に リクエストボディの未読部分を消費し、ハンドラがリクエストから読み取りとレスポンスの書き込みを 同時に行うことを防止します。EnableFullDuplexを呼び出すと、この動作が無効になり、 ハンドラがリクエストからの読み取りを続けながらレスポンスを同時に書き込むことができるようになります。

HTTP/2リクエストの場合、Go HTTPサーバーは常に並行して読み取りとレスポンスを許可します。

func (*ResponseController) Flush

func (c *ResponseController) Flush() error

Flushは、バッファリングされたデータをクライアントにフラッシュします。

func (*ResponseController) Hijack

func (c *ResponseController) Hijack() (net.Conn, *bufio.ReadWriter, error)

Hijackは、呼び出し元が接続を引き継ぐことを可能にします。 詳細については、Hijackerインターフェースを参照してください。

func (*ResponseController) SetReadDeadline

func (c *ResponseController) SetReadDeadline(deadline time.Time) error

SetReadDeadlineは、ボディを含むリクエスト全体の読み取りの期限を設定します。 期限が超過した後にリクエストボディから読み取りを行うと、エラーが返されます。 ゼロ値は期限がないことを意味します。

期限が超過した後に読み取り期限を設定しても、期限は延長されません。

func (*ResponseController) SetWriteDeadline

func (c *ResponseController) SetWriteDeadline(deadline time.Time) error

SetWriteDeadlineは、レスポンスの書き込みの期限を設定します。 期限が超過した後にレスポンスボディに書き込みを行うと、ブロックされず、 データがバッファリングされている場合は成功する可能性があります。 ゼロ値は期限がないことを意味します。

期限が超過した後に書き込み期限を設定しても、期限は延長されません。

type ResponseWriter

type ResponseWriter interface {
	Header() Header

	Write([]byte) (int, error)

	WriteHeader(statusCode int)
}

ResponseWriterインターフェースは、HTTPハンドラーがHTTPレスポンスを構築するために使用されます。

[Handler.ServeHTTP] が返された後に、ResponseWriter を使用することはできません。

Example (Trailers)

HTTP トレーラーは、ヘッダーの前ではなく、HTTP レスポンスの後にあるヘッダーのようなキー/値のセットです。

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
		// WriteHeader または Write の呼び出しの前に、HTTP レスポンス中に設定するトレーラーを宣言してください。
		// これらの 3 つのヘッダーは、実際にはトレーラーで送信されます。
		w.Header().Set("Trailer", "AtEnd1, AtEnd2")
		w.Header().Add("Trailer", "AtEnd3")

		w.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
		w.WriteHeader(http.StatusOK)

		w.Header().Set("AtEnd1", "value 1")
		io.WriteString(w, "This HTTP response has both headers before this text and trailers at the end.\n")
		w.Header().Set("AtEnd2", "value 2")
		w.Header().Set("AtEnd3", "value 3") // これらはトレーラーとして表示されます。
	})
}

type RoundTripper

type RoundTripper interface {
	RoundTrip(*Request) (*Response, error)
}

RoundTripperは、指定された Request に対する Response を取得するための単一のHTTPトランザクションを実行する能力を表すインターフェースです。

RoundTripperは、複数のゴルーチンによる同時使用に対して安全である必要があります。

var DefaultTransport RoundTripper = &Transport{
	Proxy: ProxyFromEnvironment,
	DialContext: defaultTransportDialContext(&net.Dialer{
		Timeout:   30 * time.Second,
		KeepAlive: 30 * time.Second,
	}),
	ForceAttemptHTTP2:     true,
	MaxIdleConns:          100,
	IdleConnTimeout:       90 * time.Second,
	TLSHandshakeTimeout:   10 * time.Second,
	ExpectContinueTimeout: 1 * time.Second,
}

DefaultTransportは Transport のデフォルト実装であり、DefaultClient によって使用されます。 必要に応じてネットワーク接続を確立し、後続の呼び出しで再利用するためにキャッシュします。 環境変数HTTP_PROXY、HTTPS_PROXY、およびNO_PROXY（またはその小文字バージョン）によって指示されたように、HTTPプロキシを使用します。

func NewFileTransport

func NewFileTransport(fs FileSystem) RoundTripper

NewFileTransportは、提供された FileSystem を提供する新しい RoundTripper を返します。 返されたRoundTripperは、その入力リクエストのURLホストを無視します。また、リクエストの 他のほとんどのプロパティも無視します。

NewFileTransport の典型的な使用例は、Transport に "file" プロトコルを登録することです。 例:

t := &http.Transport{}
t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
c := &http.Client{Transport: t}
res, err := c.Get("file:///etc/passwd")
...

func NewFileTransportFS

func NewFileTransportFS(fsys fs.FS) RoundTripper

NewFileTransportFS returns a new RoundTripper, serving the provided file system fsys. The returned RoundTripper ignores the URL host in its incoming requests, as well as most other properties of the request. The files provided by fsys must implement io.Seeker.

The typical use case for NewFileTransportFS is to register the "file" protocol with a Transport, as in:

fsys := os.DirFS("/")
t := &http.Transport{}
t.RegisterProtocol("file", http.NewFileTransportFS(fsys))
c := &http.Client{Transport: t}
res, err := c.Get("file:///etc/passwd")
...

type SameSite

type SameSite int

SameSiteは、サーバーがクッキー属性を定義して、ブラウザがクロスサイトリクエストと一緒にこのクッキーを送信できなくすることを可能にします。主な目的は、クロスオリジン情報漏洩のリスクを軽減し、クロスサイトリクエスト偽造攻撃に対する保護を提供することです。

詳細については、https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 を参照してください。

const (
	SameSiteDefaultMode SameSite = iota + 1
	SameSiteLaxMode
	SameSiteStrictMode
	SameSiteNoneMode
)

type ServeMux

type ServeMux struct {
	// contains filtered or unexported fields
}

ServeMuxは、HTTPリクエストマルチプレクサーです。 それは、登録されたパターンのリストに対して、各受信リクエストのURLを一致させ、 URLに最も近いパターンのハンドラーを呼び出します。

Patterns

パターンは、リクエストのメソッド、ホスト、およびパスに一致することができます。 いくつかの例：

• "/index.html" は、任意のホストとメソッドに対してパス "/index.html" に一致します。
• "GET /static/" は、"/static/" で始まるGETリクエストに一致します。
• "example.com/" は、ホスト "example.com" への任意のリクエストに一致します。
• "example.com/{$}" は、ホストが "example.com" でパスが "/" のリクエストに一致します。
• "/b/{bucket}/o/{objectname...}" は、最初のセグメントが "b" で、3番目のセグメントが "o" のパスに一致します。 "bucket" は2番目のセグメントを示し、"objectname" はパスの残りを示します。

一般的に、パターンは以下のようになります。

[METHOD][HOST]/[PATH]

すべての3つの部分はオプションです。"/" は有効なパターンです。 METHODが存在する場合、後に単一のスペースもしくはタブが続く必要があります。

パターンのリテラル（ワイルドカードでない）部分は、リクエストの対応する部分と大文字小文字を区別して一致します。

メソッドのないパターンはすべてのメソッドに一致します。メソッドがGETの場合、GETとHEADの両方のリクエストに一致します。 それ以外の場合、メソッドは完全に一致する必要があります。

ホストのないパターンはすべてのホストに一致します。ホストがあるパターンは、そのホストのURLにのみ一致します。

パスには、{NAME}または{NAME...}のワイルドカードセグメントを含めることができます。 例えば、"/b/{bucket}/o/{objectname...}" です。 ワイルドカード名は有効なGo識別子でなければなりません。 ワイルドカードは完全なパスセグメントでなければなりません。つまり、スラッシュに続き、スラッシュまたは文字列の終わりに続く必要があります。 例えば、"/b_{bucket}" は有効なパターンではありません。

通常、ワイルドカードはリクエストURLの次のリテラルスラッシュ（%2Fではない）で終わる、単一のパスセグメントにのみ一致します。 ただし、"..."が存在する場合、ワイルドカードは、スラッシュを含むURLパスの残り全体に一致します。 （したがって、"..."ワイルドカードはパターンの末尾以外に現れることはできません。） ワイルドカードの一致は、ワイルドカードの名前を指定して Request.PathValue を呼び出すことで取得できます。 パスの末尾にスラッシュがある場合、匿名の "..." ワイルドカードとして機能します。

特別なワイルドカード {$} は、URLの末尾にのみ一致します。 例えば、パターン "/{$}" はパス "/" にのみ一致し、パターン "/" はすべてのパスに一致します。

一致には、パターンパスと受信リクエストパスの両方が、セグメントごとにエスケープされていない状態で使用されます。 したがって、パス "/a%2Fb/100%25" は、2つのセグメント "a/b" と "100%" を持つと見なされます。 パターン "/a%2fb/" はそれに一致しますが、パターン "/a/b/" は一致しません。

Precedence

2つ以上のパターンがリクエストに一致する場合、最も具体的なパターンが優先されます。 パターンP1がP2よりも具体的であるとは、P1がP2のリクエストの厳密なサブセットに一致する場合を指します。 つまり、P2がP1のすべてのリクエストに一致し、それ以上に一致する場合です。 もし、どちらも具体的でない場合、そのパターンは競合します。 このルールには、後方互換性のための1つの例外があります： 2つのパターンがそれ以外の場合に競合し、1つはホストを持ち、もう1つは持っていない場合、 ホストを持つパターンが優先されます。 [ServeMux.Handle]または[ServeMux.HandleFunc]に渡されるパターンが すでに登録されている他のパターンと競合する場合、それらの関数はパニックを引き起こします。

一般的なルールの例として、"/images/thumbnails/"は"/images/"よりも具体的であり、両方とも登録できます。 前者は"/images/thumbnails/"で始まるパスに一致し、後者は"/images/"サブツリー内の他のパスに一致します。

別の例として、パターン"GET /"と"/index.html"を考えてみてください。 両方が"/index.html"のGETリクエストに一致しますが、前者のパターンはすべての他のGETおよびHEADリクエストに一致し、 後者のパターンは異なるメソッドを使用する"/index.html"のすべてのリクエストに一致します。 パターンは競合します。

Trailing-slash redirection

末尾スラッシュまたは "..." ワイルドカードを使用して登録されたサブツリーのハンドラを持つ ServeMux を考えてみてください。 ServeMuxが末尾スラッシュのないサブツリールートのリクエストを受信した場合、 末尾スラッシュを追加してリクエストをリダイレクトします。 この動作は、末尾スラッシュまたは "..." ワイルドカードを使用しないパスの別個の登録によって上書きできます。 例えば、"/images/"を登録すると、ServeMuxは"/images"のリクエストを"/images/"にリダイレクトします。 "/images"が別途登録されていない限りです。

Request sanitizing

ServeMuxは、URLリクエストパスとHostヘッダーをサニタイズし、ポート番号を削除し、.または..セグメントまたは重複したスラッシュを含むリクエストを同等のクリーンなURLにリダイレクトします。

Compatibility

ServeMuxのパターン構文と一致動作は、Go 1.22で大幅に変更されました。 古い動作を復元するには、GODEBUG環境変数を "httpmuxgo121=1" に設定します。 この設定は、プログラムの起動時に1回だけ読み取られます。実行中の変更は無視されます。

互換性のない変更には以下が含まれます。

• ワイルドカードは1.21では通常のリテラルパスセグメントでした。 例えば、パターン "/{x}" は1.21ではそのパスのみに一致しますが、1.22では1つのセグメントのパスに一致します。
• 1.21では、既存のパターンと競合しない限り、パターンは拒否されませんでした。 1.22では、構文的に無効なパターンは ServeMux.Handle および ServeMux.HandleFunc でパニックを引き起こします。 例えば、1.21では、パターン "/{" と "/a{x}" はそれ自身に一致しますが、1.22では無効であり、登録時にパニックを引き起こします。
• 1.22では、パターンの各セグメントがエスケープ解除されますが、1.21ではそうではありませんでした。 例えば、1.22ではパターン "/%61" はパス "/a" ("%61"は "a"のURLエスケープシーケンス) に一致しますが、 1.21ではパス "/%2561" のみに一致します（"%25"はパーセント記号のエスケープです）。
• パターンをパスに一致させる場合、1.22ではパスの各セグメントがエスケープ解除されますが、1.21ではパス全体がエスケープ解除されます。 この変更は、スラッシュに隣接する%2Fエスケープを持つパスがどのように処理されるかに影響します。 詳細については、https://go.dev/issue/21955 を参照してください。

func NewServeMux

func NewServeMux() *ServeMux

NewServeMuxは、新しい ServeMux を割り当てて返します。

func (*ServeMux) Handle

func (mux *ServeMux) Handle(pattern string, handler Handler)

Handleは、指定されたパターンのハンドラを登録します。 登録済みのパターンと競合する場合、Handleはパニックを発生させます。

Example

// ServeMux を作成し、"/api/" には apiHandler{} を、"/" には無名関数を割り当てます。
mux := http.NewServeMux()
mux.Handle("/api/", apiHandler{})
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
	// "/" パターンはすべてにマッチするため、ここでルートにいることを確認する必要があります。
	if req.URL.Path != "/" {
		http.NotFound(w, req)
		return
	}
	fmt.Fprintf(w, "Welcome to the home page!")
})

func (*ServeMux) HandleFunc

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))

HandleFuncは、指定されたパターンのハンドラ関数を登録します。 登録済みのパターンと競合する場合、HandleFuncはパニックを発生させます。

func (*ServeMux) Handler

func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)

Handlerは、r.Method、r.Host、およびr.URL.Pathを参照して、 指定されたリクエストに使用するハンドラーを返します。 常にnilでないハンドラーを返します。 パスが正規形式でない場合、ハンドラーは正規パスにリダイレクトする内部生成ハンドラーになります。 ホストにポートが含まれている場合、ハンドラーの一致時には無視されます。

CONNECTリクエストでは、パスとホストは変更されずに使用されます。

Handlerは、リクエストに一致する登録済みのパターン、または内部で生成されたリダイレクトの場合はリダイレクトをたどった後に一致するパスを返します。

リクエストに適用される登録済みハンドラーがない場合、 Handlerは「ページが見つかりません」というハンドラーと空のパターンを返します。

func (*ServeMux) ServeHTTP

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

ServeHTTPは、リクエストURLに最も近いパターンを持つハンドラにリクエストをディスパッチします。

type Server

type Server struct {
	// Addrは、サーバーがリッスンするためのTCPアドレスをオプションで指定します。
	// 形式は「host:port」です。空の場合、「:http」（ポート80）が使用されます。
	// サービス名はRFC 6335で定義され、IANAによって割り当てられます。
	// アドレスの形式の詳細については、net.Dialを参照してください。
	Addr string

	Handler Handler

	// DisableGeneralOptionsHandlerがtrueの場合、"OPTIONS *"リクエストをHandlerに渡します。
	// それ以外の場合、200 OKとContent-Length: 0で応答します。
	DisableGeneralOptionsHandler bool

	// TLSConfigは、ServeTLSとListenAndServeTLSで使用するためのTLS構成をオプションで提供します。
	// この値はServeTLSとListenAndServeTLSによってクローンされるため、tls.Config.SetSessionTicketKeysなどのメソッドを使用して構成を変更することはできません。
	// SetSessionTicketKeysを使用するには、TLSリスナーを使用してServer.Serveを使用します。
	TLSConfig *tls.Config

	// ReadTimeoutは、ボディを含むリクエスト全体を読み取るための最大時間です。
	// ゼロまたは負の値はタイムアウトがないことを意味します。
	//
	// ReadTimeoutは、ハンドラが各リクエストボディの許容可能な締め切りまたはアップロードレートを決定することを許可しないため、
	// 大抵のユーザーはReadHeaderTimeoutを使用することを好むでしょう。
	// 両方を使用することもできます。
	ReadTimeout time.Duration

	// ReadHeaderTimeoutは、リクエストヘッダを読み取るために許される時間です。
	// ヘッダを読み取った後、接続の読み取りデッドラインはリセットされ、
	// ハンドラは本文にとって何が遅すぎると考えられるかを決定できます。
	// もしゼロならば、ReadTimeoutの値が使用されます。
	// もし負の値、またはゼロでReadTimeoutがゼロまたは負の値の場合、タイムアウトはありません。
	ReadHeaderTimeout time.Duration

	// WriteTimeoutは、レスポンスの書き込みがタイムアウトする前の最大時間です。
	// 新しいリクエストヘッダーが読み取られるたびにリセットされます。
	// ReadTimeoutと同様に、ハンドラがリクエストごとに決定を下すことを許可しません。
	// ゼロまたは負の値はタイムアウトがないことを意味します。
	WriteTimeout time.Duration

	// IdleTimeoutは、keep-alivesが有効な場合に次のリクエストを待つための最大時間です。
	// もしゼロならば、ReadTimeoutの値が使用されます。
	// もし負の値、またはゼロでReadTimeoutがゼロまたは負の値の場合、タイムアウトはありません。
	IdleTimeout time.Duration

	// MaxHeaderBytesは、リクエストヘッダーのキーと値、およびリクエストラインを解析するためにサーバーが読み取ることができる最大バイト数を制御します。
	// リクエストボディのサイズには影響しません。
	// ゼロの場合、DefaultMaxHeaderBytesが使用されます。
	MaxHeaderBytes int

	// TLSNextProtoは、ALPNプロトコルアップグレードが発生した場合に提供されたTLS接続の所有権を引き継ぐための関数をオプションで指定します。
	// マップキーはネゴシエートされたプロトコル名です。
	// Handler引数はHTTPリクエストを処理するために使用され、RequestのTLSとRemoteAddrを初期化します（設定されていない場合）。
	// 関数が返されると、接続は自動的に閉じられます。
	// TLSNextProtoがnilでない場合、HTTP/2サポートは自動的に有効になりません。
	TLSNextProto map[string]func(*Server, *tls.Conn, Handler)

	// ConnStateは、クライアント接続の状態が変化したときに呼び出されるオプションのコールバック関数を指定します。
	// 詳細については、ConnState型と関連する定数を参照してください。
	ConnState func(net.Conn, ConnState)

	// ErrorLogは、接続の受け入れ時のエラー、ハンドラの予期しない動作、および
	// FileSystemの基礎となるエラーに対するオプションのロガーを指定します。
	// nilの場合、ログはlogパッケージの標準ロガーを使用して行われます。
	ErrorLog *log.Logger

	// BaseContextは、このサーバーの着信リクエストのベースコンテキストを返すオプションの関数を指定します。
	// 提供されたListenerは、リクエストを開始する特定のリスナーです。
	// BaseContextがnilの場合、デフォルトはcontext.Background()です。
	// nilでない場合、非nilのコンテキストを返す必要があります。
	BaseContext func(net.Listener) context.Context

	// ConnContextは、新しい接続cに使用されるコンテキストを変更するオプションの関数を指定します。
	// 提供されたctxはBaseContextから派生し、ServerContextKeyの値を持ちます。
	ConnContext func(ctx context.Context, c net.Conn) context.Context
	// contains filtered or unexported fields
}

Serverは、HTTPサーバーを実行するためのパラメータを定義します。 Serverのゼロ値は有効な構成です。

func (*Server) Close

func (s *Server) Close() error

Closeは、すべてのアクティブなnet.Listenerと、StateNew、StateActive、または StateIdle の状態にある接続をすぐに閉じます。 優雅なシャットダウンには、Server.Shutdown を使用してください。

Closeは、WebSocketsなどのハイジャックされた接続を閉じようとはせず（そしてそれらについては何も知りません）、試みません。

Closeは、Server の基礎となるListener(s)を閉じる際に返される任意のエラーを返します。

func (*Server) ListenAndServe

func (s *Server) ListenAndServe() error

ListenAndServeは、TCPネットワークアドレスs.Addrでリッスンし、 Serve を呼び出して着信接続のリクエストを処理します。 受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

s.Addrが空白の場合、":http"が使用されます。

ListenAndServeは常に非nilのエラーを返します。Server.Shutdown または Server.Close の後、 返されるエラーは ErrServerClosed です。

func (*Server) ListenAndServeTLS

func (s *Server) ListenAndServeTLS(certFile, keyFile string) error

ListenAndServeTLSは、TCPネットワークアドレスs.Addrでリッスンし、 ServeTLS を呼び出して着信TLS接続のリクエストを処理します。 受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

Server のTLSConfig.CertificatesまたはTLSConfig.GetCertificateがどちらも設定されていない場合、 サーバーの証明書と対応する秘密鍵が含まれるファイルを提供する必要があります。 証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

s.Addrが空白の場合、":https"が使用されます。

ListenAndServeTLSは常に非nilのエラーを返します。Server.Shutdown または Server.Close の後、返されるエラーは ErrServerClosed です。

func (*Server) RegisterOnShutdown

func (s *Server) RegisterOnShutdown(f func())

RegisterOnShutdownは、Server.Shutdown 時に呼び出す関数を登録します。 これは、ALPNプロトコルアップグレードを受けた接続やハイジャックされた接続を優雅にシャットダウンするために使用できます。 この関数は、プロトコル固有の優雅なシャットダウンを開始する必要がありますが、シャットダウンが完了するのを待つ必要はありません。

func (*Server) Serve

func (s *Server) Serve(l net.Listener) error

Serveは、Listener lで着信接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。 サービスgoroutineはリクエストを読み取り、s.Handlerを呼び出してそれに応答します。

Listenerが *tls.Conn 接続を返し、TLS Config.NextProtosで「h2」が構成されている場合、HTTP/2サポートが有効になります。

Serveは常に非nilのエラーを返し、lを閉じます。 Server.Shutdown または Server.Close の後、返されるエラーは ErrServerClosed です。

func (*Server) ServeTLS

func (s *Server) ServeTLS(l net.Listener, certFile, keyFile string) error

ServeTLSは、Listener lで着信接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。 サービスgoroutineはTLSのセットアップを実行し、リクエストを読み取り、s.Handlerを呼び出してそれに応答します。

サーバー用の証明書と一致する秘密鍵を含むファイルを提供する必要があります。これは、Server の TLSConfig.Certificates、TLSConfig.GetCertificate、または config.GetConfigForClientが設定されていない場合に必要です。 証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

ServeTLSは常に非nilのエラーを返し、lを閉じます。 Server.Shutdown または Server.Close の後、返されるエラーは ErrServerClosed です。

func (*Server) SetKeepAlivesEnabled

func (s *Server) SetKeepAlivesEnabled(v bool)

SetKeepAlivesEnabledは、HTTP keep-alivesが有効かどうかを制御します。 デフォルトでは、keep-alivesは常に有効になっています。非常にリソースが制限された環境またはシャットダウン中のサーバーのみ、それらを無効にする必要があります。

func (*Server) Shutdown

func (s *Server) Shutdown(ctx context.Context) error

Shutdownは、アクティブな接続を中断することなく、サーバーを正常にシャットダウンします。 Shutdownは、まずすべてのオープンなリスナーを閉じ、次にすべてのアイドル状態の接続を閉じ、 そして接続がアイドル状態に戻ってから無期限に待機し、その後シャットダウンします。 提供されたコンテキストがシャットダウンが完了する前に期限切れになった場合、 Shutdownはコンテキストのエラーを返します。それ以外の場合は、Server の基礎となる Listener(s)を閉じる際に返される任意のエラーを返します。

Shutdownが呼び出されると、Serve、ListenAndServe、および ListenAndServeTLS はすぐに ErrServerClosed を返します。プログラムが 終了せず、代わりにShutdownが返るのを待つことを確認してください。

Shutdownは、WebSocketsのようなハイジャックされた接続を閉じたり、それらを待つことは試みません。 Shutdownの呼び出し元は、長時間稼働する接続に対してシャットダウンを別途通知し、 必要に応じてそれらが閉じるのを待つべきです。シャットダウン通知関数を登録する方法については、 Server.RegisterOnShutdown を参照してください。

Shutdownを呼び出した後、サーバーを再利用することはできません。Serveなどのメソッドを呼び出すと、ErrServerClosedが返されます。

Example

package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/os/signal"
)

func main() {
	var srv http.Server

	idleConnsClosed := make(chan struct{})
	go func() {
		sigint := make(chan os.Signal, 1)
		signal.Notify(sigint, os.Interrupt)
		<-sigint

		// 割り込みシグナルを受信したため、シャットダウンします。
		if err := srv.Shutdown(context.Background()); err != nil {
			// リスナーのクローズ時のエラー、またはコンテキストのタイムアウト:
			log.Printf("HTTP server Shutdown: %v", err)
		}
		close(idleConnsClosed)
	}()

	if err := srv.ListenAndServe(); err != http.ErrServerClosed {
		// リスナーの開始またはクローズ時のエラー:
		log.Fatalf("HTTP server ListenAndServe: %v", err)
	}

	<-idleConnsClosed
}

type Transport

type Transport struct {

	// Proxyは、指定されたRequestに対するプロキシを返す関数を指定します。
	// 関数が非nilのエラーを返す場合、リクエストは提供されたエラーで中止されます。
	//
	// プロキシのタイプは、URLスキームによって決定されます。
	// "http"、"https"、"sock5"、および"socks5h"がサポートされています。
	// スキームが空の場合、"http"が想定されます。
	// "socks5"は"socks5h"と同じように扱われます。
	//
	// プロキシURLにuserinfoサブコンポーネントが含まれている場合、
	// プロキシリクエストはProxy-Authorizationヘッダーでユーザー名とパスワードを渡します。
	//
	// Proxyがnilまたはnilの*URLを返す場合、プロキシは使用されません。
	Proxy func(*Request) (*url.URL, error)

	// OnProxyConnectResponseは、TransportがCONNECTリクエストのプロキシからHTTPレスポンスを受信したときに呼び出されます。
	// これは、200 OKレスポンスのチェックの前に呼び出されます。
	// エラーを返すと、リクエストはそのエラーで失敗します。
	OnProxyConnectResponse func(ctx context.Context, proxyURL *url.URL, connectReq *Request, connectRes *Response) error

	// DialContextは、暗号化されていないTCP接続を作成するためのダイアル関数を指定します。
	// DialContextがnilである場合（および下記の非推奨のDialもnilである場合）、
	// トランスポートはnetパッケージを使用してダイアルします。
	//
	// DialContextは、RoundTripの呼び出しと並行して実行されます。
	// ダイアルを開始するRoundTrip呼び出しが、後のDialContextが完了する前に
	// 以前にダイアルされた接続を使用する場合があります。
	DialContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// Dialは、暗号化されていないTCP接続を作成するためのダイアル関数を指定します。
	//
	// Dialは、RoundTripの呼び出しと並行して実行されます。
	// 以前にダイアルされた接続が後でアイドル状態になる場合、
	// 後のDialが完了する前に、ダイアルを開始するRoundTrip呼び出しが以前にダイアルされた接続を使用する場合があります。
	//
	// Deprecated: 代わりにDialContextを使用してください。これにより、トランスポートはダイアルが不要になった直後にキャンセルできます。
	// 両方が設定されている場合、DialContextが優先されます。
	Dial func(network, addr string) (net.Conn, error)

	// DialTLSContextは、プロキシを使用しないHTTPSリクエストのためのTLS接続を作成するためのオプションのダイアル関数を指定します。
	//
	// DialTLSContextがnilである場合（および下記の非推奨のDialTLSもnilである場合）、
	// DialContextとTLSClientConfigが使用されます。
	//
	// DialTLSContextが設定されている場合、HTTPSリクエストに対してDialおよびDialContextフックは使用されず、
	// TLSClientConfigおよびTLSHandshakeTimeoutは無視されます。
	// 返されたnet.Connは、すでにTLSハンドシェイクを完了しているものと見なされます。
	DialTLSContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// DialTLSは、プロキシを使用しないHTTPSリクエストのためのTLS接続を作成するためのオプションのダイアル関数を指定します。
	//
	// Deprecated: 代わりにDialTLSContextを使用してください。これにより、トランスポートはダイアルが不要になった直後にキャンセルできます。
	// 両方が設定されている場合、DialTLSContextが優先されます。
	DialTLS func(network, addr string) (net.Conn, error)

	// TLSClientConfigは、tls.Clientで使用するTLS構成を指定します。
	// nilの場合、デフォルトの構成が使用されます。
	// nil以外の場合、HTTP/2サポートがデフォルトで有効になっていない場合があります。
	TLSClientConfig *tls.Config

	// TLSHandshakeTimeoutは、TLSハンドシェイクを待機する最大時間を指定します。
	// ゼロの場合、タイムアウトはありません。
	TLSHandshakeTimeout time.Duration

	// DisableKeepAlivesがtrueの場合、HTTP keep-alivesが無効になり、
	// サーバーへの接続は単一のHTTPリクエストにのみ使用されます。
	//
	// これは、同様に名前が付けられたTCP keep-alivesとは無関係です。
	DisableKeepAlives bool

	// DisableCompressionがtrueの場合、Transportは、Requestに既存のAccept-Encoding値がない場合に、
	// "Accept-Encoding: gzip"リクエストヘッダーで圧縮を要求しません。
	// Transportが自動的にgzipを要求し、gzipされたレスポンスを受け取った場合、Response.Bodyで透過的にデコードされます。
	// ただし、ユーザーが明示的にgzipを要求した場合は、自動的に解凍されません。
	DisableCompression bool

	// MaxIdleConnsは、すべてのホストをまたいでアイドル（keep-alive）接続の最大数を制御します。
	// ゼロの場合、制限はありません。
	MaxIdleConns int

	// MaxIdleConnsPerHostがゼロでない場合、ホストごとに保持する最大アイドル（keep-alive）接続数を制御します。
	// ゼロの場合、DefaultMaxIdleConnsPerHostが使用されます。
	MaxIdleConnsPerHost int

	// MaxConnsPerHostは、ダイアル、アクティブ、およびアイドル状態の接続を含む、ホストごとの総接続数をオプションで制限します。
	// 制限を超えると、ダイアルはブロックされます。
	//
	// ゼロは制限がないことを意味します。
	MaxConnsPerHost int

	// IdleConnTimeoutは、アイドル（keep-alive）接続が自己クローズする前にアイドル状態になる最大時間です。
	// ゼロは制限がないことを意味します。
	IdleConnTimeout time.Duration

	// ResponseHeaderTimeoutがゼロでない場合、リクエスト（ボディがある場合はそれも含む）を完全に書き込んだ後、
	// サーバーのレスポンスヘッダーを待機する時間を指定します。
	// この時間には、レスポンスボディを読み取る時間は含まれません。
	ResponseHeaderTimeout time.Duration

	// ExpectContinueTimeoutがゼロでない場合、リクエストに"Expect: 100-continue"ヘッダーがある場合、
	// リクエストヘッダーを完全に書き込んだ後、サーバーの最初のレスポンスヘッダーを待機する時間を指定します。
	// ゼロはタイムアウトがないことを意味し、サーバーの承認を待たずに、すぐにボディを送信します。
	// この時間には、リクエストヘッダーを送信する時間は含まれません。
	ExpectContinueTimeout time.Duration

	// TLSNextProtoは、TLS ALPNプロトコルネゴシエーション後にTransportが代替プロトコル（HTTP/2など）に切り替える方法を指定します。
	// Transportがプロトコル名が空でないTLS接続をダイアルし、TLSNextProtoにそのキーのマップエントリが含まれている場合（"h2"など）、
	// リクエストの権限（"example.com"または"example.com:1234"など）とTLS接続でfuncが呼び出されます。
	// この関数は、その後リクエストを処理するRoundTripperを返さなければなりません。
	// TLSNextProtoがnilでない場合、HTTP/2サポートは自動的に有効になりません。
	TLSNextProto map[string]func(authority string, c *tls.Conn) RoundTripper

	// ProxyConnectHeaderは、CONNECTリクエスト中にプロキシに送信するヘッダーをオプションで指定します。
	// ヘッダーを動的に設定するには、GetProxyConnectHeaderを参照してください。
	ProxyConnectHeader Header

	// GetProxyConnectHeaderは、ip:portターゲットへのCONNECTリクエスト中にproxyURLに送信するヘッダーを返すためのオプションの関数を指定します。
	// エラーを返すと、TransportのRoundTripはそのエラーで失敗します。
	// ヘッダーを追加しない場合は、(nil, nil)を返すことができます。
	// GetProxyConnectHeaderが非nilの場合、ProxyConnectHeaderは無視されます。
	GetProxyConnectHeader func(ctx context.Context, proxyURL *url.URL, target string) (Header, error)

	// MaxResponseHeaderBytesは、サーバーのレスポンスヘッダーに許可されるレスポンスバイト数の制限を指定します。
	//
	// ゼロは、デフォルトの制限を使用することを意味します。
	MaxResponseHeaderBytes int64

	// WriteBufferSizeは、トランスポートへの書き込み時に使用される書き込みバッファのサイズを指定します。
	// ゼロの場合、デフォルト値（現在は4KB）が使用されます。
	WriteBufferSize int

	// ReadBufferSizeは、トランスポートから読み取るときに使用される読み取りバッファのサイズを指定します。
	// ゼロの場合、デフォルト値（現在は4KB）が使用されます。
	ReadBufferSize int

	// ForceAttemptHTTP2は、非ゼロの
	// Dial, DialTLS, または DialContext 関数または TLSClientConfig が提供されたときに、
	// HTTP/2が有効になるかどうかを制御します。
	// デフォルトでは、これらのフィールドのいずれかの使用は、保守的にHTTP/2を無効にします。
	// カスタムダイヤラーやTLS設定を使用しつつ、HTTP/2への
	// アップグレードを試みるには、これをtrueに設定します。
	ForceAttemptHTTP2 bool
	// contains filtered or unexported fields
}

Transportは、HTTP、HTTPS、およびHTTPプロキシ（HTTPまたはHTTPS with CONNECTのいずれか）をサポートする RoundTripper の実装です。

デフォルトでは、Transportは将来の再利用のために接続をキャッシュします。 これにより、多くのホストにアクセスする場合に多数のオープンな接続が残る可能性があります。 この動作は、Transport.CloseIdleConnections メソッドと [Transport.MaxIdleConnsPerHost] および [Transport.DisableKeepAlives] フィールドを使用して管理できます。

Transportは必要に応じて作成するのではなく、再利用する必要があります。 Transportは、複数のgoroutineによる同時使用に対して安全です。

Transportは、HTTPおよびHTTPSリクエストを行うための低レベルのプリミティブです。 クッキーやリダイレクトなどの高レベルの機能については、Client を参照してください。

Transportは、HTTP URLではHTTP/1.1を、HTTPS URLではHTTP/1.1またはHTTP/2を使用します。 これは、サーバーがHTTP/2をサポートしているかどうか、およびTransportの構成によって異なります。 DefaultTransport はHTTP/2をサポートしています。 Transportで明示的にHTTP/2を有効にするには、golang.org/x/net/http2 を使用してConfigureTransportを呼び出します。 HTTP/2についての詳細については、パッケージのドキュメントを参照してください。

ステータスコードが1xx範囲にあるレスポンスは、自動的に処理されます（100 expect-continue）。 ただし、HTTPステータスコード101（Switching Protocols）は、終端ステータスと見なされ、Transport.RoundTrip によって返されます。 無視された1xxレスポンスを表示するには、httptraceトレースパッケージのClientTrace.Got1xxResponseを使用します。

Transportは、ネットワークエラーに遭遇した場合にのみ、接続がすでに正常に使用されており、 リクエストが冪等であり、ボディがないか、または [Request.GetBody] が定義されている場合に、 リクエストを再試行します。HTTPリクエストは、HTTPメソッドがGET、HEAD、OPTIONS、またはTRACEである場合、 または Header マップに「Idempotency-Key」または「X-Idempotency-Key」エントリが含まれている場合、冪等と見なされます。 冪等性キーの値がゼロ長のスライスの場合、リクエストは冪等と見なされますが、ヘッダーはワイヤーに送信されません。

func (*Transport) CancelRequest

func (t *Transport) CancelRequest(req *Request)

CancelRequestは、その接続を閉じることにより、進行中のリクエストをキャンセルします。 CancelRequestは、 Transport.RoundTrip が返された後にのみ呼び出す必要があります。

Deprecated: 代わりに、キャンセル可能なコンテキストを持つリクエストを作成するために Request.WithContext を使用してください。 CancelRequestは、HTTP/2リクエストをキャンセルできません。 これは、Goの将来のリリースでno-opになる可能性があります。

func (*Transport) Clone

func (t *Transport) Clone() *Transport

Cloneは、tのエクスポートされたフィールドのディープコピーを返します。

func (*Transport) CloseIdleConnections

func (t *Transport) CloseIdleConnections()

CloseIdleConnectionsは、以前のリクエストから接続されていたが、現在はアイドル状態になっている"keep-alive"状態の接続を閉じます。 現在使用中の接続は中断しません。

func (*Transport) RegisterProtocol

func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper)

RegisterProtocolは、新しいプロトコルをスキームとともに登録します。 Transport は、指定されたスキームを使用してリクエストをrtに渡します。 HTTPリクエストのセマンティクスをシミュレートする責任は、rtにあります。

RegisterProtocolは、他のパッケージが"ftp"や"file"などのプロトコルスキームの実装を提供するために使用できます。

rt.RoundTripが ErrSkipAltProtocol を返す場合、Transportは、 登録されたプロトコルのように扱わずに、その1つのリクエストに対して自身で Transport.RoundTrip を処理します。

func (*Transport) RoundTrip

func (t *Transport) RoundTrip(req *Request) (*Response, error)

RoundTripは、RoundTripper インターフェースを実装します。

クッキーやリダイレクトの処理などのより高度なHTTPクライアントサポートについては、 Get、Post、および Client 型を参照してください。

RoundTripインターフェースと同様に、RoundTripによって返されるエラータイプは未指定です。