big.Int.Int64()で困らない！Go言語での巨大整数変換テクニック

math/big パッケージは、通常の int や int64 では表現できないような非常に大きな整数（任意精度整数）を扱うための型 big.Int を提供しています。

big.Int.Int64() メソッドは、この big.Int 型の値を、Go言語の組み込み型である int64 に変換しようとするときに使用します。

関数のシグネチャ

func (x *Int) Int64() int64

このメソッドは、*Int 型のレシーバ x に対して呼び出され、int64 型の値を返します。

• 値が int64 の範囲を超過する場合
  x が表す整数が int64 の範囲に収まらない場合、返される値は 未定義 (undefined) となります。これは、特定の決まったエラー値が返されるわけではなく、Goのドキュメントでは「何が返されるか保証されない」という意味合いです。通常は、big.Int の下位64ビットが返されることが多いですが、この挙動に依存すべきではありません。値が範囲外になる可能性がある場合は、このメソッドを使用する前に、big.Int の値が int64 に収まるかどうかを確認するなどの追加の処理が必要です。

• 値が int64 の範囲に収まる場合
  x が表す整数が int64 型の最小値（−263）から最大値（263−1）の範囲に収まる場合、その値を int64 として返します。

利用例

例えば、計算結果が int64 に収まることが分かっている場合や、収まるかどうかを事前にチェックした上で変換したい場合などに使用します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// big.Int を作成
	bigNum1 := big.NewInt(12345) // int64 の範囲に収まる数
	bigNum2 := new(big.Int)
	bigNum2.SetString("9223372036854775807", 10) // int64 の最大値 (2^63 - 1)
	bigNum3 := new(big.Int)
	bigNum3.SetString("9223372036854775808", 10) // int64 の最大値 + 1 (範囲外)

	// Int64() を使って変換
	int64Num1 := bigNum1.Int64()
	fmt.Printf("bigNum1 (%s) を int64 に変換: %d\n", bigNum1.String(), int64Num1)

	int64Num2 := bigNum2.Int64()
	fmt.Printf("bigNum2 (%s) を int64 に変換: %d\n", bigNum2.String(), int64Num2)

	int64Num3 := bigNum3.Int64() // 範囲外のため、返り値は未定義
	fmt.Printf("bigNum3 (%s) を int64 に変換: %d (注意: 値が大きすぎるため未定義の挙動)\n", bigNum3.String(), int64Num3)

	// 変換可能か事前に確認する例
	// big.Int には IsInt64() という便利なメソッドがあります
	fmt.Println("\n--- IsInt64() を使ったチェック ---")
	if bigNum1.IsInt64() {
		fmt.Printf("bigNum1 (%s) は int64 に収まります: %d\n", bigNum1.String(), bigNum1.Int64())
	} else {
		fmt.Printf("bigNum1 (%s) は int64 に収まりません\n", bigNum1.String())
	}

	if bigNum3.IsInt64() {
		fmt.Printf("bigNum3 (%s) は int64 に収まります: %d\n", bigNum3.String(), bigNum3.Int64())
	} else {
		fmt.Printf("bigNum3 (%s) は int64 に収まりません\n", bigNum3.String())
	}
}

注意点

• ゼロ値
  big.Int のゼロ値 (new(big.Int)) は 0 を表し、Int64() を呼び出すと 0 が返されます。
• オーバーフローの危険性
  big.Int が int64 の範囲を超える値を保持している場合、Int64() メソッドを使用すると、予期しない値が返される可能性があります。そのため、Int64() を呼び出す前に big.Int.IsInt64() メソッドを使って、変換対象の big.Int の値が int64 に収まるかどうかを必ず確認することが推奨されます。

---

math/big パッケージの big.Int.Int64() メソッドは、big.Int 型の値を int64 型に変換する際に非常に便利ですが、その性質上、特定の落とし穴があります。ここでは、よくあるエラーとそのトラブルシューティングについて説明します。

値のオーバーフロー（最も一般的かつ重大なエラー）

エラーの内容
big.Int が int64 の表現可能な範囲（−263 から 263−1 まで）を超える値を保持しているにもかかわらず、Int64() を呼び出してしまった場合。

なぜ問題なのか
Go のドキュメントに明記されている通り、値が int64 の範囲を超えている場合、Int64() が返す値は 未定義 (undefined) です。これは、何が返されるか保証されないことを意味します。多くの場合、big.Int の内部表現の下位64ビットがそのまま int64 として解釈されることが多いですが、これは実装依存であり、将来のGoのバージョンで変更される可能性もあります。この未定義の挙動に依存したコードは、バグの温床となります。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// int64 の最大値 + 1
	// 9223372036854775807 (int64 の最大値)
	// 9223372036854775808 (int64 の最大値 + 1)
	tooBig := new(big.Int)
	tooBig.SetString("9223372036854775808", 10) // 範囲外

	// この呼び出しは未定義の挙動を引き起こす
	result := tooBig.Int64()
	fmt.Printf("Original big.Int: %s\n", tooBig.String())
	fmt.Printf("Int64() result (undefined behavior): %d\n", result)
	// 環境によっては負の数や予期しない大きな正の数が表示されることがあります
}

トラブルシューティング

• 代替手段の検討
  int64 の範囲を超える可能性がある場合は、そもそも int64 に変換するのではなく、引き続き *big.Int 型で処理を続けるか、文字列として出力することを検討します。
• エラーハンドリングの導入
  IsInt64() で false が返された場合、プログラムのロジックに応じて適切なエラーハンドリング（例えば、エラーを返す、ログに出力する、デフォルト値を設定する、別の型（例: string）で値を保持し続けるなど）を行うべきです。
• IsInt64() による事前チェック
  Int64() を呼び出す前に、必ず big.Int.IsInt64() メソッドを使って、値が int64 の範囲に収まるかどうかを確認します。

  package main
  
  import (
  	"fmt"
  	"math/big"
  )
  
  func main() {
  	tooBig := new(big.Int)
  	tooBig.SetString("9223372036854775808", 10)
  
  	if tooBig.IsInt64() {
  		result := tooBig.Int64()
  		fmt.Printf("Converted to int64: %d\n", result)
  	} else {
  		fmt.Printf("Error: big.Int value '%s' is too large for int64.\n", tooBig.String())
  		// ここでエラーハンドリングを行う
  		// 例えば、エラーを返す、パニックを起こす、別の型で処理する、など
  	}
  
  	validNum := big.NewInt(100)
  	if validNum.IsInt64() {
  		result := validNum.Int64()
  		fmt.Printf("Converted to int64: %d\n", result)
  	} else {
  		fmt.Printf("Error: big.Int value '%s' is too large for int64.\n", validNum.String())
  	}
  }
  

負の数の扱い

エラーの内容
big.Int が非常に大きな負の数（int64 の最小値 −263 よりも小さい値）を保持している場合。

なぜ問題なのか
これもオーバーフローと同様に、Int64() が返す値が未定義になる原因となります。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// int64 の最小値 - 1
	// -9223372036854775808 (int64 の最小値)
	// -9223372036854775809 (int64 の最小値 - 1)
	tooSmall := new(big.Int)
	tooSmall.SetString("-9223372036854775809", 10) // 範囲外

	result := tooSmall.Int64() // 未定義の挙動
	fmt.Printf("Original big.Int: %s\n", tooSmall.String())
	fmt.Printf("Int64() result (undefined behavior): %d\n", result)
}

トラブルシューティング
これもオーバーフローと同様に、IsInt64() による事前チェックが最も効果的です。

変換元が nil ポインタの場合

エラーの内容
big.Int のポインタが nil の状態で Int64() を呼び出そうとした場合。

なぜ問題なのか
Go では nil ポインタに対するメソッド呼び出しは、nil レシーバを許容するように設計されていない限り、ランタイムパニック（"nil pointer dereference"）を引き起こします。big.Int のメソッドは通常、nil レシーバを許容しません。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var num *big.Int // nil ポインタ
	// num.Int64() // ここでパニックが発生する
	// fmt.Println(num.Int64()) // この行は実行されない

	// 正しい利用例: 初期化された big.Int を使用
	num = big.NewInt(10)
	fmt.Println(num.Int64()) // 10
}

• nil チェック
  メソッドを呼び出す前に if num != nil のような nil チェックを追加することもできます。ただし、これは問題の根本原因を解決するよりも、パニックを防ぐための防御的なコーディングです。理想的には、nil になりうる状況を事前に避けるべきです。
• ポインタの初期化確認
  big.Int のポインタを使用する前に、必ず big.NewInt() や new(big.Int) などで初期化されていることを確認します。

1. 常に IsInt64() で事前チェックする
   これが最も重要です。値が int64 の範囲に収まることを確認してから Int64() を呼び出してください。
2. オーバーフロー時のハンドリング
   IsInt64() が false を返した場合の処理ロジック（エラー返却、ログ出力、代替処理など）を明確に定義します。
3. nil ポインタに注意
   big.Int のポインタは適切に初期化されていることを確認し、nil のままメソッドを呼び出さないようにします。

---

math/big パッケージの big.Int.Int64() メソッドは、big.Int 型の値を int64 型に変換するために使われます。ここでは、さまざまなシナリオにおける使用例と、関連するベストプラクティスをコードと共に解説します。

例1: 正常な変換（値が int64 の範囲に収まる場合）

最も基本的な使用例です。big.Int の値が int64 の表現可能な範囲（−263 から 263−1）に収まる場合、期待通りの変換が行われます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 正の数
	smallPositive := big.NewInt(123456789)
	val1 := smallPositive.Int64()
	fmt.Printf("big.Int: %s -> int64: %d\n", smallPositive.String(), val1) // big.Int: 123456789 -> int64: 123456789

	// 負の数
	smallNegative := big.NewInt(-987654321)
	val2 := smallNegative.Int64()
	fmt.Printf("big.Int: %s -> int64: %d\n", smallNegative.String(), val2) // big.Int: -987654321 -> int64: -987654321

	// 0
	zero := big.NewInt(0)
	val3 := zero.Int64()
	fmt.Printf("big.Int: %s -> int64: %d\n", zero.String(), val3) // big.Int: 0 -> int64: 0

	// int64 の最大値
	maxInt64 := new(big.Int).SetString("9223372036854775807", 10) // 2^63 - 1
	val4 := maxInt64.Int64()
	fmt.Printf("big.Int: %s -> int64: %d\n", maxInt64.String(), val4) // big.Int: 9223372036854775807 -> int64: 9223372036854775807

	// int64 の最小値
	minInt64 := new(big.Int).SetString("-9223372036854775808", 10) // -2^63
	val5 := minInt64.Int64()
	fmt.Printf("big.Int: %s -> int64: %d\n", minInt64.String(), val5) // big.Int: -9223372036854775808 -> int64: -9223372036854775808
}

解説
これらの例では、big.Int で表現された数値が int64 の範囲内に収まっているため、Int64() メソッドは正確な int64 値を返します。

例2: Int64() を安全に使うためのチェック（推奨される方法）

big.Int の値が int64 の範囲を超える可能性がある場合、Int64() を呼び出す前に big.Int.IsInt64() メソッドを使ってチェックすることが非常に重要です。これにより、未定義の挙動や予期せぬ結果を防ぐことができます。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// int64 の範囲に収まる値
	numWithinRange := big.NewInt(1000)

	// int64 の最大値より大きい値
	// 9223372036854775807 (int64 Max)
	// 9223372036854775808 (int64 Max + 1)
	numTooBig := new(big.Int)
	numTooBig.SetString("9223372036854775808", 10)

	// int64 の最小値より小さい値
	// -9223372036854775808 (int64 Min)
	// -9223372036854775809 (int64 Min - 1)
	numTooSmall := new(big.Int)
	numTooSmall.SetString("-9223372036854775809", 10)

	// ----------------------------------------------------
	// numWithinRange のチェック
	if numWithinRange.IsInt64() {
		val := numWithinRange.Int64()
		fmt.Printf("'%s' は int64 に収まります: %d\n", numWithinRange.String(), val)
	} else {
		// このブロックは実行されない
		fmt.Printf("'%s' は int64 に収まりません\n", numWithinRange.String())
	}

	fmt.Println("---")

	// numTooBig のチェック
	if numTooBig.IsInt64() {
		// このブロックは実行されない
		val := numTooBig.Int64()
		fmt.Printf("'%s' は int64 に収まります: %d\n", numTooBig.String(), val)
	} else {
		fmt.Printf("エラー: '%s' は int64 に収まりません。変換をスキップします。\n", numTooBig.String())
		// ここで適切なエラーハンドリングを行う:
		// 例: エラーを返す、ログに記録する、代替の処理を行う（文字列として扱うなど）
	}

	fmt.Println("---")

	// numTooSmall のチェック
	if numTooSmall.IsInt64() {
		// このブロックは実行されない
		val := numTooSmall.Int64()
		fmt.Printf("'%s' は int64 に収まります: %d\n", numTooSmall.String(), val)
	} else {
		fmt.Printf("エラー: '%s' は int64 に収まりません。変換をスキップします。\n", numTooSmall.String())
		// 同様に適切なエラーハンドリングを行う
	}
}

解説
この例では、IsInt64() が true を返した場合にのみ Int64() を呼び出しています。これにより、値が int64 の範囲外である場合の未定義の挙動を回避し、安全なコードを記述できます。エラーハンドリングのコメントも示しています。

例3: 関数からの安全な int64 変換とエラー返却

実際のアプリケーションでは、big.Int から int64 への変換を関数としてカプセル化し、変換できない場合はエラーを返すようにするのが一般的です。

package main

import (
	"errors"
	"fmt"
	"math/big"
)

// ToInt64 converts a big.Int to an int64, returning an error if it overflows.
// big.Int を int64 に変換します。オーバーフローする場合はエラーを返します。
func ToInt64(b *big.Int) (int64, error) {
	if b == nil {
		return 0, errors.New("input big.Int is nil")
	}
	if !b.IsInt64() {
		return 0, fmt.Errorf("value %s is too large or too small for int64", b.String())
	}
	return b.Int64(), nil
}

func main() {
	// 変換成功例
	val1 := big.NewInt(12345)
	if i64, err := ToInt64(val1); err != nil {
		fmt.Printf("変換エラー for %s: %v\n", val1.String(), err)
	} else {
		fmt.Printf("変換成功 for %s: %d\n", val1.String(), i64)
	}

	// オーバーフローエラー例 (正の数)
	valTooBig := new(big.Int).SetString("9223372036854775808", 10)
	if i64, err := ToInt64(valTooBig); err != nil {
		fmt.Printf("変換エラー for %s: %v\n", valTooBig.String(), err)
	} else {
		fmt.Printf("変換成功 for %s: %d\n", valTooBig.String(), i64)
	}

	// オーバーフローエラー例 (負の数)
	valTooSmall := new(big.Int).SetString("-9223372036854775809", 10)
	if i64, err := ToInt64(valTooSmall); err != nil {
		fmt.Printf("変換エラー for %s: %v\n", valTooSmall.String(), err)
	} else {
		fmt.Printf("変換成功 for %s: %d\n", valTooSmall.String(), i64)
	}

	// nil ポインタのエラー例
	var nilBigInt *big.Int
	if i64, err := ToInt64(nilBigInt); err != nil {
		fmt.Printf("変換エラー for nil: %v\n", err)
	} else {
		fmt.Printf("変換成功 for nil: %d\n", i64)
	}
}

解説
ToInt64 関数は、big.Int が nil でないか、かつ int64 の範囲に収まるかをチェックし、問題があればエラーを返します。これにより、呼び出し元は安全に変換処理を行い、エラー時には適切に対応できます。これは、堅牢なアプリケーションを構築する上で推奨されるアプローチです。

例4: int64 以外の型への変換の検討

場合によっては、big.Int の値を int64 に変換する必要がない、またはできないことがあります。そのような場合は、big.Int の別のメソッド（例: String()）や、より大きな整数型への変換を検討します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	veryLargeNum := new(big.Int)
	veryLargeNum.SetString("123456789012345678901234567890", 10) // int64 の範囲をはるかに超える

	if veryLargeNum.IsInt64() {
		// このブロックは実行されない
		fmt.Printf("int64 に変換: %d\n", veryLargeNum.Int64())
	} else {
		fmt.Printf("int64 には大きすぎます。\n")
		// オプション1: 文字列として扱う
		fmt.Printf("文字列として取得: %s\n", veryLargeNum.String())

		// オプション2: 他の big.Int 演算を続ける
		anotherBigNum := big.NewInt(100)
		sum := new(big.Int).Add(veryLargeNum, anotherBigNum)
		fmt.Printf("big.Int としての演算結果: %s\n", sum.String())
	}

	// big.Float や big.Rat への変換が必要な場合
	// big.Int を float64 に変換する (精度損失の可能性あり)
	// (big.Float を介して変換するのがより安全)
	f64Val, _ := new(big.Float).SetInt(big.NewInt(1000000000000000000)).Float64() // 非常に大きいint64
	fmt.Printf("big.Int を float64 に変換 (精度損失の可能性): %f\n", f64Val)
}

解説
この例では、big.Int が int64 に収まらない場合に、その値を文字列として扱う方法や、引き続き big.Int 型として演算を続ける方法を示しています。特に桁数が非常に大きい場合は、文字列として保存したり、big.Float などの他の任意精度型に変換して処理を続けるのが適切です。

---

big.Int.Int64() は big.Int を int64 に変換する便利なメソッドですが、値が int64 の範囲を超えた場合に未定義の挙動となるため、常に安全に使えるわけではありません。多くの場合、Int64() の代わりに、あるいはその呼び出しと組み合わせて、他の方法を検討する必要があります。

主な代替手段や関連するプログラミングの選択肢は以下の通りです。

big.Int.IsInt64() と安全なエラーハンドリング

これは、Int64() を使う上で最も推奨される「代替」というよりは「安全な利用方法」です。Int64() を呼び出す前に値が int64 の範囲に収まるかをチェックし、収まらない場合はエラーとして処理します。

目的
int64 の範囲を超えた場合にパニックや未定義の挙動を防ぎ、プログラムに制御されたエラーパスを提供する。

コード例

package main

import (
	"errors"
	"fmt"
	"math/big"
)

// ToInt64Safely は big.Int を int64 に安全に変換します。
// 範囲外の場合はエラーを返します。
func ToInt64Safely(b *big.Int) (int64, error) {
	if b == nil {
		return 0, errors.New("nil big.Int cannot be converted to int64")
	}
	if !b.IsInt64() {
		return 0, fmt.Errorf("value %s is out of int64 range", b.String())
	}
	return b.Int64(), nil
}

func main() {
	inRange := big.NewInt(12345)
	outOfRangePositive := new(big.Int).SetString("9223372036854775808", 10) // int64 Max + 1
	outOfRangeNegative := new(big.Int).SetString("-9223372036854775809", 10) // int64 Min - 1

	val, err := ToInt64Safely(inRange)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Printf("'%s' -> %d (OK)\n", inRange.String(), val)
	}

	val, err = ToInt64Safely(outOfRangePositive)
	if err != nil {
		fmt.Println("Error:", err) // Error: value 9223372036854775808 is out of int64 range
	} else {
		fmt.Printf("'%s' -> %d (OK)\n", outOfRangePositive.String(), val)
	}

	val, err = ToInt64Safely(outOfRangeNegative)
	if err != nil {
		fmt.Println("Error:", err) // Error: value -9223372036854775809 is out of int64 range
	} else {
		fmt.Printf("'%s' -> %d (OK)\n", outOfRangeNegative.String(), val)
	}

	var nilBigInt *big.Int
	val, err = ToInt64Safely(nilBigInt)
	if err != nil {
		fmt.Println("Error:", err) // Error: nil big.Int cannot be converted to int64
	} else {
		fmt.Printf("'%s' -> %d (OK)\n", "nil", val)
	}
}

解説
これが big.Int から組み込み型への変換を行う場合の標準的なアプローチです。IsInt64() は、big.Int の値が int64 に収まるかどうかを真偽値で返します。

big.Int.String() による文字列変換

値が int64 の範囲に収まらない場合や、数値計算ではなく、単に大きな整数値を表現・保存・表示したい場合に有効な方法です。

目的
任意の大きさの整数値を正確に保持し、可読性の高い形式で表示する。

コード例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	veryLargeNumber := new(big.Int)
	veryLargeNumber.SetString("123456789012345678901234567890", 10) // int64 をはるかに超える

	strVal := veryLargeNumber.String()
	fmt.Printf("big.Int を文字列として取得: %s\n", strVal)

	// 文字列からの再変換も可能
	reconverted := new(big.Int)
	reconverted.SetString(strVal, 10)
	fmt.Printf("文字列から再変換: %s\n", reconverted.String())
}

解説
String() メソッドは、big.Int の値を10進数の文字列として返します。これは、ログ出力、データベースへの保存、JSON や他のデータ形式でのシリアライズなどに広く利用されます。精度が失われることはありません。

計算を big.Int のまま続ける

多くの場合、big.Int を使うのは、途中の計算で int64 の範囲を超えうるためです。もし最終的な結果も int64 に収まらない可能性があったり、途中の計算で精度を保ちたい場合は、最初から最後まで big.Int 型で計算を続けるのが最も安全で自然な方法です。

目的
巨大な数値を扱う計算において、精度を完全に維持する。

コード例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	num1 := new(big.Int).SetString("9876543210987654321", 10) // int64 の最大値付近
	num2 := new(big.Int).SetString("1234567890123456789", 10) // int64 の最大値付近

	// big.Int のまま足し算
	sum := new(big.Int).Add(num1, num2)
	fmt.Printf("Sum of big.Ints: %s + %s = %s\n", num1.String(), num2.String(), sum.String())

	// big.Int のまま掛け算
	product := new(big.Int).Mul(num1, num2)
	fmt.Printf("Product of big.Ints: %s * %s = %s\n", num1.String(), num2.String(), product.String())

	// 比較なども big.Int のメソッドで行う
	if sum.Cmp(product) < 0 {
		fmt.Printf("Sum (%s) is less than Product (%s)\n", sum.String(), product.String())
	}
}

解説
big.Int 型は、加算 (Add)、減算 (Sub)、乗算 (Mul)、除算 (Div)、剰余 (Mod)、比較 (Cmp) など、すべての基本的な算術演算をメソッドとして提供しています。これらのメソッドを使用することで、精度を損なうことなく非常に大きな数値の計算を続けることができます。

big.Float や big.Rat への変換

もし計算が整数だけでなく、浮動小数点数や有理数（分数）を扱う必要がある場合、math/big パッケージの big.Float や big.Rat 型への変換を検討します。

目的
非常に大きな数値の浮動小数点計算や分数計算を行う。

コード例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	largeInt := new(big.Int).SetString("1000000000000000000000000000000", 10) // 10^30

	// big.Float への変換 (精度を指定可能)
	floatVal := new(big.Float).SetInt(largeInt)
	fmt.Printf("big.Int を big.Float に変換: %s\n", floatVal.Text('f', 0)) // 精度0で表示

	// big.Int と big.Float の計算
	oneThird := new(big.Float).Quo(big.NewFloat(1.0), big.NewFloat(3.0))
	resultFloat := new(big.Float).Mul(floatVal, oneThird)
	fmt.Printf("big.Float での計算: %s * 1/3 = %s\n", floatVal.Text('f', 0), resultFloat.Text('f', 5)) // 小数点以下5桁で表示

	// big.Rat (有理数) への変換
	ratVal := new(big.Rat).SetInt(largeInt)
	fmt.Printf("big.Int を big.Rat に変換: %s\n", ratVal.String()) // 1000000000000000000000000000000/1

	// big.Rat での計算
	quarter := big.NewRat(1, 4)
	resultRat := new(big.Rat).Mul(ratVal, quarter)
	fmt.Printf("big.Rat での計算: %s * 1/4 = %s\n", ratVal.String(), resultRat.String()) // 250000000000000000000000000000/1
}

解説

• big.Rat: 任意精度の有理数（分数）です。割り算の結果を分数として正確に保持したい場合に適しています。
• big.Float: 任意精度の浮動小数点数です。非常に大きな値や非常に小さな値を扱う際に、標準の float64 では精度が足りなくなる場合に利用します。

big.Int.Int64() の代替手段を検討する際の選択肢は、最終的に「その数値をどのように利用したいか」によって決まります。

• 浮動小数点数や分数として扱いたい場合
  big.Float や big.Rat への変換を検討します。
• 大きな数値の計算を続ける場合
  そのまま big.Int のメソッド群を使って計算を続けます。これが最も math/big パッケージの意図に沿った使い方です。
• 値を表現したい、保存したいだけの場合
  String() メソッドで文字列に変換するのが簡単で安全です。
• int64 に確実に収まる場合
  IsInt64() でチェックし、Int64() を使うのが最も直接的です。