初心者が使えそうだと思ったGoパッケージをまとめる

#はじめに
学習の一環としてGoの初心者がこれから個人開発をするにあたって使えそうだと思ったパッケージを逆引き的な感じでまとめました。
まだ途中なのでこれから開発が進むに連れてどんどん補充していく予定。

##timeパッケージ
Goの時間に関係するパッケージ
###時間を表示したい
```Go
time.NOW()
//現在時刻を返す関数
//>>2021-10-24 16:02:29.28855 +0900 JST m=+0.000072118
```

###特定の時刻を作成、表示したい
```
t2 := time.Date(2020, 6, 10, 10, 10, 10, 0, time.Local)

//指定した時間を生成
fmt.Println(t2)
//>>2020-06-10 10:10:10 +0900 JST
fmt.Println(t2.Year())
//>>2020
fmt.Println(t2.YearDay())
//>>162
fmt.Println(t2.Month())
//>>June
fmt.Println(t2.Weekday())
//>>Wednesday
fmt.Println(t2.Day())
//>>10
fmt.Println(t2.Hour())
//>>10
fmt.Println(t2.Minute())
//>>10
fmt.Println(t2.Second())
//>>10
fmt.Println(t2.Nanosecond())
//>>0
fmt.Println(t2.Zone())
//>>JST 32400
//タイムゾーンを表示
```
###時間を表現したい
```
//時刻の感覚を表現する
//time.Duration型を渡す
fmt.Println(time.Hour)
//>>1h0m0s
fmt.Printf("%T\n", time.Hour)
//>>time.Duration
fmt.Println(time.Minute)
//>>1m0s
fmt.Println(time.Second)
//>>1s
fmt.Println(time.Millisecond)
//>>1ms
fmt.Println(time.Microsecond)
//>>1µs
fmt.Println(time.Nanosecond)
//>>1ns
```
###文字列を時間に変換したい
```
d, _ := time.ParseDuration("2h30m")
fmt.Println(d)
//文字列を変換できる、2h30m0sと表示
```
###取得した時間に特定の時間を追加したい
```
t3 := time.Now()
t3 = t3.Add(2*time.Minute + 15*time.Second)
fmt.Println(t3)
```
###2つの時間の差分を求めたい
```
t1 := time.Date(2020, 6, 10, 10, 10, 10, 0, time.Local)
t2 := time.Now()
t3 := t1.Sub(t2)
fmt.Println(t3)
//>>-12030h21m24.789621s
```
###時間の比較をしたい
```
t1 := time.Date(2020, 6, 10, 10, 10, 10, 0, time.Local)
t2 := time.Now()
fmt.Println(t1.Before(t2))
//>>ture
fmt.Println(t1.After(t2))
//>>false
```
###時間を止めたい
```
time.Sleep(5 * time.Second)
//この後に続くプログラムを5秒間停止させる
```

##mathパッケージ
###円周率を表示したい
```
fmt.Println(math.Pi)
//>>3.141592653589793
```
###2の平方根を求めたい
```
fmt.Println(math.Sqrt2)
//>>1.4142135623730951
```
###float32で表現可能な最大数を求めたい
```
fmt.Println(math.MaxFloat32)
//>>3.4028234663852886e+38
```
###float32で表現可能な0ではない最小値を求めたい
```
fmt.Println(math.SmallestNonzeroFloat32)
//>>1.401298464324817e-45
```
###float64で表現可能な最大数を求めたい
```
fmt.Println(math.MaxFloat64)
//>>1.7976931348623157e+308
```
###float64で表現可能な0ではない最小値
```
fmt.Println(math.SmallestNonzeroFloat64)
//>>5e-324
```
###int64で上記を再現
```
fmt.Println(math.MaxInt64)
//>>9223372036854775807
fmt.Println(math.MinInt64)
//>>-9223372036854775808
```
###絶対値を取得したい
```
fmt.Println(math.Abs(100))
//>>100
fmt.Println(math.Abs(-100))
//>>100
```
###累乗を求めたい
```
fmt.Println(math.Pow(0, 2))
//>>0
fmt.Println(math.Pow(2, 2))
//>>4
```
###平方根、立方根を求めたい
```
fmt.Println(math.Sqrt(2))
//>>1.4142135623730951
fmt.Println(math.Cbrt(8))
//>>2
```
###最大値、最小値を求めたい
```
fmt.Println(math.Max(1, 2))
//>>2
fmt.Println(math.Min(1, 2))
//>>1
```
###小数点以下の切り捨て、切り上げをしたい
```
//math.Trunc 整数の正負を問わず小数点以下を単純に切り捨てる
fmt.Println(math.Trunc(3.14))
//>>3
fmt.Println(math.Trunc(-3.14))
//>>-3

//math.Floor 引数の数値より小さい最大の整数を返す
fmt.Println(math.Floor(3.5))
//>>3
fmt.Println(math.Floor(-3.5))
//>>-4

fmt.Println(math.Ceil(3.5))
//>>4
fmt.Println(math.Ceil(-3.5))
//>>-3
```

##fmtパッケージ
###fmtの標準表示をしたい(改行されないver)
```
fmt.Print("Hello")
//>>Hello
```
###文字の表示をしたい(改行されるver)
```
fmt.Println("Hello", "World!!")
//>>Hello World!
//文字列は半角スペースで区切られる
```
###文字列のフォーマットを指定したい
```
fmt.Printf("%s\n", "Hello")
//>>Hello
fmt.Printf("%#v\n", "Hello")
//>>"Hello"
```
###書き込み先を指定した文字出力
```
//Fprint 書き込み先指定
fmt.Fprint(os.Stdout, "Hello")
//>>Helloと出力される
```

##strconvパッケージ
###bool値を文字列に変換したい
```
bt := true
fmt.Printf("%T\n", strconv.FormatBool(bt))
//>>string
fmt.Println(strconv.FormatBool(bt))
//>>true
```
###整数を文字列にしたい
```
i := strconv.FormatInt(-100, 10)
fmt.Printf("%v, %T\n", i, i)
//>>-100, string

i2 := strconv.Itoa(100)
fmt.Printf("%v, %T\n", i2, i2)
//>>100, string
```
###文字列を真偽値に変換したい
```
bt1, _ := strconv.ParseBool("true")
fmt.Printf("%v, %T\n", bt1, bt1)
//>>true, boolと出力

bt2, _ := strconv.ParseBool("1")
bt3, _ := strconv.ParseBool("t")
bt4, _ := strconv.ParseBool("f")
bt5, _ := strconv.ParseBool("TRUE")
bt6, _ := strconv.ParseBool("True")
fmt.Println(bt2, bt3, bt4, bt5, bt6)
//すべてtrueと出力

bf1, ok := strconv.ParseBool("false")
if ok != nil {
	fmt.Println("Convert Error")
}
//エラーハンドリングも行える

fmt.Printf("%v, %T\n", bf1, bf1)
false, boolと出力

bf2, _ := strconv.ParseBool("0")
bf3, _ := strconv.ParseBool("f")
bf4, _ := strconv.ParseBool("F")
bf5, _ := strconv.ParseBool("FALSE")
bf6, _ := strconv.ParseBool("False")
fmt.Println(bf2, bf3, bf4, bf5, bf6)
//すべてfalseと出力

```
###文字列を整数型に変換したい
```
i3, _ := strconv.ParseInt("12345", 10, 0)
fmt.Printf("%v, %T\n", i3, i3)
//>>12345, int64

i4, _ := strconv.ParseInt("-1", 10, 0)
fmt.Printf("%v, %T\n", i4, i4)
//>>-1, int64

i10, _ := strconv.Atoi("123")
fmt.Println(i10)
//>>123
```
###文字列を浮動小数点型に変換したい
```
fl1, _ := strconv.ParseFloat("3.14", 64)
//>>3.14
fl2, _ := strconv.ParseFloat(".2", 64)
//>>0.2
fl3, _ := strconv.ParseFloat("-2", 64)
//>>-2
fl4, _ := strconv.ParseFloat("1.2345e8", 64)
//>>1.2345e+08
fl5, _ := strconv.ParseFloat("1.2345E8", 64)
//>>1.2345e+08
fmt.Println(fl1, fl2, fl3, fl4, fl5)
```

##stringsパッケージ
```
//文字列の操作に関連するパッケージ
```
###文字列の連結をしたい
```
s1 := strings.Join([]string{"A", "B", "C"}, ",")
//カンマ区切り

s2 := strings.Join([]string{"A", "B", "C"}, "")
//直接連結
fmt.Println(s1, s2)
//>>A,B,C ABC
```
###検索したい最初の文字が何番目にあるかを探し、index番号を返したい
```
i1 := strings.Index("ABCDE", "A")
i2 := strings.Index("ABCDE", "D")
fmt.Println(i1, i2)
//>>0 3
```
###特定の文字が含まれる最後の文字のIndex番号を取得したい
```
i3 := strings.LastIndex("ABCDABCD", "BC")
fmt.Println(i3)
//>>5

i4 := strings.IndexAny("ABCDABCD", "BC")
i5 := strings.LastIndexAny("ABCDABCD", "BC")
fmt.Println(i4, i5)
//>>1 6
```
###検索対象の文字列が指定した文字列で始まるか/終わるか確認したい
```
b1 := strings.HasPrefix("ABC", "A")
//始まるか
b2 := strings.HasSuffix("ABC", "C")
//終わるか
fmt.Println(b1, b2)
//>>true true
```
###指定した文字列が含まれているか？
```
b3 := strings.Contains("ABC", "B")
//指定した文字列が含まれているか
b4 := strings.ContainsAny("ABCDE", "BD")
//指定した文字列が一語でも該当していたら
fmt.Println(b3, b4)
//>>true true
```
###第一引数の文字数の中で第二引数の文字が何個含まれているか確認したい
```
b6 := strings.Count("ABCABC", "B")
b7 := strings.Count("ABCABC", "")
fmt.Println(b6, b7)
```
###文字列を指定した回数分繰り返して結合したい
```
s3 := strings.Repeat("ABC", 4)
//>>ABCABCABCABC
s4 := strings.Repeat("ABC", 0)
//>>何も表示されない
fmt.Println(s3, s4)
```
###特定の文字列の指定した文字を別の文字に指定した回数分変更したい
```
s5 := strings.Replace("AAAAAA", "A", "B", 1)
//>>AはBに1回分置換される

s6 := strings.Replace("AAAAAA", "A", "B", -1)
//>>AはBすべて置換される。(-1を引数に指定すると該当する文字列すべてを置換する)
fmt.Println(s5, s6)
//>>BAAAAA BBBBBB
```
###文字列を分割したい
```
s7 := strings.Split("A,B,C,D,E", ",")
fmt.Println(s7)
//>>[A B C D E]
//セパレータを取り除いて分割

s8 := strings.SplitAfter("A,B,C,D,E", ",")
fmt.Println(s8)
//>>[A, B, C, D, E]
//セパレータを取り除かず分割

s9 := strings.SplitN("A,B,C,D,E", ",", 2)
fmt.Println(s9)
//>>[A B,C,D,E]
//分割する数を引数で指定、２つに分かれている

s10 := strings.SplitAfterN("A,B,C,D,E", ",", 4)
fmt.Println(s10)
//[A, B, C, D,E]

```
###文字列を大文字から小文字、小文字から大文字に変換したい
```
s11 := strings.ToLower("ABC")
fmt.Println(s11)
//>>abc
s12 := strings.ToLower("E")
fmt.Println(s12)
//>>e

s13 := strings.ToUpper("abc")
fmt.Println(s13)
//>>ABC
s14 := strings.ToUpper("e")
fmt.Println(s14)
//>>E
```
###文字列の前後のスペースを取り除きたい
```
s13 := strings.TrimSpace("     --    abc    --    ")
fmt.Println(s13)
//>>--    abc    --
//前後の空白は取り除かれる
s14 := strings.TrimSpace("       abc       ")
fmt.Println(s14)
//abc
//全角もとりのぞくことができる
```
###文字列からスペースで区切られたフィールドを取り出したい
```
s18 := strings.Fields("a b c")
fmt.Println(s18)
//>>[a b c]

fmt.Println(s18[1])
//>>b
//インデックス番号でも取り出せる
```

##regexpパッケージ
```
正規表現をサポートする機能をもつパッケージ
```
###特定の文字列が正規表現にマッチするか？(基本形)
```
match, _ := regexp.MatchString("A", "ABC")
//第一引数が正規表現、第二引数が検索対象の文字列
fmt.Println(match)
//>>true

//上記は簡易的な形。実行の度に正規表現のコンパイルを行うため大量の実行には向かない。予め正規表現をコンパイルしておく必要がある
//エラー時は第二引数でエラーを返す
re1, _ := regexp.Compile("A")
match = re1.MatchString("ABC")
fmt.Println(match)
//>>true

//上記と違いこちらはエラー時直接runtimeエラーを吐く
re2 := regexp.MustCompile("A")
match = re2.MatchString("ABC")
fmt.Println(match)
//>>true
```
###特定の文字列が正規表現にマッチするか？(フラグ一覧)
```
/*
フラグ一覧
	i 大文字小文字を区別しない
	m マルチラインモード(^と&が文頭、文末に加えて行頭、行末にマッチ)
	s .が\nにマッチ
	U 最小マッチへの変換
*/

re1 := regexp.MustCompile(`(?i)abc`)
match := re1.MatchString("ABC")
//フラグiをつけているので大文字にも該当する

fmt.Println(match)
//>>true
```
###特定の文字列が正規表現にマッチするか？(パターン一覧)
```
/*
パターン一覧
	^ 文頭(mフラグが有効な場合は行頭にも)
	$ 文末(mフラグが有効な場合は行末にも)
	\A 文頭
	\z 文末
	\b ASCIIによるワード協会
	\B 非ASCIIによるワード協会
*/
re1 := regexp.MustCompile(`^ABC$`)
match := re1.MatchString("ABC")
fmt.Println(match)
//>>true

match = re1.MatchString("   ABC   ")
fmt.Println(match)
//>>false
//文頭、文末にスペースが存在するためエラー
```
###特定の文字列が正規表現にマッチするか？(繰り返しパターン一覧)
```
/*
繰り返しのパターン一覧
	x* 0回以上繰り返すx(最大マッチ)
        x+ 1回以上繰り返すx(最小マッチ)
	x? 0回以上1回以下繰り返すx
	x{n,m} n回以上,m回以下繰り返すx (最大マッチ)
        x{n, } n回以上繰り返すx (最大マッチ)
	x{n} n回繰り返すx(最大マッチ)
	x*? 0回以上繰り返すx(最小マッチ)
	x+? 1回以上繰り返すx(最小マッチ)
	x?? 0回以上1回以下繰り返すx(最小マッチ)
        x{n,m}? n回以上,m回以下繰り返すx (最小マッチ)
	x{n, }? n回以上繰り返すx (最小マッチ)
        x{n}? n回繰り返すx(最小マッチ)
*/

re1 := regexp.MustCompile("a+b*")
//aを1回以上、bを0回以上繰り返す正規表現

fmt.Println(re1.MatchString("ab"))
//>>true
fmt.Println(re1.MatchString("a"))
//>>true
fmt.Println(re1.MatchString("ab"))
//>>true
fmt.Println(re1.MatchString("aaaabbbbbb"))
//>>true
fmt.Println(re1.MatchString("b"))
//>>false

re1 := regexp.MustCompile(`[XYZ]`)
//[]内の文字のどれかが該当していたらtrue
fmt.Println(re1.MatchString("Y"))
//>>true

re2 := regexp.MustCompile(`^[0-9A-Za-z]{3}$`)
//[]内の文字が{}内の回数文マッチしていたらtrue
fmt.Println(re2.MatchString("ABC"))
//>>true
fmt.Println(re2.MatchString("abcdefg"))
//>>false
re3 := regexp.MustCompile(`[^0-9A-Za-z_]`)
//[]内の文字がマッチしていなかったらtrue
fmt.Println(re3.MatchString("ABC"))
//>>false
fmt.Println(re3.MatchString("あ"))
//>>true
```
###特定の文字列が正規表現にマッチするか？(グループ一覧)
```
/*
	(正規表現) グループ (順序によるキャプチャ)
	(?:正規表現) グループ (キャプチャされない)
	(?:P<name>正規表現) 名前付きグループ
*/

re2 := regexp.MustCompile((`(abc|ABC)(xyz|XYZ)`))
//abc or ABCのグループとxyz or XYZのグループの２つで正規表現のチェックを行う
fmt.Println(re2.MatchString("abcxyz"))
//>>true
fmt.Println(re2.MatchString("ABCXYZ"))
//>>true
fmt.Println(re2.MatchString("ABCxyz"))
//>>true
fmt.Println(re2.MatchString("ABCabc"))
//>>false
```
###正規表現にマッチした文字列を取得したい
```
re := regexp.MustCompile((`(abc|ABC)(xyz|XYZ)`))

fs1 := re.FindString("AAAAABCXYZZZZ")
//正規表現にマッチした文字列の取得
fmt.Println(fs1)
//>>ABCXYZ

fs2 := re.FindAllString("ABCXYZABCXYZ", -1)
//マッチした複数の文字列を出力する。第二引数では取得する回数を指定できる。-1だとマッチした回数だけ取得を行う。
fmt.Println(fs2)
//>>[ABCXYZ ABCXYZ]
```
###正規表現にマッチした文字列を指定した文字列に置換したい
```
re1 := regexp.MustCompile(`\s+`)
fmt.Println(re1.ReplaceAllString("AAA BBB CCC", ","))
//>>AAA,BBB,CCC

re2 := regexp.MustCompile(`、|。`)
fmt.Println(re2.ReplaceAllString("おはようございます、今日も一日頑張りましょう。", ""))
//>>おはようございます今日も一日頑張りましょう
```
###正規表現にマッチした文字列を軸に分割したい
```
re1 := regexp.MustCompile((`(abc|ABC)(xyz|XYZ)`))
fmt.Println(re1.Split("ASHLJRTABCXYZGGOUHABCXYZ", -1))
//>>[ASHLJRT GGOUH ]

re2 := regexp.MustCompile(`\s+`)
fmt.Println(re2.Split("aaa   bbb    ccc", -1))
//>>[aaa bbb ccc]
```

##cryptパッケージ
```
###ハッシュ値の生成したい
```

```
    //------------------------------
    /* SHA-1 */
    s1 := sha1.New()
    io.WriteString(s1, "ABCDE")
    fmt.Printf("%x\n", s1.Sum(nil))
    // => "7be07aaf460d593a323d0db33da05b64bfdcb3a5"
    //------------------------------
    /* SHA-256 */
    s256 := sha256.New()
    io.WriteString(s256, "ABCDE")
    fmt.Printf("%x\n", s256.Sum(nil))
    // => "f0393febe8baaa55e32f7be2a7cc180bf34e52137d99e056c817a9c07b8f239a"
    //------------------------------
    /* SHA-512 */
    s512 := sha512.New()
    io.WriteString(s512, "ABCDE")
    fmt.Printf("%x\n", s512.Sum(nil))
    // => "9989a8fcbc29044b5883a0a36c146fe7415b1439e995b4d806e
```
##jsonパッケージ
```
jsonに関連するパッケージ
```
###変数の内容をjsonに変換したい
```
bs, er := json.Marshal(変数)
```
###jsonを構造体に変換したい
```
u1 := new(User)

if err := jsonUnmarshal(bs, &u1); er != nil {
  fmt.Println(err)
}
//userを新規でnewし既存のjsonデータを引数として送ることで元データの内容に変換できる
```

##sortパッケージ
```
文字や数値の並べ替えに関連するパッケージ
```
###文字、数字の並べ替えをしたい
```
i := []int{5, 3, 2, 4, 5, 6, 4, 8, 9, 8, 7, 10}
s := []string{"a", "z", "j"}

fmt.Println(i, s)
//>>[5 3 2 4 5 6 4 8 9 8 7 10] [a z j]

sort.Ints(i)
//整数型の並べ替え
sort.Strings(s)
//文字列型の並べ替え

fmt.Println(i, s)
//>>[2 3 4 4 5 5 6 7 8 8 9 10] [a j z]
```

```
//Entryという構造体を定義
type Entry struct {
	Name  string
	Value int
}

func main() {
　　　　　//Entryに代入
	el := []Entry{
		{"A", 20},
		{"F", 40},
		{"i", 30},
		{"b", 10},
		{"t", 15},
		{"y", 30},
		{"c", 30},
		{"w", 30},
	}
	fmt.Println(el)
　　　　　//>>[{A 20} {F 40} {i 30} {b 10} {t 15} {y 30} {c 30} {w 30}]

　　　　　//Slice Nameを昇順に整列させる。安定ソートを保証しない。
	sort.Slice(el, func(i, j int) bool { return el[i].Name < el[j].Name })
	fmt.Println(el)
　　　　　//>>[{A 20} {F 40} {b 10} {c 30} {i 30} {t 15} {w 30} {y 30}]

　　　　　//Slice Nameを昇順に整列させる。安定ソートを保証する。
        sort.SliceStable(el, func(i, j int) bool { return el[i].Name < el[j].Name })
　　　　　fmt.Println(el)
　　　　　//>>[{A 20} {F 40} {b 10} {c 30} {i 30} {t 15} {w 30} {y 30}]

}
```
##net/urlパッケージ
```
urlに関連するパッケージ
```
###URLをURL型にparseしたい
```
u, _ := url.Parse("http://example.com/search?a=1&b=2#top")
fmt.Println(u.Scheme)
//>>http

fmt.Println(u.Host)
//>>example.com

fmt.Println(u.Path)
//>>/search

fmt.Println(u.RawQuery)
//>>a=1&b=2

fmt.Println(u.Fragment)
//>>top

fmt.Println(u.Query())
map[a:[1] b:[2]]
```
###URLを生成したい
```
url := &url.URL{}
url.Scheme = "https:"
url.Host = "google.com"
q := url.Query()
q.Set("q", "Golang")

url.RawQuery = q.Encode()
fmt.Println(url)
//>>https:://google.com?q=Golang
```