基本データ型【数値型、文字型、ブール型、文字列】#
数値型【整数型、浮動小数点型】#
整数型【符号付き整数型、符号なし整数型、その他の整数型】#
== 整数値を格納する型、デフォルト値は 0==
【1】符号付き整数型：
| 型 | 符号の有無 | 占有ストレージ | 表数範囲 |
|---|---|---|---|
| int8 | 有 | 1 バイト | -27~27-1（-128~127） |
| int16 | 有 | 2 バイト | -215~215-1（-32768~32767） |
| int32 | 有 | 4 バイト | -231~231-1（-2147483648~2147483647） |
| int64 | 有 | 8 バイト | -263~263-1 |
【2】符号なし整数型：
| 型 | 符号の有無 | 占有ストレージ | 表数範囲 |
|---|---|---|---|
| uint8 | 無 | 1 バイト | 0~255 |
| uint16 | 無 | 2 バイト | 0~216-1 |
| uint32 | 無 | 4 バイト | 0~231-1 |
| uint64 | 無 | 8 バイト | 0~263-1 |
【3】その他の整数型：
| 型 | 符号の有無 | 占有ストレージ | 表数範囲 |
|---|---|---|---|
| int | 有 | 32 ビットシステムで 4 バイト 64 ビットシステムで 8 バイト | -231~231-1 -263~263-1 |
| uint | 無 | 32 ビットシステムで 4 バイト 64 ビットシステムで 8 バイト | 0~232-1 0~264-1 |
| rune | 有 | int32 と等価 | -231~231-1 |
| byte | 無 | uint8 と等価 | 0~255 |
浮動小数点型#
== 小数値を格納する型、デフォルト値は 0==
| 型 | 占有ストレージ | 表数範囲 |
|---|---|---|
| float32 | 4 バイト | -3.403E38~3.403E38 |
| float64 | 8 バイト | -1.798E308~1.798E308 |
golangのデフォルトの浮動小数点型はfloat64です
文字型#
Golangには専用の文字型がなく、単一の文字を保存する場合は一般的にbyteを使用します
ASCII 表：
漢字の文字はUnicodeコード値に対応しており、byte型はオーバーフローするため、intを使用できます
UTF-8 エンコーディング表 :
== まとめ：Golang の文字は UTF-8 エンコーディングを使用しています（Unicode は対応する文字セットで、UTF-8 はその中の一つのエンコーディング方式です）==
エスケープ文字：
ブール型
== 値は true と false のみを許可する型、デフォルト値は false==
ブール型は bool 型とも呼ばれ、1 バイトを占有し、論理演算に適しており、一般的にプログラムのフロー制御に使用されます
文字列#
== 固定長の文字が連結された文字列、デフォルト値は ""==
1、特殊文字がない場合、ダブルクォーテーション""で表します；特殊文字がない場合、バッククォート``で表します
package main
import "fmt"
func main() {
var str1 string = "abc"
fmt.Println(str1)
var str2 string = `a\b\c`
fmt.Println(str2)
}
2、文字列の結合と注意事項：
package main
import "fmt"
func main() {
var str1 string = "abc" + "def"
str1 += "xyz"
fmt.Println(str1)
//文字列の結合が長すぎて改行したい場合、各行は必ずプラス記号で終わる必要があります
var str2 string = "abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc" +
"abc" + "abc" + "abc"
fmt.Println(str2)
}
基本データ型間の変換#
Go言語では異なる型の変数間の代入には明示的な変換が必要で、明示的な変換（強制変換）のみが可能です
package main
import "fmt"
func main() {
var n1 int = 100
//var n2 float32 = n1 これは変換できず、明示的な変換が必要です
var n2 float32 = float32(n1)
fmt.Println(n1)
fmt.Println(n2)
//int64からint8に変換する場合、コンパイルエラーは発生しませんが、データがオーバーフローします。これは大きなオブジェクトを小さなコンテナに詰め込むようなものです
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4) //出力は56
}
基本データ型と string の変換#
== 開発中に、基本データ型を string に変換したり、string を基本データ型に変換したりする必要がよくあります ==
方法 1#
fmt.Sprintf("%パラメータ"，式)、パラメータと式の型が一致する必要があります
package main
import "fmt"
func main() {
var n1 int = 15
var n2 float32 = 5.5
var n3 bool = true
var n4 byte = 'A'
var m1 string = fmt.Sprintf("%d", n1)
fmt.Printf("m1のデータ型は：%T, %q", m1, m1)
fmt.Println()
var m2 string = fmt.Sprintf("%f", n2)
fmt.Printf("m2のデータ型は：%T,%q", m2, m2)
fmt.Println()
var m3 string = fmt.Sprintf("%t", n3)
fmt.Printf("m3のデータ型は：%T,%q", m3, m3)
fmt.Println()
var m4 string = fmt.Sprintf("%c", n4)
fmt.Printf("m4のデータ型は：%T,%q", m4, m4)
}
実行結果
m1のデータ型は：string, "15"
m2のデータ型は：string,"5.500000"
m3のデータ型は：string,"true"
m4のデータ型は：string,"A"
方法 2#
strconvパッケージの関数を使用
package main
import (
"fmt"
"strconv"
)
func main() {
var n1 int = 15
//最初の引数はint64に変換する必要があり、2番目の引数は進数を指定します
var m1 string = strconv.FormatInt(int64(n1), 10)
fmt.Printf("m1のデータ型は：%T, %q", m1, m1)
fmt.Println()
var n2 float64 = 5.5
//2番目の引数'f'（-ddd.dddd）、3番目の引数は小数点以下の桁数を指定し、4番目の引数は浮動小数点型を指定します
var m2 string = strconv.FormatFloat(n2, 'f', 9, 64)
fmt.Printf("m2のデータ型は：%T,%q", m2, m2)
fmt.Println()
var n3 bool = true
var m3 string = strconv.FormatBool(n3)
fmt.Printf("m3のデータ型は：%T,%q", m3, m3)
fmt.Println()
}
実行結果
m1のデータ型は：string, "15"
m2のデータ型は：string,"5.500000000"
m3のデータ型は：string,"true"
== まとめ：主に方法 1 を使用します ==
string 型を基本型に変換#
strconvパッケージの関数を使用
package main
import (
"fmt"
"strconv"
)
func main() {
//string---->bool
var n1 string = "true"
var m1 bool
//ParseBool関数の戻り値は2つ(value bool, err error)
//valueは得られたブール型のデータで、errは発生したエラーで、errは_で直接無視できます
m1, _ = strconv.ParseBool(n1)
fmt.Printf("m1のデータ型は：%T, %v", m1, m1)
fmt.Println()
//string---->int64
var n2 string = "55"
var m2 int64
//2番目の引数は進数を指定し、3番目の引数は結果がオーバーフローせずに代入できる整数型を指定します。0、8、16、32、64はそれぞれint、int8、int16、int32、int64を表します
m2, _ = strconv.ParseInt(n2, 10, 64)
fmt.Printf("m2のデータ型は：%T, %v", m2, m2)
fmt.Println()
//string---->float
var n3 string = "8.8"
var m3 float64
//2番目の引数は期待される受信型を指定し、32はfloat32（戻り値は精度を変えずにfloat32に代入できます）、64はfloat64を表します
m3, _ = strconv.ParseFloat(n3, 64)
fmt.Printf("m3のデータ型は：%T, %v", m3, m3)
fmt.Println()
//注意：必ずstring型が有効なデータに変換できることを確認してください。例えば、"123"を整数に変換できますが、"Hello"を整数に変換することはできません。そうしないと、変換後の型のデフォルト値になります
var n4 string = "golang"
var m4 bool
m4, _ = strconv.ParseBool(n4)
fmt.Printf("m4のデータ型は：%T, %v", m4, m4)
fmt.Println()
var n5 string = "golang"
var m5 int64
m5, _ = strconv.ParseInt(n5, 10, 64)
fmt.Printf("m5のデータ型は：%T, %v", m5, m5)
}
実行結果
m1のデータ型は：bool, true
m2のデータ型は：int64, 55
m3のデータ型は：float64, 8.8
m4のデータ型は：bool, false
m5のデータ型は：int64, 0