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")

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

body, _ := ioutil.ReadAll(res.Body)    // レスポンスボディを取得
res.Body.Close()    // レスポンスボディ取得したらクローズする

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

res, err := http.Post("url", "application/json", bytes.NewBuffer([]byte(jsonText)))
body, _ := ioutil.ReadAll(res.Body)
res.Body.Close()

// パラメーターの設定
values := url.Values{}
values.Add("name", "Yoshito")
values.Add("number", 13)
 
// POSTメソッドで取得
res, err := http.PostForm("url", values)
body, _ := ioutil.ReadAll(res.Body)
res.Body.Close()

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()

// エンドポイント"/get"にアクセスしたときのハンドラーを登録
http.HandleFunc("/get", func(w http.ResponseWriter, r *hrrp.Request) {
    // レスポンスを書き込む
    fmt.Fprint(w, "Hi")
})
 
// 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有効
}

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
}