go version

go version go1.27.1 windows/amd64

mkdir hello
cd hello
go mod init example.com/hello

package main

import "fmt"

func main() {
    fmt.Println("Hello, World")
}

go run main.go

go run .

// greet.go
package main

func greet(name string) string {
    return "Hello, " + name
}

// main.go
package main

import "fmt"

func main() {
    fmt.Println(greet("Go言語"))
}

go run .

go build -o hello .

go fmt ./...

go test ./...

// 行コメント（行末まで）

/*
ブロックコメント（複数行）
*/

var _count int // 先頭が_なのでパッケージ外からは見えない
var count int  // 先頭が小文字でも同様に見えない
var Count int  // 先頭が大文字なら他パッケージから見える

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

true := 1

// var if int = 1 // コンパイルエラー

func inc(x int) int { return x + 1 }

a = b /* 改行を含むコメントは改行扱いになる
*/ + c // コンパイルエラー: a = b; + c と解釈される

if x < 0 {
    return -x
}

if x < 0
{
    // コンパイルエラー: if x < 0; と解釈される
}

var x int = 10
var y = 20        // 型推論でint
z := 30           // 短い変数宣言（関数内のみ）

package demo

var count = 0 // OK
// n := 1     // コンパイルエラー: パッケージレベルでは:=不可

x := 1
_ = x

var (
    host = "localhost"
    port = 8080
)

func swap(a, b int) (int, int) { return b, a }
x, y = 1, 2
x, y = swap(x, y) // 2, 1

x, y = y, x

var m map[string]int     // m == nil
// m["x"] = 1            // ハッシュ表が無いのでpanic
m = make(map[string]int) // または m = map[string]int{}
m["x"] = 1

var s []int
s = append(s, 1) // 要素を格納する配列を確保して動く

const Pi = 3.14159
const (
    StatusOK       = 200
    StatusNotFound = 404
)

var limit = 10
// const max = limit              // コンパイルエラー: 変数は定数式に使えない
// const n = len([]int{1, 2, 3})  // コンパイルエラー: スライスの長さは定数にならない
// const now = time.Now()         // コンパイルエラー: 実行時の値は使えない

const (
    Sunday = iota // 0
    Monday        // 1
    Tuesday       // 2
)

const (
    _  = iota             // 0を捨てる
    KB = 1 << (10 * iota) // 1024
    MB                    // 1048576
    GB                    // 1073741824
)

a, b := 1, 2
sum := a + b       // 3
masked := a & b    // 0
ok := a < b        // true
both := true && ok // true

pos := +10     // 10
neg := -10     // -10
on := true
stopped := !on // false
flipped := ^uint8(0b00001100) // 0b11110011

var n int = 10
p := &n
v := *p // 10

ch := make(chan int, 1)
ch <- 1
got := <-ch // 1

a, b := 10, 3
sum := a + b              // 13
joined := "go" + "lang"   // "golang"
diff := a - b             // 7
prod := a * b             // 30
quot := a / b             // 3
negQuot := (-10) / 3      // -3
rem := a % b              // 1

x, y := uint8(0b1100), uint8(0b1010)
bitAnd := x & y           // 8
bitOr := x | y            // 14
bitXor := x ^ y           // 6
bitClear := x &^ y        // 4
shiftLeft := x << 1       // 24
shiftRight := x >> 1      // 6

x, y := 1, 2
isLess := x < y            // true
isLessOrEqual := x <= y    // true
isGreater := x > y         // false
isGreaterOrEqual := x >= y // false
isEqual := x == y          // false
isNotEqual := x != y       // true

// []int{1} == []int{1}                   // コンパイルエラー: スライス同士は比較不可
// map[int]int{1: 1} == map[int]int{1: 1} // コンパイルエラー: マップ同士は比較不可
// func() {} == func() {}                 // コンパイルエラー: 関数同士は比較不可

var pending []int
isNil := pending == nil // true: スライス、マップ、関数はnilと比較可能

func sideEffect(n int) int { return n }

active := true
paused := !active // false

if false && sideEffect(2) == 2 {
    // 左辺がfalseのためsideEffectは評価されない
}

if true || sideEffect(2) == 2 {
    // 左辺がtrueのためsideEffectは評価されない
}

i := 0
i++
i--

// f(i++) // コンパイルエラー: 文のため式の中では使えない

var x int = 1
var y float64 = 2
// z := x + y // コンパイルエラー: 型の異なる変数同士は演算不可
mixed := float64(x) + y
sum := x + 2 // 非型付き定数2はintとして扱われる

n := 1
s := "go"
var err error

// if n { }      // コンパイルエラー: 条件式は真偽値が必要
// if s { }      // コンパイルエラー
// ok := bool(n) // コンパイルエラー: intからboolへの変換は不可

hasN := n != 0       // true
hasS := s != ""      // true
hasErr := err != nil // false

const size = 1 + 2*3
var arr [size]int

n := 1 + 2*3 // 乗算が優先され7になる

x := uint8(0b1100)
n := ^x >> 1 // 単項演算の^xが優先されるため121

func f() int { return 1 }
func g() int { return 2 }

sum := f() + g() // f()の実行後にg()が実行され3になる

var seq int

func next() int {
    seq++
    return seq
}

func sub(a, b int) int { return a - b }

sub(next(), next()) // 左辺が1、右辺が2となり常に-1

n := 1
inc := func() int { n++; return n }
pair := []int{n, inc()} // nの参照とinc()の実行順序が未規定のため[1, 2]または[2, 2]

x := 1
y := 2
{
    fmt.Println(y) // 2
    x := 3
    fmt.Println(x) // 3
}
fmt.Println(x) // 1

x, y := 1, 2
x, z := 3, 4 // xは代入、zは新規

Outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if j == 1 {
            break Outer // 内側も外側も抜け、両方のループを終了
        }
    }
}

Outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if j == 1 {
            continue Outer // 内側を抜け、外側ループの次のiへ
        }
    }
}

i := 0
Again:
    fmt.Println(i)
    i++
    if i < 3 {
        goto Again
    }

decimal := 42
binary := 0b101010
octal := 0o52
hex := 0x2A
withSep := 1_000_000

f := 3.14159
e := 1.5e-10
imag := 2i

var x float64 = 1 // 1はfloat64になる
var y float32 = 2 // 2はfloat32になる

r := 'あ'
newline := '\n'

s := "hello"
raw := `line1
line2`

for i, r := range "Go言語" {
    fmt.Printf("%d: %c\n", i, r)
}

// 0: G
// 1: o
// 2: 言
// 5: 語 // 日本語はUTF-8で1文字が複数バイトのためインデックスが飛ぶ

s := "Go言語"
b := []byte(s)
fmt.Println(b)                // [71 111 232 168 128 232 170 158]
fmt.Println(string(b))        // Go言語

var ch byte = 'A'
var r rune = '語'
fmt.Printf("%T %c\n", ch, ch) // uint8 A
fmt.Printf("%T %c\n", r, r)   // int32 語

s := "hello"
b := []byte(s)
b[0] = 'J'
fmt.Println(s)         // hello
fmt.Println(string(b)) // Jello

b2 := []byte{'h', 'i'}
t := string(b2)
b2[0] = 'H'
fmt.Println(t)          // hi
fmt.Println(string(b2)) // Hi

type Celsius float64   // 型定義: Celsiusはfloat64とは別の型
type ID = int          // 型エイリアス: IDとintは同一型

var i int = 42
f := float64(i)

type Celsius float64
var c Celsius = 100        // OK: 非型付き定数100はCelsiusとして使える
var t float64 = float64(c)

// var x float64 = i       // NG: 型付きのintはfloat64へ代入できない

var p *int      // ゼロ値はnil
fmt.Println(*p) // panic: nilポインタの間接参照

x := 42
p := &x
fmt.Println(*p) // 42
*p = 100
fmt.Println(x)  // 100

x := 42
p := &x
q := p
*q = 7
fmt.Println(x, *p, *q) // 7 7 7

a, b := 1, 1
p, q := &a, &a
r := &b
fmt.Println(p == q) // true（同じ変数a）
fmt.Println(p == r) // false（値は同じでも別の変数）

var emptyA, emptyB struct{}
pa, pb := &emptyA, &emptyB
fmt.Println(pa == pb) // 結果は仕様で決まっていない

n := 10
p := &n                           // OK: 変数
q := &(*p)                        // OK: 間接参照（pは非nil。同じ変数nを指す）
nums := []int{1, 2}
r := &nums[0]                     // OK: スライスの要素
arrLit := &[3]int{1, 2, 3}        // OK: 配列の複合リテラル
sliceLit := &[]int{1, 2}          // OK: スライスの複合リテラル
mapLit := &map[string]int{"a": 1} // OK: マップの複合リテラル

// &10                             // NG: 基本リテラルはアドレスを取れない
const c = 10
// &c                              // NG: 定数はアドレスを取れない
m := map[string]int{"a": 1}
// &m["a"]                         // NG: マップの要素はアドレスを取れない
// &time.Now()                     // NG: 関数の戻り値はアドレスを取れない

// var np *int
// _ = &(*np)                      // NG: nilの間接参照はパニック

func setToZero(n int) { n = 0 }       // コピーされた引数nのみが0になる
func setToZeroPtr(n *int) { *n = 0 }  // *n経由で呼び出し元の変数を0にする

count := 5
setToZero(count)
fmt.Println(count) // 5

setToZeroPtr(&count)
fmt.Println(count) // 0

// 型を渡すとゼロ値へのポインタを返す
pZero := new(int)
fmt.Println(*pZero) // 0

// 式を渡すとその値で初期化されたポインタを返す
pVal := new(42)
fmt.Println(*pVal)  // 42

// new(nil)         // NG: nilはnewの引数にできない

pMap := new(map[string]int)    // *map[string]int（*pMapはnil）
// (*pMap)["key"] = 1          // NG: nilマップへの代入でパニック

m := map[string]int{}          // リテラルで初期化したら書き込み可能
m["key"] = 1

pSlice := new([]int)           // *[]int（*pSliceはnil）
*pSlice = append(*pSlice, 1)   // OK: 戻り値を代入すればappendできる

s := make([]int, 0, 5)         // []int（指定したlenとcap）
ch := make(chan int)           // chan int（送受信できる）

type Point struct {
    X, Y float64
}

var p Point
p.X = 1
fmt.Println(p.X) // 1

type Header struct {
    Flag uint8
    _    [3]byte
    Size uint32
}

p1 := Point{1, 2}        // Pointの値
p2 := Point{X: 1, Y: 2}  // Pointの値
p3 := &Point{X: 1, Y: 2} // *Point

// p3と同じ意味
p := Point{X: 1, Y: 2}
p4 := &p // *Point

type Engine struct{ Power int }
type Car struct {
    Engine
    Model string
}

c := Car{Engine: Engine{Power: 150}, Model: "compact"}
fmt.Println(c.Power)    // 昇格

a := Point{X: 1, Y: 2}
b := Point{X: 1, Y: 2}
fmt.Println(a == b)     // true

c := Point{X: 1, Y: 3}
fmt.Println(a == c)     // false

type Vertex struct {
    X, Y float64
}
// fmt.Println(a == Vertex{X: 1, Y: 2})     // コンパイルエラー: 型が違う
fmt.Println(a == Point(Vertex{X: 1, Y: 2})) // true

type Record struct {
    Tags []string
}
var r1, r2 Record
// fmt.Println(r1 == r2) // コンパイルエラー: 比較できないフィールドがある

var a [3]int
// var b [4]int = a // コンパイルエラー: 型が異なる

arr := [3]int{1, 2, 3}
dup := arr                  // 配列全体のコピー
dup[0] = 0
fmt.Println(arr[0], dup[0]) // 1, 0（元の配列arrは変わらない）

nums := []int{1, 2, 3}
buf := make([]byte, 0, 64) // len=0, cap=64

all := []int{0, 1, 2, 3, 4}
mid := all[1:4]  // midは[1, 2, 3]、len=3

mid[0] = 99
fmt.Println(all) // [0 99 2 3 4]（元配列が書き換わるためall側にも反映される）

fmt.Println(len(mid), cap(mid)) // 3, 4

fullCap := all[1:4:4]                   // len=3, cap=3（max - low = 4 - 1）
fmt.Println(len(fullCap), cap(fullCap)) // 3, 3

all := []int{0, 1, 2, 3, 4}
wide := all[1:4]            // len=3, cap=4（元配列のインデックス4に既に値がある）
wide = append(wide, 9)
fmt.Println(all)            // [0 1 2 3 9]（元配列のall[4]が9で上書きされる）

all = []int{0, 1, 2, 3, 4}
tight := all[1:4:4]         // len=3, cap=3（空き容量なし）
tight = append(tight, 9)    // 新しい配列が別個に確保されてコピーされ、tightの参照先が切り替わる
fmt.Println(all)            // [0 1 2 3 4]（元のallや元配列は影響を受けない）

all := []int{0, 1, 2, 3, 4}
mid := all[1:4]              // [1, 2, 3]
dst := make([]int, len(mid)) // 独立した新しい元配列を確保
copy(dst, mid)               // 要素をコピー

dst[0] = 0
fmt.Println(dst[0], mid[0])  // 0, 1（dstの変更はmidやallに影響しない）

var s []int
fmt.Println(s == nil, len(s), cap(s)) // true 0 0

s = append(s, 10, 20)
fmt.Println(s, s == nil)              // [10 20] false

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

s := []int{1}
append(s, 2)                // 戻り値を捨てるとsのlenは1のまま
s = append(s, 2)            // 再代入することでlen=2になる

v := []int{1}
t := v
t = append(t, 99)           // 変数tのみlen=2に更新
fmt.Println(len(v), len(t)) // 1, 2（vは変化しない）

func grow(s []int) {
    s = append(s, 99)            // 関数内の変数sのみlen=2になる
}

data := make([]int, 1, 2)        // len=1, cap=2
grow(data)
fmt.Println(len(data))           // 1（呼び出し元のスライスのlenは不変）
fmt.Println(data[1])             // 99（capに空きがあったため元配列には書き込まれている）

narrow := []int{1}               // len=1, cap=1
grow(narrow)
fmt.Println(len(narrow), narrow) // 1, [1]（cap不足で別配列に再割り当てされたため影響なし）

rows, cols := 2, 3
matrix := make([][]int, rows)
for i := range matrix {
    matrix[i] = make([]int, cols)
}

// 避けるべき例: 走査中にスライスを変更する
s := []int{1, 2, 3}
for i, v := range s {
    s = append(s, v) // 反復対象や終了条件が不定になる
}

scores := make(map[string]int) // map[string]int{"go": 90} でも初期化可能
scores["go"] = 90
scores["rust"] = 85

fmt.Println(scores["go"]) // 90

v, ok := scores["java"]
fmt.Println(v, ok)        // 0, false（キーが存在しない）

delete(scores, "go")
fmt.Println(scores["go"], scores["rust"]) // 0, 85

var m map[string]int
// m["k"] = 1    // panic: nilマップへの書き込み

v, ok := m["k"] // v=0, ok=false（読み取りは安全）
delete(m, "k")  // キーが存在しなくても安全

scores := map[string]int{"go": 90, "rust": 85, "java": 80}
for lang, score := range scores {
    fmt.Println(lang, score)
}
// 走査を実行するたびに出力順が変わることがある

keys := make([]string, 0, len(scores))
for lang := range scores {
    keys = append(keys, lang)
}
sort.Strings(keys)

for _, lang := range keys {
    fmt.Println(lang, scores[lang]) // go, java, rustの昇順で出力
}

var c Celsius = 36.5
var f float64 = float64(c) // OK
// var f float64 = c       // コンパイルエラー

type Count = int
var n int = 0
var c Count = n // 同一型なので明示的な型変換が不要

type ID int
type UserID ID // UserIDの基底型はint

var a int = 1
var b int = a

var c Celsius = 36.5
var f float64 = float64(c)

var ptr *int = nil
var slice []int = nil
var m map[string]int = nil
var ch chan int = nil
var fn func() = nil
var i any = nil

import (
	"errors"
)
// 組み込みのerrorインターフェースを実装した非インターフェース型が返る
var err error = errors.New("something went wrong")

const limit = 300

var wide int = limit     // OK: 300はintの範囲内
// var tiny int8 = limit // コンパイルエラー: 300はint8の範囲外

const whole = 1.0
var n int = int(whole)          // OK

const frac = 1.5
// var n int = int(frac)        // NG: 1.5は整数として正確に表現できない

const letter = 'A'
var b byte = letter             // OK: 'A'は65でbyteに表現できる
var one string = string(letter) // OK: runeを1文字のstringに変換

const text = "go"
var s string = text             // OK
var bs []byte = []byte(text)    // OK: stringをバイト列に変換
var first byte = text[0]        // OK: 先頭バイト 'g' (103)
// var lone byte = byte(text)   // NG: 文字列全体はbyte1個に表現できない

const max int8 = 127    // OK
// const bad int8 = 300 // NG: 300はint8に表現できない

// 定数の場合はコンパイルエラー
// const x float64 = 1.5
// var y int = int(x)

// 変数の場合はコンパイル可能
var n float64 = 1.5
var m int = int(n) // 切り捨てられて1になる

type Shape interface {
    Area() float64
}

type Shape interface {
    Area() float64
}

type Rect struct{ W, H float64 }

func (r Rect) Area() float64 {
    return r.W * r.H
}

var a Shape = Rect{W: 3, H: 4} // RectがShapeのメソッドを持つので代入可能

type Rect struct{ W, H float64 }
func (r Rect) Area() float64    { return r.W * r.H }
func (r *Rect) Scale(f float64) { r.W *= f; r.H *= f }

type Shape interface { Area() float64 }
type Scaler interface { Scale(float64) }

var a Shape = Rect{}     // OK: RectにAreaがある
// var s Scaler = Rect{} // NG: RectにScaleがない
var s Scaler = &Rect{}   // OK: *RectにScaleがある

type Shape interface { Area() float64 }

type Rect struct{ W, H float64 }
func (r Rect) Area() float64 { return r.W * r.H }

type Frame struct {
    Rect
}

var a Shape = Frame{} // OK: AreaがFrameのメソッド集合に入る

var a Shape
fmt.Println(a == nil) // true

var p *Rect
fmt.Println(p == nil)  // true: ポインタ変数としてはnil

var a2 Shape = p
fmt.Println(a2 == nil) // false: 動的型*Rectがある

type Shape interface {
    Area() float64
}
type Perimer interface {
    Perimeter() float64
}
type Measurer interface {
    Shape
    Perimer
}

type Rect struct{ W, H float64 }
func (r Rect) Area() float64      { return r.W * r.H }
func (r Rect) Perimeter() float64 { return 2 * (r.W + r.H) }

type Circle struct{ R float64 }
func (c Circle) Area() float64 { return 3.14159 * c.R * c.R }

var m Measurer = Rect{}      // OK
var a Shape = Rect{}         // OK
var p Perimer = Rect{}       // OK
// var c Measurer = Circle{} // NG: Perimeterがない

var v any = Rect{W: 3, H: 4}
r, ok := v.(Rect)
if !ok {
    // 動的型がRectでない
    return
}
// ここではrをRectとして使える

func show(x any) {
    switch v := x.(type) {
    case Rect:
        fmt.Println("rect:", v)
    case Circle:
        fmt.Println("circle:", v)
    default:
        fmt.Println("other type")
    }
}

type Shape interface { Area() float64 }
type Scaler interface { Scale(float64) }

type Rect struct{ W, H float64 }
func (r Rect) Area() float64 {
    return r.W * r.H
}
func (r *Rect) Scale(f float64) {
    r.W *= f
    r.H *= f
}

var _ Shape = Rect{}        // OK
// var _ Scaler = Rect{}    // NG: RectにはScaleがない
var _ Scaler = (*Rect)(nil) // OK

func Min[T any](a, b T) T {
    if a < b { // コンパイルエラー: Tがanyでは<が使えない
        return a
    }
    return b
}

import "cmp"

func Min[T cmp.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

n := Min(3, 5)      // 引数からTがintと推論される
m := Min[int](3, 5) // 角括弧で型引数を明示的に指定

type Number interface {
    ~int | ~int64 | ~float64
}

func Sum[T Number](xs []T) T {
    var total T
    for _, x := range xs {
        total += x
    }
    return total
}

type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

var s Stack[int]
s.Push(10)
// s.Push("text") // コンパイルエラー: stringはintに代入できない

func (s Stack[T]) Map[U any](f func(T) U) Stack[U] {
    items := make([]U, len(s.items))
    for i, v := range s.items {
        items[i] = f(v)
    }
    return Stack[U]{items: items}
}

var numbers Stack[int]
numbers.Push(1)
numbers.Push(2)

// intのStackからboolのStackへ変換
flags := numbers.Map(func(v int) bool {
    return v > 0
})

if x < 0 {
    return -x
} else if x == 0 {
    return 0
}
return x

if n, err := strconv.Atoi(s); err != nil {
    return err
} else {
    fmt.Println(n) // nはここまで有効
}
// fmt.Println(n) // コンパイルエラー

for n < 100 {
    n *= 2
}

for {
    if done {
        break
    }
}

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

var prints []func()
for i := 0; i < 3; i++ {
    prints = append(prints, func() { fmt.Println(i) })
}
for _, p := range prints {
    p() // 0 1 2
}

// スライスは添字と値を受け取る
s := []string{"a", "b"}
for i, v := range s {
    fmt.Println(i, v)
}

// マップはキーと値を受け取る。走査順序は決まっていない
m := map[string]int{"x": 1, "y": 2}
for k, v := range m {
    fmt.Println(k, v)
}

// チャネルは受信した値のみを受け取る
ch := make(chan int, 2)
ch <- 10
ch <- 20
close(ch)
for v := range ch {
    fmt.Println(v) // 10 20
}

for i := range 3 {
    fmt.Println(i) // 0 1 2
}

// 呼び出し側に値を渡すイテレータ関数
seq := func(yield func(int) bool) {
    for n := 0; n < 3; n++ {
        if !yield(n) {
            return // 呼び出し側のループ終了を検知し、無駄な処理の継続を防ぐ
        }
    }
}

// イテレータ関数をrangeで走査
for n := range seq {
    fmt.Println(n) // 0 1 2
}

// 値なし
noVal := func(yield func() bool) {
    if !yield() {
        return
    }
}
for range noVal {
    // 反復のみ行う
}

// 1値
singleVal := func(yield func(string) bool) {
    if !yield("hello") {
        return
    }
}
for v := range singleVal {
    fmt.Println(v) // hello
}

// 2値
pairVal := func(yield func(string, int) bool) {
    if !yield("a", 1) {
        return
    }
}
for k, v := range pairVal {
    fmt.Println(k, v) // a 1
}

Outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if j == 1 {
            continue // 内側ループの次の反復へ進む
        }
        if j == 2 {
            break // 内側ループだけを終了して外側の次のiへ進む
        }
        if i == 1 {
            break Outer // 外側ループごと終了する
        }
        fmt.Println(i, j)
    }
}
// 0 0 を出力して終了

switch day {
case "Mon":
    fmt.Println("月曜")
case "Tue", "Wed":
    fmt.Println("火〜水")
default:
    fmt.Println("その他")
}

switch rank {
case 1:
    fmt.Println("金")
    fallthrough
case 2:
    fmt.Println("銀")
case 3:
    fmt.Println("銅")
}
// rankが1のとき: 金と銀を出力
// rankが2のとき: 銀を出力
// rankが3のとき: 銅を出力

switch {
case x < 0:
    fmt.Println("負")
case x == 0:
    fmt.Println("ゼロ")
default:
    fmt.Println("正")
}

switch n, err := strconv.Atoi(input); {
case err != nil:
    fmt.Println("invalid")
case n == 0:
    fmt.Println("zero")
default:
    fmt.Println(n) // nはswitch全体で有効
}
// fmt.Println(n) // コンパイルエラー

func describe(x any) {
    switch v := x.(type) {
    case int:
        fmt.Println("int", v)    // vはint型
    case string:
        fmt.Println("string", v) // vはstring型
    default:
        fmt.Println("other", v)  // vは元のxと同じany型
    }
}

func add(a, b int) int {
    return a + b
}

func mix(a, b int, factor float64) float64 {
    return float64(a+b) * factor
}

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

v, err := divide(10, 2)
if err != nil {
    return err
}

f, err := os.Open(path)
if err != nil {
    return err
}
defer f.Close()

for i := 0; i < 3; i++ {
    defer fmt.Println(i) // 登録時にiが評価される → 終了時に2, 1, 0の順
}

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // この時点のx, yを返す（return x, yと同じ）
}

func scaled() (result int) {
    defer func() {
        result *= 7
    }()
    return 6 // 呼び出し側には42が渡る
}

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum()
sum(1, 2, 3)

func greet(prefix string, names ...string) {}
greet("hi:", []string{"Ann", "Bo"}...)

func replaceFirst(nums ...int) {
    if len(nums) > 0 {
        nums[0] = 0
    }
}

origin := []int{10, 20, 30}
replaceFirst(origin...)
fmt.Println(origin) // [0 20 30] 元のスライスが参照している配列が書き換わる

func twice(n int) int {
    return n * 2
}

var fn func(int) int = twice
z := fn(3) // zは6

add := func(x, y int) int {
    return x + y
}
total := add(1, 2) // 3

n := func(x int) int { return x * 2 }(3) // 6

func counter() func() int {
    n := 0
    return func() int { // この関数リテラルがクロージャ
        n++
        return n
    }
}

next := counter()
v1 := next() // 1
v2 := next() // 2

type Rect struct{ W, H float64 }

func (r Rect) Area() float64 {
    return r.W * r.H
}

type Length float64

func (l Length) Double() Length {
	return l * 2
}

func (r Rect) Area() float64 {
    return r.W * r.H
}

// 呼び出し元の値を書き換えている
func (r *Rect) Scale(f float64) {
    r.W *= f
    r.H *= f
}

type Rect struct{ W, H float64 }
func (r Rect) Area() float64    { return r.W * r.H }
func (r *Rect) Scale(f float64) { r.W *= f; r.H *= f }

r := Rect{W: 3, H: 4}
r.Scale(2)             // コンパイラが (&r).Scale(2) に読み替える
fmt.Println(r.Area())

p := &Rect{W: 3, H: 4}
p.Scale(2)             // ポインタレシーバなのでそのまま呼べる
fmt.Println(p.Area())  // コンパイラが (*p).Area() に読み替える

// Rect{W: 1, H: 1}.Scale(2)       // NG: リテラルはアドレスが取得できない
(&Rect{W: 1, H: 1}).Scale(2)       // OK: &Rect{...}でリテラルから*Rectを作れる（変数に入れないので変更は捨てられる）

rects := map[string]Rect{"a": {}}
// rects["a"].Scale(2)             // NG: mapのインデックス式はアドレスが取得できない
v := rects["a"]
v.Scale(2)
rects["a"] = v                     // 変数に取り出して変更し、mapへ戻す

var p *Rect
// p.Area()   // 値レシーバ: 呼び出し時に(*p)で値コピー → nilポインタデリファレンスでパニック
// p.Scale(2) // ポインタレシーバ: 呼び出しは成功するが、内部でr.Wを参照 → nilポインタデリファレンスでパニック

r := Rect{W: 3, H: 4}
fn := r.Area       // メソッド値: レシーバがあらかじめ結び付いている
fmt.Println(fn())

area := Rect.Area  // メソッド式: レシーバを第1引数で渡す
fmt.Println(area(r))

type Engine struct{}
func (e Engine) Start() {}

type Car struct {
    Engine
}

var c Car
c.Start() // Engine.Start が昇格

f, err := os.Open("file.txt")
if err != nil {
    return err
}
// ここ以降は正常にファイルが開けている前提で処理できる

type error interface {
    Error() string
}

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

return fmt.Errorf("item %d not found", itemID)

return fmt.Errorf("open %s: %w", path, err)

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

wrapped := fmt.Errorf("load config: %w", ErrNotFound)
fmt.Println(errors.Is(wrapped, ErrNotFound)) // true

textOnly := fmt.Errorf("load config: %v", ErrNotFound)
fmt.Println(errors.Is(textOnly, ErrNotFound)) // false

type QueryError struct {
    Query string
    Err   error
}

func (e *QueryError) Error() string {
    return fmt.Sprintf("query %q: %v", e.Query, e.Err)
}

func mayFail(ok bool) error {
    if ok {
        return nil // 成功
    }
    return errors.New("failed")
}

if err := mayFail(true); err != nil {
    // 失敗処理
} else {
    // 成功処理
}

func load() error {
    var perr *os.PathError
    return perr // perrはnilだが、戻り値のerrorは非nil
}

func mustPositive(n int) int {
    if n <= 0 {
        panic("unreachable: positive number required")
    }
    return n
}

func safeDivide(a, b int) (res int, err error) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered:", r)
            err = fmt.Errorf("panic: %v", r)
        }
    }()
    return a / b, nil
}

_, err := safeDivide(10, 0)
fmt.Println(err) // panic: runtime error: integer divide by zero

done := make(chan struct{})
go func() {
    fmt.Println("別のゴルーチンから")
    done <- struct{}{}
}()
fmt.Println("main側")
<-done

go fmt.Println("worker")
// mainがすぐ終わると、workerの出力が欠けることがある

ch := make(chan string)
go func() {
    ch <- "ping" // 送信
}()
msg := <-ch      // 受信
fmt.Println(msg) // ping

ch <- v    // 送信
x := <-ch  // 受信
<-ch       // 値を捨てる受信

ch := make(chan int)
var send chan<- int = ch    // (chan<- int)(ch)でも同じ
var recv <-chan int = ch    // (<-chan int)(ch)でも同じ
go func() { send <- 1 }()
fmt.Println(<-recv)         // OK
// <-send                   // NG: 送信専用から受信できない
// recv <- 1                // NG: 受信専用へ送信できない
// close(recv)              // NG: 受信専用は閉じられない

ch := make(chan int)
go func() {
    ch <- 1    // 受信が来るまでここで待つ
}()
n := <-ch      // 送信が来るまでここで待つ
fmt.Println(n) // 1

ch := make(chan int)
go func() {
    n := <-ch      // 送信が来るまでここで待つ
    fmt.Println(n) // 1
}()
ch <- 1            // 受信が来るまでここで待つ

ch := make(chan int)
ch <- 1 // 受信するゴルーチンがいない → デッドロック

done := make(chan struct{})
go func() {
    fmt.Println("worker")
    done <- struct{}{} // 完了の合図
}()
<-done                 // mainが待つ → workerの出力を見られる

var wg sync.WaitGroup
wg.Go(func() { fmt.Println("worker", 1) })
wg.Go(func() { fmt.Println("worker", 2) })
wg.Wait() // すべてのゴルーチンが終わるまで待つ

var wg sync.WaitGroup
wg.Add(2)
for id := 1; id <= 2; id++ {
    go func(id int) {
        defer wg.Done()
        fmt.Println("worker", id)
    }(id)
}
wg.Wait()

ch := make(chan int, 2)
ch <- 10 // 空きがあるのでブロックされない
ch <- 20
fmt.Println(<-ch, <-ch) // 10 20

ch := make(chan int, 1)
ch <- 1
// ch <- 2 // 受信が無いとここでブロックされる（他に動くゴルーチンがなければデッドロック）

ch := make(chan int)
close(ch)
// ch <- 1 // panic: send on closed channel

ch := make(chan int, 1)
ch <- 7
close(ch)

v, ok := <-ch
fmt.Println(v, ok) // 7 true（バッファに残っていた値）

v, ok = <-ch
fmt.Println(v, ok) // 0 false（空になってもブロックされず、ゼロ値とfalseが返る）

v, ok = <-ch
fmt.Println(v, ok) // 0 false（何度受信しても同じ）

ch := make(chan string, 2)
ch <- "a"
ch <- "b"
close(ch)

for s := range ch {
    fmt.Println(s) // a → b
}

ch1 := make(chan string, 1)
ch2 := make(chan string, 1)
ch1 <- "from ch1"

select {
case msg := <-ch1:
    fmt.Println(msg) // from ch1
case msg := <-ch2:
    fmt.Println(msg)
default:
    fmt.Println("no communication")
}

var message string
var ready bool

go func() {
    message = "done"
    ready = true
}()

for !ready {
    // readyがtrueになるのを待つ
}
fmt.Println(message) // 空文字列が表示される可能性がある

go func() {
    name := ""
    name = "gopher"
    fmt.Println(name) // 同じゴルーチン内なので必ずgopher
}()

name := "gopher"
go func() {
    fmt.Println(name) // 必ずgopher
}()

var name string
go func() {
    name = "gopher"
}()
fmt.Println(name) // 空文字列のことがある

var name string
done := make(chan struct{})
go func() {
    name = "gopher"
    done <- struct{}{}
}()
<-done
fmt.Println(name) // 必ずgopher

var name string
done := make(chan struct{})
go func() {
    name = "gopher"
    close(done)
}()
<-done
fmt.Println(name) // 必ずgopher

var name string
done := make(chan struct{}, 1)
go func() {
    name = "gopher"
    <-done
}()
done <- struct{}{}
fmt.Println(name) // 空文字列のことがある

var name string
done := make(chan struct{}, 1)
go func() {
    name = "gopher"
    <-done
}()
done <- struct{}{}
done <- struct{}{}
fmt.Println(name) // 必ずgopher

var counter int

go func() {
    counter++
}()

fmt.Println(counter) // データ競合: 0か1かは決まらない

go test -race ./...
go run -race main.go

var (
    mu sync.Mutex
    n  int
)

mu.Lock()
go func() {
    defer mu.Unlock()
    n++
}()
mu.Lock()
fmt.Println(n) // 必ず1
mu.Unlock()

mkdir demo
cd demo
go mod init example.com/demo

module example.com/demo

go 1.26

// greeter/greet.go
package greeter

func Hello(name string) string {
    return "hello, " + name
}

// main.go
package main

import (
    "fmt"

    "example.com/demo/greeter"
)

func main() {
    fmt.Println(greeter.Hello("Go"))
}

import "fmt"

import (
    "errors"
    myio "io"
    _ "image/png"
)

import . "fmt"

func main() {
    Println("hello") // fmt.Println("hello")と同じ
}

// greeter/greet.go
package greeter

func Hello(name string) string {
    return "hello, " + name
}

import "example.com/demo/greeter" // importするときはディレクトリ名

greeter.Hello("Go")               // 呼び出すときはpackage名

package greeter

func Hello() string { // 他パッケージから呼べる
    return hello()
}

func hello() string { // 同じパッケージ内だけ
    return "hello"
}

import "example.com/demo/greeter"

greeter.Hello()
// greeter.hello() // コンパイルエラー: 小文字は他パッケージから見えない

// ParseConfigは設定ファイルを読み込む。
func ParseConfig(path string) (*Config, error) {
    // ...
}

// このコメントはドキュメントにならない

func other() {}

// Statusは処理の状態です。
type Status int

const (
    Ready   Status = 1 // 準備完了
    Running Status = 2 // 実行中
)

// Serverは待ち受け設定です。
type Server struct {
    Host string // 待ち受けホスト
    Port int    // 待ち受けポート
}

func init() {
    log.SetFlags(log.LstdFlags)
}

gofmt -w main.go

go fmt ./...

// greeter/greet_test.go
package greeter

import "testing"

func TestHello(t *testing.T) {
    if Hello("Go") != "hello, Go" {
        t.Fatal("unexpected greeting")
    }
}

// greeter/greet_ext_test.go
package greeter_test

import (
    "testing"

    "example.com/demo/greeter"
)

func TestHello(t *testing.T) {
    if greeter.Hello("Go") != "hello, Go" {
        t.Fatal("unexpected greeting")
    }
    // greeter.hello() // コンパイルエラー: 他パッケージからは見えない
}

go get rsc.io/quote

package main

import (
    "fmt"

    "rsc.io/quote"
)

func main() {
    fmt.Println(quote.Hello())
}

go run .

module example.com/demo

go 1.26

require rsc.io/quote v1.5.2

import "rsc.io/quote"

go mod tidy

go get rsc.io/[email protected]
go get rsc.io/quote@latest

go get rsc.io/quote/v3@latest

import "rsc.io/quote/v3"

quote.HelloV3()

go install .

go install golang.org/x/tools/cmd/stringer@latest
stringer -help