Golang int를 string으로, string을 int로: 타입 변환

Go는 절대 암묵적으로 타입을 변환하지 않습니다. 호환되는 타입 사이는 T(v)로, 숫자와 텍스트 사이는 strconv 패키지로 변환합니다. 가장 많이 검색되는 두 가지 변환입니다:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa("integer to ASCII")는 int를 10진수 텍스트로 형식화합니다. strconv.Atoi("ASCII to integer")는 텍스트를 int로 파싱하고, 텍스트가 올바른 숫자가 아니면 오류를 반환합니다. 그 오류는 항상 확인하세요.

T(v) 변환

Go의 변환 문법은 대상 타입의 이름을 딴 함수 호출처럼 보입니다. 세 가지 상황에서 동작합니다:

1. 숫자 타입 사이(int, int64, float64, uint8, ...),
2. string과 []byte 또는 []rune 사이,
3. 기반 타입이 같은 타입 사이(Celsius와 float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

결과를 자세히 보세요:

• int(3.9)는 3이고 int(-3.9)는 -3입니다. 변환은 반올림하지 않고 0 쪽으로 절삭합니다. 원하는 동작을 고르려면 먼저 math.Round, math.Floor, math.Ceil을 쓰세요. math.Round는 0.5를 0에서 먼 쪽으로 반올림하므로 -3.5는 -4가 됩니다.
• 하위 8비트만 남으므로(300에서 256을 뺌) uint8(300)은 44이고, 같은 이유로 int8(200)은 -56입니다. 오류도 패닉도 없습니다.
• Celsius와 float64는 기반 타입이 같으므로 자유롭게 변환되지만, 명시적으로만 가능합니다.

값을 일부러 변수에 넣었습니다. 상수라면 같은 변환이 컴파일되지 않습니다.

상수는 검사되고, 변수는 검사되지 않는다

범위에 맞지 않는 상수를 변환하면 컴파일 오류입니다. 같은 값을 가진 변수를 변환하면 조용히 순환합니다:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

정수가 아닌 상수를 정수 타입으로 변환하는 것도 거부되지만, 변수에 담긴 같은 값은 절삭됩니다:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

실수 값이 대상 정수 타입의 범위를 벗어나면(예: int64(1e20)) 결과는 구현에 따라 다릅니다. 예를 들어 amd64와 arm64는 다른 답을 줍니다. 신뢰할 수 없는 값은 변환하기 전에 범위를 확인하세요.

숫자를 문자열로 바꾸기

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat는 형식 바이트('f'는 고정 소수점, 'e'는 지수, 'g'는 둘 중 짧은 쪽), 정밀도(-1은 "정확히 왕복하는 가장 적은 자릿수"를 뜻함), 원래 실수의 비트 크기(64 또는 32)를 받습니다.

strconv는 값을 인터페이스에 담아 fmt의 범용 형식화 경로를 거치는 fmt.Sprint보다 빠릅니다. 성능이 중요한 반복문에서는 차이가 드러나지만, 가끔 하는 변환이라면 읽기 좋은 쪽을 고르세요.

문자열을 숫자로 바꾸기

ParseInt는 항상 int64를 반환합니다. bitSize 인자(0, 8, 16, 32, 64)가 받아들이는 범위를 정하므로, 더 작은 타입으로 변환해도 결과가 반드시 들어맞습니다. base가 0이면 "접두사로 추론"한다는 뜻이라서 0x1f, 0o17, 0b101, 1_000이 모두 파싱됩니다.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

출력에서 알 수 있는 것:

• " 42"는 실패합니다. Atoi는 선택적인 부호와 숫자만 받고 그 외에는 받지 않습니다. bufio에서 온 입력은 보통 \n으로 끝나므로 잘라 내세요.
• "4.2"는 Atoi에 유효하지 않습니다. 소수에는 ParseFloat를 쓰세요.
• 범위를 벗어난 오류일 때 ParseInt는 오류와 함께 들어맞는 가장 큰 값(int8이면 127)을 반환합니다. 오류가 nil이 아니면 그 값을 쓰지 마세요.
• 오류는 strconv.ErrSyntax나 strconv.ErrRange를 감싼 *strconv.NumError 값이므로 errors.Is로 구분할 수 있습니다.

ParseBool은 1, t, T, TRUE, true, True와 그에 대응하는 거짓 형태를 받습니다. "yes"와 "on"은 오류입니다.

string(65) 함정

정수를 string으로 변환하면 숫자가 아니라 그 유니코드 코드 포인트에 해당하는 문자가 만들어집니다:

n := 65
s := string(n) // "A", not "65"

컴파일러는 받아들이지만 go vet이 보고합니다:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

정말로 문자를 원한다면 룬으로 분명히 하세요: string(rune(n)). 숫자를 텍스트로 원한다면 strconv.Itoa(n)을 쓰세요. rune이나 byte를 string으로 변환하는 것은 문제없고 흔한 일입니다:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

문자열, 바이트, 룬

string, []byte, []rune은 T(v)로 서로 변환됩니다. 문자열은 불변이고 슬라이스는 그렇지 않으므로 변환할 때마다 데이터가 복사됩니다:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

문자 단위로 인덱싱하거나 수정해야 한다면 []rune으로, 입출력, 해싱, 바이트 단위 편집에는 []byte로 변환하세요. UTF-8은 rune과 byte 페이지에서 자세히 다룹니다.

변환과 타입 단언

변환은 값을 한 구체 타입에서 다른 구체 타입으로 바꿉니다. 인터페이스(any, error, io.Reader)에서 구체 값을 꺼내는 것은 다른 연산인 타입 단언입니다:

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

먼저 단언하고, 그다음 변환하세요. comma-ok 형태 n, ok := v.(int)를 쓰면 타입이 틀렸을 때 패닉을 피할 수 있습니다.

빠른 참조

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}