package main 

import ( 
	"log" //пакет для логирования 
	"net/http" //пакет для создания web приложений
	) 


func home(w http.ResponseWriter, r *http.Request) { 
	w.Write([]byte("Hello from Snippetbox")) 
	} 
//основная функция, `home` которая получает на вход указатель кто слушает канал:
//w http.ResponseWriter чтобы выводить значения в web

//r *http.Request - структура, которую получаем на вход

func main() { 

mux := http.NewServeMux() 
//указатель на web сервер
mux.HandleFunc("/", home) 
//обработчик запросов
log.Println("Starting server on :4000") 
//логируем подключение
err := http.ListenAndServe(":4000", mux) 
//слушаем порт 
log.Fatal(err) 
}

type ResponseWriter interface {
	// Header возвращает карту заголовков, которая будет отправлена
	// [ResponseWriter.WriteHeader]. 
	Header() Header

	// Write записывает данные в соединение как часть HTTP-ответа.
	Write([]byte) (int, error)

	// WriteHeader отправляет заголовок ответа HTTP с указанным
	// кодом состояния.
	WriteHeader(statusCode int)
}

type Request struct {
	// Method задает метод HTTP (GET, POST, PUT и т.д.).
	Method string
	// Для клиентских запросов URL's Host указывает сервер, к которому нужно // подключиться.
	URL *url.URL
	// Версия протокола для входящих запросов сервера.
	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
	Request Header
	// Body - это тело запроса.
	Body io.ReadCloser
	// GetBody определяет необязательную функцию для возврата новой копии Body. 
	GetBody func() (io.ReadCloser, error)
	// ContentLength записывает длину связанного содержимого.
	ContentLength int64
	// TransferEncoding перечисляет кодировки передачи данных от крайних к внутренней. 
	TransferEncoding []string
	Close bool
	// Для серверных запросов поле Host указывает хост, на котором URL-адрес. 
	Host String
	// Form содержит разобранные данные формы
	Form url.Values
	// PostForm содержит разобранные данные формы из параметров тела PATCH, POST
	// или параметров тела PUT.
	PostForm url.Values
	// MultipartForm - это разобранная многочастная форма, включая загрузку файлов.
	MultipartForm *multipart.Form
	// Trailer определяет дополнительные заголовки, которые отправляются после запроса
	// body.
	Trailer Header
	// RemoteAddr позволяет HTTP-серверам и другому программному обеспечению записывать сетевой адрес, отправивший запрос
	RemoteAddr String
	// RequestURI - это немодифицированный запрос-цель в
	RequestURI String
	// TLS позволяет HTTP-серверам и другому программному обеспечению записывать информацию о TLS-соединении
	TLS *tls.ConnectionState
	// Cancel - необязательный канал, закрытие которого указывает на то, что клиентский
	// запрос следует считать отмененным. 
	Cancel <-chan struct{}
	// Response - это ответ перенаправления, который вызвал этот запрос.
	Response *Response
	// Pattern - шаблон [ServeMux], который соответствует запросу.
	Pattern string
	// содержит отфильтрованные или неотфильтрованные поля
}

package main 
import ( 
      "log" 
	  "net/http" 
) 

func home(w http.ResponseWriter, r *http.Request) { w
.Write([]byte("Hello from Snippetbox")) 
} создаем функции обработчики каждого адреса

func snippetView(w http.ResponseWriter, r *http.Request) { 
w.Write([]byte("Display a specific snippet...")) 

} // для теста просто выводим что-нибудь

func snippetCreate(w http.ResponseWriter, r *http.Request) { 
w.Write([]byte("Create a new snippet...")) } 

func main() { 
// Register the two new handler functions and corresponding URL patterns with  // the servemux, in exactly the same way that we did before.  
mux := http.NewServeMux() 
mux.HandleFunc("/", home) 
mux.HandleFunc("/snippet/view", snippetView) 
mux.HandleFunc("/snippet/create", snippetCreate) 
// обрабатываем каждый адрес из браузера и запускаем функцию обработчик

log.Println("Starting server on :4000") 
err := http.ListenAndServe(":4000", mux) 
log.Fatal(err) 
}

if r.URL.Path != "/" { 
	http.NotFound(w, r) 
	return 
} 
w.Write([]byte("Hello from Snippetbox"))

var DefaultServeMux = NewServeMux()

func snippetCreate(w http.ResponseWriter, r *http.Request) {
    if r.Method != "POST" { // просто покажет каким методом отправили запрос
		w.Header().Set("Allow", "POST")` //- эта настройка подскажет в ответе, какой метод разрешен
        w.WriteHeader(405) // отправим код статуса в заголовке ответа
        w.Write([]byte("Method Not Allowed")) // и просто напишем сообщение в случае неправильного кода
        return
    }

    w.Write([]byte("Create a new snippet...")) //это сообщение успеха
}

curl -i -X POST http://localhost:4000/snippet/create // это для тестирования из командной строки

w.Header().Set("Content-Type", "application/json") 
w.Write([]byte(`{"name":"Alex"}`))

w.Header().Set("Cache-Control", "public, max-age=31536000")
w.Header().Add("Cache-Control", "public")
w.Header().Add("Cache-Control", "max-age=31536000")
w.Header().Del("Cache-Control")
w.Header().Get("Cache-Control")
w.Header().Values("Cache-Control")

w.Header()["X-XSS-Protection"] = []string{"1; mode=block"}

w.Header()["Date"] = nil

/snippet/view?id=1 // обработка строки запроса

    id, err := strconv.Atoi(r.URL.Query().Get("id"))
    if err != nil || id < 1 {
        http.NotFound(w, r)
        return
    }

ui/html/pages/home.tmpl

<!doctype html>
<html lang='en'>
    <head>
        <meta charset='utf-8'>
        <title>Home - Snippetbox</title>
    </head>
    <body>
        <header>
            <h1><a href='/'>Snippetbox</a></h1>
        </header>
        <main>
            <h2>Latest Snippets</h2>
            <p>There's nothing to see here yet!</p>
        </main>
        <footer>Powered by <a href='https://golang.org/'>Go</a></footer>
    </body>
</html>

    ts, err := template.ParseFiles("./ui/html/pages/home.tmpl")
    if err != nil {
        log.Println(err.Error())
        http.Error(w, "Internal Server Error", 500)
        return
    }

    err = ts.Execute(w, nil) //отправляет шаблон в поток w
    if err != nil {
        log.Println(err.Error())
        http.Error(w, "Internal Server Error", 500)
    }

{{define "base"}}
<!doctype html>
<html lang='en'>
    <head>
        <meta charset='utf-8'>
        <title>{{template "title" .}} - Snippetbox</title>
    </head>
    <body>
        <header>
            <h1><a href='/'>Snippetbox</a></h1>
        </header>
        <main>
            {{template "main" .}}
        </main>
        <footer>Powered by <a href='https://golang.org/'>Go</a></footer>
    </body>
</html>
{{end}}

{{define "title"}}Home{{end}}

{{define "main"}}
    <h2>Latest Snippets</h2>
    <p>There's nothing to see here yet!</p>
{{end}}

    files := []string{
        "./ui/html/base.tmpl",
        "./ui/html/pages/home.tmpl",
    }

    ts, err := template.ParseFiles(files...)
    if err != nil {
        log.Println(err.Error())
        http.Error(w, "Internal Server Error", 500)
        return
    }

    err = ts.ExecuteTemplate(w, "base", nil)
    if err != nil {
        log.Println(err.Error())
        http.Error(w, "Internal Server Error", 500)
    }

{{define "base"}}
    <h1>An example template</h1>
    {{block "sidebar" .}}
        <p>My default sidebar content</p>
    {{end}}
{{end}}

fileServer := http.FileServer(http.Dir("./ui/static/"))

mux.Handle("/static/", http.StripPrefix("/static", fileServer)) //http.StripPrefix позволяет правильно работать в адресной строке с именами файлов

func (h *home) ServeHTTP(w http.ResponseWriter, r *http.Request) { w.Write([]byte("This is my home page")) }

mux := http.NewServeMux() 
mux.Handle("/", &home{})

mux := http.NewServeMux() 
mux.HandleFunc("/", home) // home здесь обычная функция

    addr := flag.String("addr", ":4000", "HTTP network address") // прочитали адрес
    flag.Parse()
...
     log.Printf("Starting server on %s", *addr) //вывели на печать
    err := http.ListenAndServe(*addr, mux) //слушаем порт, который получили из адресной строки
    log.Fatal(err)

addr := os.Getenv("SNIPPETBOX_ADDR")

type config struct {
    addr      string
    staticDir string
}

var cfg config

flag.StringVar(&cfg.addr, "addr", ":4000", "HTTP network address")
flag.StringVar(&cfg.staticDir, "static-dir", "./ui/static", "Path to static assets")

flag.Parse()

log.Printf("Starting server on %s", *addr) // Information message
err := http.ListenAndServe(*addr, mux)
log.Fatal(err) // Error message

    infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime) // создали макет лога для сообщений
    errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile) //макет лога для ошибок
... //вывод лога
    infoLog.Printf("Starting server on %s", *addr)
    err := http.ListenAndServe(*addr, mux)
    errorLog.Fatal(err)

$ go run ./cmd/web
INFO    2022/01/29 16:00:50 Starting server on :4000
ERROR   2022/01/29 16:00:50 main.go:37: listen tcp :4000: bind: address already in use
exit status 1

$ go run ./cmd/web >>/tmp/info.log 2>>/tmp/error.log

    infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime)
    errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)

	srv := &http.Server{
        Addr:     *addr,
        ErrorLog: errorLog,
        Handler:  mux,
    }
// включаем сервер с обработчиком ошибок
err := srv.ListenAndServe()

f, err := os.OpenFile("/tmp/info.log", os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
    log.Fatal(err)
}
defer f.Close()

infoLog := log.New(f, "INFO\t", log.Ldate|log.Ltime)

type application struct {
    errorLog *log.Logger
    infoLog  *log.Logger
}

    infoLog := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime)
    errorLog := log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)

app := &application{
        errorLog: errorLog,
        infoLog:  infoLog,
    }

func (app *application) home(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        http.NotFound(w, r)
        return
    }

func main() {
    app := &config.Application{
        ErrorLog: log.New(os.Stderr, "ERROR\t", log.Ldate|log.Ltime|log.Lshortfile)
    }

    mux.Handle("/", examplePackage.ExampleHandler(app))
}

func ExampleHandler(app *config.Application) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ...
        ts, err := template.ParseFiles(files...)
        if err != nil {
            app.ErrorLog.Println(err.Error())
            http.Error(w, "Internal Server Error", 500)
            return
        }
        ...
    }
}

package main

import (
    "errors"
    "fmt"
    "html/template" // Uncomment import
    "net/http"
    "strconv"

    "snippetbox.alexedwards.net/internal/models"
)

files := []string{ 
	"./ui/html/base.tmpl", 
	"./ui/html/partials/nav.tmpl", 
	"./ui/html/pages/view.tmpl", 
}

ts, err := template.ParseFiles(files...) 
if err != nil {
	app.serverError(w, err) 
	return 
}

err = ts.ExecuteTemplate(w, "base", snippet) //собираем в шаблоне base и передаем в него структуру данных snippet
	if err != nil { 
		app.serverError(w, err) 
}

type Snippet struct { 
	ID int 
	Title string 
	Content string 
	Created time.Time 
	Expires time.Time 
}

{{define "title"}}Snippet #{{.ID}}{{end}} 
{{define "main"}} 
	<div class='snippet'> 
		<div class='metadata'> 
			<strong>{{.Title}}</strong> 
			<span>#{{.ID}}</span> 
		</div> 
		<pre><code>{{.Content}}</code></pre> 
		<div class='metadata'> 
			<time>Created: {{.Created}}</time> 
			<time>Expires: {{.Expires}}</time> 
		</div> 
	</div> 
{{end}}

type templateData struct { 
	Snippet *models.Snippet 
}

data := &templateData{ 
	Snippet: snippet, 
}

err = ts.ExecuteTemplate(w, "base", data) 
	if err != nil { 
		app.serverError(w, err) 
	}

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}

{{define "main"}}
    <div class='snippet'>
        <div class='metadata'>
            <strong>{{.Snippet.Title}}</strong>
            <span>#{{.Snippet.ID}}</span>
        </div>
        <pre><code>{{.Snippet.Content}}</code></pre>
        <div class='metadata'>
            <time>Created: {{.Snippet.Created}}</time>
            <time>Expires: {{.Snippet.Expires}}</time>
        </div>
    </div>
{{end}}

{{define "base"}}
...
{{end}}

{{define "title"}}Home{{end}}

{{define "main"}}
    <h2>Latest Snippets</h2>
    <p>There's nothing to see here yet!</p>
{{end}}

{{define "base"}}
<!doctype html>
<html lang='en'>
    <head>
        <meta charset='utf-8'>
        <title>{{template "title" .}} - Snippetbox</title>
    </head>
    <body>
        <header>
            <h1><a href='/'>Snippetbox</a></h1>
        </header>
        <main>
            {{template "main" .}}
        </main>
        <footer>Powered by <a href='https://golang.org/'>Go</a></footer>
    </body>
</html>
{{end}}

{{define "base"}}
    <h1>An example template</h1>
    {{block "sidebar" .}}
        <p>My default sidebar content</p>
    {{end}}
{{end}}

{{define "title"}}Snippet #{{.Snippet.ID}}{{end}}

{{define "main"}}
    {{with .Snippet}}
    <div class='snippet'>
        <div class='metadata'>
            <strong>{{.Title}}</strong>
            <span>#{{.ID}}</span>
        </div>
        <pre><code>{{.Content}}</code></pre>
        <div class='metadata'>
            <time>Created: {{.Created}}</time>
            <time>Expires: {{.Expires}}</time>
        </div>
    </div>
    {{end}}
{{end}}

package main

import (
    "html/template" // New import
    "path/filepath" // New import

    "snippetbox.alexedwards.net/internal/models"
)

...

func newTemplateCache() (map[string]*template.Template, error) {
    // Initialize a new map to act as the cache.
    cache := map[string]*template.Template{}

    // Use the filepath.Glob() function to get a slice of all filepaths that
    // match the pattern "./ui/html/pages/*.tmpl". This will essentially gives
    // us a slice of all the filepaths for our application 'page' templates
    // like: [ui/html/pages/home.tmpl ui/html/pages/view.tmpl]
    pages, err := filepath.Glob("./ui/html/pages/*.tmpl")
    if err != nil {
        return nil, err
    }

    // Loop through the page filepaths one-by-one.
    for _, page := range pages {
        // Extract the file name (like 'home.tmpl') from the full filepath
        // and assign it to the name variable.
        name := filepath.Base(page)

        // Create a slice containing the filepaths for our base template, any
        // partials and the page.
        files := []string{
            "./ui/html/base.tmpl",
            "./ui/html/partials/nav.tmpl",
            page,
        }

        // Parse the files into a template set.
        ts, err := template.ParseFiles(files...)
        if err != nil {
            return nil, err
        }

        // Add the template set to the map, using the name of the page
        // (like 'home.tmpl') as the key.
        cache[name] = ts
    }

    // Return the map.
    return cache, nil
}

type application struct {
    errorLog      *log.Logger
    infoLog       *log.Logger
    snippets      *models.SnippetModel
    templateCache map[string]*template.Template //это кэш
}

    // Initialize a new template cache...
    templateCache, err := newTemplateCache() //вызываем функцию и создаем кэш
    if err != nil {
        errorLog.Fatal(err)
    }

    app := &application{
        errorLog:      errorLog,
        infoLog:       infoLog,
        snippets:      &models.SnippetModel{DB: db},
        templateCache: templateCache,
    }

package main

...

func (app *application) render(w http.ResponseWriter, status int, page string, data *templateData) {
    // Retrieve the appropriate template set from the cache based on the page
    // name (like 'home.tmpl'). If no entry exists in the cache with the
    // provided name, then create a new error and call the serverError() helper
    // method that we made earlier and return.
    ts, ok := app.templateCache[page]
    if !ok {
        err := fmt.Errorf("the template %s does not exist", page)
        app.serverError(w, err)
        return
    }

    // Write out the provided HTTP status code ('200 OK', '400 Bad Request'
    // etc).
    w.WriteHeader(status)

    // Execute the template set and write the response body. Again, if there
    // is any error we call the the serverError() helper.
    err := ts.ExecuteTemplate(w, "base", data)
    if err != nil {
        app.serverError(w, err)
    }
}

func (app *application) home(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        app.notFound(w)
        return
    }

    snippets, err := app.snippets.Latest()
    if err != nil {
        app.serverError(w, err)
        return
    }

    // Use the new render helper.
    app.render(w, http.StatusOK, "home.tmpl", &templateData{
        Snippets: snippets,
    })
}

package main

...

func newTemplateCache() (map[string]*template.Template, error) {
    cache := map[string]*template.Template{}

    pages, err := filepath.Glob("./ui/html/pages/*.tmpl")
    if err != nil {
        return nil, err
    }

    for _, page := range pages {
        name := filepath.Base(page)

        // Parse the base template file into a template set.
        ts, err := template.ParseFiles("./ui/html/base.tmpl")
        if err != nil {
            return nil, err
        }

        // Call ParseGlob() *on this template set* to add any partials.
        ts, err = ts.ParseGlob("./ui/html/partials/*.tmpl")
        if err != nil {
            return nil, err
        }

        // Call ParseFiles() *on this template set* to add the  page template.
        ts, err = ts.ParseFiles(page)
        if err != nil {
            return nil, err
        }

        // Add the template set to the map as normal...
        cache[name] = ts
    }

    return cache, nil
}

package main

import (
    "bytes" // New import
    "fmt"
    "net/http"
    "runtime/debug"
)

...

func (app *application) render(w http.ResponseWriter, status int, page string, data *templateData) {
    ts, ok := app.templateCache[page]
    if !ok {
        err := fmt.Errorf("the template %s does not exist", page)
        app.serverError(w, err)
        return
    }

    // инициализация буфера
    buf := new(bytes.Buffer)

    // записываем результат рендеринга в буфер
    err := ts.ExecuteTemplate(buf, "base", data)
    if err != nil {
        app.serverError(w, err)
        return
    }

    // запишем статус в заголовок ответа
    w.WriteHeader(status)

    // возвращаем результат успешного рендеринга
    buf.WriteTo(w)
}

type templateData struct {
    CurrentYear int
    Snippet     *models.Snippet
    Snippets    []*models.Snippet
}

func (app *application) newTemplateData(r *http.Request) *templateData {//получаем на вход указатель с данными запроса 
    return &templateData{ //и возвращаем указатель с данными ответа
        CurrentYear: time.Now().Year(),// по дороге посчитаем какой текущий год
    }
}

//загружаем из базы данные в переменную snippets
	snippets, err := app.snippets.Latest()
    if err != nil {
        app.serverError(w, err)
        return
    }

	data := app.newTemplateData(r) //создаем переменную типа templateData
    data.Snippets = snippets       //записываем в структуру переменной значения из базы данных

//вызываем функцию render и передаем ей структуру с изменяемыми данными
	app.render(w, http.StatusOK, "home.tmpl", data)

func humanDate(t time.Time) string {
    return t.Format("02 Jan 2006 at 15:04")
}

var functions = template.FuncMap{
    "humanDate": humanDate,
}

    for _, page := range pages {
        name := filepath.Base(page)
//перед парсером файла с шаблоном, передаем переменную functions с объявленными функциями
//функций может быть несколько
        ts, err := template.New(name).Funcs(functions).ParseFiles("./ui/html/base.tmpl") 
        if err != nil {
            return nil, err
        }

        ts, err = ts.ParseGlob("./ui/html/partials/*.tmpl")
        if err != nil {
            return nil, err
        }

        ts, err = ts.ParseFiles(page)
        if err != nil {
            return nil, err
        }

        cache[name] = ts
    }

<td>{{humanDate .Created}}</td>
или
<time>Created: {{.Created | humanDate}}</time>
или
<time>{{.Created | humanDate | printf "Created: %s"}}</time>

func myMiddleware(next http.Handler) http.Handler {
    fn := func(w http.ResponseWriter, r *http.Request) {
        // TODO: Execute our middleware logic here...
        next.ServeHTTP(w, r)
    }

    return http.HandlerFunc(fn)
}

func myMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // TODO: Execute our middleware logic here...
        next.ServeHTTP(w, r)
    })
}