Zwj`Blog

package main

import (
   // ここにコードを追加する必要があります。[1]
   "flag"
   "fmt"
)

var name string

func init() {
   // ここにコードを追加する必要があります。[2]
   flag.StringVar(&name, "name", "everyone", "The greeting object.")
}

func main() {
   // ここにコードを追加する必要があります。[3]
   flag.Parse()
   fmt.Printf("Hello, %s!\n", name)
}

go run main.go -name="Robert"

Hello, Robert!

// 変数の宣言
var a int = 10

// 短い宣言
b := 20
fmt.Println(a, b)

// 複数代入
c, d, e := 30, 40, 50
fmt.Println(c, d, e)

// 変数の値を交換
f, g := 99, 88
fmt.Println(f, g)//99 88
f, g = g, f
fmt.Println(f, g)//88 99

// 値/戻り値を無視
h, _ := 10, 20
fmt.Println(h)

// フォーマット出力
fmt.Printf("%d\n", 1)         //%d 1 整数として出力
fmt.Printf("%f\n", 1.1)       //%f 1.100000 浮動小数点型として出力
fmt.Printf("%.2f\n", 1.11111) //%.2f 1.11 浮動小数点型として出力し、小数点以下2桁を保持
fmt.Printf("%t\n", false)     //%t false ブール型データとして出力
fmt.Printf("%s\n", "false")   //%s false 文字列型データとして出力
fmt.Printf("%c\n", 'a')       //%c 'a' 文字型データとして出力
fmt.Printf("%p\n", &a)        //%p 0x1400012c008 ポインタデータとして出力アドレス
fmt.Printf("%T\n", a)         //%T その変数の型を出力

// ユーザー入力を取得
fmt.Scan(&a)   // 入力88
fmt.Println(a) // 出力88

var n byte = 'a' // byteは単一の文字しか格納できない
var m rune = '樹' // runeは他の言語のcharに相当し、単一のUnicode文字/中国語などを格納する
fmt.Println(n,m)

// 定数の定義
const a = false

const (
   b = iota
   c = iota
   d = iota
)
fmt.Println(b, c, d) //0 1 2

const (
   f = iota
   g
   h
)
fmt.Println(f, g, h) //0 1 2

const (
   i    = iota
   j, k = iota, iota
)
fmt.Println(i, j, k) //0 1 1

// 型変換
c := 3
d := float64(c)
fmt.Println(c, d)

• 条件式の括弧を省略できます。
• 初期化文を持ち、コードブロックのローカル変数を定義できます。
• コードブロックの左括弧は条件式の末尾に必ず置く必要があります。

if ブール式 {
  /* ブール式がtrueのときに実行 */
} 

x := 0
if n := "abc"; x > 0 { // 初期化文は必ずしも変数の定義である必要はありません。例えばprintln("init")も可能です。
   println(n[2])
} else if x < 0 { // else ifとelseの左括弧の位置に注意。
   println(n[1])
} else {
   println(n[0])
}

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

package main

import "fmt"

func main() {
   /* ローカル変数を定義 */
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
      case grade == "A" :
         fmt.Printf("優秀!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("合格\n" )      
      case grade == "F":
         fmt.Printf("不合格\n" )
      default:
         fmt.Printf("悪い\n" )
   }
   fmt.Printf("あなたの成績は %s\n", grade )
}    

優秀!
あなたの成績は A  

switch x.(type){
    case type:
       statement(s)      
    case type:
       statement(s)
    /* 任意の数のcaseを定義できます */
    default: /* オプション */
       statement(s)
}  

package main

import "fmt"

func main() {
    var x interface{}
    // 書き方1：
    switch i := x.(type) { // 初期化文付き
    case nil:
        fmt.Printf(" x の型 :%T\r\n", i)
    case int:
        fmt.Printf("x は int 型")
    case float64:
        fmt.Printf("x は float64 型")
    case func(int) float64:
        fmt.Printf("x は func(int) 型")
    case bool, string:
        fmt.Printf("x は bool または string 型")
    default:
        fmt.Printf("未知型")
    }
    // 書き方2
    var j = 0
    switch j {
    case 0:
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("def")
    }
    // 書き方3
    var k = 0
    switch k {
    case 0:
        println("fallthrough")
        fallthrough
        /*
            Goのswitchは非常に柔軟で、式は定数や整数である必要はなく、実行プロセスは上から下に進み、マッチする項目が見つかるまで続きます。
            もしswitchに式がなければ、trueにマッチします。
            Goではswitchはデフォルトで各caseの最後にbreakが付いているようなもので、
            マッチが成功した後は他のcaseを自動的に実行せず、全体のswitchから抜けますが、
            fallthroughを使用すると後続のcaseのコードを強制的に実行できます。
        */
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("def")
    }
    // 書き方4
    var n = 0
    switch { // 条件式を省略し、if...else if...elseとして使用できます
    case n > 0 && n < 10:
        fmt.Println("i > 0 and i < 10")
    case n > 10 && n < 20:
        fmt.Println("i > 10 and i < 20")
    default:
        fmt.Println("def")
    }
}   

    x の型 :<nil>
    fallthrough
    1
    1
    def

    for init; condition; post { }
    for condition { }
    for { }
    init： 一般的には制御変数に初期値を与える代入式です；
    condition： 関係式または論理式、ループ制御条件です；
    post： 一般的には制御変数の増分または減分を与える代入式です。
    for文の実行プロセスは次のとおりです：
    ①最初に式initに初期値を与えます；
    ②代入式initが指定されたcondition条件を満たすかどうかを判別し、真であればループ条件を満たし、ループ体内の文を実行し、次にpostを実行し、2回目のループに入ります。再度conditionを判別します。そうでなければconditionの値が偽であると判断し、条件を満たさないのでforループを終了し、ループ体の外の文を実行します。   
s := "abc"

for i, n := 0, len(s); i < n; i++ { // よくあるforループ、初期化文をサポートしています。
    println(s[i])
}

n := len(s)
for n > 0 {                // while (n > 0) に置き換えられます {}
    n-- 
    println(s[n])        // for (; n > 0;) に置き換えられます {}
}

for {                    // while (true) に置き換えられます {}
    println(s)            // for (;;) に置き換えられます {}
}  

package main

func length(s string) int {
    println("call length.")
    return len(s)
}

func main() {
    s := "abcd"

    for i, n := 0, length(s); i < n; i++ {     // length関数を何度も呼び出すのを避けます。
        println(i, s[i])
    } 
}  

    call length.
    0 97
    1 98
    2 99
    3 100 

package main

import "fmt"

func main() {

   var b int = 15
   var a int

   numbers := [6]int{1, 2, 3, 5}

   /* forループ */
   for a := 0; a < 10; a++ {
      fmt.Printf("a の値は: %d\n", a)
   }

   for a < b {
      a++
      fmt.Printf("a の値は: %d\n", a)
      }

   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x の値 = %d\n", i,x)
   }   
} 

    a の値は: 0
    a の値は: 1
    a の値は: 2
    a の値は: 3
    a の値は: 4
    a の値は: 5
    a の値は: 6
    a の値は: 7
    a の値は: 8
    a の値は: 9
    a の値は: 1
    a の値は: 2
    a の値は: 3
    a の値は: 4
    a の値は: 5
    a の値は: 6
    a の値は: 7
    a の値は: 8
    a の値は: 9
    a の値は: 10
    a の値は: 11
    a の値は: 12
    a の値は: 13
    a の値は: 14
    a の値は: 15
    第 0 位 x の値 = 1
    第 1 位 x の値 = 2
    第 2 位 x の値 = 3
    第 3 位 x の値 = 5
    第 4 位 x の値 = 0
    第 5 位 x の値 = 0  

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s)
   }
   statement(s)
}  

package main

import "fmt"

func main() {
   /* ローカル変数を定義 */
   var i, j int

   for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break // 因子が見つかった場合、素数ではありません
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d  は素数です\n", i)
      }
   }  
}  

    2  は素数です
    3  は素数です
    5  は素数です
    7  は素数です
    11  は素数です
    13  は素数です
    17  は素数です
    19  は素数です
    23  は素数です
    29  は素数です
    31  は素数です
    37  は素数です
    41  は素数です
    43  は素数です
    47  は素数です
    53  は素数です
    59  は素数です
    61  は素数です
    67  は素数です
    71  は素数です
    73  は素数です
    79  は素数です
    83  は素数です
    89  は素数です
    97  は素数です  

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("これは無限ループです。\n");
    }
}  

for key, value := range oldMap {
    newMap[key] = value
}   

package main

func main() {
    s := "abc"
    // 2nd valueを無視し、string/array/slice/mapをサポートします。
    for i := range s {
        println(s[i])
    }
    // indexを無視します。
    for _, c := range s {
        println(c)
    }
    // すべての戻り値を無視し、単に反復します。
    for range s {

    }

    m := map[string]int{"a": 1, "b": 2}
    // (key, value)を返します。
    for k, v := range m {
        println(k, v)
    }
}   

    97
    98
    99
    97
    98
    99
    a 1
    b 2  

package main

import "fmt"

func main() {
    a := [3]int{0, 1, 2}

    for i, v := range a { // index、valueはコピーから取得されます。

        if i == 0 { // 修正前に、元の配列を修正します。
            a[1], a[2] = 999, 999
            fmt.Println(a) // 修正が有効であることを確認し、出力 [0, 999, 999]。
        }

        a[i] = v + 100 // コピーから取得した値を使用して元の配列を修正します。

    }

    fmt.Println(a) // 出力 [100, 101, 102]。
}   

    [0 999 999]
    [100 101 102]   

package main

func main() {
    a := [2]int{}
    println(len(a), cap(a)) 
}

2 2

package main

import (
    "fmt"
)

func main() {

    var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

    for k1, v1 := range f {
        for k2, v2 := range v1 {
            fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
        }
        fmt.Println()
    }
}

    (0,0)=1 (0,1)=2 (0,2)=3 
    (1,0)=7 (1,1)=8 (1,2)=9 

package main

import "fmt"

func printArr(arr *[5]int) {
    arr[0] = 10
    for i, v := range arr {
        fmt.Println(i, v)
    }
}

func main() {
    var arr1 [5]int
    printArr(&arr1)
    fmt.Println(arr1)
    arr2 := [...]int{2, 4, 6, 8, 10}
    printArr(&arr2)
    fmt.Println(arr2)
}

    1. スライス：スライスは配列の参照であるため、スライスは参照型です。しかし、自身は構造体であり、値コピーで渡されます。
    2. スライスの長さは変更可能であるため、スライスは可変の配列です。
    3. スライスの反復方法は配列と同じで、len()を使用して長さを求めることができます。これは使用可能な要素の数を示し、読み書き操作はこの制限を超えてはなりません。
    4. capはスライスの最大拡張容量を求めることができ、配列の制限を超えてはなりません。0 <= len(slice) <= len(array)、ここでarrayはsliceが参照する配列です。
    5. スライスの定義：var 変数名 []型、例えば var str []string var arr []int。
    6. スライス == nil の場合、len、cap の結果はどちらも0になります。

package main

import "fmt"

func main() {
   //1.スライスの宣言
   var s1 []int
   if s1 == nil {
      fmt.Println("空です")
   } else {
      fmt.Println("空ではありません")
   }
   // 2.:=
   s2 := []int{}
   // 3.make()
   var s3 []int = make([]int, 0)
   fmt.Println(s1, s2, s3)
   // 4.初期化代入
   var s4 []int = make([]int, 0, 0)
   fmt.Println(s4)
   s5 := []int{1, 2, 3}
   fmt.Println(s5)
   // 5.配列からスライス
   arr := [5]int{1, 2, 3, 4, 5}
   var s6 []int
   // 前包後不包
   s6 = arr[1:4]
   fmt.Println(s6)
}

//全体：
var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[start:end]
var slice1 []int = arr[:end]
var slice2 []int = arr[start:]
var slice3 []int = arr[:]
var slice4 = arr[:len(arr)-1] //スライスの最後の要素を削除
//局所：
arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
slice5 := arr[start:end]
slice6 := arr[:end]
slice7 := arr[start:]
slice8 := arr[:]
slice9 := arr[:len(arr)-1] //スライスの最後の要素を削除

package main

import (
    "fmt"
)

var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[2:8]
var slice1 []int = arr[0:6]        //簡略化して var slice []int = arr[:end]
var slice2 []int = arr[5:10]       //簡略化して var slice[]int = arr[start:]
var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:]
var slice4 = arr[:len(arr)-1]      //スライスの最後の要素を削除
func main() {
    fmt.Printf("全体変数：arr %v\n", arr)
    fmt.Printf("全体変数：slice0 %v\n", slice0)
    fmt.Printf("全体変数：slice1 %v\n", slice1)
    fmt.Printf("全体変数：slice2 %v\n", slice2)
    fmt.Printf("全体変数：slice3 %v\n", slice3)
    fmt.Printf("全体変数：slice4 %v\n", slice4)
    fmt.Printf("-----------------------------------\n")
    arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    slice5 := arr[2:8]
    slice6 := arr[0:6]         //簡略化して slice := arr[:end]
    slice7 := arr[5:10]        //簡略化して slice := arr[start:]
    slice8 := arr[0:len(arr)]  //slice := arr[:]
    slice9 := arr[:len(arr)-1] //スライスの最後の要素を削除
    fmt.Printf("局所変数： arr2 %v\n", arr2)
    fmt.Printf("局所変数： slice5 %v\n", slice5)
    fmt.Printf("局所変数： slice6 %v\n", slice6)
    fmt.Printf("局所変数： slice7 %v\n", slice7)
    fmt.Printf("局所変数： slice8 %v\n", slice8)
    fmt.Printf("局所変数： slice9 %v\n", slice9)
}

    全体変数：arr [0 1 2 3 4 5 6 7 8 9]
    全体変数：slice0 [2 3 4 5 6 7]
    全体変数：slice1 [0 1 2 3 4 5]
    全体変数：slice2 [5 6 7 8 9]
    全体変数：slice3 [0 1 2 3 4 5 6 7 8 9]
    全体変数：slice4 [0 1 2 3 4 5 6 7 8]
    -----------------------------------
    局所変数： arr2 [9 8 7 6 5 4 3 2 1 0]
    局所変数： slice5 [2 3 4 5 6 7]
    局所変数： slice6 [0 1 2 3 4 5]
    局所変数： slice7 [5 6 7 8 9]
    局所変数： slice8 [0 1 2 3 4 5 6 7 8 9]
    局所変数： slice9 [0 1 2 3 4 5 6 7 8]

package main

import (
    "fmt"
)

func main() {

    var a = []int{1, 2, 3}
    fmt.Printf("スライス a : %v\n", a)
    var b = []int{4, 5, 6}
    fmt.Printf("スライス b : %v\n", b)
    c := append(a, b...)
    fmt.Printf("スライス c : %v\n", c)
    d := append(c, 7)
    fmt.Printf("スライス d : %v\n", d)
    e := append(d, 8, 9, 10)
    fmt.Printf("スライス e : %v\n", e)

}

    スライス a : [1 2 3]
    スライス b : [4 5 6]
    スライス c : [1 2 3 4 5 6]
    スライス d : [1 2 3 4 5 6 7]
    スライス e : [1 2 3 4 5 6 7 8 9 10]

package main

import (
    "fmt"
)

func main() {

    s1 := make([]int, 0, 5)
    fmt.Printf("%p\n", &s1)

    s2 := append(s1, 1)
    fmt.Printf("%p\n", &s2)

    fmt.Println(s1, s2)

}

    0xc42000a060
    0xc42000a080
    [] [1]

package main

import (
    "fmt"
)

func main() {
    data := [...]int{0, 1, 2, 3, 4, 5}

    s := data[6:8]
    s[0] += 100
    s[1] += 200

    fmt.Println(s)
    fmt.Println(data)
}

    [102 203]
    [0 1 102 203 4 5]

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3}
    p := &s[2] // *int, 底層配列要素のポインタを取得します。
    *p += 100

    fmt.Println(s)
}

    [0 1 102 3]

package main

import (
    "fmt"
)

func main() {
    str := "hello world"
    s1 := str[0:5]
    fmt.Println(s1)

    s2 := str[6:]
    fmt.Println(s2)
}

    hello
    world

package main

import (
    "fmt"
)

func main() {
    str := "Hello world"
    s := []byte(str) //中国語の文字は[]rune(str)を使用する必要があります
    s[6] = 'G'
    s = s[:8]
    s = append(s, '!')
    str = string(s)
    fmt.Println(str)
}

    Hello Go!

package main

import (
    "fmt"
)

func main() {
    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    d1 := slice[6:8]
    fmt.Println(d1, len(d1), cap(d1))
    d2 := slice[:6:8]
    fmt.Println(d2, len(d2), cap(d2))
}

    strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1)

//MyIntをint型として定義
type MyInt int 

type TypeAlias = Type 

type byte = uint8
type rune = int32

//タイプ定義
type NewInt int

//タイプエイリアス
type MyInt = int

func main() {
    var a NewInt
    var b MyInt

    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
} 

type タイプ名 struct {
  フィールド名 フィールド型
  フィールド名 フィールド型
  …
} 

    1.タイプ名：自定義構造体の名前を示します。同じパッケージ内で重複してはいけません。
    2.フィールド名：構造体のフィールド名を示します。構造体内のフィールド名は一意である必要があります。
    3.フィールド型：構造体フィールドの具体的な型を示します。 

type person struct {
    name string
    city string
    age  int8
} 

type person1 struct {
    name, city string
    age        int8
} 

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p = person{
        "名前",
        "都市",
        18,
    }
    fmt.Println(p)
}

package main

import (
    "fmt"
)

func main() {
    var user struct{Name string; Age int}
    user.Name = "pprof.cn"
    user.Age = 18
    fmt.Printf("%#v\n", user)
} 

    var p2 = new(person)
    fmt.Printf("%T\n", p2)     //*main.person
    fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}  

func main() {
    var a *int
    a = new(int)
    *a = 10
    fmt.Println(*a)
}

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p4 person
    fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
} 

p5 := person{
    name: "pprof.cn",
    city: "北京",
    age:  18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"pprof.cn", city:"北京", age:18}

p6 := &person{
    name: "pprof.cn",
    city: "北京",
    age:  18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"pprof.cn", city:"北京", age:18} 

p7 := &person{
    city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

p8 := &person{
    "pprof.cn",
    "北京",
    18,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"pprof.cn", city:"北京", age:18}

    1. 構造体のすべてのフィールドを初期化する必要があります。
    2. 初期値の埋め込み順序は、構造体内のフィールドの宣言順序と一致する必要があります。
    3. この方法はキーと値の初期化方法と混用できません。  

//Animal 動物
type Animal struct {
    name string
}

func (a *Animal) move() {
    fmt.Printf("%sは動く！\n", a.name)
}

//Dog 犬
type Dog struct {
    Feet    int8
    *Animal //匿名構造体を通じて継承を実現
}

func (d *Dog) wang() {
    fmt.Printf("%sはワンワンワンと言う\n", d.name)
}

func main() {
    d1 := &Dog{
        Feet: 4,
        Animal: &Animal{ //注意：構造体ポインタを埋め込む
            name: "レレ",
        },
    }
    d1.wang() //レレはワンワンワンと言う
    d1.move() //レレは動く！
}

//Address アドレス構造体
type Address struct {
    Province string
    City     string
    CreateTime string
}

//Email メール構造体
type Email struct {
    Account    string
    CreateTime string
}

//User ユーザー構造体
type User struct {
    Name    string
    Gender  string
    Address
    Email
}

func main() {
    var user3 User
    user3.Name = "pprof"
    user3.Gender = "女"
    // user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
    user3.Address.CreateTime = "2000" //Address構造体のCreateTimeを指定
    user3.Email.CreateTime = "2000"   //Email構造体のCreateTimeを指定
}  

    `key1:"value1" key2:"value2"`  

//Student 学生
type Student struct {
    ID     int
    Gender string
    Name   string
}

//Class クラス
type Class struct {
    Title    string
    Students []*Student
}

func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSONシリアル化：構造体-->JSON形式の文字列
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    //JSON逆シリアル化：JSON形式の文字列-->構造体
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
} 

    `key1:"value1" key2:"value2"`  

//Student 学生
type Student struct {
    ID     int
    Gender string
    Name   string
}

//Class クラス
type Class struct {
    Title    string
    Students []*Student
}

func main() {
    c := &Class{
        Title:    "101",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name:   fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID:     i,
        }
        c.Students = append(c.Students, stu)
    }
    //JSONシリアル化：構造体-->JSON形式の文字列
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json:%s\n", data)
    //JSON逆シリアル化：JSON形式の文字列-->構造体
    str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
    c1 := &Class{}
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        fmt.Println("json unmarshal failed!")
        return
    }
    fmt.Printf("%#v\n", c1)
} 

    type インターフェース名 interface{
        メソッド名1( パラメータリスト1 ) 戻り値リスト1
        メソッド名2( パラメータリスト2 ) 戻り値リスト2
        …
    } 

    1.インターフェース名：インターフェースを自定義の型名として定義します。Go言語のインターフェースは命名時に一般的に単語の後にerを追加します。たとえば、書き込み操作を持つインターフェースはWriterと呼ばれ、文字列機能を持つインターフェースはStringerと呼ばれます。インターフェース名はそのインターフェースの型の意味を強調する必要があります。
    2.メソッド名：メソッド名の最初の文字が大文字であり、このインターフェースの型名の最初の文字も大文字である場合、このメソッドはインターフェースが所在するパッケージ（package）以外のコードからアクセス可能です。
    3.パラメータリスト、戻り値リスト：パラメータリストと戻り値リストのパラメータ変数名は省略可能です。  

// Sayer インターフェース
type Sayer interface {
    say()
} 

type dog struct {}

type cat struct {} 

// dogがSayerインターフェースを実装
func (d dog) say() {
    fmt.Println("汪汪汪")
}

// catがSayerインターフェースを実装
func (c cat) say() {
    fmt.Println("喵喵喵")
} 

func main() {
    var x Sayer // Sayer型の変数xを宣言
    a := cat{}  // catをインスタンス化
    b := dog{}  // dogをインスタンス化
    x = a       // catインスタンスを直接xに代入
    x.say()     // 喵喵喵
    x = b       // dogインスタンスを直接xに代入
    x.say()     // 汪汪汪
} 

type Mover interface {
    move()
}

type dog struct {}

func (d dog) move() {
    fmt.Println("犬が動く")
}  

func main() {
    var x Mover
    var wangcai = dog{} // 旺財はdog型
    x = wangcai         // xはdog型を受け取ることができる
    var fugui = &dog{}  // 富貴は*dog型
    x = fugui           // xは*dog型を受け取ることができる
    x.move()
} 

func (d *dog) move() {
    fmt.Println("犬が動く")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺財はdog型
    x = wangcai         // xはdog型を受け取ることができない
    var fugui = &dog{}  // 富貴は*dog型
    x = fugui           // xは*dog型を受け取ることができる
} 

type People interface {
    Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
    if think == "sb" {
        talk = "あなたは大イケメンです"
    } else {
        talk = "こんにちは"
    }
    return
}

func main() {
    var peo People = Student{}
    think := "bitch"
    fmt.Println(peo.Speak(think))
}

// Sayer インターフェース
type Sayer interface {
    say()
}

// Mover インターフェース
type Mover interface {
    move()
} 

type dog struct {
    name string
}

// Sayerインターフェースを実装
func (d dog) say() {
    fmt.Printf("%sは汪汪汪と言う\n", d.name)
}

// Moverインターフェースを実装
func (d dog) move() {
    fmt.Printf("%sは動く\n", d.name)
}

func main() {
    var x Sayer
    var a = dog{name: "旺財"}
    x = a
    x.say()
    var y Mover
    y = a
    y.move()
} 

// Mover インターフェース
type Mover interface {
    move()
} 

type dog struct {
    name string
}

type car struct {
    brand string
}

// dog型がMoverインターフェースを実装
func (d dog) move() {
    fmt.Printf("%sは走る\n", d.name)
}

// car型がMoverインターフェースを実装
func (c car) move() {
    fmt.Printf("%sは70マイルの速度で走る\n", c.brand)
}

func main() {
    var x Mover
    var a = dog{name: "旺財"}
    var b = car{brand: "ポルシェ"}
    x = a
    x.move()
    x = b
    x.move()
} 

    旺財は走る
    ポルシェは70マイルの速度で走る 

// WashingMachine 洗濯機
type WashingMachine interface {
    wash()
    dry()
}

// 乾燥機
type dryer struct{}

// WashingMachineインターフェースのdry()メソッドを実装
func (d dryer) dry() {
    fmt.Println("脱水中")
}

// Haier洗濯機
type haier struct {
    dryer // 乾燥機を匿名で埋め込む
}

// WashingMachineインターフェースのwash()メソッドを実装
func (h haier) wash() {
    fmt.Println("洗濯中")
}

func main() {
    var x WashingMachine
    x = haier{}
    x.wash()
    x.dry()
}

func main() {
    // 空インターフェースxを定義
    var x interface{}
    s := "pprof.cn"
    x = s
    fmt.Printf("type:%T value:%v\n", x, x)
    i := 100
    x = i
    fmt.Printf("type:%T value:%v\n", x, x)
    b := true
    x = b
    fmt.Printf("type:%T value:%v\n", x, x)
}

// 空インターフェースを関数パラメータとして使用
func show(a interface{}) {
    fmt.Printf("type:%T value:%v\n", a, a)
} 

// 空インターフェースをmapの値として使用
var studentInfo = make(map[string]interface{})
studentInfo["name"] = "李白"
studentInfo["age"] = 18
studentInfo["married"] = false
fmt.Println(studentInfo) 

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil 

    x.(T) 

    x：interface{}型の変数を示します
    T：xが可能性のある型を示します。

func main() {
    var x interface{}
    x = "pprof.cn"
    v, ok := x.(string)
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("型アサーション失敗")
    }
} 

func justifyType(x interface{}) {
    switch v := x.(type) {
    case string:
        fmt.Printf("xは文字列です，値は%vです\n", v)
    case int:
        fmt.Printf("xは整数です，値は%vです\n", v)
    case bool:
        fmt.Printf("xはブールです，値は%vです\n", v)
    default:
        fmt.Println("サポートされていない型です！")
    }
} 

    1. 組み込み関数
    2. 関数Fの中にpanic文が書かれている場合、その後の実行コードは終了し、panicが発生した関数F内にdefer関数リストが存在する場合、deferの逆順で実行されます。
    3. 関数Fの呼び出し元Gに戻り、G内の関数F文の後のコードは実行されず、関数G内にdefer関数リストが存在する場合、deferの逆順で実行されます。
    4. goroutine全体が終了し、エラーを