Log Requests and Responses in Gin!



package main

import "github.com/gin-gonic/gin"


func RequestLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()

        c.Next()

        latency := time.Since(t)

        fmt.Printf("%s %s %s %s\n",
            c.Request.Method,
            c.Request.RequestURI,
            c.Request.Proto,
            latency,
        )
    }
}

func ResponseLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("X-Content-Type-Options", "nosniff")

        c.Next()

        fmt.Printf("%d %s %s\n",
            c.Writer.Status(),
            c.Request.Method,
            c.Request.RequestURI,
        )
    }
}

func main() {
    r := gin.Default()
    // Add logging middleware
    r.Use(RequestLogger())
    r.Use(ResponseLogger())

    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, World!",
        })
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Получить курс доллара на forex


func forex() string {
	client := &http.Client{
		Timeout: 10 * time.Second,  
	}

 	req, err := http.NewRequest("GET", "https://www.investing.com/currencies/usd-rub", nil)
	if err != nil {
		log.Fatal(err)
	}

 	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537")

	res, err := client.Do(req)
	if err != nil {
		log.Println(err)
	}
	defer res.Body.Close()
	if res.StatusCode != 200 {
		log.Printf("status code error: %d %s", res.StatusCode, res.Status)
	}

	// Load the HTML document
	doc, err := goquery.NewDocumentFromReader(res.Body)
	if err != nil {
		log.Println(err)
	}

	var price string
	doc.Find("span[data-test='instrument-price-last']").Each(func(index int, item *goquery.Selection) {
		price = item.Text()
		fmt.Println(price)
	})

	return price
}

Работа со строками в golang



package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(    
        // true
        strings.Contains("test", "es"), 

        // 2
        strings.Count("test", "t"),

        // true
        strings.HasPrefix("test", "te"), 

        // true
        strings.HasSuffix("test", "st"), 

        // 1
        strings.Index("test", "e"), 

        // "a-b"
        strings.Join([]string{"a","b"}, "-"),

        // == "aaaaa"
        strings.Repeat("a", 5), 

        // "bbaa"
        strings.Replace("aaaa", "a", "b", 2),

        // []string{"a","b","c","d","e"}
        strings.Split("a-b-c-d-e", "-"), 

        // "test"
        strings.ToLower("TEST"), 

        // "TEST"
        strings.ToUpper("test"), 

    )
}

Golang interface

Проверка, что наша структура user реализует интерфейс User
Создаем переменную которая не нужна с типом User и значением структуры user



var _ User = &user{}

type User interface {
	ChangFIO(newFio string)
}

type user struct {
	FIO string
}

func (u *user) ChangFIO(newFio string) {

}

Invoke golang



package main

import (
	"fmt"
	"reflect"
)

var funcMap = map[string]interface{}{
	"Hello": Hello,
}

func Hello(name string) {
	fmt.Printf("Hello, %s!\n", name)
}

func main() {
	nameFunc := "Hello"

	if fn, ok := funcMap[nameFunc]; ok {
		funcValue := reflect.ValueOf(fn)
		args := []reflect.Value{reflect.ValueOf("Gopher")}
		funcValue.Call(args)
	} else {
		fmt.Println("Function not found!")
	}
}

gracefully shutdown HTTP server

	// listen to OS signals and gracefully shutdown HTTP server
	stopped := make(chan struct{})
	go func() {
		sigint := make(chan os.Signal, 1)
		signal.Notify(sigint, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
		<-sigint
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		if err := srv.Shutdown(ctx); err != nil {
			log.Printf("HTTP Server Shutdown Error: %v", err)
		}
		close(stopped)
	}()

	log.Printf("Starting HTTP server on %s", cfg.HTTPAddr)

	// start HTTP server
	if err := srv.ListenAndServe(); err != http.ErrServerClosed {
		log.Fatalf("HTTP server ListenAndServe Error: %v", err)
	}

	<-stopped