func powInt(x, y int) int {
    return int(math.Pow(float64(x), float64(y)))
}

以防你不得不重复使用它并保持它更干净一点。

如果你的输入是int，而输出总是int，那么你处理的是32位数，编写自己的函数来处理这个乘法比使用math.Pow更有效。math.Pow，正如其他答案中提到的，需要64位值。
以下是15^15的基准比较（接近32位表示的上限）：

// IntPow calculates n to the mth power. Since the result is an int, it is assumed that m is a positive power
func IntPow(n, m int) int {
    if m == 0 {
        return 1
    }
    result := n
    for i := 2; i <= m; i++ {
        result *= n
    }
    return result
}

// MathPow calculates n to the mth power with the math.Pow() function
func MathPow(n, m int) int {
    return int(math.Pow(float64(n), float64(m)))
}

结果是：

go test -cpu=1 -bench=.
goos: darwin
goarch: amd64
pkg: pow
BenchmarkIntPow15   195415786            6.06 ns/op
BenchmarkMathPow15  40776524            27.8 ns/op

我认为最好的解决方案是你应该编写类似于上面所示的IntPow(m, n int)的函数。我的基准测试显示，与使用math.Pow相比，它在单个CPU核上的运行速度快4倍以上。

由于没有人提到一个有效的方法（对数）来处理整数x和n，如果你想自己实现它，如下所示：

// Assumption: n >= 0
func PowInts(x, n int) int {
   if n == 0 { return 1 }
   if n == 1 { return x }
   y := PowInts(x, n/2)
   if n % 2 == 0 { return y*y }
   return x*y*y
}

如果你想得到整数的精确幂，使用（* big.Int）. Exp.你可能很快就会溢出int64，得到大于2的幂。

虽然Eissa对高效解决方案的上述回答在技术上是正确的，但递归可能会降低性能。请参阅The most efficient way to implement an integer based power function pow(int, int)以获得更优的解决方案。以下是翻译成Go语言的C解决方案：

func IntPow(base, exp int) int {
    result := 1
    for {
        if exp & 1 == 1 {
            result *= base
        }
        exp >>= 1
        if exp == 0 {
            break
        }
        base *= base
    }

    return result
}

在我的基准测试中，这几乎是递归版本的两倍。