ホーム / Go言語 /

【Go言語の型変換】基本から実践まで初心者向けに簡単解説！

2025年4月16日水曜日

Go言語

この記事ではGo言語の型変換について、ゼロからしっかり学んでいきましょう。

Go言語を書き始めて、「あれ？ 型が違うって怒られちゃった…」なんて経験、ありませんか？ そう、Go言語は型にちょっぴり厳しいのです。でも大丈夫！ 型変換をマスターすれば、データの種類を自由自在に操れるようになります。

この記事では、型変換の基本から、数値同士、文字列と数値の変換、そしてちょっと応用的な使い方まで、サンプルコード満載で解説していきますよ。

この記事を読むと、こんなことができるようになります。

  • Go言語でなぜ型変換が必要なのかが分かる
  • 基本的な型変換の書き方が身につく
  • 数値どうしの型変換ができるようになる
  • 文字列と数値を相互に変換できるようになる
  • 型変換するときの注意点が分かる
  • 型に関するエラーを自分で解決できるようになる

Go言語で「型変換」が必要な理由とは？

まず、どうしてGo言語では「型変換」が必要なんでしょうか？

Go言語は静的型付け言語と呼ばれるプログラミング言語です。これは、変数を使うときに「この変数には整数（int型）を入れます」「こっちには文字列（string型）を入れます」みたいに、最初に型を決めておく必要がある、という意味なんです。

そして、一度決めた型と違う種類のデータは、基本的には直接代入したり、一緒に計算したりできません。

例えば、こんなコードを書くとエラーになります。

package main

import "fmt"

func main() {
    var integerValue int = 100
    var stringValue string = "点"

    // fmt.Println(integerValue + stringValue) // これはエラーになる！
    // invalid operation: integerValue + stringValue (mismatched types int and string)

    fmt.Println(integerValue) // これはOK
    fmt.Println(stringValue)  // これもOK
}

整数型の `integerValue` と文字列型の `stringValue` を足し合わせようとすると、「型が違うよ！」とGoコンパイラに怒られてしまうんですね。

こういう場合に、一方の型をもう一方の型に合わせてあげる操作、それが型変換です。Go言語でスムーズにデータを扱うためには、この型変換が欠かせない操作となるわけです。

Go言語における型変換の基本的な考え方

Go言語の型変換は、実はとってもシンプルです。

基本の形は、変換したい型で、変換元の値をカッコで囲むだけ！

書き方

変換先の型(変換元の値)

例えば、整数型の値 `10` を、浮動小数点数型（小数点を扱える型）の `float64` に変換したい場合は、次のように書きます。

float64(10)

たったこれだけです。簡単でしょう？

この基本の形 `T(v)` （Tが型、vが値）を覚えておけば、色々な場面で応用が効きますよ。

【数値編】Go言語での基本的な数値型変換

まずは、プログラミングでよく使う数値同士の型変換を見ていきましょう。
整数（`int`や`int64`など）と、小数点数（`float32`や`float64`など）の間での変換が代表的です。

これも、先ほどの基本の形 `変換先の型(変換元の値)` を使うだけでOKです。

数値型変換の書き方 (サンプルコード)

実際にコードで見てみるのが一番分かりやすいですね。

ここでは、整数 `int` を浮動小数点数 `float64` へ、逆に `float64` を `int` へ変換してみます。

package main

import "fmt"

func main() {
    var i int = 100
    var f float64 = 3.14

    // int から float64 へ変換
    var fFromI float64 = float64(i)

    // float64 から int へ変換
    var iFromF int = int(f)

    fmt.Println("元のint:", i)
    fmt.Println("intから変換したfloat64:", fFromI)
    fmt.Println("元のfloat64:", f)
    fmt.Println("float64から変換したint:", iFromF) // 小数点以下に注目！
}

シンプルに型で値を囲むだけ、という基本がここでも生きていますね。

数値型変換の使い方と実行結果

上のサンプルコードを実行すると、こんな結果が表示されます。

元のint: 100
intから変換したfloat64: 100
元のfloat64: 3.14
float64から変換したint: 3

コードを解説しますね。

  • var fFromI float64 = float64(i)
    整数 `i` (値は100) を `float64()` で囲んで、`float64` 型の変数 `fFromI` に入れています。結果は `100` と表示されていますが、内部的には小数点を扱える `100.0` のような状態になっています。
  • var iFromF int = int(f)
    浮動小数点数 `f` (値は3.14) を `int()` で囲んで、`int` 型の変数 `iFromF` に入れています。結果は `3` になりました。

ここで注目してほしいのは、`float64` から `int` への変換結果です。

元の値 `3.14` の小数点以下 `.14` が、バッサリ切り捨てられて `3` になっています。四捨五入ではない点に注意しましょう。

数値型変換の注意点：データ損失の可能性

先ほどの `float64` から `int` への変換で見たように、数値の型変換では元のデータの一部が失われる可能性があります。

特に、表現できる範囲が広い型や、精度が高い型（例 `float64`）から、範囲が狭い型や精度が低い型（例 `int`）へ変換する際には注意が必要です。

  • float64` → `int : 小数点以下が切り捨てられる。
  • 大きな整数型 (`int64`) → 小さな整数型 (`int8`) : 値が収まりきらず、予期せぬ値になる可能性がある（オーバーフロー）。

どの型からどの型へ変換するのか、そして変換によって情報が失われても問題ないか、しっかり確認しながら使うことが肝心です。

【文字列編】Go言語での文字列と数値の型変換 (`strconv`パッケージ)

次に、文字列と数値の間での型変換です。

例えば、ユーザーが入力した数字の文字列を計算に使いたい場合や、計算結果の数値を文字列として表示したい場合など、出番は多いです。

ただし、数値型同士の変換のように `string(123)` や `int("123")` といった単純な書き方はできません。（エラーになったり、意図しない結果になったりします）

そこで登場するのが `strconv` パッケージです！ `strconv` は "string conversion" (文字列変換) の略で、Go言語で文字列と他の型（特に数値）を安全かつ正確に変換するための機能がたくさん用意されています。

文字列と数値の型変換の書き方 (`strconv`)

`strconv` パッケージを使った、代表的な変換を見てみましょう。

文字列を `int` に変換する `Atoi`、`int` を文字列にする `Itoa`、文字列を `float64` にする `ParseFloat`、`float64` を文字列にする `FormatFloat` を使ってみます。

package main

import (
    "fmt"
    "strconv" // strconv パッケージを import するのを忘れずに！
)

func main() {
    // 文字列 "123" を int 型に変換
    strNum := "123"
    intValue, err := strconv.Atoi(strNum) // Atoi は int と error を返す
    if err != nil {
        fmt.Println("Atoi エラー:", err)
    } else {
        fmt.Printf("文字列\"%s\" -> int: %d (型: %T)\n", strNum, intValue, intValue)
        // 計算もできる！
        fmt.Printf("%d + 100 = %d\n", intValue, intValue+100)
    }

    fmt.Println("---")

    // int 型 456 を 文字列に変換
    num := 456
    strValue := strconv.Itoa(num) // Itoa は string を返す
    fmt.Printf("int %d -> 文字列: \"%s\" (型: %T)\n", num, strValue, strValue)
    // 文字列結合もできる！
    fmt.Println("結果は " + strValue + " です。")

    fmt.Println("---")

    // 文字列 "3.1415" を float64 型に変換
    strFlt := "3.1415"
    // ParseFloat は float64 と error を返す。第二引数はビット数 (64bit)
    fltValue, err := strconv.ParseFloat(strFlt, 64)
    if err != nil {
        fmt.Println("ParseFloat エラー:", err)
    } else {
        fmt.Printf("文字列\"%s\" -> float64: %f (型: %T)\n", strFlt, fltValue, fltValue)
    }

    fmt.Println("---")

    // float64 型 2.718 を 文字列に変換
    flt := 2.718
    // FormatFloat は string を返す。'f'は小数点形式, -1は最小桁数, 64はビット数
    strFmtValue := strconv.FormatFloat(flt, 'f', -1, 64)
    fmt.Printf("float64 %f -> 文字列: \"%s\" (型: %T)\n", flt, strFmtValue, strFmtValue)

    fmt.Println("---")

    // 変換できない文字列の場合
    strInvalid := "abc"
    _, err = strconv.Atoi(strInvalid) // エラーが発生するはず
    if err != nil {
        fmt.Printf("文字列\"%s\"のAtoi エラー: %s\n", strInvalid, err) // エラー内容を表示
    }
}

`strconv` の関数、特に文字列から数値へ変換する関数 (`Atoi`, `ParseFloat` など) は、多くの場合、変換後の値と一緒に `error` 型の値を返します。 

これがエラーハンドリングで非常に重要になります。

文字列と数値の型変換の使い方と実行結果

上のコードを実行した結果は以下のようになります。

文字列"123" -> int: 123 (型: int)
123 + 100 = 223
---
int 456 -> 文字列: "456" (型: string)
結果は 456 です。
---
文字列"3.1415" -> float64: 3.141500 (型: float64)
---
float64 2.718000 -> 文字列: "2.718" (型: string)
---
文字列"abc"のAtoi エラー: strconv.Atoi: parsing "abc": invalid syntax

解説を見ていきましょう。

  • strconv.Atoi("123")
    文字列 "123" が正しく整数 `123` に変換され、計算にも使えていますね。
  • strconv.Itoa(456)
    整数 `456` が文字列 "456" に変換され、他の文字列と結合できています。
  • strconv.ParseFloat("3.1415", 64)
    文字列 "3.1415" が `float64` 型の数値 `3.141500` になりました。
  • strconv.FormatFloat(2.718, 'f', -1, 64)
    `float64` 型の数値 `2.718` が文字列 "2.718" に変換されました。
  • strconv.Atoi("abc")
    "abc" は数字ではないので、整数に変換できず、エラーが発生しています。エラー内容 `strconv.Atoi: parsing "abc": invalid syntax` （構文が無効だよ）が表示されています。

ポイントは、文字列から数値への変換 (`Atoi`, `ParseFloat`) では、変換が成功したかどうかのチェック（エラーハンドリング）が必須ということです。

もしエラーチェックを怠ると、変換に失敗したときにプログラムが意図しない動きをしたり、最悪の場合停止（パニック）したりする可能性が出てきます。

文字列と数値の型変換の注意点 - エラーハンドリングの必須性

前述の通り、`strconv` パッケージを使って文字列から数値へ変換する場合、必ずエラーチェックを行いましょう。

例えば、ユーザーに入力してもらった数値をプログラムで使いたいケースを考えてみてください。ユーザーが間違って数字以外の文字（例 "abc"）を入力する可能性は十分にありますよね。
もし `Atoi` や `ParseFloat` の返す `error` を無視してしまうと…

  • 変換に失敗しても気づかず、変な値（多くの場合ゼロ値）のまま処理が進んでしまう。
  • 意図しない計算結果になる。
  • 場合によってはプログラムが予期せず停止する（パニック）。

といった問題が起こりえます。

サンプルコードで示したように、`if err != nil { ... }` の形で、必ずエラーが発生していないかを確認するクセをつけましょう。これが安全なプログラムを作るための第一歩です。

【応用編】その他のGo言語 型変換（型アサーション・型スイッチ）

基本的な数値と文字列の変換をマスターしたら、もう一歩進んでみましょう。

Go言語には `interface{}` という、どんな型でも格納できる特別な型があります。

色々な型の値を一時的にまとめて扱いたい時などに使いますが、`interface{}` 型の変数から元の具体的な型（`int` や `string` など）の値を取り出す際には、特別な型変換の方法が必要になります。
それが型アサーションと型スイッチです。

これは少し応用的な内容なので、「こんな方法もあるんだな」程度に頭の片隅に置いておく感じで大丈夫ですよ。

型アサーション (`value.(Type)`)
`interface{}` 型の値 `value` を、特定の型 `Type` に変換しようと試みます。

もし `value` が実際に `Type` 型の値を持っていれば成功し、そうでなければプログラムが停止（パニック）します。安全に行うには、`value, ok := value.(Type)` のように書いて、`ok` が `true` かどうかで成功を確認します。

package main

import "fmt"

func main() {
    var i interface{} = "hello" // interface{} 型に文字列を格納

    // 文字列型への型アサーション（成功するはず）
    s, ok := i.(string)
    if ok {
        fmt.Printf("型アサーション成功: \"%s\" (型: %T)\n", s, s)
    } else {
        fmt.Println("文字列への型アサーション失敗")
    }

    // 整数型への型アサーション（失敗するはず）
    _, ok = i.(int)
    if ok {
        fmt.Println("整数への型アサーション成功")
    } else {
        fmt.Println("整数への型アサーション失敗")
    }
}

型スイッチ (`switch value.(type)`)
`switch` 文を使って、`interface{}` 型の値 `value` が実際にどの型なのかを判別し、型に応じた処理を行うことができます。

package main

import "fmt"

func printType(v interface{}) {
    switch t := v.(type) {
    case int:
        fmt.Printf("整数です: %d\n", t)
    case string:
        fmt.Printf("文字列です: \"%s\"\n", t)
    case bool:
        fmt.Printf("真偽値です: %t\n", t)
    default:
        fmt.Printf("知らない型です: %T 値: %v\n", t, t)
    }
}

func main() {
    printType(123)
    printType("こんにちは")
    printType(true)
    printType(3.14) // float64 は default にマッチ
}

これらのテクニックは、より柔軟なコードを書く際に役立ちますが、まずは基本の数値・文字列変換をしっかりマスターすることが先決です！

【まとめ】Go言語の型変換を理解してエラーをなくそう！

お疲れ様でした！ Go言語の型変換について、基本から応用まで一通り見てきましたね。
今回の内容を簡単に振り返ってみましょう。

  • Goは静的型付け言語なので、型が違うデータ同士を扱うには型変換が必要。
  • 基本的な数値変換は 変換先の型(変換元の値) で行う。ただしデータ損失に注意。
  • 文字列と数値の変換には strconv パッケージを使う。Atoi, Itoa, ParseFloat, FormatFloatなどが便利。
  • strconv で文字列から数値に変換する際は、必ずエラーハンドリングを行うこと。
  • 応用として、interface{} から特定の型を取り出す型アサーションや型スイッチがある。

型変換は、Goプログラミングの基礎体力のようなものです。しっかり身につければ、型に関するエラーに悩まされることがぐっと減り、よりスムーズに、そして自信を持ってコードを書けるようになるはずです。

今回学んだことを活かして、どんどんGo言語でプログラムを書いてみてくださいね！応援しています！

【関連記事】 Go言語とは？特徴・できること・将来性

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ