ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

Go에서 가변 함수 마스터하기: 유연성과 강력함

9月 07, 2025
# Go

James Reed

Infrastructure Engineer · Leapcell

この記事はEnglish、日本語、Deutschでも利用できます
Cover of "Go에서 가변 함수 마스터하기: 유연성과 강력함"

간결함과 효율성을 위해 설계된 Go 언어는 프로그래밍을 직관적으로 만드는 강력한 기능을 제공합니다. 그러한 기능 중 하나가 **가변 함수(variadic function)**로, 함수가 특정 유형의 가변 개수의 인수를 허용하는 메커니즘입니다. 이 기능은 코드의 유연성과 재사용성을 크게 향상시켜, 변화하는 요구 사항에 더 잘 적응하는 함수를 설계할 수 있게 합니다.

가변 함수란 무엇인가요?

Go에서 가변 함수는 기본적으로 마지막 매개변수 유형 앞에 말줄임표(...)로 표시됩니다. 이는 함수가 해당 유형의 0개 이상의 인수를 허용할 수 있음을 나타냅니다. 가변 함수를 호출하면 Go는 함수 본문 내에서 이러한 인수를 자동으로 슬라이스로 수집합니다.

기본 구문은 다음과 같습니다:

func functionName(fixedArg1 type1, fixedArg2 type2, variadicArg ...variadicType) {
    // Function body
}

여기서 fixedArg1과 fixedArg2는 고정된 개수의 일반 매개변수이고, variadicArg는 함수에 전달된 모든 추가 인수를 포함할 variadicType 슬라이스입니다.

간단한 예제: 숫자 합산

가변 함수의 고전적인 예시는 임의의 개수의 정수를 합하는 함수입니다.

package main

import "fmt"

// sum은 가변 개수의 정수를 받아 그 합을 반환합니다.
func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println("Sum of 1, 2, 3:", sum(1, 2, 3))         // 출력: Sum of 1, 2, 3: 6
    fmt.Println("Sum of 10, 20:", sum(10, 20))            // 출력: Sum of 10, 20: 30
    fmt.Println("Sum of nothing:", sum())                // 출력: Sum of nothing: 0
    fmt.Println("Sum of 5:", sum(5))                      // 출력: Sum of 5: 5
}

이 sum 함수에서 함수 내부의 numbers는 []int 슬라이스처럼 작동합니다. 다른 슬라이스처럼 for...range 루프를 사용하여 반복할 수 있습니다.

슬라이스를 가변 함수에 전달하기

요소가 있는 슬라이스가 이미 있고 이를 가변 함수에 전달하고 싶다면 어떻게 해야 할까요? Go는 동일한 말줄임표(...) 연산자를 호출 지점에서 사용하여 슬라이스를 개별 인수로 "펼칠" 수 있는 편리한 방법을 제공합니다.

package main

import "fmt"

func printGreetings(names ...string) {
    if len(names) == 0 {
        fmt.Println("Hello, nobody!")
        return
    }
    for _, name := range names {
        fmt.Printf("Hello, %s!\n", name)
    }
}

func main() {
    individualNames := []string{"Alice", "Bob", "Charlie"}
    
    // 개별 이름 전달
    printGreetings("David", "Eve")
    // 출력:
    // Hello, David!
    // Hello, Eve!

    fmt.Println("---")

    // ... 연산자를 사용하여 슬라이스 전달
    printGreetings(individualNames...) // 슬라이스 펼치기
    // 출력:
    // Hello, Alice!
    // Hello, Bob!
    // Hello, Charlie!
    
    fmt.Println("---")

    // 고정 인자와 펼쳐진 슬라이스를 혼합하는 것도 가능합니다
    allNames := []string{"Frank", "Grace"}
    printGreetings("Heidi", allNames...)
    // 출력:
    // Hello, Heidi!
    // Hello, Frank!
    // Hello, Grace!
}

호출 지점의 이 ...는 기존 슬라이스를 가변 함수와 함께 활용하는 방법을 이해하는 데 중요하며, 수동으로 추출할 필요가 없습니다.

가변 함수의 사용 사례

가변 함수는 단순한 구문적 설탕(syntactical sugar)이 아니라, 다양한 시나리오에서 실용적인 목적을 제공합니다:

  1. 로깅 함수: 일반적인 응용 프로그램은 형식 문자열과 포맷될 임의의 개수의 인수를 허용하는 유연한 로깅 유틸리티를 만드는 것입니다.

    package main

import (
    "fmt"
    "log"
)

// LogV는 fmt.Printf와 유사하게 선택적 인수를 포함한 메시지를 로깅합니다.
func LogV(format string, v ...interface{}) {
    log.Printf(format, v...) // 가변 인수를 log.Printf에 직접 전달
}

func main() {
    LogV("User %s logged in from %s", "JohnDoe", "192.168.1.1")
    LogV("Application started on port %d", 8080)
    LogV("No specific message here.")
}

    가변 인수에 대한 interface{} 유형에 주목하세요. 이를 통해 LogV는 모든 유형의 인수를 허용하므로 매우 다재다능합니다.

  2. 구성 및 옵션: 구성 옵션을 받는 함수는 가변 인수를 사용하여 일련의 옵션 함수 또는 키-값 쌍을 받을 수 있습니다.

    HTTP 클라이언트를 구축한다고 상상해 보세요. 여기서 다양한 옵션을 지정할 수 있습니다:

    package main

import "fmt"

type Client struct {
    Timeout int
    Retries int
    Debug   bool
}

type ClientOption func(*Client)

func WithTimeout(timeout int) ClientOption {
    return func(c *Client) {
        c.Timeout = timeout
    }
}

func WithRetries(retries int) ClientOption {
    return func(c *Client) {
        c.Retries = retries
    }
}

func WithDebug(debug bool) ClientOption {
    return func(c *Client) {
        c.Debug = debug
    }
}

func NewClient(options ...ClientOption) *Client {
    client := &Client{
        Timeout: 30, // 기본 타임 아웃
        Retries: 3,  // 기본 재시도
        Debug:   false,
    }

    for _, option := range options {
        option(client) // 각 옵션 함수 적용
    }
    return client
}

func main() {
    // 기본 설정으로 클라이언트 생성
    defaultClient := NewClient()
    fmt.Printf("Default Client: %+v\n", defaultClient)

    // 사용자 정의 타임 아웃 및 디버그로 클라이언트 생성
    customClient1 := NewClient(WithTimeout(60), WithDebug(true))
    fmt.Printf("Custom Client 1: %+v\n", customClient1)

    // 사용자 정의 재시도로 클라이언트 생성
    customClient2 := NewClient(WithRetries(5))
    fmt.Printf("Custom Client 2: %+v\n", customClient2)
}

    이 "함수형 옵션" 패턴은 Go에서 선택적 매개변수를 처리하는 강력하고 관용적인 방법이며, 가변 함수를 많이 활용합니다.

  3. 컬렉션 조작: 최대값, 최소값 찾기 또는 문자열 연결과 같은 컬렉션을 처리하는 함수.

    package main

import "fmt"
import "strings"

// ConcatenateStrings는 여러 문자열을 하나로 결합합니다.
func ConcatenateStrings(sep string, s ...string) string {
    return strings.Join(s, sep)
}

func main() {
    fmt.Println(ConcatenateStrings(", ", "apple", "banana", "cherry")) // 출력: apple, banana, cherry
    fmt.Println(ConcatenateStrings("-", "one", "two"))                // 출력: one-two
    fmt.Println(ConcatenateStrings(" | "))                           // 출력:
}

중요 고려 사항 및 모범 사례

  • 마지막 매개변수만 가능: 함수는 하나의 가변 매개변수만 가질 수 있으며, 반드시 함수 시그니처의 마지막 매개변수여야 합니다. 이 규칙은 파싱을 단순화하고 함수의 고정 인수가 가변 인자와 명확하게 구분되도록 보장합니다.

  • 유형 동질성: 가변 매개변수에 전달되는 모든 인수는 함수 시그니처에 지정된 것과 동일한 유형이어야 합니다. 다른 유형의 인수를 허용해야 하는 경우, 로깅 예제에서와 같이 ...interface{}를 사용하세요. 이를 통해 가변 매개변수는 모든 유형을 허용할 수 있으며, 함수 내에서 유형 단언(type assertion) 또는 유형 전환(type switch)이 필요합니다.

  • 빈 인수에 대한 nil 슬라이스: 가변 함수에 인수가 전달되지 않으면, 함수 내 해당 슬라이스는 nil이 됩니다(빈 슬라이스가 아님). 이 경우를 처리하는 것이 일반적으로 좋으며, 특히 슬라이스를 반복하는 경우에 그렇습니다. nil 슬라이스의 len은 0이며, nil 슬라이스에 대한 for...range 반복은 안전하며 어떤 반복도 실행하지 않습니다.

    func processArgs(args ...string) {
    if args == nil {
        fmt.Println("No arguments provided (slice is nil)")
    } else if len(args) == 0 {
        fmt.Println("No arguments provided (slice is empty but not nil)")
    } else {
        fmt.Printf("Processing %d arguments: %v\n", len(args), args)
    }
}

func main() {
    processArgs() // 출력: No arguments provided (slice is nil)
    emptySlice := []string{}
    processArgs(emptySlice...) // 출력: No arguments provided (slice is empty but not nil)
    processArgs("a", "b") // 출력: Processing 2 arguments: [a b]
}

  • 성능: 편리하지만, 많은 수의 개별 인수를 가변 함수에 전달하면 Go가 이를 담을 새 슬라이스를 생성해야 하므로 약간의 오버헤드가 발생할 수 있음에 유의하세요. 특히 고정된 많은 수의 인수가 있는 매우 성능이 중요한 경로의 경우, 미리 할당된 슬라이스를 명시적으로 전달하는 것이 약간 더 빠를 수 있지만, 대부분의 응용 프로그램의 경우 가변 함수의 편리함이 이 최소한의 오버헤드보다 더 큽니다. Go 컴파일러는 종종 이러한 경우를 효과적으로 최적화합니다.

  • 편의성보다 명확성: 모든 선택적 매개변수에 대해 가변 함수를 과도하게 사용하지 마세요. 함수가 논리적으로 소수의 고정된 선택적 매개변수를 취하는 경우, 명시적인 선택적 매개변수 또는 구조체가 함수의 예상 입력에 대한 더 나은 명확성을 제공할 수 있습니다. 가변 함수는 인수의 개수가 진정으로 임의적이고 예측 불가능할 때 빛을 발합니다.

결론

가변 함수는 Go에서 코드의 유연성과 재사용성을 촉진하는 다재다능하고 강력한 기능입니다. 구문, 인수가 슬라이스로 수집되는 방식, 그리고 펼침 연산자(...)를 언제 적용하는지 이해함으로써, 더 잘 적응하고 표현력이 뛰어난 Go 프로그램을 작성할 수 있습니다. 강력한 로깅 메커니즘부터 우아한 구성 패턴에 이르기까지, 가변 함수를 마스터하는 것은 Go 개발 도구 키트에서 가치 있는 기술입니다. 간결함과 강력함 사이의 균형을 유지하여 Go의 설계 철학과 완벽하게 일치합니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts