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

はじめに

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

timeパッケージ

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