型と型アサーション（Types and type assertions） - Golang learning step 2-1

// 1. 基本型の例
var i int = 42         // 整数型
var f float64 = 3.14   // 浮動小数点型
var b bool = true      // 真偽値型
var s string = "hello" // 文字列型

// 2. 集約型の例
type Person struct {  // 構造体型
    Name string
    Age  int
}
var colors [3]string = [3]string{"red", "green", "blue"}  // 配列型

// 3. 参照型の例
var slice []int         // スライス型
var dict map[string]int // マップ型
var ch chan string      // チャネル型
var ptr *int            // ポインタ型

// 4. インターフェース型の例
type Reader interface { // インターフェース型
    Read(p []byte) (n int, err error)
}
type Writer interface {
    Write(p []byte) (n int, err error)
}

// 1. 基本形式
value, ok := interface変数.(具体的な型)

// 2. 簡略形式 (変換失敗時はパニックが発生)
value := interface変数.(具体的な型)

var i interface{} = "hello"

// 型アサーションを使用して、i が string 型であることを確認し、値を取得する
s := i.(string)

// i の値が string 型の 'hello' であるため、"hello" と出力される
fmt.Println(s) 

panic: interface conversion: interface {} is string, not int

var i interface{} = 123

s, ok := i.(string)
if ok {
    fmt.Println("string型です:", s)
} else {
    fmt.Println("string型ではありません")
}

string型ではありません

type User struct {
    Name string
}

func main() {
    var i interface{} = struct{ Name string }{"John"}
    if v, ok := i.(User); ok {
        // User型として処理
    } else {
        // 異なる型の場合の処理
    }
}

package main

import "fmt"

func doSomething(i interface{}) {
  switch v := i.(type) {
  case int:
    fmt.Println("整数:", v)
  case string:
    fmt.Println("文字列:", v)
  default:
    fmt.Println("不明な型")
  }
}

func main() {
  var i interface{} = "hello"
  doSomething(i)
}
// 出力:
// 文字列: hello

package main

import "fmt"

// 任意の値を文字列に変換する関数
func toString(v interface{}) (string, error) {
  switch val := v.(type) {
  case string:
    return val, nil
  case int:
    return fmt.Sprintf("%d", val), nil
  case float64:
    return fmt.Sprintf("%.2f", val), nil
  case bool:
    return fmt.Sprintf("%t", val), nil
  default:
    return "", fmt.Errorf("unsupported type: %T", v)
  }
}

func main() {
  values := []interface{}{
    "Hello",
    42,
    3.14,
    true,
  }

  for _, v := range values {
    result, err := toString(v)
    if err != nil {
      fmt.Println(err)
    }
    fmt.Printf("値: %v, 変換後: %s, 型: %T\n", v, result, v)
    // 値: Hello, 変換後: Hello, 型: string
    // 値: 42, 変換後: 42, 型: int
    // 値: 3.14, 変換後: 3.14, 型: float64
    // 値: true, 変換後: true, 型: bool
  }

  // interface{} 型の値から map[string]interface{} への型アサーション
  var data interface{} = map[string]interface{}{
    "name": "John",
    "age":  30,
  }

  if m, ok := data.(map[string]interface{}); ok {
    // m["name"] を string として取り出せた場合（ok = true）
    if name, ok := m["name"].(string); ok {
      fmt.Printf("名前: %s\n", name)
      // 名前: John
    }
    // m["age"] を int として取り出せた場合（ok = true）
    if age, ok := m["age"].(int); ok {
      fmt.Printf("年齢: %d\n", age)
      // 年齢: 30
    }
  }
}

value, ok := i.(Type)
if !ok {
    // エラー処理
}

switch v := i.(type) {
case TypeA:
    // TypeAの処理
case TypeB:
    // TypeBの処理
default:
    // その他の型の処理
}

func process(i interface{}) {
  switch v := i.(type) {
  case int:
    fmt.Println("整数:", v)
  case string:
    fmt.Println("文字列:", v)
  default:
    fmt.Println("不明な型:", v)
  }
}

// 1. パニックの可能性
s := i.(string)

// 2. より安全な方法
s, ok := i.(string)
if !ok {
    // エラー処理
}

func process(i interface{}) error {
    v, ok := i.(string)
    if !ok {
        return fmt.Errorf("expected string, got %T", i)
    }
    // 処理を続行
    return nil
}