Go constant.BinaryOp 怎样对分数字面量做精确运算

我第一次用 go/constant 做常量求值时，最容易误判的是“分数”。Go 没有单独的 1/3 分数字面量，但可以把两个整数交给 constant.BinaryOp 的 token.QUO，得到仍然保持精确语义的有理数结果。

官方资料：https://pkg.go.dev/go/constant

要让分数保持精确，先用 token.QUO 做常量除法，再用 constant.Num、constant.Denom 或 ExactString 读取结果；不要在中途调用 Float64Val。

BinaryOp 的结果为什么可以保持分数

constant.BinaryOp(x, op, y) 表示二元表达式 x op y。它接收两个 constant.Value 和一个 go/token 运算符，结果仍然是 constant.Value。官方文档特别说明，比较要使用 Compare，移位要使用 Shift，不能把它们都塞给 BinaryOp。

对数字常量而言，整数相除产生的结果可以用有理数表示。例如 1/3 不需要先变成 0.333333...；内部可以保留分子 1、分母 3，后续继续参与加法、乘法时仍按精确值计算。

先用 token.QUO 构造一个精确的三分之一

关键点是运算符。token.QUO 表示普通除法，两个 Int 值做这类常量除法后，可以得到表示分数的 Float 值。这里的 Float 是 constant.Kind 的分类，不等于已经转换成机器浮点数。

package main

import (
	"fmt"
	"go/constant"
	"go/token"
)

func main() {
	// 两个整数通过普通除法构造 1/3，结果仍交给 constant.Value 保存。
	one := constant.MakeInt64(1)
	three := constant.MakeInt64(3)
	oneThird := constant.BinaryOp(one, token.QUO, three)

	// ExactString 用于查看完整的常量文本，避免只看近似显示。
	fmt.Println("kind:", oneThird.Kind())
	fmt.Println("exact:", oneThird.ExactString())
	fmt.Println("num:", constant.Num(oneThird))
	fmt.Println("denom:", constant.Denom(oneThird))
}

这个示例的重点不是把结果打印成某种固定格式，而是保留了三个可用事实：结果的种类、精确文本，以及分子和分母。实际工具中建议把 Value 继续传给后续求值步骤，最后一步再决定显示格式。

把多个分数组合起来，结果仍按有理数计算

有了 1/3 后，可以继续和由十进制字面量创建的常量相加。MakeFromLiteral 会按照 Go 字面量规则解析输入；例如 "0.5" 可以精确表示为二分之一。这样就能看到 1/3 + 5/6 = 7/6 这类计算不会因为中途转成 float64 而丢失分母信息。

package main

import (
	"fmt"
	"go/constant"
	"go/token"
)

func main() {
	// 先得到 1/3；QUO 是普通常量除法，不是整数截断除法。
	oneThird := constant.BinaryOp(
		constant.MakeInt64(1), token.QUO, constant.MakeInt64(3),
	)

	// 5/6 由整数除法得到，两个 Value 都还没有转换成 float64。
	fiveSixths := constant.BinaryOp(
		constant.MakeInt64(5), token.QUO, constant.MakeInt64(6),
	)

	// 加法直接在常量值上进行，结果应为 7/6。
	result := constant.BinaryOp(oneThird, token.ADD, fiveSixths)
	fmt.Println(result.ExactString())
}

输出的精确形式可能随标准库的显示规则呈现为分数或等价的精确数值，但它不会因为这一步加法自动变成近似的二进制浮点数。对需要稳定序列化的工具，优先保存 Num(result) 和 Denom(result)。

Num、Denom 与 ExactString 分别适合什么场景

我在调试常量求值器时，通常把这三个 API 分成三种用途。Num 与 Denom 适合结构化保存和继续做分数级别的判断；ExactString 适合日志、诊断消息和快照测试。对于过大或无法表示成分数的值，官方 API 可能返回 Unknown，调用方要把它当成“结果不可用”处理。

package main

import (
	"fmt"
	"go/constant"
	"go/token"
)

func main() {
	// 计算 2/7，保留为 constant.Value 供后续检查。
	value := constant.BinaryOp(
		constant.MakeInt64(2), token.QUO, constant.MakeInt64(7),
	)

	// Num 和 Denom 适合写入结构化结果，不依赖显示字符串解析。
	if value.Kind() == constant.Unknown {
		// Unknown 代表求值阶段已经无法提供可靠结果。
		fmt.Println("unknown constant")
		return
	}
	fmt.Println("num:", constant.Num(value))
	fmt.Println("denom:", constant.Denom(value))
	fmt.Println("exact:", value.ExactString())

	// Float64Val 会返回是否能无损表示；false 时只能把结果当近似值用。
	f, exact := constant.Float64Val(value)
	fmt.Printf("float64=%v exact=%t\n", f, exact)
}

这里最重要的是第二个返回值。即使程序确实拿到了一个 float64，也不能据此认为它和原来的分数相等；只有 exact 为 true 时，才可以把该转换当作无损表示。

两个容易踩到的运算符边界

第一，token.QUO_ASSIGN 有特殊用途。官方文档说明，如果两个操作数都是 Int，使用它可以强制进行整数除法并保证结果是 Int。因此要表达分数，不要误用这个运算符。

// QUO 得到可继续保存分母的结果；QUO_ASSIGN 强制整数结果。
fraction := constant.BinaryOp(constant.MakeInt64(1), token.QUO, constant.MakeInt64(3))
integer := constant.BinaryOp(constant.MakeInt64(1), token.QUO_ASSIGN, constant.MakeInt64(3))
fmt.Println(fraction.Kind(), fraction.ExactString())
fmt.Println(integer.Kind(), integer.ExactString())

第二，除数为零会触发运行时 panic，未知值参与运算则通常继续产生未知值。常量分析工具如果输入来自不完整源码或前一步已经报错，应先检查 Kind() == constant.Unknown，并在自己的错误模型中保留原因，不要把未知值当成零。

我的取舍：最后一步才转成 float64

这套 API 给我的实际经验是：精确值和展示值最好分层。解析阶段只用 constant.Value，需要做等价判断、生成诊断或落盘时使用 Num、Denom、ExactString；只有调用方明确要求图表、普通数值接口或硬件浮点参数时，才调用 Float64Val，同时把 exact 标记一起传出去。

所以，标题里的“分数字面量”更准确地说是“由常量字面量和除法表达式得到的分数结果”。只要 BinaryOp 的中间结果没有被提前降级为机器浮点数，后面的精确运算就可以继续进行。

相关问题

Go constant.BinaryOp 能直接处理比较吗？不能。比较应使用 constant.Compare，移位使用 constant.Shift。

为什么打印出来的小数看起来不像分数？Value.String() 是面向阅读的短形式，数值可能是近似显示；需要无损文本时使用 ExactString()。

什么时候可以放心转成 float64？只有调用方接受机器浮点数，并且 Float64Val 返回的 exact 为 true 时，才适合把它当作无损转换。