Golangの入門(最低限これくらいは知っておいた方がいい)

# 有益Udemy
全部は紹介しきれないので

https://www.udemy.com/course/golang-webgosql/?couponCode=24T4MT90924B

# 公式ドキュメント

https://pkg.go.dev/std

# Goのメリット
GoはRailsとかと比べたら軽量なので、企業で導入されることケース多いです。
Railsとかだとマイクロサービスの立ち上げがありますが、かなり容量やパフォーマンスなどがヘビーみたいです。
だからGoで作ろう、またはリプレースしようってなるみたいです。

またブロックチェーンの現場など最先端の現場で使われることが多いです。

# Goのデメリット
GoはRailsやLaravelみたいにコマンド1発でファイルができるとかではないです。
ライブラリ選定など1から組まなけれ䜀ならない䛾で、ボイラーテンプレートがあれば効率的に立


# 環境構築(Mac)
今回はMacで環境構築をやっていきます。

```
brew install go
```

- バージョン確認
```
$ go version
go version go1.23.1 darwin/amd64
```

# 簡単な出力
簡単な出力からやっていきます。
```main.go
package main //Goはpackageの宣言から
//fmtはformatパッケージ
import "fmt"
//簡単な出力　　main関数がエントリーポイントでプログラムの本体
func main(){
	fmt.Println("Goの練習")
}
```
コマンドは今回の場合、
```
go run main.go
```
でGoの練習と出力されます。

- ビルドの実行法
```
go build main.go
```

# 変数
変数の書き方です。
```main.go
package main
import "fmt"
//変数

func main(){
	//明示的な定義
	// var 変数名　型　= 値
	var i int = 1000
	fmt.Println(i)
	// 1000

	var s string = "Goの練習だ"
	fmt.Println(s)
	//Goの練習だ

	var t,f bool = true,false
	fmt.Println(f,t)
	//true false

	var(
		i2 int = 2000
		s2 string = "Goをやるぞ"
	)
}
```

# 定数
以下が定数の書き方です。
```main.go
package main
import "fmt"
//定数(グローバルに書くことが多い)
const Pi = 3.14

const (
	URL = "http://xxx.co.jp"
	SiteName = "test"
)
//暗号の省略
const (
	A = 1
	B
	C
	D = "A"
	E
	F
)

func main(){
	fmt.Println(Pi)
	// Pi = 3
	// fmt.Println(Pi)
	
	fmt.Println(URL,SiteName)

	fmt.Println(A,B,C,D,E,F)
}
//3.14
//http://xxx.co.jp test
//1 1 1 A A A
```

# 演算子
- ***算術演算子***
```main.go
package main

import "fmt"

func main() {
	fmt.Println(1 + 2)

	fmt.Println(10 - 3)

	fmt.Println(5 * 8)

	fmt.Println(50 / 5)

	fmt.Println(13 % 3)
}

/*
3
7
40
10
1
*/
```
- ***比較演算子***
```main.go
package main

import "fmt"

func main() {

	fmt.Println(3 == 3)

	fmt.Println(5 == 8)

	fmt.Println(10 <= 50)

	fmt.Println(3 >= 30)

	fmt.Println(2 < 10)
	fmt.Println(5 > 1)

	fmt.Println(true == false)

	fmt.Println(true != false)
}
/*
true
false
true
false
true
true
false
true
*/
```
- ***論理演算子***
```main.go
package main

import "fmt"

unc main() {
	fmt.Println(true && false == true)
	fmt.Println(true && true == true)
	fmt.Println(true && false == false)

	fmt.Println(true || false == true)
	fmt.Println(false || false == true)

	fmt.Println(!true)
	fmt.Println(!false)
}
/*
false
true
true
true
false
false
true
*/
```

# ポインタ型
ポインタという機能があり、***変数がメモリ上の他の変数のアドレスを指す特別な型***のことです。変数の値そのものではなく、変数が格納されているメモリのアドレスを操作できるようになります。

```main.go
package main

import "fmt"

func Double(i int){
	i = i * 2
}

func Doublev2(i *int){
	*i = *i*2
}

//ポインタ
func main(){
	var n int = 1000
	fmt.Println(n)

	fmt.Println(&n)

	Double(n)

	fmt.Println(n)

	//ポインタ宣言
	var p *int = &n
	fmt.Println(p)
	fmt.Println(*p)

	Doublev2(&n)
	fmt.Println(n)
}
/*1000
0xc000090020
1000
0xc000090020
1000
2000
*/
```

# 関数
関数の使い方です。
```function.go
package main

import "fmt"

// 関数

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

func Div(x, y int) (int, int) {
	q := x / y
	r := x % y
	return q, r
}

func Double(price int) (result int) {
	result = price * 2
	return
}

func Noreturn() {
	fmt.Println("No Return")
	return
}

func main() {
	i := Plus(1, 2)
	fmt.Println(i)

	i2, _ := Div(9, 4)
	fmt.Println(i2)

	i4 := Double(1000)
	fmt.Println(i4)

	Noreturn()
}

/*
3
2
2000
No Return
*/
```

# 条件分岐(if for switch文)
まずはif文からです。
- ```if```
```if.go
import "fmt"

//if
//条件分岐

func main() {
	a := 0
	if a == 20 {
		fmt.Println("twenty")
	} else {
		fmt.Println("Nothing")
	}
}
//Nothing
```
次は***else if***も使っています。
```if.go
package main

import "fmt"

//if
//条件分岐

func main() {
	a := 10
	if a == 20 {
		fmt.Println("twenty")
	} else if a == 10 {
		fmt.Println("ten")
	} else{
		fmt.Println("Nothing")
	}
}

//ten
```
次は簡易文付きのif文です。
```if.go
package main

import "fmt"

//if
//条件分岐

func main() {
	a := 10
	if a == 20 {
		fmt.Println("twenty")
	} else if a == 10 {
		fmt.Println("ten")
	} else{
		fmt.Println("Nothing")
	}

	if b:=1000; b== 1000 {
		fmt.Println("thousand")
	}

}
//ten
//thousand
```

- ```for```
breakを使用
```for.go
package main

import "fmt"

//if
//繰り返し処理

func main() {
	i:= 0
	for {
		i ++
		if i == 3{
			break;
		}
		fmt.Println("ループ")
	}
}
//ループ
//ループ
```

```for.go
func main() {

	point := 0
	for point < 10 {
		fmt.Println(point)
		point++
	}
}
	// 1
	// 2
	// 3
	// 4
	// 5
	// 6
	// 7
	// 8
	// 9
```
continue
```for.go
package main

import "fmt"

//if
//繰り返し処理

func main() {
    for i := 0; i < 10; i++ {
		if i == 3{
			continue
		}
		if i == 6 {
			break	
		}
		fmt.Println(i)
	}
}
// 0
// 1
// 2
// 4
// 5
```


# 構造体struct
***複数の異なる型のデータをまとめて1つのデータとして扱えるデータ型***です。

```struct.go
package main

import "fmt"

type User struct {
	Name string
	Age int

}

func main(){
	var userA User
	userA.Name = "太郎"
	userA.Age = 30
	fmt.Println(userA)
}

//{太郎 30}
```

# 標準パッケージの種類
以下のものはよく使われるみたいですが、1つ1つ説明したら長くなるので割愛します。
他にも色々あるので調べてください。
- os
- time
- math
- rand
- flag
- fmt
- log
- stconv
- strings


# 資料

https://zenn.dev/y16ra/articles/251c3770365689