Go言語の関数とメソッドについて解説

package main
import "fmt"
// PrintHello は「こんにちは、Go言語！」と出力する関数サンプル
func PrintHello() {
    fmt.Println("こんにちは、Go言語！")
}
func main() {
    // PrintHello関数を呼び出して動作を確認
    PrintHello()
}

こんにちは、Go言語！

package main
import "fmt"
// Sum は2つの整数を受け取り、その和を返す関数サンプル
func Sum(a int, b int) int {
    return a + b
}
func main() {
    result := Sum(3, 5) // 3と5の和を計算
    fmt.Println("和:", result)
}

和: 8

package main
import "fmt"
// Divide は2つの整数を受け取り、商と余りを名前付き戻り値で返す関数サンプル
func Divide(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return // 名前付き戻り値なので返す値を指定せずにreturn可能
}
func main() {
    q, r := Divide(10, 3)
    fmt.Println("商:", q, "余り:", r)
}

商: 3 余り: 1

package main
import "fmt"
// getCounter は無名関数を返すクロージャのサンプルです
func getCounter() func() int {
    counter := 0
    // 無名関数が変数counterをキャプチャ
    return func() int {
        counter++ // クロージャ内でcounterを更新
        return counter
    }
}
func main() {
    counterFunc := getCounter()
    fmt.Println("カウント:", counterFunc()) // 1
    fmt.Println("カウント:", counterFunc()) // 2
}

カウント: 1
カウント: 2

package main
import "fmt"
// Person は人物情報を表す構造体サンプル
type Person struct {
    Name string
}
// Greet はPerson型のレシーバーを持つメソッドサンプル
func (p Person) Greet() {
    fmt.Println("こんにちは、", p.Name, "さん！")
}
func main() {
    p := Person{Name: "Taro"}
    p.Greet()
}

こんにちは、 Taro さん！

package main
import "fmt"
// Counter はカウンターの値を保持する構造体サンプル
type Counter struct {
    Value int
}
// Increment はポインタレシーバーでカウンターの値を更新するメソッドサンプル
func (c *Counter) Increment() {
    c.Value++
}
// Display は値レシーバーでカウンターの状態を表示するメソッドサンプル
func (c Counter) Display() {
    fmt.Println("現在の値:", c.Value)
}
func main() {
    counter := Counter{Value: 5}
    counter.Display()
    counter.Increment() // ポインタレシーバーを用いて値を変更
    counter.Display()
}

現在の値: 5
現在の値: 6

package main
import "fmt"
// Rectangle は長方形の情報を保持する構造体サンプル
type Rectangle struct {
    Width  float64
    Height float64
}
// Area はRectangle型の面積を計算するメソッドサンプル
func (rec Rectangle) Area() float64 {
    return rec.Width * rec.Height
}
func main() {
    rect := Rectangle{Width: 4.0, Height: 5.0}
    area := rect.Area()
    fmt.Println("面積:", area)
}

面積: 20

package main
import "fmt"
// Book は本の情報を表す構造体サンプル
type Book struct {
    Title  string
    Author string
}
// Summary はBook型の概要を表示するメソッドサンプル
func (b Book) Summary() {
    fmt.Println("『", b.Title, "』は", b.Author, "による作品です")
}
func main() {
    book := Book{Title: "Go入門", Author: "山田太郎"}
    book.Summary()
}

『 Go入門 』は 山田太郎 による作品です

package main
import "fmt"
// Speaker は話す機能を表すインターフェースサンプル
type Speaker interface {
    Speak()
}
// Animal は動物を表す構造体サンプル
type Animal struct {
    Name string
}
// Speak はAnimal型がSpeakerインターフェースを満たすためのメソッドサンプル
func (a Animal) Speak() {
    fmt.Println(a.Name, "は鳴いています")
}
func main() {
    var s Speaker
    s = Animal{Name: "犬"}
    s.Speak()
}

犬 は鳴いています

package main
import (
    "fmt"
    "sync"
)
// Processor は処理を実行する構造体サンプル
type Processor struct {
    ID int
}
// Process はProcessor型が実行する処理のサンプルメソッド
func (p Processor) Process() {
    fmt.Println("Processor", p.ID, "が処理を実行中")
}
// Execute は複数のProcessorのProcessメソッドを並行実行する関数サンプル
func Execute(processors []Processor) {
    var wg sync.WaitGroup
    for _, processor := range processors {
        wg.Add(1)
        // goroutine内で各ProcessorのProcessメソッドを呼び出す
        go func(proc Processor) {
            defer wg.Done()
            proc.Process()
        }(processor)
    }
    wg.Wait()
}
func main() {
    processors := []Processor{
        {ID: 1},
        {ID: 2},
        {ID: 3},
    }
    Execute(processors)
}

Processor 1 が処理を実行中
Processor 2 が処理を実行中
Processor 3 が処理を実行中

package main
import (
    "errors"
    "fmt"
)
// Divider は除算処理を行う構造体サンプル
type Divider struct{}
// DivideWithError はエラー処理付きで除算を行うメソッドサンプル
func (d Divider) DivideWithError(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("0で割ることはできません")
    }
    return a / b, nil
}
func main() {
    d := Divider{}
    result, err := d.DivideWithError(10, 0)
    if err != nil {
        fmt.Println("エラー:", err)
    } else {
        fmt.Println("結果:", result)
    }
}

エラー: 0で割ることはできません

package main
import "fmt"
// CreateSlice は事前に容量を指定してスライスを初期化するサンプル関数です
func CreateSlice(n int) []int {
    // スライスを長さ0、容量nで初期化
    s := make([]int, 0, n)
    for i := 0; i < n; i++ {
        s = append(s, i)
    }
    return s
}
func main() {
    slice := CreateSlice(5)
    fmt.Println("スライス:", slice)
}

スライス: [0 1 2 3 4]

package main
import "fmt"
import "testing"
// Sum は2つの整数の和を計算する関数サンプルです
func Sum(a, b int) int {
    return a + b
}
// TestSum はSum関数の動作を検証するテスト関数サンプルです
func TestSum(t *testing.T) {
    expected := 8
    result := Sum(3, 5)
    if result != expected {
        t.Errorf("Sum(3,5) = %d; 期待値は %d", result, expected)
    }
}
func main() {
    // ユニットテストはgo testで実行するため、ここではSum関数の結果を表示
    result := Sum(3, 5)
    fmt.Println("Sumの結果:", result)
}

Sumの結果: 8

package main
import "fmt"
// StateHolder は内部状態を持つ構造体サンプルです
type StateHolder struct {
    Value int
}
// Increase はStateHolderのValueを1増加させるメソッドサンプルです
func (s *StateHolder) Increase() {
    s.Value++
}
func main() {
    // テスト1：初期状態からIncreaseを1回実行
    test1 := &StateHolder{Value: 0}
    test1.Increase()
    fmt.Println("テスト1の結果:", test1.Value)
    // テスト2：初期状態からIncreaseを2回実行
    test2 := &StateHolder{Value: 0}
    test2.Increase()
    test2.Increase()
    fmt.Println("テスト2の結果:", test2.Value)
}

テスト1の結果: 1
テスト2の結果: 2

package main
import (
    "log"
)
// ProcessData は入力データを倍にして返す処理のサンプルです
func ProcessData(data int) int {
    log.Println("処理開始 データ:", data)
    result := data * 2
    log.Println("処理終了 結果:", result)
    return result
}
func main() {
    // ProcessData関数の結果を確認
    result := ProcessData(10)
    log.Println("最終結果:", result)
}

2023/10/05 12:00:00 処理開始 データ: 10
2023/10/05 12:00:00 処理終了 結果: 20
2023/10/05 12:00:00 最終結果: 20

package main
import "fmt"
// beforeRefactor はリファクタリング前の例として、直接計算を行う関数サンプルです
func beforeRefactor(a int, b int) int {
    sum := a + b
    // 複雑な処理がここにあったと仮定
    return sum
}
// afterRefactor は共通の計算処理を関数化したリファクタリング後の例です
func afterRefactor(a int, b int) int {
    return computeSum(a, b)
}
// computeSum は共通の計算処理を担当する関数サンプルです
func computeSum(a int, b int) int {
    return a + b
}
func main() {
    a, b := 5, 7
    fmt.Println("リファクタリング前:", beforeRefactor(a, b))
    fmt.Println("リファクタリング後:", afterRefactor(a, b))
}

リファクタリング前: 12
リファクタリング後: 12