これだけは覚えたい！Go言語の基本データ型を詳しく解説

Go言語のデータ型を学ぶことは、Goプログラミングの第一歩としてすごく大事なんですよ。

この記事では、Go言語のプログラミングで必ず使うことになる、基本的なデータの種類（データ型）について、初心者の方でも分かるように、サンプルコードをたっぷり使いながら解説を進めます。

「プログラミングって難しそう…」と思っている人も、データ型の基本が分かれば、コードを書くのがきっと楽しくなりますよ！

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

• データ型がプログラムでどんな役割を担っているか理解できる
• Go言語の基本的なデータ型（数字、文字、Yes/Noなど）を知れる
• それぞれのデータ型をコードでどう書くか、どう使うかが分かる
• 初心者がつまずきやすい注意点も把握できる

Go言語のデータ型とは？

プログラムを書くとき、私たちはコンピュータに色々な情報を扱ってもらいますよね。例えば、計算させたい「数字」や、画面に表示したい「メッセージ（文字）」などです。

データ型というのは、まさにこうした情報の「種類」を区別するためのラベルみたいなものです。「これは数字ですよー」「これは文字ですよー」とコンピュータに教えてあげる役割を持っています。

なぜ種類を区別する必要があるかというと、コンピュータは情報の種類によって扱い方を変える必要があるからです。数字なら足し算や引き算ができますが、文字に足し算をしようとしても困ってしまいますよね？

Go言語では、プログラムを書くときに「この変数（データを入れる箱）には、この種類のデータを入れますよ」と最初に決めるルールになっています。これにより、間違いが起こりにくく、コンピュータも効率よく動作できる、というわけです。

Go言語の主要な基本データ型

Go言語には様々なデータ型が用意されていますが、まずはプログラムの基本となる、以下の4つのデータ型をしっかり押さえていきましょう。これらを使いこなせるようになれば、書けるプログラムの幅がぐっと広がります！

• 整数型 数字の中でも、小数点を含まない数を扱います。
• 浮動小数点数型 小数点を含む数を扱うときに使います。
• 文字列型 文字や文章など、文字の並びを扱います。
• 真偽値型 「はい」か「いいえ」のような、二つの状態だけを表します。

では、それぞれのデータ型について、もっと詳しく見ていきましょう！

整数型 (int, uint) - 数字を扱う基本

まずは、プログラミングで一番よく使うであろう「整数」、つまり小数点のない数字を扱うデータ型です。Go言語では主に int という型を使います。

int はプラスの数、マイナスの数、そしてゼロを扱うことができます。

もしマイナスの数を使わないことが分かっている場合は uint (符号なし整数) という型もありますが、まずは int を使う、と覚えておけば大丈夫でしょう。

変数を宣言して整数を入れる基本的な書き方を見てみます。

package main

import "fmt"

func main() {
    // var を使って変数を宣言し、型(int)を指定して値を代入
    var score int = 100
    fmt.Println(score) // 出力: 100

    // 型推論(:=)を使って宣言と代入を同時に行う (型は自動でintと判断される)
    level := 5
    fmt.Println(level) // 出力: 5

    // 簡単な計算もできます
    totalScore := score + 50
    fmt.Println(totalScore) // 出力: 150
}

上のコードを実行すると、このように表示されます。

100
5
150

var score int = 100 は、「score という名前の箱を用意して、そこには int 型のデータだけを入れます。初期値は 100 です」という意味合いになります。

level := 5 はもっと短く書ける方法で、「level という名前の箱を用意して、5 を入れます。5 は整数なので、型は自動的に int に決めてね」という意味になります。便利なのでよく使われますよ。

浮動小数点数型 (float32, float64) - 小数点を扱う

次に、円周率の3.14や、消費税計算などで出てくるような、小数点を含む数値を扱うデータ型です。Go言語では float64 や float32 を使います。

float64 の方が float32 よりも扱える値の範囲が広く、より細かい小数点以下まで表現できます（高精度）。特別な理由がない限り、通常は float64 を使うのが一般的です。

書き方を見てみましょう。

package main

import "fmt"

func main() {
    // var を使って float64 型の変数を宣言
    var pi float64 = 3.14159
    fmt.Println(pi) // 出力: 3.14159

    // 型推論(:=)を使う (小数点があるので float64 と判断される)
    radius := 5.5
    fmt.Println(radius) // 出力: 5.5

    // 浮動小数点数同士の計算
    area := pi * radius * radius
    fmt.Println(area) // 出力: 95.0330775
}

実行結果はこうなります。

3.14159
5.5
95.0330775

整数型と同じように var で型を明示する方法と、:= で型推論に任せる方法があります。小数点を含む数値を := で宣言すると、自動的に float64 型として扱われることが多いです。

文字列型 (string) - 文字や文章を扱う

プログラムでは、画面にメッセージを表示したり、ユーザーの名前を扱ったりすることがよくありますね。そういった「文字の並び」、つまり文章などを扱うのが string 型です。

Go言語で文字列を表現するには、扱いたい文字の並びをダブルクォーテーション（二重引用符）で囲みます。例えば Hello のような感じです。

package main

import "fmt"

func main() {
    // var を使って string 型の変数を宣言
    var message string = "こんにちは、Go言語！"
    fmt.Println(message) // 出力: こんにちは、Go言語！

    // 型推論(:=) を使う (ダブルクォーテーションで囲まれているので string と判断される)
    name := "Gopher" // Gopher は Go言語のマスコットキャラクターの名前です！
    fmt.Println(name) // 出力: Gopher

    // 文字列は + 記号でつなげることができます
    greeting := message + " " + name + "さん"
    fmt.Println(greeting) // 出力: こんにちは、Go言語！ Gopherさん
}

実行すると、メッセージが表示されます。

こんにちは、Go言語！
Gopher
こんにちは、Go言語！ Gopherさん

日本語のようなマルチバイト文字も問題なく扱えます。文字列同士を + でつなげると、簡単に連結できるのも便利ですね。

真偽値型 (bool) - Yes/Noを扱う

プログラムはよく「もし○○だったら××する」といった条件によって動きを変えます。その「○○」が正しいか、正しくないか、という二つの状態だけを表すのが bool 型です。

bool 型が持つことができる値は true (真、正しい) と false (偽、間違い) の二つだけです。とってもシンプル！

package main

import "fmt"

func main() {
    // var を使って bool 型の変数を宣言 (初期値は false)
    var isReady bool
    fmt.Println(isReady) // 出力: false

    // true を代入
    isReady = true
    fmt.Println(isReady) // 出力: true

    // 型推論(:=) で true を代入
    isOk := true
    fmt.Println(isOk) // 出力: true

    // 比較演算子の結果は bool 型になります
    result := (5 > 3) // 5 は 3 より大きいか？ -> 正しい (true)
    fmt.Println(result) // 出力: true
}

実行結果を見てみましょう。

false
true
true
true

条件分岐（if 文など）で「もし isReady が true なら…」といった形で使われることが多いデータ型です。比較演算子（> や <、== など）を使った結果も bool 型になります。

実践！Go言語 基本データ型サンプルコードと解説

これまで見てきた基本データ型をいくつか組み合わせて、簡単なプログラムを書いてみましょう。変数を宣言して、値を表示するだけのシンプルな例です。

package main

import "fmt"

func main() {
    // プレイヤー情報を変数で管理するイメージ
    playerName := "Hero" // string 型
    playerLevel := 10     // int 型
    playerExp := 150.75   // float64 型
    isBeginner := false  // bool 型

    // fmt.Printf を使うと、書式を指定して表示できる
    // %s は文字列, %d は10進数整数, %f は浮動小数点数, %t は真偽値
    fmt.Printf("プレイヤー名: %s\n", playerName)
    fmt.Printf("レベル: %d\n", playerLevel)
    fmt.Printf("経験値: %f\n", playerExp)
    fmt.Printf("初心者フラグ: %t\n", isBeginner)

    // レベルアップのシミュレーション
    playerLevel = playerLevel + 1 // レベルを1上げる
    isBeginner = (playerLevel <= 10) // レベル10以下なら初心者 (falseになるはず)

    fmt.Printf("レベルアップ！ 新しいレベル: %d\n", playerLevel)
    fmt.Printf("初心者フラグ更新: %t\n", isBeginner)
}

このコードを実行すると、次のような出力が得られます。

プレイヤー名: Hero
レベル: 10
経験値: 150.750000
初心者フラグ: false
レベルアップ！ 新しいレベル: 11
初心者フラグ更新: false

この例では、プレイヤーの名前（string）、レベル（int）、経験値（float64）、初心者かどうか（bool）をそれぞれ変数に入れています。

fmt.Printf という関数を使うと、%s や %d のような特別な記号（フォーマット指定子）を使って、色々な型の値を整形して表示できます。これも覚えておくと便利ですよ。

後半では、レベルを上げたり、レベルに応じて初心者フラグを更新したりしています。このように、変数の値はプログラムの実行中に変更できるのが普通です。

型変換の基本 (Type Conversion)

Go言語は型に厳しい言語で、基本的には 違うデータ型の変数同士を直接計算することはできません。

例えば、整数型の 10 と浮動小数点数型の 5.5 を足し算しようとすると、エラーになってしまいます。「型の種類が違うから計算できないよ！」と怒られちゃうんですね。

こういう場合に必要になるのが「型変換」です。あるデータ型の値を、別のデータ型に変換する操作を指します。書き方はシンプルで、変換したい型名(変換する値) のように書きます。

package main

import "fmt"

func main() {
    intValue := 10
    floatValue := 5.5

    // int型の intValue を float64型 に変換してから足し算
    // mismatched types int and float64 のようなエラーを防ぐ
    result := float64(intValue) + floatValue
    fmt.Println(result) // 出力: 15.5

    // float64型 の result を int型 に変換
    // 小数点以下は切り捨てられる点に注意！
    resultInt := int(result)
    fmt.Println(resultInt) // 出力: 15
}

実行結果です。

15.5
15

float64(intValue) で int 型の 10 を float64 型の 10.0 に変換しています。これで floatValue (5.5) と足し算ができるようになります。

逆に int(result) で float64 型の 15.5 を int 型に変換すると、小数点以下はバッサリ切り捨てられて 15 になる、という点も覚えておきましょう。

ゼロ値 (Zero Value) について

Go言語には「ゼロ値」という考え方があります。これは、変数を宣言したときに、もし初期値を指定しなかった場合、型ごとに自動的に設定される「初期値」のことです。

他のプログラミング言語だと、初期値を入れないと中身が不定（ゴミデータ）になったりエラーになったりすることもありますが、Go言語ではちゃんと初期値が用意されているので安心です。

主な基本データ型のゼロ値は以下の通りです。

• int や他の整数型 → 0
• float32, float64 → 0.0
• string → 空の文字列 ("")
• bool → false

実際にコードで確認してみましょう。

package main

import "fmt"

func main() {
    var number int
    var rate float64
    var text string
    var isValid bool

    // 初期値を代入せずにそのまま表示してみる
    fmt.Printf("intのゼロ値: %d\n", number)
    fmt.Printf("float64のゼロ値: %f\n", rate)
    fmt.Printf("stringのゼロ値: [%s]\n", text) // 空文字だと分かりにくいので[]で囲む
    fmt.Printf("boolのゼロ値: %t\n", isValid)
}

実行結果はこのようになります。

intのゼロ値: 0
float64のゼロ値: 0.000000
stringのゼロ値: []
boolのゼロ値: false

このように、var で宣言しただけだと、それぞれの型のゼロ値が入っていることが分かりますね。これはGo言語の便利な特徴の一つです。

Go言語の基本データ型 利用時の注意点

基本的なデータ型の使い方に慣れてきたところで、初心者のうちにつまずきやすい点をいくつか紹介しておきますね。知っておくと、エラーが出たときにも冷静に対処できるはずです。

• 違う型同士の計算は原則NG
  先ほどの「型変換」でも触れましたが、int と float64 を直接足したり引いたりすることはできません。計算する前に、型を揃えてあげる必要があります。

• := と = の使い分け
  := (コロンイコール) は、新しい変数を「宣言」して、同時に値を「代入」するときに使います。一度宣言した変数に、後から別の値を入れる（再代入する）ときは = (イコール) を使います。これを間違えるとエラーになります。

  // 正しい例
  level := 1 // 宣言と代入
  level = 2  // 再代入
  
  // 間違いやすい例
  // level := 3 // 一度宣言した変数に再度 := は使えない (no new variables on left side of :=)
  

• 整数の割り算の結果
  int 型の変数同士で割り算をすると、結果も int 型になります。つまり、小数点以下は切り捨てられます。例えば 5 / 2 は 2.5 ではなく 2 になります。小数点以下も計算に含めたい場合は、float64 型を使うなどの工夫が必要です。

  fmt.Println(5 / 2) // 出力: 2
  fmt.Println(5.0 / 2.0) // 出力: 2.5
  

これらの点を頭の片隅に置いておくと、スムーズにプログラミングを進めやすくなりますよ。

【まとめ】Go言語のデータ型の基本をマスターしよう

お疲れ様でした！ 今回は、Go言語のプログラミングの本当に基礎となる、基本的なデータ型について見てきました。

• 整数 (int) 小数点のない数字
• 浮動小数点数 (float64) 小数点のある数字
• 文字列 (string) 文字や文章
• 真偽値 (bool) true か false

これらの基本データ型を理解し、変数に入れて扱えるようになることが、Go言語でプログラムを書く上での土台になります。最初は少し戸惑うかもしれませんが、実際にコードを書いて動かしてみるのが一番の近道です。

今回学んだデータ型は、これから学ぶであろう条件分岐（if文）や繰り返し（for文）、関数といった、もっと複雑なプログラムを作る際にも必ず登場します。

ぜひ、この記事のサンプルコードを自分で打ち込んで実行したり、少し数値を変更したりして、データ型の動きに慣れてみてくださいね。基本をしっかり押さえたので、自信を持ってGo言語の学習を進めていきましょう！

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