5.3. 프로그램언어 고(Go)에서의 데이터 타입 변환 방법

by

프로그램언어 고(Go)의 정수형으로 변환하는 방법

고(Go) 프로그램 언어의 정수형으로 변환하는 방법에 대해 설명드리겠습니다.

고(Go)에서 정수형으로 변환할 때 주로 strconv 패키지의 함수들을 사용합니다.

가장 기본적으로 정수형으로 변환할 때는 strconv.Atoi 함수를 사용합니다. 이 함수는 문자열을 인자로 받아서 정수형으로 변환해줍니다.


package main

import "strconv"

func main() {

    stringVar := "100"
    
    intVar, err := strconv.Atoi(stringVar)
    if err != nil {
        // 핸들 에러
    }
    
    println(intVar) // 100
}

위의 예제코드에서 문자열 “100”을 정수형으로 변환하는 것을 확인할 수 있습니다.
strconv.Atoi 함수가 에러를 반환할 수 있기 때문에 에러처리를 해주는 것이 좋습니다.

정수를 문자열로 변환할 때는 strconv.Itoa 함수를 사용합니다. 이 함수는 정수값을 인자로 받아서 문자열을 반환합니다.


package main

import "strconv"

func main() {

    intVar := 100
    
    stringVar := strconv.Itoa(intVar)
    
    println(stringVar) // "100"
}

위와 같이 strconv.Itoa 함수를 사용하면 손쉽게 정수형을 문자열로 변환할 수 있습니다.

이 외에도 문자열을 int, int64, float64 등 다양한 숫자형으로 변환할 수 있는 함수들이 strconv 패키지에 준비되어 있습니다.

예를들어 문자열을 float64형으로 변환할 때는 strconv.ParseFloat 함수를 사용합니다.

  
package main

import "strconv"

func main() {

    stringVar := "3.14159"
    
    floatVar, err := strconv.ParseFloat(stringVar, 64) 
    if err != nil {
        // 핸들 에러
    }
    
    println(floatVar) // 3.14159
}

이처럼 고(Go)에서는 문자열과 숫자형 사이의 변환이 매우 간편합니다.
strconv 패키지가 이를 위한 다양한 유틸리티 함수들을 제공하고 있기 때문입니다.

위의 예제들을 통해 간단한 사용 방법을 익혔다면 더 다양한 활용이 가능합니다.
문자열과 숫자형 사이의 변환이 필요한 경우 strconv 패키지를 기억해주시기 바랍니다.

프로그램언어 고(Go)의 실수형으로 변환하는 방법

고(Go)언어의 실수형으로 변환하는 방법을 설명드리겠습니다. 

package main

import (
    "fmt"
    "strconv"
)

func main() {

    var num1 int = 10
    var num2 float64
    
    // int를 float64로 변환하는 방법1 
    // float64(num1) 으로 형변환
    num2 = float64(num1) 
    fmt.Printf("num1 type: %T, num1=%v \n", num1, num1)
    fmt.Printf("num2 type: %T, num2=%v \n", num2, num2)

    // int를 float64로 변환하는 방법2
    // strconv 패키지의 ParseFloat 함수 사용
    num2, _ = strconv.ParseFloat(strconv.Itoa(num1), 64)
    fmt.Printf("num2 type: %T, num2=%v \n", num2, num2)

}

예제코드에서 고(Go)언어의 정수형 변수 num1을 실수형 변수 num2에 저장하는 방법을 2가지를 보여드렸습니다.

첫 번째는 float64(num1)으로 형변환 하는 것이고, 두 번째는 strconv 패키지의 ParseFloat 함수를 사용하는 것입니다.

형변환을 사용할 때는 단순하고 코드가 간결합니다. ParseFloat 함수를 사용할 때는 문자열을 통해 변환하기 때문에 추가 처리가 필요하지만, 변환할 때 정밀도를 지정할 수 있다는 장점이 있습니다.

예제에서는 64비트 float형으로 변환하고 있습니다. 고(Go)언어의 실수형은 32비트 float32와 64비트 float64가 있습니다.

위 예제코드를 통해 고(Go)언어에서 정수를 실수형으로 변환하는 방법을 익혔기를 바랍니다. 형변환이나 ParseFloat 함수를 사용할 때 장단점을 이해하고 상황에 맞게 사용할 수 있게되시길 바랍니다.

코드에 대한 설명이 부족하다면 문의 주시면 좀 더 자세히 설명 드리겠습니다.

프로그램언어 고(Go)의 문자열으로 변환하는 방법

고(Go) 프로그램 언어의 문자열을 다른 타입으로 변환하는 방법에 대해 설명드리겠습니다. 

package main

import "fmt"

func main() {
    var str string = "Hello World"

    // 문자열을 바이트 슬라이스로 변환
    bytes := []byte(str)
    fmt.Println(bytes)

    // 바이트 슬라이스를 문자열로 변환
    str2 := string([]byte{'H', 'e', 'l', 'l', 'o'})
    fmt.Println(str2)  
}

고(Go)에서는 문자열을 []byte 타입의 바이트 슬라이스로 쉽게 변환할 수 있습니다.

예를 들어, 

bytes := []byte(str)

와 같이 문자열 뒤에 []byte를 지정하면 바이트 슬라이스로 변환할 수 있습니다.

반대로 바이트 슬라이스를 문자열로 변환하고 싶다면,

str2 := string([]byte{'H', 'e', 'l', 'l', 'o'})

와 같이 string 함수를 사용하고 바이트 슬라이스를 파라미터로 전달하면 됩니다.

이처럼 고(Go)에서는 문자열과 바이트 슬라이스 간의 변환이 매우 간편합니다.

필요에 따라 적절히 사용하시기 바랍니다.

프로그램언어 고(Go)의 불린으로 변환하는 방법

Go언어에서 불린(boolean) 타입으로 값을 변환하는 방법은 주로 아래와 같습니다.

package main

import "fmt"

func main() {

    // 문자열을 불린값으로 변환
    var str1 string = "true"
    b1 := str1 == "true" // true
    fmt.Println(b1)

    var str2 string 
    b2 := str2 == "true" // false, str2는 ""
    fmt.Println(b2)

    // 정수를 불린값으로 변환 
    // 0은 false, 0이 아닌 정수는 true
    n1 := 1
    b3 := n1 != 0  
    fmt.Println(b3) // true

    n2 := 0
    b4 := n2 != 0
    fmt.Println(b4) // false
}

위 예제코드에서 보다시피, Go언어에서는 다음과 같은 방법으로 값을 불린 타입으로 변환할 수 있습니다.

1. 문자열과 “true”를 비교하여 true/false 판단
2. 정수값과 0을 비교하여 true/false 판단

즉, 조건문이나 부정문 등을 활용하여 true/false를 판단한 뒤, 해당 결과를 불린 변수에 할당하면 됩니다.

예를 들어 위 예제의 str1 변수를 “true” 문자열과 비교한 뒤 같다면(==) true를, 다르다면 false를 b1 변수에 할당합니다.

마찬가지로 정수 n1에 1을 할당한 뒤 0과 다르다면(!=) true로, 정수 n2에 0을 할당한 뒤 0과 다르다면 false를 할당하는 방법입니다.

이 외에도 포인터나 인터페이스가 nil인지 여부로 true/false를 판단하는 방법도 있습니다. 자세한 내용은 Go언어 문서를 참고하시기 바랍니다.

프로그램언어 고(Go)의 타입 변환 에러 처리 방법

프로그램언어 고(Go)에서 타입 변환 시 에러가 발생하면 보통 다음과 같은 방법으로 처리합니다.


package main

import "fmt"

func main() {

    var i int = 5
    var f float64 = 1.2

    //int를 float64로 변환
    f = float64(i)
    fmt.Println(f)

    //제대로 안되는 변환
    f = 1.2
    i = int(f) // 소수점이 버려짐
    fmt.Println(i)

}

위 예제코드에서 int 타입의 변수 i를 float64 타입으로 명시적 변환을 하였습니다. 이 경우에는 문제없이 변환이 수행됩니다.

하지만 float64 타입의 변수 f를 int 타입으로 변환하면 소수점 이하가 버려지므로 정확한 변환이 이뤄지지 않습니다.

이때 다음과 같은 방법들로 에러를 처리할 수 있습니다.

1. 변환 전에 확인하기


f := 1.2
if f != math.Trunc(f) {
    log.Print("손실이 발생할 수 있는 변환") 
    return 
}
i := int(f)

Trunc 함수를 사용하여 소수점 이하가 0이 아니면 에러로 처리합니다.

2. 변환 후 검사하기


f := 1.2
i := int(f)

if f != float64(i) {
    log.Print("정확한 변환이 이뤄지지 않음")
    return
}

int로 변환된 i를 다시 float64로 변환하여 원래 값과 비교합니다.

3. Panic & Recover


func safeConvert() {
    defer func() {
        if r := recover(); r != nil {
            log.Print("변환 에러") 
        }
    }()

    f := 1.2 
    i := int(f) //패닉 발생
}

panic & recover를 사용하여 에러를 처리하는 방법도 있습니다.

이 외에도 에러 타입을 정의하거나 변환 함수를 커스텀izing하여 처리할 수도 있습니다.

가장 좋은 방법은 버그를 사전에 방지하기 위해 변환이 필요한 경우에 명시적 변환을 사용하는 것입니다.

Leave a Comment