Golang이라고도 알려진 Go는 정적인 유형의 언어입니다. 이는 모든 변수의 유형이 컴파일 타임에 알려짐으로써 코드에 안전성과 예측 가능성을 제공한다는 의미입니다. 그러나 이를 위해서는 한 유형에서 다른 유형으로의 변환이 명시적이고 의도적으로 이루어져야 합니다. 이 글에서는 기본 숫자 변환부터 보다 복잡한 인터페이스 및 포인터 변환까지 Go에서 사용할 수 있는 다양한 유형 캐스팅 및 변환 메커니즘을 살펴보겠습니다.

1. 기본 유형 변환

Go에서는 정수, 부동 소수점 숫자, 문자열과 같은 기본 유형 간의 변환을 허용하지만 이러한 변환은 명시적으로 수행되어야 합니다.

숫자 유형

다양한 숫자 유형 간의 변환은 간단하지만 명시적이어야 합니다.

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

이 예에서는 int를 float64와 uint로 변환합니다. Go는 자동(암시적) 유형 변환을 수행하지 않기 때문에 이러한 변환은 명시적입니다.

문자열과 바이트 슬라이스

Go 문자열은 변경할 수 없지만 변경 가능한 바이트 슬라이스([]바이트)로 변환할 수 있습니다.

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

마찬가지로 문자열과 룬 조각([]rune) 간에 변환할 수 있습니다. 여기서 rune은 int32의 유형 별칭입니다:

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. 사용자 정의 유형 변환

Go에서는 기존 유형을 기반으로 자신만의 유형을 정의할 수 있습니다. 사용자 정의 유형과 기본 유형 간의 변환은 명시적입니다.

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

이 명시적 변환은 컴파일러가 코드의 안전성을 확인할 수 있도록 하기 위해 필요합니다.

3. 포인터 변환

Go의 포인터는 변수의 메모리 주소를 참조합니다. 값과 포인터 사이를 변환할 수 있습니다:

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. 인터페이스 유형 변환

Go의 인터페이스는 일련의 메소드를 정의하는 데 사용됩니다. 구체적인 유형과 인터페이스 간에 변환할 수 있습니다.

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

유형 주장

유형 어설션은 인터페이스의 구체적인 값에 대한 액세스를 제공합니다.

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

유형 스위치

유형 스위치를 사용하면 인터페이스의 동적 유형에 따라 다양한 작업을 수행할 수 있습니다.

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. 안전하지 않은 전환

unsafe 패키지를 사용하면 Go의 유형 안전성을 우회하여 불법적인 변환을 활성화할 수 있습니다.

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

경고: 안전하지 않은 변환은 정의되지 않은 동작으로 이어질 수 있으므로 꼭 필요한 경우에만 사용해야 합니다.

6. 채널 유형 변환

채널은 Go의 강력한 기능으로, 고루틴 간의 통신을 가능하게 합니다. 양방향 채널과 단방향 채널 간을 변환할 수 있습니다:

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. 구조체 및 배열 변환


동일한 레이아웃을 가진 구조체 또는 배열 간의 변환에는 명시적인 형변환이 필요합니다.


type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)





  
  
  8. 슬라이스 변환


슬라이스는 배열에 대한 참조이며 동일한 유형의 슬라이스 간에 변환할 수 있지만 서로 다른 유형의 슬라이스 간에 변환하려면 명시적인 변환이 필요합니다.


var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type





  
  
  9. Nil 인터페이스 변환


Go의 nil 값은 모든 인터페이스 유형에 할당될 수 있습니다.


var x interface{} = nil
var y error = nil





  
  
  10. 함수 유형 변환


Go 함수는 서명이 호환된다면 다른 유형으로 변환될 수 있습니다:


type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType





  
  
  11. 배열에서 슬라이스로의 변환


기본적으로 배열에 대한 참조인 배열에서 슬라이스를 생성할 수 있습니다.


var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice





  
  
  결론


Go의 유형 캐스팅 및 변환은 설계상 명시적이므로 코드를 더 안전하고 이해하기 쉽게 만듭니다. Go는 명시적 변환을 요구함으로써 일부 다른 프로그래밍 언어에서 흔히 발생하는 암시적 유형 강제 변환으로 인해 발생할 수 있는 미묘한 버그를 방지하는 데 도움이 됩니다. 강력하고 효율적인 Go 프로그램을 작성하려면 이러한 변환을 이해하고 올바르게 사용하는 것이 중요합니다.