Go言語の型変換：intとstringの相互変換、strconvの使い方

Goは型を暗黙に変換しません。互換性のある型どうしは T(v) で、数値とテキストの間は strconv パッケージで変換します。最もよく検索される2つの変換は次のとおりです。

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の変換の構文は、変換先の型の名前を使った関数呼び出しのように見えます。使えるのは次の3つの場面です。

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 です。変換は ゼロ方向に切り捨て ます。四捨五入はしません。挙動を選ぶには、先に math.Round、math.Floor、math.Ceil を使います。math.Round は0.5をゼロから遠い方向に丸めるので、-3.5 は -4 になります。
• uint8(300) は 44 です。下位8ビットだけが残るからです（300から256を引いた値）。int8(200) が -56 になるのも同じ理由です。エラーもpanicもありません。
• 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.Sprint より高速です。fmt.Sprint は値をインターフェースに包み、fmtの汎用的な整形処理を通るからです。ホットなループではこの差が表れますが、たまに変換する程度なら読みやすいほうを選べば十分です。

文字列を数値に変換する

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 と、それに対応するfalseの形を受け付けます。"yes" や "on" はエラーです。

string(65)の罠

整数を string に変換しても数字にはなりません。そのUnicodeコードポイントを持つ文字になります。

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 に、I/O、ハッシュ計算、バイト単位の編集には []byte に変換します。UTF-8の詳細はルーンとバイトのページで扱っています。

変換と型アサーションの違い

変換は、ある具体的な型の値を別の具体的な型に変えるものです。インターフェース（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

先にアサーションし、それから変換します。カンマok形式の n, ok := v.(int) を使えば、型が違ったときのpanicを避けられます。

早見表

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