Goのデータ型
■Goのデータについて
Goのプログラミングでは、変数にどんなデータが入るのか？型の宣言をしなければならない！
例えば
var x uint→変数ｘは8ビット整数
などのように、特定の型を宣言しなければならない！
■型の種類
1）論理値型
論理値（プール値）型は、boolとして定義されていて、treue（真）とfalse（偽）の2つの定数がある。
2）整数型
・intやuintのデータサイズはシステムに依存する
3）浮動小数点型
実数を保存する浮動小数点型
実数の計算では、実数を2進数の内部表現に変換する際に誤差を発生することがある。
4）複素数型
実数部と虚数部からなる複素数
5）文字列型
文字列型は0文字以上の文字からなる文字列の値を表示します。
文字列型は、string
例文1
var a,b,c string
a = "ABCdef"
b = "123456"
c = a + b →ABCdef123456
例文2
package main
import "fmt"
func main() {
var s = "hello,go language"
d := s[0:5]
fmt.Println(d)
}
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run 文字列.go
hello
6)配列型
配列は、同じ型の要素を並べたもの、変数を宣言するときには、型の名前の前に[ ]で要素数を指定する
var vi [5]int //要素数5の整数配列
var vf[10]float32 //要素数10の整数配列
7）スライス型
スライスとは、ある配列内の連続した領域への参照です。スライスは配列と似ていますが、最も特徴的な点は、Go の配列は宣言した時点で型とサイズが決められているのに対して、「スライスはサイズが決められていない」という点
例えば
a := []int{1, 2, 3} // [3] や [...] などと書く配列と違い、[] と書く
fmt.Println(a) // [1 2 3]
fmt.Println(a[0]) // 1
「スライス.go」ファイルを下記のようにコーデング
package main
import "fmt"
// スライスの情報 (内容、長さ、キャパシティ) を表示する関数
func printInfo(a []int) {
s := fmt.Sprintf("%v", a)
fmt.Printf("%-22s %3d %3d\n", s, len(a), cap(a))
}
// main 関数
func main() {
a := []int{} // 空のスライス (nil)
// ヘッダの表示
fmt.Printf("%-22s len cap\n", "values")
// スライスに 1 から 10 までの数字を追加
for i := 0; i < 10; i++ {
a = append(a, i+1) // 値を追加
printInfo(a) // 情報の表示
}
}
実行結果
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run スライス.go
values len cap
[1] 1 1
[1 2] 2 2
[1 2 3] 3 4
[1 2 3 4] 4 4
[1 2 3 4 5] 5 8
[1 2 3 4 5 6] 6 8
[1 2 3 4 5 6 7] 7 8
[1 2 3 4 5 6 7 8] 8 8
[1 2 3 4 5 6 7 8 9] 9 16
[1 2 3 4 5 6 7 8 9 10] 10 16
8）構造体型
構造体は、フィールドと呼ばれる要素の集まり。
Go の構造体は struct キーワードを使って、次のように定義する。
type 構造体の名前 struct {
フィールド名1 データ型1
フィールド名2 データ型2
...
}
例文 「kouzou.go」ファイルを作って、実行してみる
package main
import "fmt"
type person struct {
name string
age int
}
func (p person) hello() {
fmt.Printf("%s (%d)\n", p.name, p.age)
}
func main() {
p := person{
name: "John",
age: 30,
}
p.hello() // John (30)
}
・実行結果
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run kouzou.go
John (30)
9）ポインター型
ポインターとは、メモリ上のオブジェクト（もの）を示す値で、ポインター変数の値は、それが示している変数のアドレス
書式
var 変数名 *型 = &値
「ポインタ.go」ファイルを作り、実行する
package main
import (
"fmt"
)
func main() {
var number int = 10
fmt.Println(&number) //0xc0001e6230
var numberP *int = &number
fmt.Println(numberP) //0xc0001e6230
fmt.Println(*numberP) //10
}
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run ポインタ.go
0xc000016098
0xc000016098
10
10）関数型
関数は呼び出し可能な名前がある一連のプログラムコード。関数型は、同一のパラメーターと同一の戻り値を持つ、全ての関数の集合を表します。
サンプルファイル「kansu.go」
package main
import "fmt"
func main() {
var f func()←関数宣言
f = greet
f()
}
func greet() {
fmt.Println("hello")
}
・実行
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run kansu.go
hello
11）インターフェース型
インターフェースは、インターフェースを介してインターフェースと一致する複数の異なるメソッドを同じ方法で呼び出せるようにするもの
・インターフェイスを定義する構文
type <型名> interface {
メソッド名(引数の型, ...) (返り値の型, ...)
・
・
}
サンプルファイル「interface.go」
package main
import "fmt"
// 食べるためのインターフェース
type Eater interface{
PutIn() // 口に入れる
Chew() // 噛む
Swallow() // 飲み込む
}
// 人間の構造体
type Human struct{
Height int // 身長
}
// カメの構造体
type Turtle struct{
Kind string // 種類
}
// 人間用のインターフェースの実装
func (h Human) PutIn(){
fmt.Println("道具を使って丁寧に口に運ぶ")
}
func (h Human) Chew(){
fmt.Println("歯でしっかり噛む")
}
func (h Human) Swallow(){
fmt.Println("よく噛んだら飲み込む")
}
// カメ用のインターフェースの実装
func (h Turtle) PutIn(){
fmt.Println("獲物を見つけたら首をすばやく伸ばして噛む")
}
func (h Turtle) Chew(){
fmt.Println("クチバシで噛み砕く")
}
func (h Turtle) Swallow(){
fmt.Println("小さく砕いたら飲み込む")
}
// インターフェースが引数になる、食べるメソッド
func EatAll(e Eater){
e.PutIn() // インターフェースから呼び出す
e.Chew()
e.Swallow()
}
func main() {
var man Human = Human{Height: 300} // 人間用の構造体を作成
var cheloniaMydas = Turtle{Kind: "アオウミガメ"} // カメ用の構造体を作成
var eat Eater // インターフェースEater型の変数を用意
fmt.Println("＜人間が食べる＞")
eat = man // Human型がインターフェースであるEater型に変換される
EatAll(eat) // インターフェースを引数に関数を呼ぶ
fmt.Println("＜カメが食べる＞")
eat = cheloniaMydas // Turtle型がインターフェースであるEater型に変換される
EatAll(eat)
}
・実行
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run interface.go
＜人間が食べる＞
道具を使って丁寧に口に運ぶ
歯でしっかり噛む
よく噛んだら飲み込む
＜カメが食べる＞
獲物を見つけたら首をすばやく伸ばして噛む
クチバシで噛み砕く
小さく砕いたら飲み込む
12）マップ型
マップは、キーと値を持つ値
m := map[string]int{
"maku": 14,
"puni": 7,
"hemu": 10,
}
fmt.Printf("%v\n", m) //=> map[maku:14 puni:7 hemu:10]
13）チャンネル型
チャンネルは同時に実行されている2つの関数に、同期実行と特定の要素型の値を受ける渡す通信機構を提供する。
ch := make(chan int)
// 送信
ch <- 1
// 受信
result := <-ch
サンプル「チャンネル.go」
package main
import "fmt"
func main() {
ch := make(chan int)
go send100(ch)
x := <-ch
fmt.Println(x)
}
func send100(ch chan int) {
ch <- 100
}
send100関数で100を送信しmain関数の方で取り出しています。
実行
PS D:\GO言語\サンプルプログラム\Go-2\2.1> go run チャンネル.go
100
