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)

proxyUrl, err := http.ProxyFromEnvironment(req)
if err != nil {
    // обработка ошибки конфигурации прокси
}
if proxyUrl != nil {
    // настроить транспорт с этим прокси
}

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, content io.ReadSeeker)

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 struct {
    // Transport определяет механизм выполнения HTTP-запросов.
    // Если nil, используется DefaultTransport.
    Transport RoundTripper

    // CheckRedirect определяет политику обработки редиректов.
    // Если задан, вызывается перед каждым редиректом.
    // Принимает новый запрос (req) и цепочку выполненных запросов (via).
    // Если возвращает ошибку, клиент прекращает выполнение.
    // Особый случай: ErrUseLastResponse возвращает последний Response без закрытия тела.
    // Если nil, используется политика по умолчанию (максимум 10 редиректов).
    CheckRedirect func(req *Request, via []*Request) error

    // Jar хранит куки для автоматической подстановки в запросы.
    // Обновляется при получении ответов с Set-Cookie.
    // Если nil, куки отправляются только если явно заданы в Request.
    Jar CookieJar

    // Timeout устанавливает общий таймаут для запроса:
    // включает подключение, редиректы и чтение тела ответа.
    // Таймер продолжает работать после вызова Get/Post/Do.
    // Нулевое значение отключает таймаут.
    // Для отмены используется контекст запроса.
    Timeout time.Duration
}

client := &http.Client{
    Timeout: 10 * time.Second,
    Jar:     cookieJar,
}
resp, err := client.Get("https://example.com")

func (c *Client) CloseIdleConnections()

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

req, _ := http.NewRequest("GET", url, nil)
resp, err := client.Do(req)
if err != nil { /* обработка */ }
defer resp.Body.Close()

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

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

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

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

type ConnState int

const (
    // StateNew - новое соединение, ожидается отправка запроса
    StateNew ConnState = iota
    
    // StateActive - соединение получило данные запроса (1+ байт)
    StateActive
    
    // StateIdle - соединение в режиме keep-alive между запросами
    StateIdle
    
    // StateHijacked - соединение было захвачено (hijacked)
    StateHijacked
    
    // StateClosed - соединение закрыто
    StateClosed
)

func (c ConnState) String() string

server := &http.Server{
    ConnState: func(conn net.Conn, state http.ConnState) {
        log.Printf("Соединение %v: %v -> %v", 
            conn.RemoteAddr(), 
            conn.LocalAddr(), 
            state.String())
    },
}

var activeConns int32

server := &http.Server{
    ConnState: func(conn net.Conn, state http.ConnState) {
        switch state {
        case http.StateActive:
            if atomic.AddInt32(&activeConns, 1) > 100 {
                conn.Close() // закрываем при превышении лимита
            }
        case http.StateClosed, http.StateHijacked:
            atomic.AddInt32(&activeConns, -1)
        }
    },
}

type connInfo struct {
    start time.Time
}

server := &http.Server{
    ConnState: func(conn net.Conn, state http.ConnState) {
        ctx := conn.Context()
        if state == http.StateNew {
            ctx = context.WithValue(ctx, "connInfo", &connInfo{
                start: time.Now(),
            })
            conn = conn.WithContext(ctx)
            return
        }
        
        if state == http.StateClosed {
            if info, ok := ctx.Value("connInfo").(*connInfo); ok {
                duration := time.Since(info.start)
                log.Printf("Соединение жило %v", duration)
            }
        }
    },
}

StateNew → StateActive → StateIdle → StateActive → ... → StateClosed
                    \           /
                     → StateHijacked

type Cookie struct {
    Name   string    // Название cookie (обязательное)
    Value  string    // Значение cookie
    Quoted bool      // Флаг, было ли значение в кавычках

    // Опциональные атрибуты:
    Path       string    // Путь действия cookie
    Domain     string    // Домен действия
    Expires    time.Time // Время истечения
    RawExpires string    // Оригинальное значение Expires (только для чтения)

    // MaxAge определяет срок жизни в секундах:
    //  0 - без Max-Age
    // <0 - немедленное удаление (аналог Max-Age: 0)
    // >0 - срок жизни в секундах
    MaxAge      int
    Secure      bool     // Только для HTTPS
    HttpOnly    bool     // Недоступно для JavaScript
    SameSite    SameSite // Политика SameSite
    Partitioned bool     // Разделенные cookie (CHIPS)
    Raw         string   // Оригинальное значение заголовка
    Unparsed    []string // Неразобранные атрибуты
}

// Простая cookie
sessionCookie := &http.Cookie{
    Name:  "session_id",
    Value: "abc123",
}

// Защищенная cookie с атрибутами
secureCookie := &http.Cookie{
    Name:     "prefs",
    Value:    "dark_theme=true",
    Path:     "/",
    Domain:   "example.com",
    MaxAge:   3600, // 1 час
    Secure:   true,
    HttpOnly: true,
    SameSite: http.SameSiteLaxMode,
}

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

cookies, err := http.ParseCookie("name1=val1; name2=val2; name1=val3")
if err != nil { /* обработка ошибки */ }
for _, c := range cookies {
    fmt.Printf("%s: %s\n", c.Name, c.Value)
}
// Вывод:
// name1: val1
// name2: val2
// name1: val3

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

cookie, err := http.ParseSetCookie("session=abc123; Path=/; HttpOnly; Max-Age=3600")
if err != nil { /* обработка ошибки */ }
fmt.Printf("Cookie: %s=%s, Path=%s\n", cookie.Name, cookie.Value, cookie.Path)

func (c *Cookie) String() string

c := &http.Cookie{Name: "test", Value: "123"}
fmt.Println(c.String()) // "test=123"

c.Path = "/"
c.HttpOnly = true
fmt.Println(c.String()) // "test=123; Path=/; HttpOnly"

func (c *Cookie) Valid() error

err := (&http.Cookie{Name: "invalid name", Value: "test"}).Valid()
if err != nil {
    fmt.Println("Invalid cookie:", err)
}

func handler(w http.ResponseWriter, r *http.Request) {
    cookie := &http.Cookie{
        Name:  "user",
        Value: "john",
        Path:  "/",
    }
    http.SetCookie(w, cookie)
}

func handler(w http.ResponseWriter, r *http.Request) {
    cookie, err := r.Cookie("session_id")
    if err != nil {
        // Обработка отсутствия cookie
    }
    fmt.Fprintf(w, "Value: %s", cookie.Value)
}

func logoutHandler(w http.ResponseWriter, r *http.Request) {
    http.SetCookie(w, &http.Cookie{
        Name:   "session",
        Value:  "",
        Path:   "/",
        MaxAge: -1, // Удалить cookie
    })
}

cookie := &http.Cookie{
    Name:     "csrf_token",
    Value:    generateToken(),
    SameSite: http.SameSiteStrictMode,
    Secure:   true,
}

type CookieJar interface {
    // SetCookies сохраняет полученные куки для указанного URL
    SetCookies(u *url.URL, cookies []*Cookie)
    
    // Cookies возвращает куки, которые должны быть отправлены для URL
    Cookies(u *url.URL) []*Cookie
}

jar, _ := cookiejar.New(nil)
client := &http.Client{
    Jar: jar,
}

// Первый запрос (получаем куки)
resp, _ := client.Get("https://example.com/login")

// Последующие запросы автоматически включают куки
resp, _ = client.Get("https://example.com/dashboard")

type Dir string

fs := http.Dir("/var/www")
http.Handle("/static/", http.FileServer(fs))

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

fs := http.Dir("public")
file, err := fs.Open("css/styles.css")
if err != nil {
    // обработка ошибки
}
defer file.Close()

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

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

type CustomFS struct {
    base string
}

func (c CustomFS) Open(name string) (http.File, error) {
    return os.Open(filepath.Join(c.base, name))
}

func FS(fsys fs.FS) FileSystem

//go:embed static/*
var staticFiles embed.FS

func main() {
    http.Handle("/", http.FileServer(http.FS(staticFiles)))
    http.ListenAndServe(":8080", nil)
}

type SafeFS struct {
    http.Dir
}

func (s SafeFS) Open(name string) (http.File, error) {
    if strings.Contains(name, "..") || strings.HasPrefix(filepath.Base(name), ".") {
        return nil, os.ErrNotExist
    }
    return s.Dir.Open(name)
}

type MemoryJar struct {
    cookies map[string][]*http.Cookie
    sync.Mutex
}

func (j *MemoryJar) SetCookies(u *url.URL, cookies []*http.Cookie) {
    j.Lock()
    defer j.Unlock()
    j.cookies[u.Host] = cookies
}

func (j *MemoryJar) Cookies(u *url.URL) []*http.Cookie {
    j.Lock()
    defer j.Unlock()
    return j.cookies[u.Host]
}

type Flusher interface {
	// Flush sends any buffered data to the client.
	Flush()
}

type HTTP2Config struct {
	// MaxConcurrentStreams опционально задает количество
	// параллельных потоков, которые могут быть открыты у пира одновременно.
	// Если значение равно нулю, то по умолчанию MaxConcurrentStreams равно как минимум 100.
	MaxConcurrentStreams int

	// MaxDecoderHeaderTableSize опционально задает верхний предел для
	// размера таблицы сжатия заголовков, используемой для декодирования заголовков, отправленных
	// пиром.
	// Допустимое значение - менее 4 Мбайт.
	// Если значение равно нулю или недействительно, используется значение по умолчанию.
	MaxDecoderHeaderTableSize int

	// MaxEncoderHeaderTableSize опционально задает верхний предел для
	// таблицы сжатия заголовков, используемой для отправки заголовков сверстнику.
	// Допустимое значение - менее 4 Мбайт.
	// Если значение равно нулю или недействительно, используется значение по умолчанию.
	MaxEncoderHeaderTableSize int

	// MaxReadFrameSize опционально указывает самый большой кадр.
	// который эта конечная точка готова прочитать.
	// Допустимое значение - от 16КиБ до 16МиБ, включительно.
	// Если значение равно нулю или недействительно, используется значение по умолчанию.
	MaxReadFrameSize int

	// MaxReceiveBufferPerConnection - это максимальный размер
	// окна управления потоком для данных, получаемых по соединению.
	// Допустимое значение - не менее 64КиБ и не более 4МиБ.
	// Если значение недействительно, используется значение по умолчанию.
	MaxReceiveBufferPerConnection int

	// MaxReceiveBufferPerStream - это максимальный размер
	// окна управления потоком для данных, получаемых в потоке (запросе).
	// Допустимое значение - менее 4 Мбайт.
	// Если значение равно нулю или недействительно, используется значение по умолчанию.
	MaxReceiveBufferPerStream int

	// SendPingTimeout - таймаут, по истечении которого проверка работоспособности с помощью ping
	// кадра будет проведена, если на соединении не будет получено ни одного кадра.
	// Если ноль, проверка работоспособности не выполняется.
	SendPingTimeout time.Duration

	// PingTimeout - таймаут, по истечении которого соединение будет закрыто.
	// если не будет получен ответ на пинг.
	// Если значение равно нулю, используется значение по умолчанию 15 секунд.
	PingTimeout time.Duration

	// WriteByteTimeout - таймаут, по истечении которого соединение будет // закрыто, если не удастся записать данные.
	// закрыто, если в него не могут быть записаны данные. Таймаут начинается, когда данные // доступны для записи.
	// доступны для записи, и продлевается каждый раз, когда записываются какие-либо байты.
	WriteByteTimeout time.Duration

	// PermitProhibitedCipherSuites, если true, разрешает использование
	// наборов шифров, запрещенных спецификацией HTTP/2.
	PermitProhibitedCipherSuites bool

	// CountError, если не равен nil, вызывается при ошибках HTTP/2.
	// Она предназначена для инкрементирования метрики для мониторинга.
	// Тип errType содержит только строчные буквы, цифры и символы подчеркивания.
	// (a-z, 0-9, _).
	CountError func(errType string)
}

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

func AllowQuerySemicolons(h Handler) Handler

func FileServer(root FileSystem) Handler

http.Handle(«/», http.FileServer(http.Dir(«/tmp»)))

func FileServerFS(root fs.FS) Обработчик

http.Handle(«/», http.FileServerFS(fsys))

func MaxBytesHandler(h Handler, n int64) Handler

func NotFoundHandler() Handler

func RedirectHandler(url string, code int) Обработчик

func StripPrefix(prefix string, h Handler) Handler

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

type HandlerFunc func(ResponseWriter, *Request)

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

type Header map[string][]string

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 interface
	// Hijack позволяет вызывающей стороне взять на себя управление соединением.
	// После вызова Hijack библиотека HTTP-сервера
	// больше ничего не будет делать с соединением.
	//
	// Ответственность за управление // и закрытие соединения ложится на вызывающую сторону.
	// и закрывать соединение.
	//
	// Возвращаемый net.Conn может иметь дедлайны чтения или записи.
	// уже установленными, в зависимости от конфигурации
	// сервера. Вызывающая сторона несет ответственность за установку
	// или очистить эти сроки по мере необходимости.
	//
	// Возвращаемый файл bufio.Reader может содержать необработанные буферизованные
	// данные от клиента.
	//
	// После вызова Hijack исходное Request.Body не должно
	// использоваться. Контекст исходного запроса остается действительным и
	// не отменяется до тех пор, пока метод ServeHTTP запроса
	// возвращается.
	Hijack() (net.Conn, *bufio.ReadWriter, error)
}

type MaxBytesError struct {
	Limit int64
}

func (e *MaxBytesError) Error() string

type Protocols struct {
	// содержит отфильтрованные или неэкспонированные поля
}

func (p Protocols) HTTP1() bool

func (p Protocols) HTTP2() bool

func (p *Protocols) SetHTTP1(ok bool)

func (p *Protocols) SetHTTP2(ok bool)

func (p *Protocols) SetUnencryptedHTTP2(ok bool)

func (p Protocols) String() string

func (p Protocols) UnencryptedHTTP2() bool

type PushOptions struct {
	// Method указывает HTTP-метод для обещанного запроса.
	// Если установлен, он должен быть «GET» или «HEAD». Пустое значение означает «GET».
	Method string

	// Header указывает дополнительные заголовки обещанного запроса. Они не могут
	// включать поля псевдозаголовков HTTP/2, такие как «:path» и «:scheme»,
	// которые будут добавлены автоматически.
	Заголовок Header
}

type Pusher interface {
	// Push инициирует HTTP/2 серверный push. При этом создается синтетический
	// запрос, используя заданную цель и опции, сериализует этот запрос
	// в фрейм PUSH_PROMISE, затем отправляет этот запрос с помощью
	// обработчика запроса сервера. Если opts равно nil, используются параметры по умолчанию.
	//
	// Цель должна быть либо абсолютным путем (например, «/path»), либо абсолютным
	// URL, содержащий действительный хост и ту же схему, что и родительский запрос.
	// Если цель - это путь, то она наследует схему и хост // родительского запроса.
	// родительского запроса.
	//
	// Спецификация HTTP/2 запрещает рекурсивные и кросс-авторитарные проталкивания.
	// Push может обнаружить или не обнаружить эти недействительные проталкивания; однако недействительные
	// push будут обнаружены и отменены соответствующими клиентами.
	//
	// Обработчики, желающие передать URL X, должны вызывать Push перед отправкой любых
	// данные, которые могут вызвать запрос на URL X. Это позволяет избежать гонки, когда
	// клиент отправляет запрос на X до получения PUSH_PROMISE для X.
	//
	// Push будет выполняться в отдельной горутине, что делает порядок прибытия
	// недетерминированным. Любая требуемая синхронизация должна быть реализована
	// вызывающей стороной.
	//
	// Push возвращает ErrNotSupported, если клиент отключил push или если push
	// не поддерживается на базовом соединении.
	Ошибка Push(target string, opts *PushOptions)
}

type Request struct {
	// Method задает метод HTTP (GET, POST, PUT и т.д.).
	// Для клиентских запросов пустая строка означает GET.
	Строка Method

	// URL указывает либо запрашиваемый URI (для серверных
	// запросов), либо URL для доступа (для клиентских запросов).
	//
	// Для серверных запросов URL анализируется из URI.
	// предоставленного в строке запроса и хранящегося в RequestURI.  Для
	// большинства запросов поля, кроме Path и RawQuery, будут // пустыми.
	// пустыми. (См. RFC 7230, раздел 5.3)
	//
	// Для клиентских запросов URL's Host указывает сервер, к которому нужно // подключиться.
	// соединиться с ним, а поле Request's Host опционально
	// определяет значение заголовка Host для отправки в HTTP
	// запросе.
	URL *url.URL

	// Версия протокола для входящих запросов сервера.
	//
	// Для клиентских запросов эти поля игнорируются. HTTP
	// клиентский код всегда использует либо HTTP/1.1, либо HTTP/2.
	// Подробнее см. документацию по транспорту.
	Proto string // «HTTP/1.0»
	ProtoMajor int // 1
	ProtoMinor int // 0

	// Заголовок содержит поля заголовка запроса, которые либо получены
	// сервером, либо должны быть отправлены клиентом.
	//
	// Если сервер получил запрос со строками заголовка,
	//
	// 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», «2»},
	// }
	//
	// Для входящих запросов заголовок Host переводится в поле
	// поле Request.Host и удаляется из карты Header.
	//
	// HTTP определяет, что имена заголовков не чувствительны к регистру. В
	// парсер запросов реализует это с помощью CanonicalHeaderKey,
	// делая первый символ и все символы, следующие за
	// дефисом прописными, а остальные - строчными.
	//
	// Для клиентских запросов некоторые заголовки, такие как Content-Length
	// и Connection, записываются автоматически, когда это необходимо, и
	// значения в Header могут игнорироваться. См. документацию
	// по методу Request.Write.
	Request Header

	// Body - это тело запроса.
	//
	// Для клиентских запросов нулевое тело означает, что запрос не имеет
	// тело, например, запрос GET. Транспорт HTTP-клиента
	// отвечает за вызов метода Close.
	//
	// Для серверных запросов тело запроса всегда не является nil
	// но при отсутствии тела немедленно возвращается EOF.
	// Сервер закроет тело запроса. Обработчику ServeHTTP
	// обработчику не нужно.
	//
	// Тело должно позволять вызывать Read одновременно с Close.
	// В частности, вызов Close должен разблокировать Read, ожидающий
	// ввода.
	Body io.ReadCloser

	// GetBody определяет необязательную функцию для возврата новой копии
	// Body. Она используется для клиентских запросов, когда перенаправление требует.
	// чтения тела более одного раза. Использование GetBody по-прежнему
	// требует установки Body.
	//
	// Для серверных запросов он не используется.
	GetBody func() (io.ReadCloser, error)

	// ContentLength записывает длину связанного содержимого.
	// Значение -1 указывает на то, что длина неизвестна.
	// Значения >= 0 указывают, что данное количество байт может быть
	// быть прочитано из Body.
	//
	// Для клиентских запросов значение 0 с ненулевым Body
	// также рассматривается как неизвестное.
	ContentLength int64

	// TransferEncoding перечисляет кодировки передачи данных от крайних к
	// внутренней. Пустой список обозначает «идентичную» кодировку.
	// TransferEncoding обычно можно игнорировать; кодировка chunked
	// автоматически добавляется и удаляется по мере необходимости при отправке и
	// получении запросов.
	TransferEncoding []string

	// Close указывает, закрывать ли соединение после
	// ответа на этот запрос (для серверов) или после отправки этого
	// запроса и чтения его ответа (для клиентов).
	//
	// Для серверных запросов HTTP-сервер обрабатывает это автоматически.
	// и это поле не нужно обработчикам.
	//
	// Для клиентских запросов установка этого поля предотвращает повторное использование
	// TCP-соединений между запросами к одним и тем же хостам, как если бы
	// Transport.DisableKeepAlives был установлен.
	Close bool

	// Для серверных запросов поле Host указывает хост, на котором
	// URL-адрес. Для HTTP/1 (согласно RFC 7230, раздел 5.4), это
	// это либо значение заголовка «Host», либо имя хоста.
	// указанное в самом URL. Для HTTP/2 это значение заголовка
	// поля псевдозаголовка «:authority».
	// Оно может иметь вид «хост:порт». Для международных доменных
	// имен, 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 определяет дополнительные заголовки, которые отправляются после запроса
	// body.
	//
	// Для серверных запросов карта Trailer изначально содержит только
	// ключи трейлеров, со значениями nil. (Клиент объявляет, какие трейлеры он
	// будет отправлять позже.)  Пока обработчик читает из Body, он не должен // ссылаться на Trailer.
	// не ссылаться на Trailer. После того как чтение из Body возвращает EOF, Trailer
	// может быть прочитан снова и будет содержать значения non-nil, если они были отправлены
	// клиентом.
	//
	// Для клиентских запросов Trailer должен быть инициализирован картой, содержащей
	// ключи трейлера для последующей отправки. Значения могут быть nil или их конечные
	// значениями. ContentLength должен быть 0 или -1, чтобы отправить чанкированный запрос.
	// После отправки HTTP-запроса значения карты могут быть обновлены, пока
	// пока читается тело запроса. Как только тело вернется в EOF, вызывающая сторона должна.
	// не мутировать Trailer.
	//
	// Немногие HTTP-клиенты, серверы или прокси поддерживают HTTP-трейлеры.
	Trailer Header

	// RemoteAddr позволяет HTTP-серверам и другому программному обеспечению записывать.
	// сетевой адрес, отправивший запрос, обычно для
	// протоколирования. Это поле не заполняется ReadRequest и // не имеет определенного формата.
	// не имеет определенного формата. HTTP-сервер в этом пакете
	// устанавливает RemoteAddr в адрес «IP:порт» перед вызовом
	// обработчика.
	// Это поле игнорируется HTTP-клиентом.
	RemoteAddr String

	// RequestURI - это немодифицированный запрос-цель в
	// Request-Line (RFC 7230, раздел 3.1.1), отправленный клиентом
	// на сервер. Обычно вместо этого поля следует использовать поле URL.
	// Ошибкой является установка этого поля в HTTP-запросе клиента.
	RequestURI String

	// TLS позволяет HTTP-серверам и другому программному обеспечению записывать
	// информацию о TLS-соединении, по которому был получен запрос
	// был получен. Это поле не заполняется ReadRequest.
	// HTTP-сервер в этом пакете устанавливает поле для
	// соединений с поддержкой TLS перед вызовом обработчика;
	// в противном случае он оставляет поле нулевым.
	// Это поле игнорируется HTTP-клиентом.
	TLS *tls.ConnectionState

	// Cancel - необязательный канал, закрытие которого указывает на то, что клиентский
	// запрос следует считать отмененным. Не все реализации
	// RoundTripper могут поддерживать Cancel.
	//
	// Для серверных запросов это поле неприменимо.
	//
	// Исправлено: Установите контекст запроса с помощью NewRequestWithContext
	// вместо этого. Если поле Cancel и контекст запроса одновременно // установлены.
	// установлены, не определено, соблюдается ли Cancel.
	Cancel <-chan struct{}

	// Response - это ответ перенаправления, который вызвал этот запрос.
	// быть создан. Это поле заполняется только во время клиентских
	// перенаправления.
	Response *Response

	// Pattern - шаблон [ServeMux], который соответствует запросу.
	// Оно пустое, если запрос не был сопоставлен с шаблоном.
	Строка Pattern
	// содержит отфильтрованные или неотфильтрованные поля
}

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() (имя пользователя, строка пароля, 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