ホーム / Go言語 /

Go言語varでの変数宣言をマスター！書き方と使い方を徹底解説

2025年4月16日水曜日

Go言語

Go言語の変数宣言`var`、しっかり理解できていますか？ プログラミングの世界に足を踏み入れたばかりだと、「変数ってそもそも何？」「`var`ってどう書くの？」なんて疑問が次々湧いてくるかもしれませんね！

この記事では、Go言語のキホン中のキホン、varを使った変数宣言について、どこよりも分かりやすく、そして楽しく解説していきます！ 小難しい話は抜きにして、具体的なコードを見ながら進めていきましょう。

この記事で学べること

  • 変数って何？ なぜ宣言が必要なの？ という基本のキ
  • varを使った変数宣言の基本的な書き方
  • 型を指定する方法と、Go言語が賢く型を推測してくれる仕組み
  • 変数の「ゼロ値」ってなんだろう？
  • 複数の変数をまとめて宣言するテクニック
  • 実際に動くサンプルコードとその詳しい解説
  • 初心者がハマりがちなvar宣言の注意点

Go言語における変数と宣言の重要性

プログラミングをしていると、計算結果やユーザーが入力した名前など、色々なデータを一時的に覚えておく必要が出てきます。

そんな時に使うのが「変数」です。変数は、データを入れておくための「名前付きの箱」みたいなものだと考えてみてください。

Go言語のような「静的型付け言語」と呼ばれるタイプのプログラミング言語では、この箱を使う前に「こういう名前で、こういう種類のデータを入れる箱を使いますよ！」と、あらかじめコンピューターに教えてあげる必要があります。これを「変数宣言」と呼びます。

なぜ宣言が必要かというと、Go言語はプログラムが動く前に、変数に想定外のデータが入らないかなどをしっかりチェックしてくれるからです。ちょっと面倒に感じるかもしれませんが、のおかげで、プログラムの間違いが減って、より安全なコードが書けるようになるのですね！

今回は、その変数宣言の中でも基本となるvarキーワードを使った方法をじっくり見ていきましょう！

Go言語の基本的な変数宣言 - `var`キーワードの使い方

さっそく、Go言語で変数を宣言する一番基本的な方法、varキーワードの使い方を見ていきましょう。基本の形はこうです。

var 変数名 型

たったこれだけ！順番に見ていくと…

  • var これは「これから変数を宣言しますよ！」というGo言語へのお知らせキーワードです。
  • 変数名 これが、データを入れておく箱（変数）に付ける名前です。自分で好きな名前を付けられますが、分かりやすい名前を付けるのがコツです。（例 age, userName など）
  • 型 これは、その箱（変数）にどんな種類のデータを入れるかを指定します。例えば、整数を入れるならint、文字列を入れるならstringといった具合です。

この3つをスペースで区切って書くのが基本ルール。簡単でしょう？

varを使った変数宣言の書き方（型指定あり）

では、実際にデータ型を指定して変数を宣言してみます。

例えば、年齢を入れるための変数ageを宣言したい場合、年齢は整数なのでint型を使います。

package main

import "fmt"

func main() {
  // int型の変数ageを宣言
  var age int
  fmt.Println(age) // この時点での値を見てみる
}

書き方：

var age int

同じように、ユーザー名（文字列）を入れる変数userNameならstring型、ログイン状態（真偽値）を表す変数isLoggedInならbool型を使います。

package main

import "fmt"

func main() {
  // string型の変数userNameを宣言
  var userName string
  // bool型の変数isLoggedInを宣言
  var isLoggedIn bool

  fmt.Println(userName)
  fmt.Println(isLoggedIn)
}

書き方：

var userName string
var isLoggedIn bool

このように、変数を使う前にvarを使って「この名前の変数には、こういう種類のデータを入れます」と型を明示するのが、Go言語の基本スタイルです。

型を指定することで、コンピューターはその変数のためにどれくらいのメモリ（記憶領域）を用意すればいいか分かりますし、違う種類のデータが入ってしまうミスを防げるわけですね。

変数への値の代入と初期値

変数を宣言しただけでは、まだ箱は空っぽ（正確には後述する「ゼロ値」が入っています）です。宣言した変数にデータを入れるには、=（イコール）記号を使います。これを「代入」と呼びます。

package main

import "fmt"

func main() {
  var message string // string型の変数messageを宣言

  // 変数messageに値を代入
  message = "こんにちは、Go言語！"

  fmt.Println(message)
}

書き方：

var message string
message = "こんにちは、Go言語！" // 宣言後に値を代入

ソースコードの表示結果：

こんにちは、Go言語！

また、宣言と同時に最初の値（初期値）を入れてしまうことも可能です。これもよく使う書き方ですよ。

package main

import "fmt"

func main() {
  // 宣言と同時に初期値を代入
  var score int = 100
  var greeting string = "Hello!"

  fmt.Println(score)
  fmt.Println(greeting)
}

書き方：

var score int = 100     // int型の変数scoreを宣言し、初期値100を代入
var greeting string = "Hello!" // string型の変数greetingを宣言し、初期値"Hello!"を代入

ソースコードの表示結果：

100
Hello!

宣言だけして後から代入するか、宣言と同時に初期値を入れるかは、状況に応じて使い分けます。 どちらの方法も覚えておくと便利です。

Go言語の`var`宣言における型推論

先ほど、変数を宣言するときには型を指定すると説明しましたね。でも、Go言語は賢いので、場合によっては型指定を省略することもできるんです！

宣言と同時に初期値を代入する場合、Goコンパイラはその初期値を見て、「あ、これは整数だな」「これは文字列だな」と判断し、自動的に変数の型を決めてくれます。これを「型推論（かたすいろん）」と呼びます。

書き方はこうです。

var 変数名 = 初期値 // 型の指定を省略！

具体例を見てみましょう。

package main

import "fmt"

func main() {
  // 型推論を使った変数宣言
  var count = 10        // 初期値10を見て、int型だと推論される
  var appName = "MyApp" // 初期値"MyApp"を見て、string型だと推論される
  var isValid = true    // 初期値trueを見て、bool型だと推論される

  fmt.Printf("countの型: %T, 値: %v\n", count, count)
  fmt.Printf("appNameの型: %T, 値: %v\n", appName, appName)
  fmt.Printf("isValidの型: %T, 値: %v\n", isValid, isValid)
}

書き方：

var count = 10
var appName = "MyApp"
var isValid = true

ソースコードの表示結果：

countの型: int, 値: 10
appNameの型: string, 値: MyApp
isValidの型: bool, 値: true

%Tを使うと変数の型を、%vを使うと変数の値を確認できます。実行結果を見ると、ちゃんとGo言語が型を推論してくれているのが分かりますね。

型推論を使うと、コードが少しスッキリします。ただし、型推論を使うには、必ず宣言と同時に初期値を指定する必要がある点に注意してくださいね。

型推論が使われる場面

型推論は、どんな時に使うと便利なのでしょうか？

一番分かりやすいのは、初期値を見れば型が明らかな場合です。

package main

import "fmt"

func main() {
	// 整数だと明らか
	var loopCount = 5

	// 文字列だと明らか
	var defaultMessage = "処理を開始します。"

	// 関数の戻り値を受ける時なども便利
	// (ここでは例として直接値を代入)
	var result, err = someFunction() // someFunctionが(int, error)を返すと仮定

	fmt.Println(loopCount)
	fmt.Println(defaultMessage)
	fmt.Println(result, err) // エラーも一緒に受け取る例
}

// 架空の関数（例示用）
func someFunction() (int, string) {
	return 10, "OK" // 仮の戻り値
}

書き方：

var loopCount = 5
var defaultMessage = "処理を開始します。"
var result, err = someFunction()

このように、= 5 と書けば誰が見ても整数（int）だと分かりますし、= "処理を開始します。" と書けば文字列（string）だと分かりますよね。こういう場合は、わざわざ var loopCount int = 5 と書かなくても、型推論に任せた方がコードが短くなります。

また、関数が複数の値を返す場合（Go言語ではよくあります）、それらをまとめて受け取るときにも型推論が便利です。

ただし、コードを読む人が型をすぐに理解できるかどうかが選択のポイントです。場合によっては、あえて型を明示した方が分かりやすいこともありますよ。

Go言語の`var`宣言とゼロ値

変数を宣言するとき、もし初期値を指定しなかったら、その変数の中身はどうなるのでしょうか？ エラーになる？ それとも空っぽ？

Go言語では、初期値を指定せずにvarで変数を宣言すると、自動的に各データ型の「ゼロ値」と呼ばれる初期値が設定されます。 これは、変数が予期せぬ値を持つのを防ぐための、Go言語の親切な仕組みです。

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

  • 数値型（int, float64など） → 0
  • bool型 → false
  • string型 → "" (空文字列)
  • ポインタ、インターフェース、スライス、チャネル、マップ、関数型 → nil

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

package main

import "fmt"

func main() {
  var initialScore int
  var initialRatio float64
  var isActive bool
  var defaultName string

  fmt.Printf("int型のゼロ値: %v\n", initialScore)
  fmt.Printf("float64型のゼロ値: %v\n", initialRatio)
  fmt.Printf("bool型のゼロ値: %v\n", isActive)
  fmt.Printf("string型のゼロ値: %v\n", defaultName)
  fmt.Printf("string型のゼロ値（引用符付き）: %q\n", defaultName) // %qで表示
}

ソースコードの表示結果：

int型のゼロ値: 0
float64型のゼロ値: 0
bool型のゼロ値: false
string型のゼロ値: 
string型のゼロ値（引用符付き）: ""

このように、値を代入しなくても、それぞれの型に応じたゼロ値が自動で入っていることが分かりますね。特にstring型は空の文字列""になる点を覚えておきましょう。

このゼロ値のおかげで、「変数を宣言したけど、値を入れるのを忘れていた！」という場合でも、プログラムが予測不能な動きをするのを避けられます。

`var`を使った複数の変数宣言

プログラムを書いていると、同じ型の変数をいくつかまとめて宣言したい時や、いくつかの変数を一度に宣言したい時があります。そんな時に便利な書き方もありますよ。

まず、同じ型の変数を複数宣言する場合です。カンマ,で区切って変数名を並べます。

package main

import "fmt"

func main() {
  // 同じ型の変数をまとめて宣言
  var x, y int // int型の変数xとyを宣言
  x = 10
  y = 20

  fmt.Println(x, y)

  var name1, name2 string = "Alice", "Bob" // 宣言と同時に初期化も可能
  fmt.Println(name1, name2)
}

書き方：

var x, y int
var name1, name2 string = "Alice", "Bob"

ソースコードの表示結果：

10 20
Alice Bob

さらに、異なる型の変数でも、varキーワードと括弧( )を使えば、まとめて宣言できます。これはコードの先頭でまとめて変数を宣言したい時などに見やすくなります。

package main

import "fmt"

func main() {
  // 異なる型の変数をまとめて宣言
  var (
    employeeID int    = 1001
    employeeName string = "Taro Yamada"
    isManager bool   = false
  )

  fmt.Println("社員ID:", employeeID)
  fmt.Println("氏名:", employeeName)
  fmt.Println("管理者フラグ:", isManager)
}

書き方：

var (
  employeeID int    = 1001
  employeeName string = "Taro Yamada"
  isManager bool   = false
)

ソースコードの表示結果：

社員ID: 1001
氏名: Taro Yamada
管理者フラグ: false

このように複数の変数をまとめて宣言する方法を知っていると、コードがスッキリして読みやすくなりますね。 状況に合わせて使い分けてみてください。

`var`宣言の実践サンプルプログラム

それでは、これまで見てきたvarを使った変数宣言の色々な方法を組み合わせた、簡単なサンプルプログラムを見てみましょう！

package main

import "fmt"

func main() {
  // --- 基本的な宣言 ---
  // 型を指定して宣言 (ゼロ値が設定される)
  var score int
  // 型を指定して宣言し、初期値を代入
  var playerName string = "Hero"

  // --- 型推論を使った宣言 ---
  var level = 1 // int型と推論される
  var exp = 0.0 // float64型と推論される (小数点はfloat64)

  // --- まとめて宣言 ---
  var (
    hp int = 100
    mp int = 50
  )

  // --- 値の代入 ---
  score = 1500 // 宣言済みの変数scoreに値を代入

  // --- 変数の値を出力 ---
  fmt.Println("--- プレイヤー情報 ---")
  fmt.Printf("名前: %s\n", playerName)
  fmt.Printf("レベル: %d\n", level)
  fmt.Printf("HP: %d / MP: %d\n", hp, mp)
  fmt.Printf("経験値: %.1f\n", exp) // %.1f で小数点以下1桁表示
  fmt.Printf("スコア: %d\n", score)

  // bool型の例 (型推論)
  var gameClear = false
  fmt.Printf("ゲームクリア状況: %t\n", gameClear) // %t でbool値を出力
}

ソースコードの表示結果：

--- プレイヤー情報 ---
名前: Hero
レベル: 1
HP: 100 / MP: 50
経験値: 0.0
スコア: 1500
ゲームクリア状況: false

このプログラムでは、型を指定した宣言、初期値付きの宣言、型推論、そしてまとめて宣言を使っています。宣言した変数に後から値を代入する例も含まれていますね。最後にfmt.Printfを使って、それぞれの変数の値を分かりやすく表示しています。

サンプルコードの解説

上のサンプルコードを少し詳しく見てみましょう。

// 型を指定して宣言 (ゼロ値が設定される)
var score int
// 型を指定して宣言し、初期値を代入
var playerName string = "Hero"

ここでは、scoreはint型として宣言され、初期値は指定されていないのでゼロ値の0が入ります。一方、playerNameはstring型で宣言され、同時に初期値Heroが代入されています。

// 型推論を使った宣言
var level = 1 // int型と推論される
var exp = 0.0 // float64型と推論される (小数点はfloat64)

levelは初期値1からint型、expは初期値0.0（小数点があるので）からfloat64型と、Go言語が自動で型を推論してくれます。わざわざintやfloat64と書かなくてもOKです。

// まとめて宣言
var (
  hp int = 100
  mp int = 50
)

hpとmpという2つのint型の変数を、var()を使ってまとめて宣言し、同時に初期値も設定しています。

// 値の代入
score = 1500 // 宣言済みの変数scoreに値を代入

最初に宣言したscore（この時点ではゼロ値の0が入っている）に、1500という新しい値を代入しています。一度宣言した変数には、このように後から何度でも値を代入し直すことができます（同じ型の値に限ります）。

// 変数の値を出力
fmt.Println("--- プレイヤー情報 ---")
fmt.Printf("名前: %s\n", playerName)
// ... (以下略) ...

fmt.Printlnやfmt.Printfは、変数の中身を確認するためによく使われる関数です。%sは文字列、%dは整数、%fは浮動小数点数、%tは真偽値を出力するための「書式指定子」と呼ばれるものです。

このように、基本的な宣言、型推論、まとめて宣言などを組み合わせることで、プログラムに必要な様々なデータを扱えるようになります。

Go言語`var`宣言の注意点

varを使った変数宣言は基本ですが、いくつか初心者が「あれ？」となりやすい注意点があります。知っておくとスムーズに開発を進められますよ！

  1. 宣言したけど使わない変数はエラーになる

    Go言語では、varで宣言した変数をプログラムの中で一度も使わないと、コンパイル時に「declared but not used（宣言されたけど使われてないよ！）」というエラーになります。

    package main

func main() {
    var unusedVar int // 宣言したけど…
    // この変数unusedVarをどこでも使わない

    // fmt.Println(unusedVar) // ← この行がないとエラーになる！
}

    これは、無駄な変数が残るのを防ぎ、コードをきれいに保つためのGo言語のルールです。もし一時的に使わない変数を残しておきたい場合は、_（ブランク識別子）に代入するという方法もありますが、基本的には使わない変数は削除するか、コメントアウトしましょう。

  2. 同じ名前の変数を同じ場所で再宣言できない

    一度varで宣言した変数と同じ名前で、同じスコープ（有効範囲、例えば同じ関数の中）で再度varを使って宣言しようとすると、「no new variables on left side of :=」や「redeclaration of ○○」のようなエラーになります。

    package main

import "fmt"

func main() {
    var count int = 10
    fmt.Println(count)

    // var count string = "hello" // ← これはエラー！同じ名前で再宣言はできない
    // count = 20 // ← 値の再代入はOK (型が同じなら)
}

    変数名は、その有効範囲内でユニーク（唯一）である必要があります。違う値を入れたい場合は、再宣言ではなく「再代入」を使います。

  3. シャドーイングに注意

    少し応用的な話ですが、「シャドーイング」という現象があります。これは、例えば関数の外側で宣言した変数と同じ名前の変数を、関数の中で新たに宣言してしまうケースです。すると、関数の中では内側で宣言した変数が優先され、外側の変数が隠れて（シャドーイングされて）しまいます。

    package main

import "fmt"

var globalVar int = 100 // 関数の外で宣言 (グローバル変数)

func main() {
    fmt.Println("main関数開始時のglobalVar:", globalVar) // 出力: 100

    var globalVar int = 200 // main関数の中で同じ名前の変数を宣言 (シャドーイング)
                            // これはエラーにはならないが、注意が必要

    fmt.Println("main関数の中のglobalVar:", globalVar) // 出力: 200 (内側の変数が優先される)

    anotherFunc()
}

func anotherFunc() {
    // この関数からは、外側のglobalVarが見える
    fmt.Println("anotherFuncの中のglobalVar:", globalVar) // 出力: 100
}

    意図しないシャドーイングはバグの原因になることもあるので、変数名をつけるときは、既にある変数名と被らないように気をつけるのがおすすめです。

これらの注意点を知っておけば、エラーが出たときも慌てずに対処できますね！

【まとめ】`var`を使った変数宣言をマスターしよう

今回はGo言語の変数宣言の基本、varキーワードの使い方について、たっぷり解説しました。

最後に、今回のポイントを復習しておきましょう。

  • 変数はデータを覚えておくための「名前付きの箱」。
  • Go言語ではvar 変数名 型で変数を宣言するのが基本。
  • 宣言と同時に初期値を代入できる var 変数名 型 = 初期値。
  • 初期値があれば型を省略できる「型推論」var 変数名 = 初期値も便利。
  • 初期値を指定しないと、型に応じた「ゼロ値」が自動で入る。
  • var x, y intやvar()で複数の変数もまとめて宣言可能。
  • 宣言した変数は必ず使う！使わないとエラーになる。
  • 同じ場所で同じ名前の変数は再宣言できない。

varを使った変数宣言は、Go言語プログラミングの本当に基礎となる部分です。この記事で紹介した書き方や注意点をしっかり押さえておけば、自信を持ってコードを書き進められるようになります。

Go言語には、var以外にも:=を使ったもっと短い変数宣言の方法もありますが、まずはこのvarをしっかり理解しておくことが、次のステップに進むための近道です。

ぜひ、サンプルコードを実際に動かしてみて、変数宣言に慣れていってくださいね！

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

このブログを検索
  • ()

自己紹介

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

QooQ