Goメモ

import (
    "fmt"    // 標準パッケージ
    "my-module/subdir/hoge"  // そのほかのパッケージ
    fuga "my-module/subdir/fuga"    // "fuga"という別名をつける
    . "my-module/subdir/piyo"    // "piyo"パッケージ内のpublicな変数，関数はパッケージ名を省略して使用できる
)

d[1:]    // 先頭から最後まで．lenは1，capは2
d[:2]    // 先頭から2番目の直前まで．lenは2，capは4
d[:]    // 全要素の参照．

s := []int{1, 2, 3}
s = append(s, 4, 5)    // [1, 2, 3, 4, 5]

l := make([]int, len(s))
copy(s, l)    // sの要素をlにコピー

// aのi番目の要素を削除
a = a[:i+copy(a[i:], a[i+1:])]

var a, b int = 1, 2
c, d := "aaa", "bbb"
var (
    e = 1
    f = "wow"
)

const (
    A = 1
    B    // 1
    C    // 1
    D = "Hi"
    E    // "Hi"
)

const (
    A = iota    // 0
    B    // 1
    C    // 2
)

func generator(init, add int) func() int {
    val := init
    return func() int {
        defer func() { val += add }()
        return val
    }
}
 
gen := generator(0, 2)
fmt.Println(gen())    // 0
fmt.Println(gen())    // 2
fmt.Println(gen())    // 4

for index, value := range []int{1 , 2, 3} {
    fmt.Printf("[%v]: %v\n", index, value)
}

for {
   LABEL:
    for {
        for {
            break LABEL
        }
    }
}

func TypeMatch(any interface{}) {
    switch v: = any.(type) {
        case int:
            return fmt.Sprintf("int %v", v)
        case string:
            return fmt.Sprintf("string %v", v)
        defaulr:
            return "???"
    }
}

type Hoge struct {}
func (Hoge)Fuga() int { return 1 }    // 値レシーバー
func (*Hoge)Piyo() int { return 2 }  // ポインターレシーバー

// ポインターを返すことでメモリを節約する
func NewT(arg1 int, arg2 int arg3 int) *T {
    return &T{Arg1: arg1, Arg2: arg2, Arg3: arg3}
}

type Hoge struct { Hogehoge int }
type Fuga struct { Hoge }
a := Hoge{}
a.Hoge.Hogehoge
a.Hogehoge    // 変数名を省略すると透過的に参照可能

func Wow(person Person) {
   // ...
}

type error interface {
    func Error() string
}

type MyError struct {
    ErrorCode int
}
func (MyError)Error() string { return "ah!" }
 
func Something() (int, error) {
    return 0, &MyError{ErrorCode: 1}    // ポインターを返す
}
 
_, err := Something()
err.(*MyError)    // 型アサーションでインスタンスの値を取り出す．インターフェースの実体は*MyError型なのでそれにキャストする

// groutine 1
ch <- 1
close(ch)

// groutine 2
for {
    if v, ok := <-ch; !ok {
        // 終了操作
        break
    }
}

// あるいは
for v := range ch {
    // something
}

wg := new(sync.WaitGroup)
wg.Add(2)   // カウンターを2にする

go func() {
    wg.Done()    // 完了したらカウンターを減らす
}()

go func() {
    wg.Done()    // 完了したらカウンターを減らす
}()

wg.Wait()    // カウンターが0になるまでメインスレッドを待機させる

// GETメソッドで取得
res, err := http.Get("url")
if err != nil {
    // ...
}
defer res.Body.Close()    // レスポンスを取得したらクローズする

res.StatusCode   // HTTPステータスコード
res.Proto   // プロトコル
res.Header  // ヘッダー情報 (map[string]string)
res.Request.Method    // リクエストRSETメソッド
res.Request.URL    // リクエスト先URL

body, _ := io.ReadAll(res.Body)    // レスポンスボディを取得

jsonText := `{"year":2023,"rank":1}`

res, err := http.Post("url", "application/json", bytes.NewBuffer([]byte(jsonText)))
if err != nil {
    // ...
}
defer res.Body.Close()    // レスポンスを取得したらクローズする

body, _ := io.ReadAll(res.Body)

// パラメーターの設定
values := url.Values{}
values.Add("name", "Yoshito")
values.Add("number", 13)
 
// POSTメソッドで取得
res, err := http.PostForm("url", values)
if err != nil {
    // ...
}
defer res.Body.Close()    // レスポンスを取得したらクローズする

body, _ := io.ReadAll(res.Body)

client := &http.Client{}
res1, _  client.Get("url")    // GETメソッド

// リクエストを作成
ctx := context.withTimeout(context.Background(), 3 * time.Second)
req, err := http.NewRequestWithContext(ctx, http.MethodDelete, "url?id=0", nil)

// リクエスト送受信
res, _ := client.Do(req)
res.Body.Close()

// エンドポイント"/users"にアクセスしたときのハンドラーを登録
// パスが"/users"で終わるものが一致する
http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
    /// レスポンスの書き込み順序に注意
    // 最初にヘッダー情報を書き込む
    w.Header().Write("Contetn-Type", "text/plain; charset=utf-8");
    // ステータスコードを書き込む
    w.WriteHeader(200);
    // レスポンスボディを書き込む
    fmt.Fprint(w, "Hi")
})

// エンドポイント"/users/"にアクセスしたときのハンドラーを登録
// パスが"/users/*"で終わるものに一致する
http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
    /// レスポンスの書き込み順序に注意
    // 最初にヘッダー情報を書き込む
    w.Header().Write("Contetn-Type", "application/json");
    // ステータスコードを書き込む
    w.WriteHeader(200);
    // レスポンスボディを書き込む
    fmt.Fprint(w, `{"name": "Yabuta"}`)
})

 
// 8080番ポート，デフォルトマルチプレクサ
http.ListenAndServe(":8080", nil)

// クッキー作成時
cookie := &http.Cookie{
    Name: "token",
    Value: "something",  // JWTなど
    HttpOnly: true,    // XSS対策
}
// w http.ResponseWriter
http.SetCookie(w, cookie)
 
// クッキー確認時
// r *http.Request
token, err := r.Cookie("token")
if roken == "ssomething" {
    // Cookie有効
}

http.handleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    // ワイルドカードはRequest.PathValue()で取得可能
    id := r.PathValue("id")
})

go get github.com/lib/pq

package main

import (
	"database/sql"
	"log"

	_ "github.com/lib/pq"
)

func main() {
	// 接続情報
	dataSource := "port=5432 user=tomato password=penne dbname=mydb sslmode=disable"

	// 接続
	DB, err := sql.Open("postgres", dataSource)
	log.Println("接続中...")
	if err != nil {
		log.Panicf("接続失敗: %v", err)
	}
	defer DB.Close()

	// 接続確認
	err = DB.Ping()
	if err != nil {
		log.Panicf("接続失敗: %v", err)
	}
}

cmd := `
CREATE TABLE IF NOT EXISTS users (
	id SERIAL PRIMARY KEY,
	name VARCHAR(50) NOT NULL,
	created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
_, err = DB.Exec(cmd)
if err != nil {
	log.Panicf("テーブル作成失敗: %v", err)
}

names := []string{"Nilton", "Horvy", "Estiven"}
cmd = `INSERT INTO users (name) VALUES ($1)`
for _, name := range names {
    // スライスの各要素に対してINSERTを実行
	_, err = DB.Exec(cmd, name)
	if err != nil {
		log.Panicf("レコード挿入失敗: %v", err)
	}
}

cmd = `SELECT id, name FROM users`
rows, err := DB.Query(cmd)
if err != nil {
	log.Panicf("レコード取得失敗: %v", err)
}
defer rows.Close()

for rows.Next() {
	var (
		id   int
		name string
	)
	err = rows.Scan(&id, &name)
	if err != nil {
		log.Panicf("レコード取得失敗: %v", err)
	}
	log.Printf("ID: %d, Name: %s", id, name)
}

// 業読み取り時のエラーチェック
if err = rows.Err(); err != nil {
	log.Panicf("エラー: %v", err)
}

// Tは比較可能な型
type Set[T comparable] map[T]struct{}
 
func NewSet[T comparable](vs ...T) Set[T] {
	s := make(Set[T])
	for _, v := range vs {
		s[v] = struct{}{}
	}
	return s
}

import (
	"context"

	"github.com/jackc/pgx/v5/pgxpool"
)

// データベース接続
pool, err := pgxpool.New(context.Background(), URI)
defer pol.Close()

// コマンド実行
cmd := `INSERT INTO users (id, name) VALUES ($1, $2)`
_, err = pool.Exec(cmd, 1, "Mogi")

// 1行取得クエリ実行
cmd = `SELECT * FROM users WHERE id = $1`
row := pool.QueryRow(context.Background(), cmd, 1)
var (
	id int,
	name string
)
err = row.Scan(&id, &name)

// 複数行取得クエリ
cmd = `SELECT id FROM users WHERE name = $1`
rows, err := pool.Query(context.Background(), cmd, "Sohma")
defer rows.Close()
for rows.Next() {
	var id int
	err := rows.Scan(&id)
}

// トランザクション開始
tx, _ := pool.Begin(context.Background())
defer tx.Rollback()

// txを通したコマンド・クエリ処理

// コミット
err = tx.Commit(context.Background())