Goのコアデータ型：整数、浮動小数点数、ブーリアン、文字列のマスター

シンプルさ、効率性、強力な型付けで知られるGoは、堅牢なアプリケーションを構築するために基本的なデータ型に大きく依存しています。動的型付け言語とは異なり、Goでは変数の型を明示的に定義する必要があり、これによりエラーを早期に検出し、コードの可読性を向上させることができます。この記事では、Goの4つの主要な組み込みデータ型である整数、浮動小数点数、ブーリアン、文字列について掘り下げ、それらの特性と使用方法についての包括的な理解を、実践的なコード例とともに提供します。

整数：カウントの基盤

Goの整数は、有理数部分のない、正および負の整数を表します。Goは、主にサイズ（ビット数）と符号付きか符号なしかによって異なる、さまざまな整数型を提供しています。適切な整数型を選択することは、メモリ効率とオーバーフローエラーの防止にとって重要です。

**符号付き整数：**正の値と負の値の両方を表すことができます。

• int8：-128から127
• int16：-32768から32767
• int32：-2,147,483,648から2,147,483,647（Unicodeコードポイントのruneのエイリアスでもあります）
• int64：-9,223,372,036,854,775,808から9,223,372,036,854,775,807
• int：プラットフォーム依存の符号付き整数型。32ビットシステムでは通常32ビット、64ビットシステムでは64ビットです。正確なサイズが重要でない場合に最も一般的に使用される整数型です。

**符号なし整数：**非負の値（ゼロおよび正）のみを表すことができます。これにより、符号付きの対応物と比較して、同じビットサイズ内に大きな正の数を格納できます。

• uint8：0から255（生のデータのbyteのエイリアスでもあります）
• uint16：0から65535
• uint32：0から4,294,967,295
• uint64：0から18,446,744,073,709,551,615
• uint：intのサイズを反映するプラットフォーム依存の符号なし整数型。
• uintptr：ポインタ値の解釈されていないビットを格納するのに十分な大きさの符号なし整数型。アプリケーションコードで直接使用されることはほとんどありません。

整数の宣言と初期化：

package main

import "fmt"

func main() {
	// 明示的な型宣言
	var age int = 30
	var population int64 = 8_000_000_000 // 可読性のためのアンダースコア（Go 1.13+）
	var score uint8 = 250               // uint8の最大値は255です
	var temperature int = -5

	// 短い変数宣言（型は推論されます）
	count := 100
	id := uint(12345)

	fmt.Printf("Age: %d (Type: %T)\n", age, age)
	fmt.Printf("Population: %d (Type: %T)\n", population, population)
	fmt.Printf("Score: %d (Type: %T)\n", score, score)
	fmt.Printf("Temperature: %d (Type: %T)\n", temperature, temperature)
	fmt.Printf("Count: %d (Type: %T)\n", count, count)
	fmt.Printf("ID: %d (Type: %T)\n", id, id)

	// 整数オーバーフローの例（値が型の範囲を超えるとコンパイル時エラーを引き起こします）
	// var tooBig uint8 = 300 // コンパイル時エラー：定数300はuint8をオーバーフローさせます
}

算術演算を実行する場合、Goではオペランドが同じ型である必要があります。型が異なる場合は、明示的な型変換が必要です。

package main

import "fmt"

func main() {
	var a int = 10
	var b int64 = 20

	// c := a + b // コンパイル時エラー：不一致の型 int と int64

	// 正しい方法：型変換
	c := int64(a) + b
	d := a + int(b)

	fmt.Printf("Result c: %d (Type: %T)\n", c, c)
	fmt.Printf("Result d: %d (Type: %T)\n", d, d)
}

浮動小数点数：小数点の処理

Goの浮動小数点数は、小数点部分を持つ数値を表すために使用されます。これらは、科学計算、金融アプリケーション、グラフィックスなどの精度を伴う計算に不可欠です。Goは2つの浮動小数点型を提供します。

• float32：単精度浮動小数点数、通常は32ビット。精度は低いですが、メモリ使用量も少なくなります。
• float64：倍精度浮動小数点数、通常は64ビット。精度が高く、浮動小数点リテラルの推論されるデフォルトの型です。

浮動小数点数の宣言と初期化：

package main

import "fmt"

func main() {
	var pi float32 = 3.14159
	var gravity float64 = 9.80665
	var price = 19.99 // float64として推論されます

	fmt.Printf("Pi: %f (Type: %T)\n", pi, pi)
	fmt.Printf("Gravity: %f (Type: %T)\n", gravity, gravity)
	fmt.Printf("Price: %f (Type: %T)\n", price, price)

	// 浮動小数点演算
	result := pi * float32(gravity) // 演算を実行するための明示的な変換
	fmt.Printf("Result of multiplication: %f\n", result)

	// 浮動小数点表現の性質上、直接の等値比較は問題が発生することがあります。
	x := 0.1
	y := 0.2
	z := 0.3

	fmt.Println("x + y == z?", (x+y == z)) // 精度問題のため、falseと表示される可能性が高いです
	fmt.Printf("x + y = %.17f\n", x+y)
	fmt.Printf("z     = %.17f\n", z)

	// 等値チェックには、小さなイプシロンとの比較を優先します
	epsilon := 0.00000001
	if (x+y)-z < epsilon && (x+y)-z > -epsilon {
		fmt.Println("x + y is approximately equal to z")
	}
}

ブーリアン：論理ゲート

ブーリアンは真理値を表し、プログラミングにおける制御フローの基本です。ブーリアン変数は、trueまたはfalseの2つの事前定義された値のいずれかを持つことができます。

ブーリアンの宣言と初期化：

package main

import "fmt"

func main() {
	var isActive bool = true
	var isLoggedIn = false // boolとして推論されます

	fmt.Printf("Is Active: %t (Type: %T)\n", isActive, isActive)
	fmt.Printf("Is Logged In: %t (Type: %T)\n", isLoggedIn, isLoggedIn)

	// ブーリアンを使用した条件文
	if isActive && !isLoggedIn {
		fmt.Println("User is active but not logged in.")
	}

	result := 10 > 5  // true
	isEligible := age >= 18 // 'age'が定義されていると仮定
	fmt.Printf("10 > 5 is: %t\n", result)
	// fmt.Printf("Is Eligible: %t\n", isEligible) // 'age'が定義されていればコメント解除
}

ブーリアンは、if、else if、elseステートメント、forループの条件、および論理演算（ANDの&&、ORの||、NOTの!）で広く使用されます。

文字列：テキストデ​​ータの処理

Goの文字列は、不変のUnicode文字（ルーブ）のシーケンスを表します。これらは組み込み型であり、不変の性質により、安全な共有と最適化されたメモリ管理が可能になるため、非常に効率的です。

文字列の宣言と初期化：

package main

import "fmt"

func main() {
	// 解釈された文字列リテラルのための二重引用符
	var message string = "Hello, Go!"
	name := "Alice"
	greeting := "こんにちは世界" // Unicode文字も問題なく使用できます

	fmt.Printf("Message: %s (Type: %T)\n", message, message)
	fmt.Printf("Name: %s (Type: %T)\n", name, name)
	fmt.Printf("Greeting: %s (Type: %T)\n", greeting, greeting)

	// 生文字列リテラル（バッククォート`）：コンテンツを文字通り解釈し、エスケープシーケエンスはありません
	multiLineString := `This is a
multi-line string.
Newlines and special characters like \t are treated as literal.`
	fmt.Println(multiLineString)

	// 文字列の連結
	fullName := name + " Smith"
	fmt.Println("Full Name:", fullName)

	// 文字列の長さ（バイト数）
	fmt.Printf("Length of 'message': %d bytes\n", len(message))
	fmt.Printf("Length of 'greeting': %d bytes (not runes!)\n", len(greeting))

	// 文字列の反復処理（ルーブごと）
	fmt.Println("Iterating over 'greeting':")
	for i, r := range greeting {
		fmt.Printf("Index: %d, Rune: %c (Unicode Value: %U)\n", i, r, r)
	}

	// インデックスによる文字へのアクセス（バイト単位）
	fmt.Printf("First byte of 'message': %c\n", message[0]) // 'H' を表示します
	// fmt.Printf("First byte of 'greeting': %c\n", greeting[0]) // マルチバイトルーブの場合は  が表示される可能性があります
	// ルーブへの直接アクセスには注意が必要です

	// 文字列は不変です：
	// message[0] = 'h' // コンパイル時エラー：message[0]（byte型の値）への代入はできません

	// 部分文字列（スライス）
	part := message[0:5] // "Hello"
	fmt.Println("Sliced part:", part)

	// 文字列比較
	s1 := "apple"
	s2 := "banana"
	s3 := "apple"
	fmt.Printf("'apple' == 'banana': %t\n", s1 == s2)
	fmt.Printf("'apple' == 'apple': %t\n", s1 == s3)
}

Goの文字列はUTF-8でエンコードされています。len()はバイト数を返しますが、for rangeで反復処理するとUTF-8が正しくデコードされ、個々のUnicode rune（int32）値とその開始バイトインデックスが提供されます。この区別は、多文化テキストを扱う際には非常に重要です。

結論

Goの基本的なデータ型—整数、浮動小数点数、ブーリアン、文字列—を理解することは、効果的なGoプログラムを作成するための基盤です。各型は特定の目的を果たし、Goの厳格な型付けは型安全性と予測可能な動作を保証します。適切な型を賢く選択することで、開発者は堅牢で効率的で読みやすいコードを作成できます。これらの基本をマスターすることは、システムプログラミングからWebサービスまで、幅広いアプリケーションのためにGoのパワーを活用するための最初のステップです。進むにつれて、これらの基本的な型が、配列、スライス、マップ、構造体のようなより複雑なデータ構造のビルディングブロックを形成し、Go開発の旅をさらに強化することに気付くでしょう。