Go言語の可変長引数（Variadic Functions）を徹底解説！「golang programs」の疑問を解消

はじめに (対象読者・この記事でわかること)

この記事は、プログラミング言語Goの学習を始めたばかりの方、特に「golang programs」というチュートリアルサイトで「Variadic Functions」（可変長引数）のセクションにつまずいてしまった方を対象としています。

この記事を読むことで、以下のことがわかるようになります。

Go言語における可変長引数とは何か、その基本的な概念
可変長引数を持つ関数の定義方法と呼び出し方
可変長引数として渡された要素（スライスや配列）へのアクセス方法
「golang programs」の「Variadic Functions」で説明されている内容の具体的な理解
可変長引数を効果的に活用するためのヒント

Go言語はシンプルで強力な言語ですが、可変長引数のような概念は、最初は少し戸惑うかもしれません。この記事では、図解や具体的なコード例を交えながら、丁寧に解説していきますので、安心して読み進めてください。

Go言語の可変長引数（Variadic Functions）とは？

Go言語における可変長引数とは、関数を呼び出す際に、引数の個数が固定されていないことを意味します。通常、関数を定義する際には、引数の数や型を具体的に指定しますが、可変長引数を利用すると、0個以上の引数を受け取れるように関数を定義できます。

これは、例えば「複数の数値を合計する関数」や「任意の数の文字列を連結する関数」などを実装したい場合に非常に便利です。毎回引数の数を変更して関数をオーバーロードする（同じ名前の関数を複数定義する）必要がなく、コードの可読性と保守性を向上させることができます。

可変長引数の宣言方法

Go言語で可変長引数を宣言するには、引数名の前に ...（三点リーダー）を付けます。この ... の後に引数の型を指定します。

Go

func sum(numbers ...int) int {
    // ... 関数本体 ...
}

上記の例では、numbers という名前の引数が、int 型の可変長引数として定義されています。関数内部では、この numbers は []int（int型のスライス）として扱われます。つまり、sum 関数は0個以上のint型の引数を受け取ることができ、関数内ではそれらをスライスとして操作できます。

可変長引数を持つ関数の呼び出し方

可変長引数を持つ関数を呼び出す際は、通常の関数のように引数をカンマ区切りで渡します。

Go

// numbers が []int{1, 2, 3} として扱われる
total := sum(1, 2, 3)

// 引数なしで呼び出すことも可能（numbers は空のスライス []int{} として扱われる）
total = sum()

また、既存のスライスや配列を可変長引数として渡したい場合は、スライスの後ろに ... を付けて展開する必要があります。

Go

nums := []int{10, 20, 30, 40}
// nums スライスを展開して sum 関数に渡す
total = sum(nums...)

この nums... という記法は、スライスの要素を個別の引数として関数に渡したい場合に不可欠です。

関数内部での可変長引数の扱い

関数内部では、可変長引数として受け取った ...T（Tは型）は、[]T（T型のスライス）として扱われます。そのため、ループ処理などで各要素にアクセスしたり、スライスのメソッドを利用したりすることができます。

Go

func greet(names ...string) {
    if len(names) == 0 {
        fmt.Println("こんにちは！")
        return
    }
    fmt.Print("こんにちは、")
    for i, name := range names {
        fmt.Print(name)
        if i < len(names)-1 {
            fmt.Print("、")
        }
    }
    fmt.Println("さん！")
}

greet("Alice", "Bob", "Charlie") // 出力: こんにちは、Alice、Bob、Charlieさん！
greet("David")                 // 出力: こんにちは、Davidさん！
greet()                        // 出力: こんにちは！

myNames := []string{"Eve", "Frank"}
greet(myNames...)              // 出力: こんにちは、Eve、Frankさん！

この例では、greet 関数は任意の数の文字列引数を受け取り、それらを連結して挨拶文を出力します。names は関数内で []string として扱われ、len() 関数で要素数を確認したり、range を使って各要素にアクセスしたりしています。

golang programs の「Variadic Functions」の段落を深く理解する

「golang programs」の「Variadic Functions」のセクションで、具体的にどの部分が理解しづらかったでしょうか？一般的に、可変長引数において初心者の方がつまずきやすいポイントは、以下の2点です。

関数内部で ...T が []T（スライス）として扱われることへの違和感。
既存のスライスを可変長引数として渡す際に ... を付ける操作。

これらの点について、さらに掘り下げて解説します。

1. `...T` はスライス `[]T` であるという事実

「golang programs」のチュートリアルでも、可変長引数として受け取った names ...string は、関数内部では []string 型のスライスになる、と説明されているはずです。この「スライスになる」ということが、なぜ重要なのでしょうか。

Go言語では、スライスは非常に強力で汎用的なデータ構造です。スライスには、要素の追加 (append)、部分スライスの取得、長さの取得 (len)、容量の取得 (cap) といった多くの便利な操作が用意されています。可変長引数がスライスとして扱われるということは、これらのスライスの機能をそのまま利用できるということです。

もし可変長引数がスライスとして扱われない場合、関数内で各引数を個別に処理するための独自の仕組みが必要になり、コードは煩雑になります。しかし、Go言語は「可変長引数はスライス」というシンプルなルールで、この問題を解決しています。

具体的なコード例で確認:

Go

package main

import "fmt"

// 可変長引数を受け取る関数
func printTypes(args ...interface{}) { // interface{} はどんな型でも受け取れる
    fmt.Printf("args の型: %T\n", args) // ここで args の型を確認
    for i, arg := range args {
        fmt.Printf("args[%d] の型: %T, 値: %v\n", i, arg, arg)
    }
}

func main() {
    fmt.Println("--- printTypes(1, \"hello\", true) を呼び出し ---")
    printTypes(1, "hello", true) // 3つの引数を渡す

    fmt.Println("\n--- printTypes() を呼び出し ---")
    printTypes() // 引数なしで呼び出す

    fmt.Println("\n--- スライスを展開して呼び出し ---")
    mySlice := []interface{}{"world", 123.45}
    printTypes(mySlice...) // スライスを展開して渡す
}

このコードの出力結果:

--- printTypes(1, "hello", true) を呼び出し ---
args の型: []interface {}
args[0] の型: int, 値: 1
args[1] の型: string, 値: hello
args[2] の型: bool, 値: true

--- printTypes() を呼び出し ---
args の型: []interface {}

--- スライスを展開して呼び出し ---
args の型: []interface {}
args[0] の型: string, 値: world
args[1] の型: float64, 値: 123.45

解説:

printTypes 関数では、args ...interface{} と定義しています。interface{} はGo言語で最も汎用的な型であり、どんな型の値でも受け取ることができます。
fmt.Printf("args の型: %T\n", args) の出力を見ると、args が常に []interface {} という「interface{} 型のスライス」であることがわかります。これは、可変長引数が関数内部でスライスとして扱われていることの直接的な証拠です。
range args を使って、スライスの各要素にアクセスし、その型と値を出力しています。
mySlice... のようにスライスを展開して関数に渡した場合でも、関数内部では args がスライスとして扱われ、展開された要素がそのスライスの要素として格納されます。

このように、可変長引数を受け取った変数は、Go言語の標準的なデータ構造である「スライス」として振る舞うため、慣れ親しんだスライスの操作方法で扱うことができるのです。

2. 既存のスライスを可変長引数として渡す際の `...` 展開

もう一つのつまずきやすいポイントは、すでに存在するスライスを可変長引数として渡す際の ... 展開です。

例えば、sum 関数を定義したとします。

Go

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

ここで、myNumbers という int 型のスライスがあり、その要素を sum 関数に渡したいとします。

Go

myNumbers := []int{5, 10, 15}

もし、単純に sum(myNumbers) と呼び出すと、どうなるでしょうか？

Go

// これはコンパイルエラーになります！
// cannot use myNumbers (type []int) as type int in argument to sum
// error: too few arguments to sum: need at least 0, got 1

コンパイルエラーが発生します。なぜなら、sum 関数は int 型の引数を0個以上受け取るように定義されていますが、myNumbers は []int 型であり、int 型ではないためです。Go言語は、[]int 型を int 型の引数リストに自動的に変換してくれるほど賢くはありません。

ここで登場するのが、スライスの展開 (slice expansion) という機能です。スライスの後ろに ... を付けることで、そのスライスの各要素を個別の引数として関数に渡すことができます。

Go

myNumbers := []int{5, 10, 15}

// myNumbers スライスを展開して sum 関数に渡す
result := sum(myNumbers...)
// これは sum(5, 10, 15) と同等になります。

これにより、myNumbers の各要素（5, 10, 15）が、sum 関数に個別の int 型引数として渡され、期待通りに計算が行われます。

なぜ ... が必要か？

これは、Go言語の型システムと、可変長引数の設計思想に基づいています。

明示性: ... を付けることで、「このスライスの要素を個別の引数として渡していますよ」という意図を明確に示しています。これにより、コードの意図が読み取りやすくなります。
柔軟性: 可変長引数自体が「0個以上の引数」を受け取るための仕組みです。一方、スライスは「固定長の配列のビュー」であり、要素の集合体です。この二つを繋ぐための「展開」という操作が ... で表現されています。

「golang programs」の該当箇所の確認:

「golang programs」の「Variadic Functions」のセクションで、もし「スライスを渡す場合は ... を付ける」という説明があった場合、それはまさにこのスライスの展開について言及しているはずです。もし、その箇所で「なぜ ... が必要なのか」という説明が不足していたり、理解しづらかったりした場合は、この解説が役立つでしょう。

「golang programs」でよくある例:

「golang programs」では、おそらく fmt.Println のような関数を例に挙げているかもしれません。fmt.Println は内部で可変長引数（...interface{}）を受け取っています。

Go

fmt.Println("Hello", "World") // "Hello" と "World" が可変長引数として渡される

myStrings := []string{"Go", "is", "fun"}
fmt.Println(myStrings...)    // スライスを展開して渡す
// 出力: Go is fun

anotherSlice := []interface{}{1, 2.5, "three"}
fmt.Println(anotherSlice...) // interface{} 型のスライスを展開して渡す

ここでも、myStrings... のようにスライスを展開しているのは、fmt.Println が string 型の可変長引数ではなく、interface{} 型の可変長引数を受け取るため、また、スライスの各要素を個別の引数として fmt.Println に渡すためです。

まとめ

本記事では、Go言語の可変長引数（Variadic Functions）について、その定義方法、呼び出し方、そして関数内部での扱い方を、具体的なコード例を交えながら解説しました。特に、「golang programs」のチュートリアルでつまずきやすいポイントである「可変長引数がスライスとして扱われること」と「既存スライスを渡す際の ... 展開」に焦点を当て、その理由と使い方を深く掘り下げました。

可変長引数 ...T は、関数内部で []T（T型のスライス）として扱われます。
既存のスライスを可変長引数として関数に渡す際は、スライスの後ろに ... を付けて展開する必要があります。

この記事を通して、Go言語の可変長引数に対する理解が深まり、ご自身のコードで効果的に活用できるようになることを願っています。今後は、可変長引数と組み合わせて使えるappend関数や、より複雑な関数パターンについても記事にする予定です。

参考資料

The Go Programming Language Specification - Function types: https://go.dev/ref/spec#Function_types (Go言語仕様書: 関数型に関する公式ドキュメント)
A Tour of Go - Functions: https://go.dev/tour/methods/16 (Go言語ツアー: 関数に関するセクション)
golang programs - Variadic Functions: (筆者が参照した「golang programs」の該当URLがあれば追記)

Go言語の可変長引数（Variadic Functions）を徹底解説！「golang programs」の疑問を解消💻