Golangの個人的チートシート

#この記事について
完全に自分用に書いているので説明は少なめで簡単な処理のものが多いですが、備忘録的に使うので随時更新します。

##stringからのキャスト
###`string` → `int`

```go
func atoi(a string) (b int) {
    b, err := strconv.Atoi(a)
    if err != nil {
        panic(err)
    }
    return
}
```

###半角スペース区切りの `string` → `[]string`

```go
func aToSlice(a string) (b []string) {
    b = strings.Fields(strings.TrimSpace(a))
    return
}
```

###半角スペース区切りの `string` → `[]int`

```go
func aToIntSlice(a string) (b []int) {
    c := strings.Fields(strings.TrimSpace(a))
    for _, v := range c {
        d := atoi(v)
        b = append(b, d)
    }
    return
}
```

###半角スペース区切りの `string` → `[]float64`

```go
func aToFloat64Slice(a string) (b []float64) {
    c := strings.Fields(strings.TrimSpace(a))
    for _, v := range c {
        d, _ := strconv.ParseFloat(v, 64)
        b = append(b, d)
    }
    return
}
```


##スライスから別の型のスライスへのキャスト

###`[]string` → `[]int`
```go
func toIntSlice(a []string) (b []int) {
    for _, s := range a {
        i := atoi(s)
        b = append(b, i)
    }
    return
}
```

###`[]int` → `[]string`

```go
func toStrSlice(a []int) (b []string) {
    for _, i := range a {
        s := strconv.Itoa(i)
        b = append(b, s)
    }
    return
}
```

##その他
###絶対値を `int` で返す

```go
func abs(a int) (b int) {
    b = int(math.Abs(float64(a)))
    return
}
```

###`map[int]int` からvalueの最大値を返す

```go
func findMaxValue(m map[int]int) (maxValue int) {
    var max int
    var maxIndex int
    for i, v := range m {
        if max <= v {
            max = v
            maxIndex = i
        }
    }
    maxValue = m[maxIndex]
    return
}
```

###`map[int]int` から最大値を持つkeyのみのスライスを返す
Goの連想配列（map）は、範囲ループを使うと順番が実行ごとに異なるので昇順でソート返す。

```go
func findMaxValueKeys(m map[int]int) (maxKeys []int) {
    maxValue := findMaxValue(m)
    
    for i, v := range m {
        if v == maxValue {
            maxKeys = append(maxKeys, i)
        }
    }
    sort.Slice(maxKeys, func (i, j int) bool { return maxKeys[i] < maxKeys[j] })
    return
}
```

### アルファベットを順番に出力

```go
for i := 0; i < 26; i++ {
    fmt.Print(string('a'+i))
}
```

### 文字列を逆順にする

```go
func reverseString(s string) (rs string) {
	for i := len(s); i > 0; i-- {
		rs += s[i-1 : i]
	}
	return
}
```

### 数字を３桁ずつカンマ区切りにする （`int` → `string`）
ループ１回でできそうだけど

```go
func decorateNum(num int) (decoratedNum string) {
	strNum := strconv.Itoa(num)

	revStrNum = reverseString(strNum)
	var revDecoratedNum string
	for i := 0; i < len(strNum); i++ {
		revDecoratedNum += revStrNum[i : i+1]
		if (i+1)%3 == 0 && i+1 < len(strNum) {
			revDecoratedNum += ","
		}
	}

	for i := len(revDecoratedNum); i > 0; i-- {
		decoratedNum += revDecoratedNum[i-1 : i]
	}

	return
}
```

### ひらがなを半角カタカナに変換
いい感じのパッケージを見つけられなかった

```go
func hiraganaToSingle(hiraganaInput string) (singleOutput string) {
	hiragana := "あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわをんぁぃぅぇぉっゃゅょゔがぎぐげござじずぜぞだぢづでどばびぶべぼぱぴぷぺぽ"
	single := "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜｦﾝｧｨｩｪｫｯｬｭｮｳｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾊﾋﾌﾍﾎﾊﾋﾌﾍﾎ"

	for i := 0; i < len([]rune(hiraganaInput)); i++ {
		for j := 0; j < len([]rune(hiragana)); j++ {
			if string([]rune(hiraganaInput)[i:i+1]) == string([]rune(hiragana)[j:j+1]) {
				singleOutput += string([]rune(single)[j : j+1])
				if j > 54 && j < 76 {
					singleOutput += "ﾞ"
				} else if j >= 76 {
					singleOutput += "ﾟ"
				}
			}
		}
	}

	return
}
```