package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
)
func main() {
artist := "Madonna"
token := "5936fb55e90cdd9938f8e7086c783c40"
url := fmt.Sprintf(
"http://ws.audioscrobbler.com/2.0/?method=artist.getinfo&artist=%s&api_key=%s&format=json", artist, token)
res, err := http.Get(url)
if err != nil {
log.Fatal(err)
}
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
var data map[string]interface{}
// десериализуете JSON
err = json.Unmarshal(body, &data)
if err != nil {
log.Fatal(err)
}
// сериализуете данные в JSON
marshaledDataBytes, err := json.MarshalIndent(data, "", "\t")
fmt.Println(string(marshaledDataBytes))
}go get github.com/adshao/go-binance/v2import (
"github.com/adshao/go-binance/v2"
)package main
import (
"log"
"time"
)
func doSomethingEvery5Seconds(ch chan bool) {
log.Println("Started!")
for {
select {
case <-ch:
return
default:
log.Println("I am doing this!")
time.Sleep(1 * time.Second)
}
}
}
func main() {
ch := make(chan bool, 1)
go doSomethingEvery5Seconds(ch)
time.Sleep(15 * time.Second)
close(ch) // Останавливаем спустя 15 секунд
}UserId int `json:"userId" db:"userId"`UserId int `json:"userId" gorm:"column:userId"`
package main
import "fmt"
import "strconv"
func main() {
var i int64 = 65
fmt.Println(strconv.FormatInt(i, 10))
// или так
fmt.Printf("%d\n", i)
}[
{
"userId": 1,
"id": 1,
"title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
"body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
}
]package main
import (
"database/sql"
"encoding/json"
"log"
"net/http"
_ "github.com/go-sql-driver/mysql"
)
type Post struct {
Userid int `json:"userId"`
ID int `json:"id"`
Title string `json:"title"`
Body string `json:"body"`
}
func main() {
posts, err := fetchPosts("https://jsonplaceholder.typicode.com/posts?id=1")
if err != nil {
log.Fatal(err)
}
db, err := sql.Open("mysql", "root:password@/Posts")
if err != nil {
log.Fatal(err)
}
err = savePosts(db, posts)
if err != nil {
log.Fatal(err)
}
}
func fetchPosts(url string) ([]Post, error) {
resp, err := http.Get(url)
if err != nil {
return nil, err
}
var posts []Post
err = json.NewDecoder(resp.Body).Decode(&posts)
return posts, err
}
func savePosts(db *sql.DB, posts []Post) error {
for _, post := range posts {
_, err := db.Exec("insert into post (id, user_id, title, body) values(?, ?, ?, ?)",
post.ID, post.Userid, post.Title, post.Body)
if err != nil {
return err
}
}
return nil
}yourproject.com/main.go
yourproject.com/go.mod (появится после выполнения команды go mod init)
yourproject.com/pkg1/pkg1.gopackage main
import "yourproject.com/pkg1"
func main() {
pkg1.SomeFunc()
}package pkg1
import "fmt"
func SomeFunc() {
fmt.Println(`SomeFunc called`)
}users/repo.go - описание интерфейса Repo
users/repo/repo.go - тут инициализация любого типа реализации в зависимости от конфига
users/repo/repo_test.go - тут тесты
(создаю все типы репозиториев (mongo, redis...)) и одними и теми же тестами прогоняю каждый тип.
Тут и инициализация репозиториев для тестов и зачистка после тестов.)
users/repo/mongodb - реализация (импортирует пакет users при необходимости)
users/repo/redis
users/repo/sqlitego test -v ./driver_test.go ./driver.gogo test -v -run ^Test_Deposit$
var c *client.Client
mbox, err := c.Select("INBOX", false)
if err != nil {
log.Fatal(err)
}
if mbox.Messages == 0 {
log.Fatal("No message in mailbox")
}
seqset := new(imap.SeqSet)
for _, message := range mbox.Messages {
// если сообщение должно быть удалено - тогда вызываете AddNum
// используем именно message.Uid а не message.SeqNum потому, что ниже мы будем вызывать UidStore, а не Store, так будет явно надёжнее
seqset.AddNum(message.Uid)
}
// отмечаем сообщения как удалённые
item := imap.FormatFlagsOp(imap.AddFlags, true)
flags := []interface{}{imap.DeletedFlag}
if err := c.UidStore(seqset, item, flags, nil); err != nil {
log.Fatal(err)
}
// удаляем сообщение
if err := c.Expunge(nil); err != nil {
log.Fatal(err)
}
log.Println("Last message has been deleted")var dateStart = time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 9, 0, 0, 0, time.UTC)
var dateEnd = time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 17, 0, 0, 0, time.UTC)
if dateStart.Before(time.Now().UTC() ){
println("star ok")
}
if dateEnd.After(time.Now().UTC()) {
println("end ok")
}package main
import (
"bufio"
"bytes"
"fmt"
"io"
"log"
"os/exec"
)
type Executor struct {
wr io.Writer
}
func (e *Executor) SetStdout(w io.Writer) {
e.wr = w
}
func (e *Executor) Exec() error {
cmd := exec.Command("ls", "/etc")
cmd.Stdout = e.wr
err := cmd.Run()
return err
}
type BufferedBrokerWriter struct {
buffer bytes.Buffer
scanner *bufio.Scanner
}
func NewBufferedBrokerWriter() *BufferedBrokerWriter {
bw := &BufferedBrokerWriter{}
bw.scanner = bufio.NewScanner(&bw.buffer)
return bw
}
func (bw *BufferedBrokerWriter) Write(p []byte) (int, error) {
return bw.buffer.Write(p)
}
func (bw *BufferedBrokerWriter) ReadLines(cnt uint) ([]string, error) {
lines := make([]string, 0, cnt)
linesCnt := uint(0)
for bw.scanner.Scan() {
line := bw.scanner.Text()
err := bw.scanner.Err()
if err != nil || line == `` {
return lines, err
}
lines = append(lines, line)
linesCnt++
if linesCnt >= cnt {
return lines, nil
}
}
return nil, io.EOF
}
func main() {
// подключаетесь к вашему брокеру сообщений,
bw := NewBufferedBrokerWriter()
e := &Executor{}
e.SetStdout(bw)
err := e.Exec()
if err != nil {
log.Fatal(err)
}
for {
lines, err := bw.ReadLines(2)
if err == io.EOF {
break
}
fmt.Printf("Lines:\n%+v\n\n", lines)
}
}package main
import (
"fmt"
"reflect"
)
func modify(input *[]int, newLen int) {
val := reflect.Indirect(reflect.ValueOf(input))
val.SetLen(newLen)
}
func main() {
input := []int{1, 2, 3}
fmt.Printf("Before: %p, value: %v\n", &input, input)
modify(&input, len(input) - 1)
fmt.Printf("After: %p, value: %v\n", &input, input)
}Before: 0xc00000c060, value: [1 2 3]
After: 0xc00000c060, value: [1 2]type Response struct {
Code int `json:"code"`
Message string `json:"message"`
}
type LoginResponse struct {
Response
Token string
}response := LoginResponse{
Response : Response {
Code: 10,
Message: `error / success message`,
},
Token: `token`,
}