go/constant - 常量值处理

go/constant 包提供了对 Go 常量值的表示和操作功能，用于处理精确的常量算术运算。

概述

go/constant 包用于表示和操作 Go 语言的常量值，支持任意精度的整数、有理数和浮点数运算。

包导入：

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

基本使用：

// 1. 创建常量值
x := constant.MakeInt64(42)
y := constant.MakeFloat64(3.14)

// 2. 常量运算
sum := constant.BinaryOp(x, token.ADD, y)

// 3. 转换为 Go 值
val, _ := constant.Int64Val(x)
fmt.Printf("值：%d\n", val)

典型示例：

示例 1：精确的常量算术运算：

package main

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

func main() {
    // 创建大整数
    a := constant.MakeFromLiteral("12345678901234567890", token.INT, 0)
    b := constant.MakeFromLiteral("98765432109876543210", token.INT, 0)
    
    // 精确加法
    sum := constant.BinaryOp(a, token.ADD, b)
    fmt.Printf("和：%s\n", sum.ExactString())
    
    // 精确乘法
    product := constant.BinaryOp(a, token.MUL, b)
    fmt.Printf("积：%s\n", product.ExactString())
    
    // 精确除法（有理数）
    quotient := constant.BinaryOp(b, token.QUO, a)
    fmt.Printf("商：%s\n", quotient.ExactString())
}

运行：

$ go run main.go
和：111111111011111111100
积：1219326311370217952237483801029953480100
商：98765432109876543210/12345678901234567890

示例 2：常量类型转换和比较：

package main

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

func main() {
    // 创建不同类型的常量
    intVal := constant.MakeInt64(42)
    floatVal := constant.MakeFloat64(3.14159)
    stringVal := constant.MakeString("Hello")
    boolVal := constant.MakeBool(true)
    
    // 类型转换
    intAsFloat := constant.ToFloat(intVal)
    fmt.Printf("int 转 float: %s\n", intAsFloat.ExactString())
    
    // 比较
    x := constant.MakeFromLiteral("100", token.INT, 0)
    y := constant.MakeFromLiteral("50", token.INT, 0)
    
    if constant.Compare(x, token.GTR, y) {
        fmt.Printf("%s > %s\n", x.ExactString(), y.ExactString())
    }
    
    // 检查类型
    fmt.Printf("intVal 是整数：%v\n", constant.IsInt(intVal))
    fmt.Printf("floatVal 是浮点数：%v\n", constant.IsFloat(floatVal))
    fmt.Printf("stringVal 是字符串：%v\n", constant.IsVal(stringVal))
}

运行：

$ go run main.go
int 转 float：42
100 > 50
intVal 是整数：true
floatVal 是浮点数：true
stringVal 是字符串：true

一、Kind 类型

常量种类类型

Kind

定义：

type Kind int

说明：

• 表示常量值的种类
• 用于区分整数、浮点数、复数等类型

未知类型

Unknown

定义：

const Unknown Kind = iota

说明：

• 表示未知或无效的常量类型
• 通常在类型推断失败时使用

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    // 创建无效常量
    invalid := constant.MakeUnknown()
    
    fmt.Printf("类型：%v\n", invalid.Kind())
    fmt.Printf("是 Unknown: %v\n", invalid.Kind() == constant.Unknown)
}

运行：

$ go run main.go
类型：Unknown
是 Unknown: true

布尔类型

Bool

定义：

const Bool Kind = iota

说明：

• 表示布尔常量（true/false）

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    t := constant.MakeBool(true)
    f := constant.MakeBool(false)
    
    fmt.Printf("true 类型：%v\n", t.Kind())
    fmt.Printf("false 类型：%v\n", f.Kind())
    
    // 获取布尔值
    val, _ := constant.BoolVal(t)
    fmt.Printf("布尔值：%v\n", val)
}

运行：

$ go run main.go
true 类型：Bool
false 类型：Bool
布尔值：true

字符串类型

String

定义：

const String Kind = iota

说明：

• 表示字符串常量

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    s := constant.MakeString("Hello, World!")
    
    fmt.Printf("类型：%v\n", s.Kind())
    fmt.Printf("字符串值：%s\n", constant.StringVal(s))
}

运行：

$ go run main.go
类型：String
字符串值：Hello, World!

整数类型

Int

定义：

const Int Kind = iota

说明：

• 表示整数常量（任意精度）
• 使用 *big.Int 存储

示例：

package main

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

func main() {
    // 创建整数
    small := constant.MakeInt64(42)
    large := constant.MakeFromLiteral("123456789012345678901234567890", token.INT, 0)
    
    fmt.Printf("小整数类型：%v\n", small.Kind())
    fmt.Printf("大整数类型：%v\n", large.Kind())
    
    // 转换为 int64
    val, _ := constant.Int64Val(small)
    fmt.Printf("int64 值：%d\n", val)
}

运行：

$ go run main.go
小整数类型：Int
大整数类型：Int
int64 值：42

浮点数类型

Float

定义：

const Float Kind = iota

说明：

• 表示浮点数常量（任意精度）
• 使用 *big.Float 存储

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    pi := constant.MakeFloat64(3.141592653589793)
    
    fmt.Printf("类型：%v\n", pi.Kind())
    fmt.Printf("浮点值：%s\n", pi.ExactString())
    
    // 转换为 float64
    val, _ := constant.Float64Val(pi)
    fmt.Printf("float64 值：%.15f\n", val)
}

运行：

$ go run main.go
类型：Float
浮点值：3.141592653589793
float64 值：3.141592653589793

复数类型

Complex

定义：

const Complex Kind = iota

说明：

• 表示复数常量（实部和虚部都是任意精度）
• 由两个 Float 组成

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    // 创建复数 3+4i
    real := constant.MakeFloat64(3.0)
    imag := constant.MakeFloat64(4.0)
    c := constant.BinaryOp(real, token.ADD, constant.MakeImag(imag))
    
    fmt.Printf("类型：%v\n", c.Kind())
    
    // 获取实部和虚部
    realPart := constant.Real(c)
    imagPart := constant.Imag(c)
    
    fmt.Printf("实部：%s\n", realPart.ExactString())
    fmt.Printf("虚部：%s\n", imagPart.ExactString())
}

运行：

$ go run main.go
类型：Complex
实部：3
虚部：4

二、Value 接口

常量值接口

Value

定义：

type Value interface {
    Kind() Kind
    String() string
    ExactString() string
}

说明：

• 所有常量值都实现此接口
• 提供类型检查和字符串表示
• 支持精确和近似两种字符串格式

方法：

• Kind()：返回常量的种类
• String()：返回字符串表示（可能近似）
• ExactString()：返回精确的字符串表示

示例：

package main

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

func main() {
    // 创建不同类型的常量
    values := []constant.Value{
        constant.MakeBool(true),
        constant.MakeString("hello"),
        constant.MakeInt64(42),
        constant.MakeFloat64(3.14),
    }
    
    for _, v := range values {
        fmt.Printf("类型：%v\n", v.Kind())
        fmt.Printf("  String: %s\n", v.String())
        fmt.Printf("  ExactString: %s\n", v.ExactString())
        fmt.Println()
    }
}

运行：

$ go run main.go
类型：Bool
  String: true
  ExactString: true

类型：String
  String: "hello"
  ExactString: "hello"

类型：Int
  String: 42
  ExactString: 42

类型：Float
  String: 3.14
  ExactString: 3.14

三、包级别函数（按字母顺序）

二元运算

BinaryOp

定义：

func BinaryOp(x constant.Value, op token.Token, y constant.Value) constant.Value

说明：

• 对两个常量执行二元运算
• 支持的运算符：+、-、*、/、%、&、|、^、&^、<<、>>
• 返回运算结果

参数：

• x：左操作数
• op：运算符（token 包中的常量）
• y：右操作数

示例：

package main

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

func main() {
    a := constant.MakeInt64(10)
    b := constant.MakeInt64(3)
    
    // 算术运算
    add := constant.BinaryOp(a, token.ADD, b)
    sub := constant.BinaryOp(a, token.SUB, b)
    mul := constant.BinaryOp(a, token.MUL, b)
    quo := constant.BinaryOp(a, token.QUO, b)
    rem := constant.BinaryOp(a, token.REM, b)
    
    fmt.Printf("加法：%s\n", add.ExactString())
    fmt.Printf("减法：%s\n", sub.ExactString())
    fmt.Printf("乘法：%s\n", mul.ExactString())
    fmt.Printf("除法：%s\n", quo.ExactString())
    fmt.Printf("取余：%s\n", rem.ExactString())
    
    // 位运算
    and := constant.BinaryOp(a, token.AND, b)
    or := constant.BinaryOp(a, token.OR, b)
    xor := constant.BinaryOp(a, token.XOR, b)
    
    fmt.Printf("按位与：%s\n", and.ExactString())
    fmt.Printf("按位或：%s\n", or.ExactString())
    fmt.Printf("按位异或：%s\n", xor.ExactString())
}

运行：

$ go run main.go
加法：13
减法：7
乘法：30
除法：10/3
取余：1
按位与：2
按位或：11
按位异或：9

转换为布尔值

BoolVal

定义：

func BoolVal(x constant.Value) (bool, bool)

说明：

• 将常量转换为 bool 值
• 返回 (值，成功标志)

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    t := constant.MakeBool(true)
    f := constant.MakeBool(false)
    notBool := constant.MakeInt64(42)
    
    val1, ok1 := constant.BoolVal(t)
    val2, ok2 := constant.BoolVal(f)
    val3, ok3 := constant.BoolVal(notBool)
    
    fmt.Printf("true -> %v, %v\n", val1, ok1)
    fmt.Printf("false -> %v, %v\n", val2, ok2)
    fmt.Printf("42 -> %v, %v\n", val3, ok3)
}

运行：

$ go run main.go
true -> true, true
false -> false, true
42 -> false, false

比较运算

Compare

定义：

func Compare(x constant.Value, op token.Token, y constant.Value) bool

说明：

• 比较两个常量
• 支持的比较运算符：==、!=、<、<=、>、>=
• 返回比较结果

示例：

package main

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

func main() {
    a := constant.MakeInt64(10)
    b := constant.MakeInt64(5)
    c := constant.MakeInt64(10)
    
    fmt.Printf("10 == 5: %v\n", constant.Compare(a, token.EQL, b))
    fmt.Printf("10 != 5: %v\n", constant.Compare(a, token.NEQ, b))
    fmt.Printf("10 > 5: %v\n", constant.Compare(a, token.GTR, b))
    fmt.Printf("10 >= 10: %v\n", constant.Compare(a, token.GEQ, c))
    fmt.Printf("10 < 5: %v\n", constant.Compare(a, token.LSS, b))
    fmt.Printf("10 <= 10: %v\n", constant.Compare(a, token.LEQ, c))
}

运行：

$ go run main.go
10 == 5: false
10 != 5: true
10 > 5: true
10 >= 10: true
10 < 5: false
10 <= 10: true

转换为浮点数

Float32Val

定义：

func Float32Val(x constant.Value) (float32, bool)

说明：

• 将常量转换为 float32 值
• 返回 (值，是否精确)

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    pi := constant.MakeFloat64(3.141592653589793)
    large := constant.MakeFromLiteral("1e300", token.FLOAT, 0)
    
    val1, exact1 := constant.Float32Val(pi)
    val2, exact2 := constant.Float32Val(large)
    
    fmt.Printf("pi -> %.10f, 精确：%v\n", val1, exact1)
    fmt.Printf("1e300 -> %e, 精确：%v\n", val2, exact2)
}

运行：

$ go run main.go
pi -> 3.1415927410, 精确：false
1e300 -> +Inf, 精确：false

转换为 float64

Float64Val

定义：

func Float64Val(x constant.Value) (float64, bool)

说明：

• 将常量转换为 float64 值
• 返回 (值，是否精确)

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    pi := constant.MakeFloat64(3.141592653589793)
    exact := constant.MakeFromLiteral("0.5", token.FLOAT, 0)
    
    val1, exact1 := constant.Float64Val(pi)
    val2, exact2 := constant.Float64Val(exact)
    
    fmt.Printf("pi -> %.15f, 精确：%v\n", val1, exact1)
    fmt.Printf("0.5 -> %.1f, 精确：%v\n", val2, exact2)
}

运行：

$ go run main.go
pi -> 3.141592653589793, 精确：true
0.5 -> 0.5, 精确：true

获取精确字符串

ExactString

定义：

func ExactString(x constant.Value) string

说明：

• 返回常量的精确字符串表示
• 对于有理数，返回分数形式

示例：

package main

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

func main() {
    // 整数
    intVal := constant.MakeInt64(42)
    
    // 浮点数
    floatVal := constant.MakeFloat64(3.14)
    
    // 有理数（除法结果）
    rational := constant.BinaryOp(
        constant.MakeInt64(10),
        token.QUO,
        constant.MakeInt64(3),
    )
    
    fmt.Printf("整数：%s\n", constant.ExactString(intVal))
    fmt.Printf("浮点数：%s\n", constant.ExactString(floatVal))
    fmt.Printf("有理数：%s\n", constant.ExactString(rational))
}

运行：

$ go run main.go
整数：42
浮点数：3.14
有理数：10/3

转换为 int64

Int64Val

定义：

func Int64Val(x constant.Value) (int64, bool)

说明：

• 将常量转换为 int64 值
• 返回 (值，是否精确)

示例：

package main

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

func main() {
    small := constant.MakeInt64(42)
    large := constant.MakeFromLiteral("1e20", token.INT, 0)
    fraction := constant.BinaryOp(
        constant.MakeInt64(10),
        token.QUO,
        constant.MakeInt64(3),
    )
    
    val1, ok1 := constant.Int64Val(small)
    val2, ok2 := constant.Int64Val(large)
    val3, ok3 := constant.Int64Val(fraction)
    
    fmt.Printf("42 -> %d, 精确：%v\n", val1, ok1)
    fmt.Printf("1e20 -> %d, 精确：%v\n", val2, ok3)
    fmt.Printf("10/3 -> %d, 精确：%v\n", val3, ok3)
}

运行：

$ go run main.go
42 -> 42, 精确：true
1e20 -> 100000000000000000000, 精确：true
10/3 -> 0, 精确：false

获取虚部

Imag

定义：

func Imag(x constant.Value) constant.Value

说明：

• 获取复数的虚部
• 如果 x 不是复数，返回 x

示例：

package main

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

func main() {
    // 创建复数 3+4i
    real := constant.MakeFloat64(3.0)
    imag := constant.MakeFloat64(4.0)
    
    // 使用 MakeImag 创建虚数部分
    imaginary := constant.MakeImag(imag)
    
    // 创建复数
    complex := constant.BinaryOp(real, token.ADD, imaginary)
    
    // 获取虚部
    imagPart := constant.Imag(complex)
    
    fmt.Printf("复数：%s\n", complex.ExactString())
    fmt.Printf("虚部：%s\n", imagPart.ExactString())
}

运行：

$ go run main.go
复数：3 + 4i
虚部：4

检查是否为整数

IsInt

定义：

func IsInt(x constant.Value) bool

说明：

• 检查常量是否为整数值
• 对于有理数，检查分母是否为 1

示例：

package main

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

func main() {
    intVal := constant.MakeInt64(42)
    floatVal := constant.MakeFloat64(3.14)
    rational := constant.BinaryOp(
        constant.MakeInt64(10),
        token.QUO,
        constant.MakeInt64(2),
    )
    rational2 := constant.BinaryOp(
        constant.MakeInt64(10),
        token.QUO,
        constant.MakeInt64(3),
    )
    
    fmt.Printf("42 是整数：%v\n", constant.IsInt(intVal))
    fmt.Printf("3.14 是整数：%v\n", constant.IsInt(floatVal))
    fmt.Printf("10/2 是整数：%v\n", constant.IsInt(rational))
    fmt.Printf("10/3 是整数：%v\n", constant.IsInt(rational2))
}

运行：

$ go run main.go
42 是整数：true
3.14 是整数：false
10/2 是整数：true
10/3 是整数：false

检查是否为浮点数

IsFloat

定义：

func IsFloat(x constant.Value) bool

说明：

• 检查常量是否为浮点数值

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    intVal := constant.MakeInt64(42)
    floatVal := constant.MakeFloat64(3.14)
    stringVal := constant.MakeString("hello")
    
    fmt.Printf("42 是浮点数：%v\n", constant.IsFloat(intVal))
    fmt.Printf("3.14 是浮点数：%v\n", constant.IsFloat(floatVal))
    fmt.Printf("hello 是浮点数：%v\n", constant.IsFloat(stringVal))
}

运行：

$ go run main.go
42 是浮点数：false
3.14 是浮点数：true
hello 是浮点数：false

检查是否为复数

IsComplex

定义：

func IsComplex(x constant.Value) bool

说明：

• 检查常量是否为复数值

示例：

package main

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

func main() {
    real := constant.MakeFloat64(3.0)
    imag := constant.MakeFloat64(4.0)
    imaginary := constant.MakeImag(imag)
    complex := constant.BinaryOp(real, token.ADD, imaginary)
    
    fmt.Printf("3+4i 是复数：%v\n", constant.IsComplex(complex))
    fmt.Printf("3.0 是复数：%v\n", constant.IsComplex(real))
}

运行：

$ go run main.go
3+4i 是复数：true
3.0 是复数：false

检查是否为有效值

IsVal

定义：

func IsVal(x constant.Value) bool

说明：

• 检查是否为有效的常量值
• 排除 Unknown 类型

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    valid := constant.MakeInt64(42)
    invalid := constant.MakeUnknown()
    
    fmt.Printf("42 是有效值：%v\n", constant.IsVal(valid))
    fmt.Printf("Unknown 是有效值：%v\n", constant.IsVal(invalid))
}

运行：

$ go run main.go
42 是有效值：true
Unknown 是有效值：false

从字面量创建常量

MakeFromLiteral

定义：

func MakeFromLiteral(literal string, tok token.Token, zero uint) constant.Value

说明：

• 从字面量字符串创建常量
• 根据 token 类型解析

参数：

• literal：字面量字符串（如 “42”、“3.14”、“true”）
• tok：token 类型（INT、FLOAT、STRING、CHAR）
• zero：偏移量（通常为 0）

示例：

package main

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

func main() {
    // 从字面量创建常量
    intVal := constant.MakeFromLiteral("42", token.INT, 0)
    floatVal := constant.MakeFromLiteral("3.14159", token.FLOAT, 0)
    stringVal := constant.MakeFromLiteral(`"hello"`, token.STRING, 0)
    charVal := constant.MakeFromLiteral(`'x'`, token.CHAR, 0)
    
    fmt.Printf("整数：%s (类型：%v)\n", intVal.ExactString(), intVal.Kind())
    fmt.Printf("浮点数：%s (类型：%v)\n", floatVal.ExactString(), floatVal.Kind())
    fmt.Printf("字符串：%s (类型：%v)\n", stringVal.ExactString(), stringVal.Kind())
    fmt.Printf("字符：%s (类型：%v)\n", charVal.ExactString(), charVal.Kind())
}

运行：

$ go run main.go
整数：42 (类型：Int)
浮点数：3.14159 (类型：Float)
字符串："hello" (类型：String)
字符：'x' (类型：Int)

创建布尔常量

MakeBool

定义：

func MakeBool(val bool) constant.Value

说明：

• 创建布尔常量

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    t := constant.MakeBool(true)
    f := constant.MakeBool(false)
    
    fmt.Printf("true: %s (类型：%v)\n", t.ExactString(), t.Kind())
    fmt.Printf("false: %s (类型：%v)\n", f.ExactString(), f.Kind())
}

运行：

$ go run main.go
true: true (类型：Bool)
false: false (类型：Bool)

创建复数常量

MakeComplex

定义：

func MakeComplex(real, imag constant.Value) constant.Value

说明：

• 从实部和虚部创建复数

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    real := constant.MakeFloat64(3.0)
    imag := constant.MakeFloat64(4.0)
    
    complex := constant.MakeComplex(real, imag)
    
    fmt.Printf("复数：%s (类型：%v)\n", complex.ExactString(), complex.Kind())
    fmt.Printf("实部：%s\n", constant.Real(complex).ExactString())
    fmt.Printf("虚部：%s\n", constant.Imag(complex).ExactString())
}

运行：

$ go run main.go
复数：3 + 4i (类型：Complex)
实部：3
虚部：4

创建浮点常量

MakeFloat64

定义：

func MakeFloat64(val float64) constant.Value

说明：

• 从 float64 创建浮点常量

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    pi := constant.MakeFloat64(3.141592653589793)
    
    fmt.Printf("pi: %s (类型：%v)\n", pi.ExactString(), pi.Kind())
}

运行：

$ go run main.go
pi: 3.141592653589793 (类型：Float)

创建虚数常量

MakeImag

定义：

func MakeImag(val constant.Value) constant.Value

说明：

• 从实数创建虚数（纯虚数）

示例：

package main

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

func main() {
    imag := constant.MakeFloat64(4.0)
    imaginary := constant.MakeImag(imag)
    
    fmt.Printf("虚数：%s (类型：%v)\n", imaginary.ExactString(), imaginary.Kind())
    
    // 创建复数 3+4i
    real := constant.MakeFloat64(3.0)
    complex := constant.BinaryOp(real, token.ADD, imaginary)
    
    fmt.Printf("复数：%s\n", complex.ExactString())
}

运行：

$ go run main.go
虚数：4i (类型：Complex)
复数：3 + 4i

创建整数常量

MakeInt64

定义：

func MakeInt64(val int64) constant.Value

说明：

• 从 int64 创建整数常量

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    val := constant.MakeInt64(123456789)
    
    fmt.Printf("整数：%s (类型：%v)\n", val.ExactString(), val.Kind())
}

运行：

$ go run main.go
整数：123456789 (类型：Int)

创建字符串常量

MakeString

定义：

func MakeString(val string) constant.Value

说明：

• 从 Go 字符串创建字符串常量

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    s := constant.MakeString("Hello, World!")
    
    fmt.Printf("字符串：%s (类型：%v)\n", s.ExactString(), s.Kind())
    fmt.Printf("Go 值：%s\n", constant.StringVal(s))
}

运行：

$ go run main.go
字符串："Hello, World!" (类型：String)
Go 值：Hello, World!

创建未知常量

MakeUnknown

定义：

func MakeUnknown() constant.Value

说明：

• 创建 Unknown 类型的常量
• 表示无效或未知的值

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    unknown := constant.MakeUnknown()
    
    fmt.Printf("Unknown: %s (类型：%v)\n", unknown.ExactString(), unknown.Kind())
    fmt.Printf("是有效值：%v\n", constant.IsVal(unknown))
}

运行：

$ go run main.go
Unknown: ??? (类型：Unknown)
是有效值：false

获取实部

Real

定义：

func Real(x constant.Value) constant.Value

说明：

• 获取复数的实部
• 如果 x 不是复数，返回 x 本身

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    complex := constant.MakeComplex(
        constant.MakeFloat64(3.0),
        constant.MakeFloat64(4.0),
    )
    
    realPart := constant.Real(complex)
    
    fmt.Printf("复数：%s\n", complex.ExactString())
    fmt.Printf("实部：%s\n", realPart.ExactString())
}

运行：

$ go run main.go
复数：3 + 4i
实部：3

获取字符串值

StringVal

定义：

func StringVal(x constant.Value) string

说明：

• 获取字符串常量的 Go 值
• 去除引号

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    s := constant.MakeString("Hello\nWorld")
    
    fmt.Printf("常量表示：%s\n", s.ExactString())
    fmt.Printf("Go 值：%s\n", constant.StringVal(s))
}

运行：

$ go run main.go
常量表示："Hello\nWorld"
Go 值：Hello
World

转换为浮点数

ToFloat

定义：

func ToFloat(x constant.Value) constant.Value

说明：

• 将常量转换为浮点数
• 整数和有理数可以转换为浮点数

示例：

package main

import (
    "fmt"
    "go/constant"
)

func main() {
    intVal := constant.MakeInt64(42)
    rational := constant.BinaryOp(
        constant.MakeInt64(22),
        token.QUO,
        constant.MakeInt64(7),
    )
    
    float1 := constant.ToFloat(intVal)
    float2 := constant.ToFloat(rational)
    
    fmt.Printf("42 -> %s\n", float1.ExactString())
    fmt.Printf("22/7 -> %s\n", float2.ExactString())
}

运行：

$ go run main.go
42 -> 42
22/7 -> 3.142857142857143

转换为整数

ToInt

定义：

func ToInt(x constant.Value) constant.Value

说明：

• 将常量转换为整数
• 浮点数和复数会取整

示例：

package main

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

func main() {
    floatVal := constant.MakeFloat64(3.14)
    rational := constant.BinaryOp(
        constant.MakeInt64(10),
        token.QUO,
        constant.MakeInt64(3),
    )
    
    int1 := constant.ToInt(floatVal)
    int2 := constant.ToInt(rational)
    
    fmt.Printf("3.14 -> %s\n", int1.ExactString())
    fmt.Printf("10/3 -> %s\n", int2.ExactString())
}

运行：

$ go run main.go
3.14 -> 3
10/3 -> 3

一元运算

UnaryOp

定义：

func UnaryOp(op token.Token, y constant.Value, prec uint) constant.Value

说明：

• 对常量执行一元运算
• 支持的运算符：+、-、^、!

参数：

• op：运算符
• y：操作数
• prec：精度（通常为 0）

示例：

package main

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

func main() {
    x := constant.MakeInt64(42)
    
    // 一元加
    pos := constant.UnaryOp(token.ADD, x, 0)
    
    // 一元减
    neg := constant.UnaryOp(token.SUB, x, 0)
    
    // 按位取反
    not := constant.UnaryOp(token.XOR, x, 0)
    
    // 逻辑非
    boolVal := constant.MakeBool(true)
    logicalNot := constant.UnaryOp(token.NOT, boolVal, 0)
    
    fmt.Printf("+42 = %s\n", pos.ExactString())
    fmt.Printf("-42 = %s\n", neg.ExactString())
    fmt.Printf("^42 = %s\n", not.ExactString())
    fmt.Printf("!true = %s\n", logicalNot.ExactString())
}

运行：

$ go run main.go
+42 = 42
-42 = -42
^42 = -43
!true = false

四、快速参考

Kind 类型

Value 接口方法

算术运算函数

类型转换函数

复数函数

类型检查函数

创建常量函数

最后更新：2026-04-04
Go 版本：Go 1.23+