KANIKIG

go build

go install

go run

// wincmd SET, macos export
export CGO_ENABLED=0	//CGOを無効にする
export GOOS=linux	//ターゲットプラットフォームをlinux, windows, darwinに設定
export GOARCH=amd64//ターゲットプロセッサアーキテクチャはamd64
go build

export CGO_ENABLED=0 GOOS=linux GOARCH=amd64
go build

var 変数名 型 = 式
var name string = "Q1mi"
var age int = 18
var name, age = "Q1mi", 20	//値に基づいて型を推論します
var (
    a string
    b int
    c bool
    d float32
)

	n := 10
	m := 200
	fmt.Println(m, n)

fmt.Print()
fmt.Printf()
fmt.Println() //改行

var studentName string

x, _ = foo()
_, y = foo()

const pi = 3.14

const (
  n1 = iota //0
  n2	//1
  n3	//2
  n4	//3
)

const (
  n1 = iota //0
  n2	//1
  _	//2 しかし破棄されます
  n3	//3
)

const (
  _ = iota
  KB = 1 << (10 * iota)
  MB = 1 << (10 * iota)
  GB = 1 << (10 * iota)
  TB = 1 << (10 * iota)
  PB = 1 << (10 * iota)
)

	// 十進数
	var a int = 10
	fmt.Printf("%d \n", a)  // 10
	fmt.Printf("%b \n", a)  // 1010  プレースホルダー%bは2進数を示します。
 
	// 八進数  0で始まります
	var b int = 077
	fmt.Printf("%o \n", b)  // 77
 
	// 十六進数  0xで始まります
	var c int = 0xff
	fmt.Printf("%x \n", c)  // ff
	fmt.Printf("%X \n", c)  // FF
	fmt.Printf("%T \n", c)  // 出力タイプ
	fmt.Printf("%v \n", c)  // 変数値を出力、任意のタイプ

math.MaxFloat64 // float64の最大値

// Windowsでのパスのエスケープ
s := "D:\\Documents\\A"

// バッククオートはそのまま出力し、複数行の文字列を示します。
s := `
asda
		asd
`
s := "D:\Documents\A"

len(str)
ss := s1 + s2
ret := strings.Split(s3, "\\")
ret = strings.Contains(s3, "abcd")
ret = strings.HasPrefix(s3, "abcd")
ret = strings.HasSufix(s3, "abcd")
ret = strings.Index(s3, "c")
ret = strings.LastIndex(s3, "c")
ret = strings.Join(a, b)

for _, char := range str {
  fmt.Printf("%c", char)
}

s3 := []rune(s2)	//スライス
s3[0] = 'e'	//変更
s4 := string(s3)

if 表現1 {
    分岐1
} else if 表現2 {
    分岐2
} else{
    分岐3
}

// ローカル変数scoreはif内でのみ有効で、メモリ使用量を減らします。
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}

for 初期文;条件式;終了文{
    ループ本体文
}

for i := 0; i < 10; i++ {
		fmt.Println(i)
}

i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}

for {
    ループ本体文
}

for i,v := range s{
  fmt.Println(i, v)
}

finger := 3
	switch finger {
	case 1:
		fmt.Println("親指")
    fallthrough
	case 2:
		fmt.Println("人差し指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("薬指")
	case 5:
		fmt.Println("小指")
	default:
		fmt.Println("無効な入力！")
	}

switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}

var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 退出ラベルを設定
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外側のforループの判断
		if breakFlag {
			break
		}
	}

for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 退出ラベルを設定
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// ラベル
breakTag:
	fmt.Println("forループを終了")

// 論理演算
&&
||
!

// ビット演算
&
|
^
<<
>>

// 代入
+=
-=
<<=

var a [3]int

var a [3]int
var b [4]int
a = b //このようにはできません。なぜならaとbは異なる型だからです。

	var testArray [3]int	//配列はint型のゼロ値で初期化されます。
	var numArray = [3]int{1, 2}	//指定した初期値を使用して初期化します。
	var cityArray = [3]string{"北京", "上海", "深圳"} //指定した初期値を使用して初期化します。
	var numArray = [...]int{1, 2} //値に基づいて配列の長さを推論します。
	var cityArray = [...]string{"北京", "上海", "深圳"}

	a := [...]int{1: 1, 3: 5}	//インデックスを指定して初期化します。
	fmt.Println(a)                  // [0 1 0 5]

for index, value := range a {
		fmt.Println(index, value)
	}

a := [3][2]string{
		{"北京", "上海"},
		{"広州", "深圳"},
		{"成都", "重慶"},
	}

	var a = []string              //文字列スライスを宣言
	var b = []int{}             //整数型スライスを宣言し初期化
	var c = []bool{false, true} //ブール型スライスを宣言し初期化
	var d = []bool{false, true} //ブール型スライスを宣言し初期化

a1 := [...]int{1, 3, 5, 7, 9, 11, 13}
s3 := a1[0:4] //左包み右非包み、インデックスは0-3のスライス

len(s3) // 4 スライスの長さ
cap(s3)	// 7 容量=元の配列スライスのポイントから末尾までの長さ

a[2:]  // a[2:len(a)]と同等
a[:3]  // a[0:3]と同等
a[:]   // a[0:len(a)]と同等

a[low : high : max]
a := [5]int{1, 2, 3, 4, 5}
t := a[1:3:5] //t:[2 3] len(t):2 cap(t):4

make([]T, size, cap)

a := make([]int, 2, 10) // 初期値は0

	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //s1をs2に直接代入し、s1とs2は同じ基盤配列を共有します。
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]

	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]

var s []int
s = append(s, 1, 2, 3)

func main() {
	//append()で要素を追加し、スライスを拡張します。
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

[0]  len:1  cap:1  ptr:0xc0000a8000
[0 1]  len:2  cap:2  ptr:0xc0000a8040
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// 0 < newcapをチェックしてオーバーフローを検出し、
		// 無限ループを防ぎます。
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// 新しい容量の計算がオーバーフローした場合、
		// 新しい容量を要求された容量に設定します。
		if newcap <= 0 {
			newcap = cap
		}
	}
}

	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)     //copy()関数を使用してスライスaの要素をスライスcにコピーします。
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]

	a = append(a[:index], a[index+1:]...)
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// インデックス2の要素を削除します。
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]

	// 基盤となる配列の長さは変わらず、要素は左にシフトされ、右側は最右の要素で補完されます。

sort.Ints(a[:])

ptr := &v // vの型はT 出力ポインタ型*T 例えば *string *int

	a := 10
	b := &a
	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018

	c := *b // ポインタの値を取得（ポインタを介してメモリから値を取得）
	fmt.Printf("type of c:%T\n", c)
	fmt.Printf("value of c:%v\n", c)

func modify1(x int) {
	x = 100
}

func modify2(x *int) {
	*x = 100
}

func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}

	a := new(int)
	b := new(bool)
	fmt.Printf("%T\n", a) // *int
	fmt.Printf("%T\n", b) // *bool
	fmt.Println(*a)       // 0
	fmt.Println(*b)       // false

	var b map[string]int
	b = make(map[string]int, 10)
	b["沙河娜扎"] = 100
	fmt.Println(b)

	map[KeyType]ValueType

	scoreMap := make(map[string]int, 8) // 初期化しないと使用できません。動的拡張を避けるため！
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	fmt.Println(scoreMap)
	fmt.Println(scoreMap["小明"])
	fmt.Printf("type of a:%T\n", scoreMap)

	userInfo := map[string]string{
		"username": "沙河小王子",
		"password": "123456",
	}

value, ok := map[key] // okはキーが存在するかどうかのbool値を返します。

	v, ok := scoreMap["张三"]
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("該当者なし")
	}

for k, v := range scoreMap {
		fmt.Println(k, v)
}

for k := range scoreMap {
		fmt.Println(k)
}

for _, v := range scoreMap {
		fmt.Println(v)
}

delete(map, key)

func main() {
	rand.Seed(time.Now().UnixNano()) //ランダム数の種を初期化します。

	var scoreMap = make(map[string]int, 200)

	for i := 0; i < 100; i++ {
		key := fmt.Sprintf("stu%02d", i) //stuで始まる文字列を生成します。
		value := rand.Intn(100)          //0〜99のランダム整数を生成します。
		scoreMap[key] = value
	}
	// map内のすべてのキーをスライスkeysに格納します。
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}
	// スライスをソートします。
	sort.Strings(keys)
	// ソートされたキーに従ってmapを反復します。
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}
}

	var mapSlice = make([]map[string]string, 3) // スライスを初期化し、各要素はmapです。
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}
	fmt.Println("初期化後")
	// スライス内のmap要素を初期化します。
	mapSlice[0] = make(map[string]string, 10)
	mapSlice[0]["name"] = "小王子"
	mapSlice[0]["password"] = "123456"
	mapSlice[0]["address"] = "沙河"
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value);
	}

func main() {
	var sliceMap = make(map[string][]string, 3)
	fmt.Println(sliceMap)
	fmt.Println("初期化後")
	key := "中国"
	value, ok := sliceMap[key]
	if !ok {
		value = make([]string, 0, 2)
	}
	value = append(value, "北京", "上海")
	sliceMap[key] = value
	fmt.Println(sliceMap)
}

func 関数名(引数 型) 戻り値型 {
    関数本体
}

func intSum(x int, y int) int {
	return x + y
}

func intSum(x, y int) int {
	return x + y
}

func intSum2(x ...int) int {
	fmt.Println(x) //xはスライスです。
	sum := 0
	for _, v := range x {
		sum = sum + v;
	}
	return sum;
}

//名前付き戻り値
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}
//スライス
func someFunc(x string) []int {
	if x == "" {
		return nil // []int{}を返す必要はありません。
	}
	...
}

type calculation func(int, int) int

func main() {
	var c calculation               // calculation型の変数cを宣言します。
	c = add                         // addをcに代入します。
	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // addを呼び出すようにcを呼び出します。

	f := add                        // 関数addを変数f1に代入します。
	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // addを呼び出すようにfを呼び出します。
}

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("認識できない演算子")
		return nil, err
	}
}

func main() {
	// 匿名関数を変数に保存します。
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 10 + 20を出力します。

	// 自実行関数：匿名関数を定義した後に()を付けて直接実行します。
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

func main() {
	fmt.Println("開始")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("終了")
}

/*
開始
終了
3
2
1
*/

//面接問題 deferで遅延実行する関数を登録する際、その関数のすべての引数はその値を確定する必要があります。
func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

/*
A 1 2 3 //defer calc("AA", 1, 3)
B 10 2 12 //defer calc("BB", 10, 12)
BB 10 12 22
AA 1 3 4
*/

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//プログラムがpanicエラーを引き起こした場合、recoverを介して回復できます。
		if err != nil {
			fmt.Println("Bで回復")
		}
	}()
	panic("Bでpanic")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

func main() {
	fmt.Print("ターミナルにこの情報を印刷します。") //改行なし
	name := "沙河小王子"
	fmt.Printf("私は：%s\n", name)
	fmt.Println("ターミナルに単独の行を表示します。")
}

// 標準出力に内容を書き込みます。
fmt.Fprintln(os.Stdout, "標準出力に内容を書き込みます。")
fileObj, err := os.OpenFile("./xx.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
	fmt.Println("ファイルを開く際にエラーが発生しました。err:", err)
	return
}
name := "沙河小王子"
// 開いたファイルハンドルに内容を書き込みます。
fmt.Fprintf(fileObj, "ファイルに書き込む情報：%s", name)

s3 := fmt.Sprintln("沙河小王子")

e := errors.New("元のエラーe")
w := fmt.Errorf("エラーをラップしました%w", e)

fmt.Scan(&name, &age, &married)
fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
fmt.Scanln(&name, &age, &married)

func bufioDemo() {
	reader := bufio.NewReader(os.Stdin) // 標準入力から読み取りオブジェクトを生成します。
	fmt.Print("内容を入力してください：")
	text, _ := reader.ReadString('\n') // 改行で終了 空白も読み取ります。
	text = strings.TrimSpace(text)
	fmt.Printf("%#v\n", text)
}

//MyIntをint型として定義します。
type MyInt int

type TypeAlias = Type

type byte = uint8
type rune = int32

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

type person struct {
	name string
	city string
	age  int8
}

type person1 struct {
	name, city string
	age        int8
}

var 構造体インスタンス 構造体型

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p1 person
	p1.name = "沙河娜扎"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

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

var p2 = new(person)
//&を使用して構造体のアドレスを取得する操作は、構造体型をnewでインスタンス化することに相当します。
p3 := &person{}


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

//構造体ポインタを使用して直接構造体メンバーにアクセスすることができます。
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

p5 := person{
  name: "小王子",
	city: "北京",
	age:  18,
}

p6 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}

p8 := &person{
	"沙河娜扎",
	"北京",
	28,
}