go 【文法・パッケージ・gorm】

func Fprintf(w io.Writer, format string, a ...any) (n int, err error) {
	p := newPrinter()
	p.doPrintf(format, a)
	n, err = w.Write(p.buf)
	p.free()
	return
}

import "math"

fmt.Println(math.Pi)

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(42, 13))
}

// before
x int, y int

// after

x, y int 

package main

import "fmt"

func main() {
	hoge := "string"
	num := 2
	fmt.Printf("type of %T\n", hoge)
	fmt.Printf("type of %T", num)
}

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// いろんな型の値を定義

	v := "aaa"
	t := reflect.TypeOf(v)

	fmt.Printf("値: %-10v | 型: %-15T | reflect.Type: %-20v | Kind: %v\n", v, v, t, t.Kind())
}

func TypeOf(i any) Type {
	return toType(abi.TypeOf(i))
}
type Type interface {
  Kind() Kind
}

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type Kind uint

const (
	Invalid       Kind = iota // 0
	Bool                      // 1
	Int                       // 2
	Int8                      // 3
	Int16                     // 4
	Int32                     // 5
	Int64                     // 6
	Uint                      // 7
	Uint8                     // 8
	Uint16                    // 9
	Uint32                    // 10
	Uint64                    // 11
	Uintptr                   // 12
	Float32                   // 13
	Float64                   // 14
	Complex64                 // 15
	Complex128                // 16
	Array                     // 17
	Chan                      // 18
	Func                      // 19
	Interface                 // 20
	Map                       // 21
	Ptr                       // 22
	Slice                     // 23
	String                    // 24  ← これ！
	Struct                    // 25
	UnsafePointer             // 26
)

var names = []string{
		"Invalid", "Bool", "Int", "Int8", "Int16", "Int32", "Int64",
		"Uint", "Uint8", "Uint16", "Uint32", "Uint64", "Uintptr",
		"Float32", "Float64", "Complex64", "Complex128",
		"Array", "Chan", "Func", "Interface", "Map", "Ptr", "Slice",
		"String", "Struct", "UnsafePointer",
	}


func (k Kind) String() string {
	if int(k) < len(names) {
		return names[k]
	}
	return "Unknown"
}

func main() {

	var a Kind

	a = 18

	fmt.Println(a.String())
}

import (
	"fmt"
)

type Kind uint

const (
	Invalid   Kind = iota // 0
	Bool                  // 1
	Int                   // 2
	Chan                  // 18
	Func                  // 19
	Interface             // 20
	Map                   // 21

)

var names = []string{"Invalid", "Bool", "Int", "Chan", "Func", "Interface", "Map"}

func (k Kind) String() string {
	return names[k]
}

func main() {

	var k Kind
	k = 4

	fmt.Printf("t %s", k)

}

const Pi = 3.14

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

// 複数も設定できる
const (
	Pi = 3.14
)

func main() {
	fmt.Println("hhoge", Pi)
}

package main

import "fmt"

func main() {
	aa := make([]int, 1)
	bb := []int{}

	fmt.Println("Hello, 世界", len(aa), cap(aa), len(bb), cap(bb))
	bb = append(bb, 1)
	fmt.Println(len(bb), cap(bb))
}

Hello, 世界 1 1 0 0
1 1

package main

import "fmt"

func add(x int, y int) int {
	return x * y
}

func main() {

	aa := make([]int, 1)

	aa[0] = 1
	aa = append(aa, 2)

	fmt.Println("Hello, 世界", aa)
}

// 結果
Hello, 世界 [0 2]

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type Todo struct {
	Title  string
	Status int
}

var datas = []string{"todo1", "todo2", "todo3"}

func main() {

	fmt.Println(len(datas))
	todos := make([]Todo, len(datas))
	todo2 := make([]Todo, len(datas))

	for i, d := range datas {
		todos[i] = Todo{Title: d, Status: 0}
	}

	fmt.Printf("%v", todos)
	fmt.Printf("%v", todo2)
}

### 出力
// todo2は 構造体のゼロ値が設定されて3つ要素がある
[{todo1 0} {todo2 0} {todo3 0}][{ 0} { 0} { 0}]

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type Todo struct {
	Title  string
	Status int
}

var datas = []string{"todo1", "todo2", "todo3"}

func main() {

	fmt.Println(len(datas))
	todos := make([]Todo, len(datas))

	for _, d := range datas {
		todos = append(todos, Todo{Title: d, Status: 0})
	}

	fmt.Printf("%v", todos)
}

### 出力
// makeで初期化された要素の後に、追加した要素がくる
[{ 0} { 0} { 0} {todo1 0} {todo2 0} {todo3 0}]

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)
}

package main

import "fmt"

func main() {
	sum := 1
	for sum < 1000 {
		sum += sum
	}
	fmt.Println(sum)
}

package main

import "fmt"

func main() {

	i := 1

LOOP:
	for {
		fmt.Println(i)
		i++

		if i == 100 {
			break LOOP
		}
	}

}

package main

import "fmt"

func main() {

	if v := 160; v < 170 {
		fmt.Println("身長が低い")
	}

}

package main

import "fmt"

func main() {

	if v := 171; v < 170 {
		fmt.Println("身長が低い")
	} else {
		fmt.Println("身長が高い")
	}

}

package main

import "fmt"

func main() {
	switch country := "Japan"; country {
	case "Japan":
		fmt.Println("こんにちわ")
	case "US":
		fmt.Println("Hello world")
	default:
		fmt.Println("Hello world")
	}

}

package main

import "fmt"

func main() {
	country := "Japan"
	switch country {
	case "Japan":
		fmt.Println("こんにちわ")
	case "US":
		fmt.Println("Hello world")
	default:
		fmt.Println("Hello world")
	}

}

package main

import "fmt"

func main() {

	defer fmt.Println("完了")

	for i := 0; i < 100; i++ {
		fmt.Println(i)
	}

}

package main

import "fmt"

func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

counting
done
9
8
7
6
5
4
3
2
1
0

package main

import "fmt"

func main() {
	var p *int
	var sp *string // ここ *intだとエラーになる
	i := 42
	p = &i

	s := "Hello"
	sp = &s
	fmt.Println(p, sp)
}

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{X: 1, Y: 3}
	fmt.Println(v.X, v.Y)
}

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

// var num int = 1
func main() {
    // 明示的な書き方
	var v Vertex = Vertex{X: 1, Y: 3}
	// v := Vertex{X: 1, Y: 3}
	fmt.Println(v.X, v.Y)
}

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{X: 1, Y: 3}
	pv := &v
	fmt.Println(pv.X, pv.Y)
}
1 3

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v3 = Vertex{}      // X:0 and Y:0
)

func main() {
	fmt.Println(v1, p, v2, v3)
}

package main

import "fmt"

func main() {
	var num []int

	fmt.Println(len(num), cap(num))

	fmt.Println(num)
}

0 0
[]

## 代入もするケース
package main

import "fmt"

func main() {
	var num = []int{1}

	fmt.Println(len(num), cap(num))

	fmt.Println(num)
}
1 1
[1]

package main

import "fmt"


func main() {

	aa := make([]int, 1)
	bb := []int{}
	aa[0] = 1
	fmt.Println("aa", len(aa), cap(aa))
	fmt.Println("bb", len(bb), cap(bb))
}
aa 1 1
bb 0 0

package main

import "fmt"

func main() {
	// len cap
	a := make([]int, 5, 10)
	fmt.Println(len(a), cap(a))
	a = append(a, 1)
	fmt.Println(len(a), cap(a))
}

package main

## makeで初期化
import "fmt"

func main() {
  // 長さは設定していない
	a := make(map[string]int)
	fmt.Println(a["aa"])
}

## {}で初期化


func main() {
	a := map[string]int{}
	fmt.Println(a["aa"])
}
0 が返却される

// 参照

m[key]

hoge := m[key]  // 変数に初期値を入れたり

// 削除

elem = m[key] // 削除済みのmapを返却

// キーの存在判定

elem, ok = m[key] // 代入か

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func (v Vertex) Calc() int {

	return 3*v.X + v.Y
}

func main() {
	v := Vertex{X: 2, Y: 3}
	fmt.Println(v.Calc())
}

var v Vertex
v.Scale(5)  // OK
p := &v
p.Scale(10) // pはポインタだけどでリファレンスしないで、メソッドを実行できる
// (*p).Scale(10)

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func (v *Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := &Vertex{3, 4}
	fmt.Printf("Before scaling: %+v, Abs: %v\n", v, v.Abs())
	v.Scale(5)
	fmt.Printf("After scaling: %+v, Abs: %v\n", v, v.Abs())
}

package main

import "fmt"

type Calcer interface {
	Calc() int
}

type Vertex struct {
	X int
	Y int
}

func (v Vertex) Calc() int {

	return 3*v.X + v.Y
}

func main() {
	var v Calcer

	v = Vertex{X: 2, Y: 3}
	fmt.Println(v.Calc())
}

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x491470]

goroutine 1 [running]:
main.main()
	/tmp/sandbox4231968961/prog.go:23 +0x10

package main

import "fmt"

type Calcer interface {
	Calc() int
}

type Vertex struct {
	X int
	Y int
}

func (v Vertex) Calc() int {

	return 3*v.X + v.Y
}

func main() {
	var v Calcer

	// v = Vertex{X: 2, Y: 3}
	fmt.Println(v.Calc())
}

package main

import "fmt"

func main() {
	var num interface{}

	num = 4

	fmt.Printf("val %d typeof %T ", num, num)
}

package main

import "fmt"

func main() {
	var i interface{} = "hello"

	// fmt.Printf("val %d typeof %T ", num, num)
	// fmt.Printf("val %string typeof %T ", i, i)
	s, ok := i.(string)
	if ok {
		fmt.Println("yahoo", s)
	} else {
		fmt.Println("ng")
	}
}

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type Calcer interface {
	Calc() int
}

type Vertex struct {
	X int
	Y int
}

type Hoge struct {
	X int
	Y int
}

func (v Vertex) Calc() int {
	return 3*v.X + v.Y
}

func (v Hoge) Calc() int {
	return 3*v.X + v.Y
}

func main() {
	var v Calcer
	v = Vertex{X: 2, Y: 3}

	_, ok := v.(Hoge)

	if ok {
		fmt.Println("OKに入った")
	} else {
		fmt.Println("OKに入ってない")

	}
	fmt.Println("Hello, 世界", v.Calc())

}

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type Calcer interface {
	Calc() int
}

type Vertex struct {
	X int
	Y int
}

type Hoge struct {
	X int
	Y int
}

func (v Vertex) Calc() int {
	return v.X + v.Y
}

func (h Hoge) Calc() int {
	return h.X + h.Y*2
}

func Print(v Calcer) {
	fmt.Printf("type inner %T\n", v)

}

func main() {

	var v Calcer

	v = Vertex{X: 2, Y: 3}

	fmt.Printf("outer %T\n", v)
	Print(v)

}

### 出力
outer main.Vertex
type inner main.Vertex

// エラーとかで 型アサーション使ってるイメージ
// 持っているメソッドは同じだけど、ログの出力の仕方が違うとか

type Calcer interface {
	Calc() int
}

type Vertex struct{ X, Y int }
type Hoge struct{ X, Y int }

func (v Vertex) Calc() int { return v.X + v.Y }
func (h Hoge) Calc() int   { return h.X - h.Y }

func DoSomething(c Calcer) {
	switch v := c.(type) {
	case Vertex:
		fmt.Println("Vertex:", v.Calc())
	case Hoge:
		fmt.Println("Hoge:", v.Calc())
	default:
		fmt.Println("Unknown type")
	}
}

type Calcer interface {
	Calc() int
}

type Vertex struct{ X, Y int }
type Hoge struct{ X, Y int }

func (v Vertex) Calc() int { return v.X + v.Y }
func (h Hoge) Calc() int   { return h.X - h.Y }

func DoSomething(c Calcer) {
	switch v := c.(type) {
	case Vertex:
		fmt.Println("Vertex:", v.Calc())
	case Hoge:
		fmt.Println("Hoge:", v.Calc())
	default:
		fmt.Println("Unknown type")
	}
}

type Stringer interface {
  String() string
}

func TypeOf(i any) Type {
	return toType(abi.TypeOf(i))
}

type Type interface {
  ... 
  Kind() Kind
}

### range パターン
package main

import "fmt"

type User struct {
	Name string
}

func main() {
	c := make(chan User)

	go func() {
		for i := 0; i < 10; i++ {
			c <- User{Name: fmt.Sprintf("Name %d", i)}
		}
		close(c)
	}()

    // closeされるまでループし続ける
	for v := range c {
		fmt.Println(v)
	}
}

### select パターン

package main

import "fmt"

type User struct {
	Name string
}

func main() {
	c := make(chan User)

	go func() {
		for i := 0; i < 10; i++ {
			c <- User{Name: fmt.Sprintf("Name %d", i)}
		}
		close(c)
	}()

Loop:
	for {
		select {
		case v, ok := <-c:
			if ok {
				fmt.Println(v)
			} else {
				// チャネルが閉じられたのでループ終了
				break Loop
			}
		}
	}

	fmt.Println("done!")
}

package main

import (
	"fmt"
	"sync"
	"time"
)

type User struct {
	Name string
}

type RecommentItem struct {
	Name string
}

type Response struct {
	User           *User
	RecommendItems []*RecommentItem
}

func fetchUserData() *User {
	time.Sleep(2 * time.Second) // 擬似的な遅延
	return &User{Name: "User Name"}
}

func fetchRecommendedItems() []*RecommentItem {
	time.Sleep(1 * time.Second) // 擬似的な遅延

	var res []*RecommentItem
	res = append(res, &RecommentItem{Name: "Recommend Item"})
	return res
}

func main() {
	var wg sync.WaitGroup
	var userData *User
	var items []*RecommentItem

	wg.Add(2)

	go func() {
		defer wg.Done()
		userData = fetchUserData()
	}()

	go func() {
		defer wg.Done()
		items = fetchRecommendedItems()
	}()

	wg.Wait()

	fmt.Printf("Fetched: %v\n", userData)
	fmt.Printf("Fetched: %v\n", items)
	res := Response{User: userData, RecommendItems: items}
	fmt.Printf("All done!: response is %+v", res)
}

package main

import (
	"fmt"
	"time"

	"golang.org/x/sync/errgroup"
)

type User struct {
	Name string
}

type RecommentItem struct {
	Name string
}

type Response struct {
	User           *User
	RecommendItems []*RecommentItem
}

func fetchUserData() (*User, error) {
	time.Sleep(2 * time.Second) // 擬似的な遅延
	return &User{Name: "User Name"}, nil
}

func fetchRecommendedItems() ([]*RecommentItem, error) {
	time.Sleep(1 * time.Second) // 擬似的な遅延

	var res []*RecommentItem
	res = append(res, &RecommentItem{Name: "Recommend Item"})
	return res, nil
}

func main() {
	var userData *User
	var items []*RecommentItem

	g := new(errgroup.Group)

	// ユーザーデータ取得
	g.Go(func() error {
		u, err := fetchUserData()
		if err != nil {
			return err
		}
		userData = u
		return nil
	})

	// レコメンドアイテム取得
	g.Go(func() error {
		i, err := fetchRecommendedItems()
		if err != nil {
			return err
		}
		items = i
		return nil
	})

	// 全てのgoroutineが完了、またはエラーが発生
	if err := g.Wait(); err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Fetched: %v\n", userData)
	fmt.Printf("Fetched: %v\n", items)
	res := Response{User: userData, RecommendItems: items}
	fmt.Printf("All done!: response is %+v\n", res)
}

package main

import (
	"net/http"
	"time"

	"github.com/labstack/echo/v4"
	"golang.org/x/sync/errgroup"
)

type User struct {
	Name string
}

type RecommendItem struct {
	Name string
}

type Response struct {
	User           *User            `json:"user"`
	RecommendItems []*RecommendItem `json:"recommend_items"`
}

func fetchUserData() (*User, error) {
	time.Sleep(2 * time.Second) // 擬似的な遅延
	return &User{Name: "User Name"}, nil
}

func fetchRecommendedItems() ([]*RecommendItem, error) {
	time.Sleep(1 * time.Second) // 擬似的な遅延
	items := []*RecommendItem{{Name: "Recommend Item"}}
	return items, nil
}

func handler(c echo.Context) error {
	var userData *User
	var items []*RecommendItem

	g := new(errgroup.Group)

	// ユーザーデータ取得
	g.Go(func() error {
		u, err := fetchUserData()
		if err != nil {
			return err
		}
		userData = u
		return nil
	})

	// レコメンドアイテム取得
	g.Go(func() error {
		i, err := fetchRecommendedItems()
		if err != nil {
			return err
		}
		items = i
		return nil
	})

	// 全ての並行処理が終了
	if err := g.Wait(); err != nil {
		// エラーがあれば 400 Bad Request を返却
		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
	}

	// 正常レスポンス
	res := Response{
		User:           userData,
		RecommendItems: items,
	}
	return c.JSON(http.StatusOK, res)
}

func main() {
	e := echo.New()

	e.GET("/api", handler)

	e.Start(":8080")
}

package main

import (
	"fmt"
)

func main() {
	c := make(chan int)

	go func() {
		c <- 1
	}()

	fmt.Println(<-c)

}

## 自作

package main

import (
	"fmt"
)

// 引数の 加算してる
// 入力する処理
func sum(s []int, c chan int) {
	sum := 0

	for _, v := range s {
		sum += v
	}
	c <- sum
}

func main() {

	c := make(chan int)
	s := []int{1, 2, 3, 3, 4, 3, 2, 2}
	e := []int{4, 2, 3, 3, 4, 3, 2, 2}

	go sum(s, c)
	go sum(e, c)

	// 送信2つは非同期だから、受信2つは待機 して4つが揃う時がある
	x, y := <-c, <-c

	fmt.Println(x, y)

}

package main

import "fmt"

// 第一引数のスライスの合計の数字を送信してる
func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
    // 受信してる
	x, y := <-c, <-c // receive from c

	fmt.Println(x, y, x+y)
}

package main

import "fmt"

func main() {
	ch := make(chan int, 2)
    // 送信を非同期で
	ch <- 1
	ch <- 2
	fmt.Println(<-ch)
	fmt.Println(<-ch)
}

package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		fmt.Printf("worker %d started job %d\n", id, j)
		time.Sleep(time.Second) // 擬似的に処理中を表現
		fmt.Printf("worker %d finished job %d\n", id, j)
		results <- j * 2
	}
}

func main() {
	const numJobs = 5
	jobs := make(chan int, numJobs) // バッファ付きチャネルを利用
	results := make(chan int, numJobs)

	// ワーカーを3つ起動
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}

	// ジョブを送信
	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs)

	// 結果を受信
	for a := 1; a <= numJobs; a++ {
		fmt.Println("result:", <-results)
	}
}

package main

import "fmt"

type User struct {
	Name string
}

func main() {
	c := make(chan User)

	go func() {
		for i := 0; i < 10; i++ {
			c <- User{Name: fmt.Sprintf("Name %d", i)}
		}
		close(c)
	}()

    // closeされるまでループし続ける
	for v := range c {
		fmt.Println(v)
	}
}

package main

import "fmt"

type User struct {
	Name string
}

func main() {
	c := make(chan User)

	go func() {
		for i := 0; i < 10; i++ {
			c <- User{Name: fmt.Sprintf("Name %d", i)}
		}
		close(c)
	}()

Loop:
	for {
		select {
		case v, ok := <-c:
			if ok {
				fmt.Println(v)
			} else {
				// チャネルが閉じられたのでループ終了
				break Loop
			}
		}
	}

	fmt.Println("done!")
}

type User struct {
    Name        []byte                 `gorm:"serializer:json"`
    Roles       Roles                  `gorm:"serializer:json"`
    Contracts   map[string]interface{} `gorm:"serializer:json"`
    JobInfo     Job                    `gorm:"type:bytes;serializer:gob"`
    CreatedTime int64                  `gorm:"serializer:unixtime;type:time"` // store int as datetime into database
}

// gorm.Modelの定義
type Model struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

db.WithContext(ctx).Find(&users)

if err := db.Where("name = ?", "jinzhu").First(&user).Error; err != nil {
  // Handle error...
}

// User は複数の CreditCards を持ちます。UserID は外部キーとなります。
type User struct {
  gorm.Model
  CreditCards []CreditCard
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}

type User struct {
  gorm.Model
  CreditCards []CreditCard `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}

type User struct {
  gorm.Model
  MemberNumber string
  CreditCards  []CreditCard `gorm:"foreignKey:UserNumber;references:MemberNumber"`
}

type CreditCard struct {
  gorm.Model
  Number     string
  UserNumber string
}

func FetchSingleRecord[T any](ctx context.Context, db *gorm.DB, buildQuery func(*gorm.DB) *gorm.DB) (result *T) {
	if err := buildQuery(db).Take(&result).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil
		}
		panic(err) // 必要に応じて適切なエラー処理に置き換えてください
	}
	return
}

package main

import (
	"errors"
	"fmt"

	"github.com/go-playground/validator/v10"
)

type User struct {
	FirstName string     `validate:"required"`
	LastName  string     `validate:"required"`
	Age       uint8      `validate:"gte=0,lte=130"` // ここ 0~130才？
	Email     string     `validate:"required,email"`
	Gender    string     `validate:"oneof=male female prefer_not_to"`
	Addresses []*Address `validate:"required,dive,required"`
}

type Address struct {
	Street string `validate:"required"`
	Cipt   string `validate:"required"`
	Planet string `validate:"required"`
	Phone  string `validate:"required"`
}

// 構造体が入る宣言か
var validate *validator.Validate

func main() {

	// validator はpackageから撮ってきてる。package validatorと宣言がある
	validate = validator.New(validator.WithRequiredStructEnabled())

	// fmt.Println("%v", validate)

	addres := &Address{
		Street: "Eavesdown Docks",
		Planet: "Persphon",
		Phone:  "none",
	}

	user := &User{
		FirstName: "Badder",
		LastName:  "Smith",
		Age:       134,
		Gender:    "male",
		Email:     "aaaa@gmail.com",
		Addresses: []*Address{addres},
	}

	err := validate.Struct(user)

	if err != nil {
		var invalidValidationError *validator.InvalidValidationError
		if errors.As(err, &invalidValidationError) {
			fmt.Println(err)
			return
		}

		// FieldErrorが複数
		var validateErrs validator.ValidationErrors
		if errors.As(err, &validateErrs) {
			for _, e := range validateErrs {
				fmt.Println(e.Namespace())
				fmt.Println(e.Field())
				fmt.Println(e.StructNamespace())
				fmt.Println(e.StructField())
				fmt.Println(e.Tag())
				fmt.Println(e.ActualTag())
				fmt.Println(e.Kind())
				fmt.Println(e.Type())
				fmt.Println(e.Value())
				fmt.Println(e.Param())
				fmt.Println()
			}
		}

		// from here you can create your own error messages in whatever language you wish
		return

	}

}

func (g *Group) POST(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
	return g.Add(http.MethodPost, path, h, m...)
}

type MiddlewareFunc func(next HandlerFunc) HandlerFunc

// HandlerFunc defines a function to serve HTTP requests.
type HandlerFunc func(c Context) error

## 実装するとき

func (e *EchoValidator) MiddlewareFunc() echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			// リクエストボディを validateType にバインド（deep copyが必要）
			req := cloneEmpty(e.validateType)
			if err := c.Bind(req); err != nil {
				return echo.NewHTTPError(400, fmt.Sprintf("Failed to bind request: %v", err))
			}

			if err := e.validate.Struct(req); err != nil {
				return echo.NewHTTPError(400, fmt.Sprintf("Validation failed: %v", err))
			}

			// c.Set で次の handler に渡すことも可能
			c.Set("validated", req)

			return next(c)
		}
	}
}

// You can edit this code!
// Click here and start typing.
package main

import (
	"encoding/json"
	"fmt"
)

type Book struct {
	Title string
}

func main() {
	b := []byte(`{"title": "リーダブルコード"}`)
	var book Book
	if err := json.Unmarshal(b, &book); err != nil {
		fmt.Println(err)
	}

	fmt.Printf("Hello, 世界 %+v", book)

	b2 := Book{Title: "jsonにされた"}

	json, err := json.Marshal(&b2)

	if err == nil {
		fmt.Printf("Hello, 世界 v2 %+v", json)

	}

}

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

type TickerResponse struct {
	Last      float64 `json:"last"`
	Bid       float64 `json:"bid"`
	Ask       float64 `json:"ask"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Volume    float64 `json:"volume"`
	Timestamp int64   `json:"timestamp"`
}

type CoinCheckClient struct{}

func (c *CoinCheckClient) GetCoin(pair string) (*TickerResponse, error) {

	url := fmt.Sprintf("https://coincheck.com/api/ticker?pair=%s", pair)

	resp, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	var ticker TickerResponse
	if err := json.NewDecoder(resp.Body).Decode(&ticker); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("ETH/JPY: Last=%.2f, High=%.2f, Low=%.2f\n", ticker.Last, ticker.High, ticker.Low)

	return &ticker, nil

}

func main() {

	client := CoinCheckClient{}

	if res, err := client.GetCoin("eth_jpy"); err != nil {
		panic(err)
	} else {
		fmt.Printf("res%v", res)
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// ここにコードを追加してください
	// 例: fmt.Println("Hello, World!")

	today := time.Now().UTC().Truncate(24 * time.Hour)

	fmt.Println("今日の日付:", today)
	fmt.Println("今日の日付:", today.Add(-30*24*time.Hour))

}

package main

import "fmt"

// newCounter は、呼び出されるたびに値を1つ増やすクロージャを返します。
func newCounter() func() int {
	count := 0 // この変数はクロージャによって「記憶」される

	return func() int {
		count++ // 記憶された count 変数を変更する
		return count
	}
}

func main() {
	// counter1 は新しいクロージャのインスタンス
	counter1 := newCounter()

	fmt.Println("--- counter1 ---")
	fmt.Println(counter1()) // 1
	fmt.Println(counter1()) // 2
	fmt.Println(counter1()) // 3

	// counter2 は別の独立したクロージャのインスタンス
	counter2 := newCounter()

	fmt.Println("\n--- counter2 ---")
	fmt.Println(counter2()) // 1
	fmt.Println(counter2()) // 2

	// counter1 は以前の状態を記憶している
	fmt.Println("\n--- counter1 (再び) ---")
	fmt.Println(counter1()) // 4
}

package main

import "fmt"

// Printerインタフェースの定義
type Printer interface {
	Print()
}

// プリンターの実装
type MyPrinter struct{}

func (mp MyPrinter) Print() {
	fmt.Println("hogehoge")
}

// Printerを属性として持つ構造体
type DecoratedPrinter struct {
	wrapped Printer
}

func (dp DecoratedPrinter) Print() {
	fmt.Println("start")
	dp.wrapped.Print()
	fmt.Println("end")
}

// Printerインタフェースをラップする
func Decorate(p Printer) Printer {
	return DecoratedPrinter{wrapped: p}
}

func main() {
	printer := Decorate(MyPrinter{})
	printer.Print()
}

package main

import (
	"encoding/csv"
	"fmt"
	"os"
)

func main() {

	file, err := os.Open("test.csv")

	if err != nil {
		panic(err)
	}
	defer file.Close()

	r := csv.NewReader(file)

	rec, err := r.Read()

	if err != nil {
		panic(err)
	}

	fmt.Println(rec)

	rec2, err2 := r.Read()

	if err2 != nil {
		panic(err2)
	}
	fmt.Printf("data %+v %T\n", rec2, rec2)
	fmt.Printf("data index 0 %+v\n", rec2[0])
	fmt.Printf("data index 1%+v\n", rec2[1])

}

// nilで初期化する必要があるらしい
var ae AppError
var ve ValidateError

a := appError{}
v  := valudateError{}

if errors.As(a, &ae) {
  // アプリケーションエアー
}

if errors.As(v, &ve) {
  // バリデーションケーションエアー
}

// もっと実践的
switch {
case errors.As(err, &ve):
    fmt.Println("ValidateError:", ve.FieldErrors())
case errors.As(err, &ae):
    fmt.Println("AppError:", ae.Code())
default:
    fmt.Println("unknown:", err)
}

package main

import (
	"errors"
	"fmt"
)

var ErrNotFound = errors.New("not found")
var ErrInternal = errors.New("internal")

type AppError struct {
	Err  error
	Info string
}

func (e *AppError) Error() string {
	return fmt.Sprintf("%s info: %s", e.Err.Error(), e.Info)
}

func (e *AppError) Unwrap() error {
	return e.Err
}

type Error struct {
	Code string
	Msg  string
}

func (e *Error) Error() string {
	return fmt.Sprintf("code: %s msg: %s", e.Code, e.Msg)
}

func main() {
	a := &AppError{Err: &Error{Code: "aaa", Msg: "aaa"}, Info: "補足"}

	if errors.Is(a, ErrInternal) {
		fmt.Println("Hello, 世界")

	} else {
		fmt.Println("not")
	}
}

package main

import (
	"errors"
	"fmt"
)

type CustomerErrorA interface {
	Error() string
	Hoge() string
}

type customerErrorA struct {
	Code string
	Msg  string
}

func (e *customerErrorA) Error() string {
	return fmt.Sprintf("code: %s msg: %s", e.Code, e.Msg)
}

func (e *customerErrorA) Hoge() string {
	return fmt.Sprintf("hoge code: %s msg: %s", e.Code, e.Msg)
}

type CustomerErrorB interface {
	Error() string
	Hoge() string
}

type customerErrorB struct {
	Code string
	Msg  string
}

func (e *customerErrorB) Error() string {
	return fmt.Sprintf("code: %s msg: %s", e.Code, e.Msg)
}

func (e *customerErrorB) Hoge() string {
	return fmt.Sprintf("hoge code: %s msg: %s", e.Code, e.Msg)
}

type CustomerErrorC interface {
	Error() string
	Ahoo() string
}

func main() {

	b := &customerErrorB{Code: "code", Msg: "msg"}

	var ca CustomerErrorA

	if errors.As(b, &ca) {
		fmt.Println("ok")
	} else {
		fmt.Println("ng")
	}

}

package apperr

import (
	"errors"
	"fmt"
	"net/http"
)

type Code string

const (
	CodeNotFound        Code = "not_found"
	CodeInvalidArgument Code = "invalid_argument"
	CodeUnauthenticated Code = "unauthenticated"
	CodePermission      Code = "permission_denied"
	CodeInternal        Code = "internal"
)

func (c Code) HTTPStatus() int {
	switch c {
	case CodeNotFound:
		return http.StatusNotFound
	case CodeInvalidArgument:
		return http.StatusBadRequest
	case CodeUnauthenticated:
		return http.StatusUnauthorized
	case CodePermission:
		return http.StatusForbidden
	default:
		return http.StatusInternalServerError
	}
}

var (
	ErrNotFound        = errors.New(string(CodeNotFound))
	ErrInvalidArgument = errors.New(string(CodeInvalidArgument))
	ErrUnauthenticated = errors.New(string(CodeUnauthenticated))
	ErrPermission      = errors.New(string(CodePermission))
	ErrInternal        = errors.New(string(CodeInternal))
)

// ===== AppError インターフェース =====
type AppError interface {
	error
	AppCode() Code
	HTTPStatus() int
}

// ===== 実装本体 =====
type Error struct {
	Code Code
	Msg  string
	err  error // cause/sentinel
}

func (e *Error) Error() string {
	if e.Msg != "" {
		return fmt.Sprintf("%s: %s", e.Code, e.Msg)
	}
	return string(e.Code)
}
func (e *Error) Unwrap() error   { return e.err }
func (e *Error) AppCode() Code   { return e.Code }
func (e *Error) HTTPStatus() int { return e.Code.HTTPStatus() }

func New(code Code, msg string) *Error                   { return &Error{Code: code, Msg: msg} }
func Wrap(code Code, msg string, cause error) *Error     { return &Error{Code: code, Msg: msg, err: cause} }

// ===== バリデーション系 =====
type ValidationError struct {
	Field   string
	Message string
}
func (v *ValidationError) Error() string { return fmt.Sprintf("%s: %s", v.Field, v.Message) }

type ValidationErrors struct {
	Errors []*ValidationError
}
func (ve *ValidationErrors) Error() string { return "validation failed" }

// 見つからない
return apperr.Wrap(apperr.CodeNotFound, "store not found", apperr.ErrNotFound)

// バリデーション
ve := &apperr.ValidationErrors{
  Errors: []*apperr.ValidationError{
    {Field: "email", Message: "invalid format"},
    {Field: "age", Message: "must be >= 18"},
  },
}

package handler

import (
	"errors"
	"net/http"

	"your/module/apperr" // ← 実パスに合わせて修正
	"github.com/labstack/echo/v4"
	"github.com/rs/zerolog/log"
)

type errorResponse struct {
	Code    string            `json:"code"`
	Message string            `json:"message"`
	Detail  map[string]string `json:"detail,omitempty"`
}

func ErrorHandler(err error, c echo.Context) {
	// 既定値（予期しないエラー）
	status := http.StatusInternalServerError
	resp := errorResponse{
		Code:    string(apperr.CodeInternal),
		Message: http.StatusText(status),
	}

	var (
		app apperr.AppError
		ves *apperr.ValidationErrors
	)

	switch {
	// 1) アプリ共通エラー（HTTP ステータスやアプリコードをここで決定）
	case errors.As(err, &app):
		status = app.HTTPStatus()
		resp.Code = string(app.AppCode())
		resp.Message = app.Error()

		// Validation の詳細が含まれていれば詰める
		if errors.As(err, &ves) && len(ves.Errors) > 0 {
			resp.Detail = make(map[string]string, len(ves.Errors))
			for _, v := range ves.Errors {
				resp.Detail[v.Field] = v.Message
			}
		}

		// 代表的センチネルごとに追加ログやマスクを入れたい場合
		switch {
		case errors.Is(err, apperr.ErrUnauthenticated):
			// 例: 追加タグ/監査ログ
		case errors.Is(err, apperr.ErrPermission):
			// 例: 監査用に principal を付けるなど
		case errors.Is(err, apperr.ErrNotFound):
			// 例: 詳細をマスク
		}

		log.Error().Stack().Err(err).
			Int("status", status).
			Str("code", resp.Code).
			Msg("request failed")

	// 2) AppError ではないが ValidationErrors が投げられた（想定外ルートの保険）
	case errors.As(err, &ves):
		status = http.StatusBadRequest
		resp.Code = string(apperr.CodeInvalidArgument)
		resp.Message = "invalid request"
		if len(ves.Errors) > 0 {
			resp.Detail = make(map[string]string, len(ves.Errors))
			for _, v := range ves.Errors {
				resp.Detail[v.Field] = v.Message
			}
		}
		log.Error().Stack().Err(err).Int("status", status).Str("code", resp.Code).Msg("validation failed")

	// 3) それ以外（本当に想定外）
	default:
		log.Error().Stack().Err(err).Int("status", status).Str("code", resp.Code).Msg("unexpected error")
	}

	if !c.Response().Committed {
		_ = c.JSON(status, resp)
	}
}

var hoge []int
fmt.Println(hoge == nil) // true
fmt.Println(hoge)        // []

empty := []int{}
fmt.Println(empty == nil) // false
fmt.Println(empty)        // []

func loadConfig(path string) map[string]string {
    if !fileExists(path) {
        return nil // ← 設定ファイルが無い
    }
    // 実際に読み込んで map に詰める
}

conf := loadConfig("config.json")
if conf == nil {
    fmt.Println("設定ファイルが存在しない")
} else {
    fmt.Println("ポート番号:", conf["port"])
}

type User struct {
    ID   int
    Name string
    Tags []string
}

func main() {
    var u User // ← ゼロ値で初期化
    fmt.Printf("%#v\n", u)
}

type User struct {
    ID   int
    Name string
}

var a User        // = User{ID:0, Name:""}
b := User{}       // 同じくゼロ値

c := struct{}{}   // フィールド無しの struct（空 struct）

package main

import "fmt"

func main() {
	var a struct{}

	fmt.Println("Hello, 世界", a)
}

### 名前なし
var x interface{}
x = 42
x = "hello"
x = []int{1, 2, 3}

### 名前つき
type Any interface{} // これも「なんでも入る型」

var x Any = "hoge"
fmt.Println(x)