Go言語の割り算と余り（/ と %）の使い方：型変換の注意点から負の数の計算まで解説

2026年5月18日

演算子

Go言語はシンプルかつ厳格な型システムを持つ言語であり、数値計算においてもその特性が強く反映されます。

プログラミングにおいて基本となる割り算と余りの計算ですが、Go言語では扱うデータの型によって挙動が大きく異なるため注意が必要です。

特に整数同士の計算における切り捨てや、浮動小数点数への型変換、さらには負の数が絡む剰余計算など、正確に理解しておくべきポイントがいくつか存在します。

この記事では、Go言語の割り算演算子 / と剰余演算子 % の基本的な使い方から、実務で役立つ応用的なテクニックまでを詳しく解説します。

目次 [ close ]

Go言語における割り算の基本仕様

Go言語で割り算を行う際は、演算子である / を使用します。

この演算子は、オペランド（演算の対象となる値）の型によって、整数除算として機能するか、あるいは浮動小数点数除算として機能するかが決まります。

整数同士の割り算における挙動

Go言語では、整数型（int、int64、uint など）同士で割り算を行うと、結果も必ず整数型になります。

このとき、小数点以下の値は一律で切り捨てられるという点に注意が必要です。

例えば、5 / 2 という計算を行った場合、数学的な答えは 2.5 ですが、Go言語の整数除算では 2 が返されます。

以下に具体的なコード例を示します。

// 整数同士の割り算の例
package main

import "fmt"

func main() {
    a := 7
    b := 3
    
    // 整数同士の計算なので結果は切り捨てられる
    result := a / b
    
    fmt.Printf("結果: %d\n", result)
}

実行結果

結果: 2

このように、意図せず情報が欠落する可能性があるため、計算結果に精度が求められる場合は型の選択に注意しなければなりません。

浮動小数点数を用いた割り算

小数点以下の値を保持したい場合は、オペランドを浮動小数点数型（float32 や float64）にする必要があります。

少なくとも片方の値が浮動小数点数であれば、結果も浮動小数点数として計算されます。

Go言語ではリテラルに小数点を含めるだけで、デフォルトで float64 型として扱われます。

// 浮動小数点数を用いた割り算の例
package main

import "fmt"

func main() {
    // 小数点を含むリテラルを使用
    a := 7.0
    b := 3.0
    
    result := a / b
    
    fmt.Printf("結果: %f\n", result)
}

実行結果

結果: 2.333333

このように、同じ / 演算子であっても、型によって得られる結果が全く異なることがわかります。

型変換（キャスト）の重要性と注意点

Go言語は厳格な静的型付け言語であるため、異なる型同士の演算を直接行うことはできません。

int型とfloat64型を混ぜて計算しようとするとコンパイルエラーが発生します。

明示的な型変換の手順

変数として定義された整数を浮動小数点数として計算したい場合は、明示的にキャストを行う必要があります。

キャストを行うには、float64(変数名) のように記述します。

// 型変換を用いた計算例
package main

import "fmt"

func main() {
    count := 10
    total := 45
    
    // そのまま計算すると 4 になる
    wrongAverage := total / count
    
    // 両方を float64 に変換してから計算する
    correctAverage := float64(total) / float64(count)
    
    fmt.Printf("不正確な平均: %v\n", wrongAverage)
    fmt.Printf("正確な平均: %v\n", correctAverage)
}

実行結果

不正確な平均: 4
正確な平均: 4.5

実務においては、データベースから取得した整数値の平均を出したり、比率を計算したりする場面でこの型変換が必須となります。

定数と変数の扱いの違い

少し特殊な仕様として、Go言語の「型のない定数（Untyped Constant）」の扱いがあります。

定数リテラル同士であれば、異なる種類に見えてもコンパイル時に適切に処理されることがあります。

しかし、一度変数に代入された値については、型の一致が厳密に求められます。

常に「計算前に型を揃える」という習慣をつけておくことが、バグを防ぐ近道です。

剰余演算子（%）による余りの計算

次に、割り算の余りを求める % 演算子について解説します。

この演算子は「モジュロ演算子」とも呼ばれ、特定の周期性を扱う処理や奇数・偶数の判定によく使われます。

剰余演算子の基本

剰余演算子は、左オペランドを右オペランドで割ったときの「余り」を返します。

Go言語において、% 演算子は整数型に対してのみ使用可能であるという強力な制約があります。

浮動小数点数に対して % を使おうとすると、コンパイルエラーになります。

// 剰余演算の例
package main

import "fmt"

func main() {
    num := 10
    
    fmt.Printf("10 / 3 の余り: %d\n", num % 3)
    
    // 偶数・奇数の判定
    if num % 2 == 0 {
        fmt.Println("10 は偶数です")
    }
}

実行結果

10 / 3 の余り: 1
10 は偶数です

負の数が含まれる場合の挙動

負の数に対する剰余計算の結果は、言語によって仕様が分かれる部分ですが、Go言語では明確なルールがあります。

Go言語の剰余演算の結果は、必ず左オペランド（被除数）の符号と一致します。

これは、多くのC系言語（C99以降）と同様の振る舞いです。

式	結果	理由
7 % 3	1	7 = 3 * 2 + 1
-7 % 3	-1	被除数が負なので結果も負
7 % -3	1	被除数が正なので結果も正
-7 % -3	-1	被除数が負なので結果も負

この仕様を理解していないと、負の数が含まれるデータのインデックス計算などで予期せぬ動作を招く恐れがあります。

ゼロ除算（Division by Zero）の回避

プログラミング全般に言えることですが、0で割る処理（ゼロ除算）は致命的なエラーの原因となります。

Go言語においても、ゼロ除算が発生した際の挙動を正しく把握しておく必要があります。

コンパイルエラーとランタイムパニック

定数によってゼロ除算が明らかな場合、Goのコンパイラはビルド時にエラーを出力してくれます。

しかし、変数を用いた計算で実行時に 0 が渡された場合、プログラムはランタイムパニック（panic: runtime error: integer divide by zero）を起こして強制終了します。

// ゼロ除算によるパニックの例
package main

import "fmt"

func main() {
    divisor := 0
    // ここでパニックが発生し、以降の処理は実行されない
    result := 10 / divisor
    fmt.Println(result)
}

安全な割り算の実装パターン

実務では、ユーザー入力や計算結果によって除数が 0 になる可能性がある場合、必ず事前にチェックを行うのが鉄則です。

// 安全な割り算の関数例
func safeDivide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("0で割ることはできません")
    }
    return a / b, nil
}

このようにエラーハンドリングを組み込むことで、堅牢なアプリケーションを構築することができます。

浮動小数点数での剰余計算（math.Mod）

前述の通り、% 演算子は整数専用です。

もし浮動小数点数で「余り」を求めたい場合は、標準ライブラリの math パッケージに含まれる math.Mod 関数を使用します。

// math.Mod の使用例
package main

import (
    "fmt"
    "math"
)

func main() {
    a := 5.5
    b := 1.2
    
    // 5.5 を 1.2 で割った余り
    result := math.Mod(a, b)
    
    fmt.Printf("結果: %v\n", result)
}

実行結果

結果: 0.7000000000000002

浮動小数点数の計算には IEEE 754 規格に伴う微小な誤差が含まれる可能性があるため、結果の比較などを行う際は注意が必要です。

高度な計算：大きな数値の扱いと精度

非常に大きな整数や、非常に高い精度が必要な金融系の計算では、標準の int や float64 では不十分な場合があります。

そのようなケースでは、math/big パッケージを利用することを検討してください。

math/big パッケージの活用

big.Int 型や big.Rat（有理数）型を使用することで、メモリが許す限りの大きさの数値を精度を落とさずに計算できます。

ただし、通常の演算子 / は使えず、メソッドチェーンのような形で計算を記述する必要があります。

// math/big を用いた割り算
package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewInt(1000000000000000000)
    b := big.NewInt(3)
    
    quo := new(big.Int).Div(a, b) // 商
    rem := new(big.Int).Mod(a, b) // 余り
    
    fmt.Printf("商: %s\n", quo.String())
    fmt.Printf("余り: %s\n", rem.String())
}

通常の割り算よりも処理負荷は高くなりますが、正確性が最優先されるシステムでは不可欠な知識です。