フリーキーズ | 独学プログラミング
技術コンテンツ転職フリーランスツール用語集ゲームタグ一覧

Go言語の関数と戻り値・可変長引数を初心者にもわかりやすく解説！基礎からベストプラクティスまで

Go言語

最終更新

リンドくん

リンドくん

先生、Go言語の関数ってどう書くんですか？他の言語とは違うって聞いたんですが...

たなべ

たなべ

たしかにGo言語の関数は確かに他の言語と少し違った特徴があるんだ。
特に複数の戻り値やエラーハンドリングの仕組みは、Go言語の大きな特徴の一つなんだよ。

プログラミングを学んでいる方の中で、Go言語に興味を持っている方は多いのではないでしょうか？
Go言語は、Googleが開発したモダンなプログラミング言語で、シンプルさと高いパフォーマンスを両立していることで人気を集めています。

この記事では、Go言語を学び始めたばかりの方に向けて、関数の定義方法、戻り値の扱い方、そして可変長引数について、基礎から実践的な使い方まで詳しく解説していきます。

プログラミング学習でお悩みの方へ

HackATAは、エンジニアを目指す方のためのプログラミング学習コーチングサービスです。 経験豊富な現役エンジニアがあなたの学習をサポートします。

✓ 質問し放題

✓ β版公開中（2025年内の特別割引）

HackATAの詳細を見る

Go言語の関数基本構文 - シンプルで読みやすい設計

リンドくん

リンドくん

まず基本的な関数の書き方から教えてもらえますか？

たなべ

たなべ

もちろん！Go言語の関数は非常にシンプルな構文になっているんだ。
まずは基本的な形から見ていこう。

Go言語の関数は、直感的で読みやすい構文が特徴です。基本的な構文は以下のようになります。

func 関数名(引数名 引数の型) 戻り値の型 {
    // 処理内容
    return 戻り値
}

実際の例で見てみよう

まずは、最もシンプルな関数から始めてみましょう。

package main

import "fmt"

// 基本的な関数の例
func greet(name string) string {
    return "Hello, " + name + "!"
}

func main() {
    message := greet("たなべ")
    fmt.Println(message) // Hello, たなべ! と出力
}

この例では、greetという関数が文字列型の引数nameを受け取り、文字列型の値を返しています。

引数なし、戻り値なしの関数

func sayHello() {
    fmt.Println("こんにちは！")
}

func main() {
    sayHello() // こんにちは！ と出力
}

戻り値がない場合は、戻り値の型を省略できます。これは他の言語でいうvoid関数に相当します。

複数の引数を持つ関数

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

// 同じ型の引数は省略して書ける
func multiply(a, b int) int {
    return a * b
}

func main() {
    result1 := add(5, 3)        // 8
    result2 := multiply(4, 7)   // 28
    fmt.Println(result1, result2)
}

Go言語では、同じ型の引数が連続する場合、型の記述を省略できるという便利な機能があります。

複数戻り値とエラーハンドリング - Go言語の強力な特徴

リンドくん

リンドくん

Go言語は複数の値を返せるって聞いたんですが、どういうことですか？

たなべ

たなべ

そう！これがGo言語の最も特徴的な機能の一つなんだ。
特にエラーハンドリングにおいて非常に強力で、安全なプログラムを書きやすくしてくれるんだよ。

Go言語の最も特徴的な機能の一つが、複数の戻り値を返せることです。これにより、計算結果とエラー情報を同時に返すことができます。

基本的な複数戻り値の例

package main

import "fmt"

// 割り算を行い、結果とエラーを返す関数
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("0で割ることはできません")
    }
    return a / b, nil
}

func main() {
    // 正常なケース
    result1, err1 := divide(10, 2)
    if err1 != nil {
        fmt.Println("エラー:", err1)
    } else {
        fmt.Println("結果:", result1) // 結果: 5
    }

    // エラーケース
    result2, err2 := divide(10, 0)
    if err2 != nil {
        fmt.Println("エラー:", err2) // エラー: 0で割ることはできません
    } else {
        fmt.Println("結果:", result2)
    }
}

名前付き戻り値 - より読みやすいコードのために

Go言語では、戻り値に名前を付けることができます。これにより、コードがより読みやすくなります。

// 名前付き戻り値を使用した例
func calculate(a, b int) (sum int, difference int, product int) {
    sum = a + b
    difference = a - b
    product = a * b
    return // 明示的に値を指定しなくても、名前付き変数が返される
}

func main() {
    s, d, p := calculate(10, 3)
    fmt.Printf("和: %d, 差: %d, 積: %d\n", s, d, p)
    // 和: 13, 差: 7, 積: 30
}

実践的なエラーハンドリングの例

package main

import (
    "fmt"
    "strconv"
)

// 文字列を整数に変換し、結果とエラーを返す
func parseAndDouble(s string) (int, error) {
    num, err := strconv.Atoi(s)
    if err != nil {
        return 0, fmt.Errorf("文字列'%s'を整数に変換できません: %v", s, err)
    }
    return num * 2, nil
}

func main() {
    testStrings := []string{"123", "abc", "456"}
    
    for _, str := range testStrings {
        result, err := parseAndDouble(str)
        if err != nil {
            fmt.Println("エラー:", err)
        } else {
            fmt.Printf("'%s'の2倍は%dです\n", str, result)
        }
    }
}

このように、Go言語の複数戻り値機能は、エラーの発生可能性がある処理を安全に扱うために非常に有用です。

可変長引数

リンドくん

リンドくん

引数の個数が決まっていない関数も作れるんですか？

たなべ

たなべ

Go言語では可変長引数という機能があって、引数の個数を柔軟に扱えるんだ。
これを使うと、より使いやすい関数を作ることができるよ。

Go言語では、可変長引数を使用することで、任意の数の引数を受け取る関数を作成できます。これは...を使って表現します。

基本的な可変長引数の使い方

package main

import "fmt"

// 可変長引数を使った合計計算関数
func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    // 様々な個数の引数で呼び出し可能
    fmt.Println(sum(1, 2, 3))           // 6
    fmt.Println(sum(1, 2, 3, 4, 5))     // 15
    fmt.Println(sum(10))                // 10
    fmt.Println(sum())                  // 0
}

文字列の可変長引数の例

// 複数の文字列を結合する関数
func joinStrings(separator string, strings ...string) string {
    if len(strings) == 0 {
        return ""
    }
    
    result := strings[0]
    for i := 1; i < len(strings); i++ {
        result += separator + strings[i]
    }
    return result
}

func main() {
    result1 := joinStrings(", ", "りんご", "みかん", "ばなな")
    fmt.Println(result1) // りんご, みかん, ばなな
    
    result2 := joinStrings(" - ", "Go", "Python", "JavaScript")
    fmt.Println(result2) // Go - Python - JavaScript
}

スライスを可変長引数として渡す

既存のスライスを可変長引数として渡すことも可能です。

func findMax(numbers ...int) int {
    if len(numbers) == 0 {
        return 0
    }
    
    max := numbers[0]
    for _, num := range numbers {
        if num > max {
            max = num
        }
    }
    return max
}

func main() {
    // 直接引数として渡す
    fmt.Println(findMax(3, 1, 4, 1, 5, 9)) // 9
    
    // スライスを展開して渡す
    numbers := []int{2, 7, 1, 8, 2, 8}
    fmt.Println(findMax(numbers...)) // 8
}

混合引数と可変長引数

通常の引数と可変長引数を組み合わせることも可能です。ただし、可変長引数は必ず最後に配置する必要があります。

// ログレベルとメッセージを受け取るログ関数
func log(level string, messages ...string) {
    fmt.Printf("[%s] ", level)
    for i, msg := range messages {
        if i > 0 {
            fmt.Print(" | ")
        }
        fmt.Print(msg)
    }
    fmt.Println()
}

func main() {
    log("INFO", "アプリケーションが開始されました")
    log("ERROR", "データベース接続エラー", "再試行します", "しばらくお待ちください")
}

関数型とクロージャ - Go言語の高度な機能

関数を変数として扱う

Go言語では、関数も値として扱うことができます。これにより、関数を変数に代入したり、他の関数の引数として渡したりできます。

package main

import "fmt"

// 関数型を定義
type Calculator func(int, int) int

// 各種計算関数
func add(a, b int) int {
    return a + b
}

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

// 関数を引数として受け取る関数
func calculate(a, b int, op Calculator) int {
    return op(a, b)
}

func main() {
    // 関数を変数に代入
    var operation Calculator
    operation = add
    fmt.Println(operation(5, 3)) // 8

    operation = subtract
    fmt.Println(operation(5, 3)) // 2

    // 関数を直接渡すことも可能
    fmt.Println(calculate(10, 4, add))      // 14
    fmt.Println(calculate(10, 4, subtract)) // 6
}

クロージャ（無名関数）の活用

// クロージャを返す関数
func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    counter1 := makeCounter()
    counter2 := makeCounter()
    
    fmt.Println(counter1()) // 1
    fmt.Println(counter1()) // 2
    fmt.Println(counter2()) // 1
    fmt.Println(counter1()) // 3
}

このように、クロージャを使うことで状態を保持する関数を作成できます。

実践的な関数設計のベストプラクティス

リンドくん

リンドくん

実際にプロジェクトで関数を書くときに気をつけることはありますか？

たなべ

たなべ

とても重要な質問だね！
保守しやすいコードを書くためには、いくつかのベストプラクティスがあるんだ。実践的なテクニックを紹介するよ。

実際の開発においては、ただ動くだけでなく、保守しやすく理解しやすい関数を書くことが重要です。

単一責任の原則

一つの関数は一つのことだけを行うべきです。

// 悪い例: 複数の責任を持つ関数
func processUserData(name, email string, age int) {
    // バリデーション
    if name == "" || email == "" || age < 0 {
        fmt.Println("無効なデータです")
        return
    }
    
    // データベース保存
    fmt.Println("データベースに保存中...")
    
    // メール送信
    fmt.Println("ウェルカムメール送信中...")
}

// 良い例: 責任を分離した関数群
func validateUser(name, email string, age int) error {
    if name == "" {
        return fmt.Errorf("名前が空です")
    }
    if email == "" {
        return fmt.Errorf("メールアドレスが空です")
    }
    if age < 0 {
        return fmt.Errorf("年齢が無効です")
    }
    return nil
}

func saveUserToDB(name, email string, age int) error {
    // データベース保存処理
    fmt.Println("ユーザーをデータベースに保存しました")
    return nil
}

func sendWelcomeEmail(email string) error {
    // メール送信処理
    fmt.Printf("ウェルカムメールを %s に送信しました\n", email)
    return nil
}

func registerUser(name, email string, age int) error {
    if err := validateUser(name, email, age); err != nil {
        return err
    }
    
    if err := saveUserToDB(name, email, age); err != nil {
        return err
    }
    
    if err := sendWelcomeEmail(email); err != nil {
        return err
    }
    
    return nil
}

適切なエラーハンドリング

package main

import (
    "fmt"
    "os"
)

// ファイルサイズを取得する関数
func getFileSize(filename string) (int64, error) {
    file, err := os.Open(filename)
    if err != nil {
        return 0, fmt.Errorf("ファイルを開けませんでした: %w", err)
    }
    defer file.Close() // 確実にファイルを閉じる
    
    info, err := file.Stat()
    if err != nil {
        return 0, fmt.Errorf("ファイル情報を取得できませんでした: %w", err)
    }
    
    return info.Size(), nil
}

func main() {
    size, err := getFileSize("example.txt")
    if err != nil {
        fmt.Printf("エラー: %v\n", err)
        return
    }
    fmt.Printf("ファイルサイズ: %dバイト\n", size)
}

設定可能な関数の設計

オプション引数が多い場合は、構造体を使って設定可能にします。

// HTTPクライアントの設定
type HTTPConfig struct {
    Timeout    int
    Retries    int
    UserAgent  string
    EnableLogs bool
}

// デフォルト設定を返す関数
func DefaultHTTPConfig() HTTPConfig {
    return HTTPConfig{
        Timeout:    30,
        Retries:    3,
        UserAgent:  "MyApp/1.0",
        EnableLogs: false,
    }
}

// HTTP リクエストを送信する関数
func sendRequest(url string, config HTTPConfig) error {
    fmt.Printf("送信中: %s (Timeout: %d秒, Retries: %d回)\n", 
        url, config.Timeout, config.Retries)
    
    if config.EnableLogs {
        fmt.Printf("User-Agent: %s\n", config.UserAgent)
    }
    
    return nil
}

func main() {
    // デフォルト設定を使用
    config := DefaultHTTPConfig()
    sendRequest("https://example.com", config)
    
    // カスタム設定
    customConfig := HTTPConfig{
        Timeout:    60,
        Retries:    5,
        UserAgent:  "CustomApp/2.0",
        EnableLogs: true,
    }
    sendRequest("https://api.example.com", customConfig)
}

まとめ

リンドくん

リンドくん

Go言語の関数、思っていたより奥が深いんですね！

たなべ

たなべ

そうなんだ！特に複数戻り値とエラーハンドリングの組み合わせは、安全なプログラムを書くための強力な武器になるよ。
これからもたくさん練習して、実際のプロジェクトで活用してみてね！

この記事では、Go言語の関数について基礎から実践的な使い方まで詳しく解説してきました。

重要なポイントをおさらいしましょう。

  • シンプルで読みやすい構文 - Go言語の関数は直感的で理解しやすい
  • 複数戻り値とエラーハンドリング - 安全なプログラムを書くための強力な機能
  • 可変長引数 - 柔軟で使いやすい関数を設計できる
  • 関数型とクロージャ - より高度な関数プログラミングが可能
  • ベストプラクティス - 保守しやすいコードを書くための実践的なテクニック

Go言語の関数機能は、シンプルでありながら非常に強力です。
特に複数戻り値によるエラーハンドリングは、他の言語にはないGo言語独特の特徴で、安全で信頼性の高いプログラムを書くのに大いに役立ちます。

プログラミング学習を続ける上で、関数はコードの再利用性と保守性を高める重要な要素です。
今回学んだ内容を実際のプロジェクトで活用し、Go言語の魅力を存分に体験してみてください。

この記事をシェア

関連するコンテンツ
Go言語のtestingパッケージでユニットテスト入門！初心者でもわかる基本とベストプラクティス

Go言語のtestingパッケージでユニットテスト入門！初心者でもわかる基本とベストプラクティス

Go言語

2025/08/20

Go言語のcontextで学ぶGraceful Shutdownとタイムアウト処理

Go言語のcontextで学ぶGraceful Shutdownとタイムアウト処理

Go言語

2025/08/19

Go言語のチャネルとは？ゴルーチン間通信をマスターして同期処理を理解しよう

Go言語のチャネルとは？ゴルーチン間通信をマスターして同期処理を理解しよう

Go言語

2025/08/18

Go言語のGoroutineで並行処理を始める！初心者でもわかる基本を解説

Go言語のGoroutineで並行処理を始める！初心者でもわかる基本を解説

Go言語

2025/08/15

Go言語ジェネリクス入門！型パラメータの書き方を初心者向けに解説

Go言語ジェネリクス入門！型パラメータの書き方を初心者向けに解説

Go言語

2025/08/14

Go言語のerror型とエラーハンドリングの慣習！初心者向けガイド

Go言語のerror型とエラーハンドリングの慣習！初心者向けガイド

Go言語

2025/08/13