最后同步日期：2026-04-15 | Godot 官方原文 — pow

pow

定义

pow() 是一个幂运算（也叫"乘方"）函数。它的作用是把一个数（底数）乘以自己若干次（指数）。pow 这个名字来自英文 "power"（幂）。

打个比方：pow(2, 3) 就是 2 x 2 x 2 = 8，意思是"2 这个数，自己乘自己 3 次"。就像细胞分裂——一个细胞分裂 3 次，就会从 1 个变成 2^3 = 8 个。

再比如：游戏里的经验值增长，如果每级所需经验是上一级的 1.5 倍，那第 10 级需要的经验就是 pow(1.5, 10)。

函数签名

C#

// Mathf.Pow 返回 float 类型
public static float Pow(float @base, float exp)

GDScript

func pow(base: float, exp: float) -> float

参数说明

参数	类型	必需	说明
base / @base	float	是	底数——被乘的那个数（如 2 的 3 次方中的 2）
exp	float	是	指数——要乘多少次（如 2 的 3 次方中的 3）

返回值

类型： float

返回 base 的 exp 次方。即 base 乘以自身 exp 次的结果。

表达式	计算过程	返回值	说明
pow(2, 3)	2 x 2 x 2	8.0	2 的 3 次方
pow(10, 2)	10 x 10	100.0	10 的平方
pow(5, 0)	（任何数的 0 次方）	1.0	任何数的 0 次方都是 1
pow(4, 0.5)	（4 的平方根）	2.0	指数可以是小数
pow(2, -1)	1 / 2	0.5	负指数表示取倒数

代码示例

基础用法

C#

using Godot;

public partial class PowExample : Node
{
    public override void _Ready()
    {
        // 基本幂运算
        GD.Print(Mathf.Pow(2f, 3f));    // 运行结果: 8（2 的 3 次方：2 x 2 x 2）
        GD.Print(Mathf.Pow(10f, 2f));   // 运行结果: 100（10 的平方）
        GD.Print(Mathf.Pow(3f, 4f));    // 运行结果: 81（3 的 4 次方）

        // 指数为 0 —— 任何数的 0 次方都是 1
        GD.Print(Mathf.Pow(999f, 0f));  // 运行结果: 1

        // 负指数 —— 2 的 -1 次方就是 1/2
        GD.Print(Mathf.Pow(2f, -1f));   // 运行结果: 0.5
    }
}

GDScript

func _ready():
    # 基本幂运算
    print(pow(2, 3))     # 运行结果: 8.0（2 的 3 次方：2 x 2 x 2）
    print(pow(10, 2))    # 运行结果: 100.0（10 的平方）
    print(pow(3, 4))     # 运行结果: 81.0（3 的 4 次方）

    # 指数为 0 —— 任何数的 0 次方都是 1
    print(pow(999, 0))   # 运行结果: 1.0

    # 负指数 —— 2 的 -1 次方就是 1/2
    print(pow(2, -1))    # 运行结果: 0.5

实际场景：游戏中的指数增长（升级经验计算）

C#

using Godot;

public partial class ExpSystem : Node
{
    // 导出属性：基础经验值（第 1 级升第 2 级需要的经验）
    [Export] public float ExBaseExp = 100f;

    // 导出属性：经验增长倍率（每级所需经验是上一级的多少倍）
    [Export] public float ExGrowthRate = 1.5f;

    // 计算从 1 级升到指定等级所需的总经验
    // 公式：baseExp * (growthRate^level - 1) / (growthRate - 1)
    private float GetTotalExpForLevel(int level)
    {
        return ExBaseExp * (Mathf.Pow(ExGrowthRate, level) - 1f) / (ExGrowthRate - 1f);
    }

    public override void _Ready()
    {
        GD.Print($"升到 5 级需要总经验: {GetTotalExpForLevel(5):F0}");
        // 运行结果: 升到 5 级需要总经验: 1310

        GD.Print($"升到 10 级需要总经验: {GetTotalExpForLevel(10):F0}");
        // 运行结果: 升到 10 级需要总经验: 5665
    }
}

GDScript

extends Node

# 导出属性：基础经验值（第 1 级升第 2 级需要的经验）
@export var ex_base_exp: float = 100.0

# 导出属性：经验增长倍率（每级所需经验是上一级的多少倍）
@export var ex_growth_rate: float = 1.5

# 计算从 1 级升到指定等级所需的总经验
# 公式：baseExp * (growthRate^level - 1) / (growthRate - 1)
func get_total_exp_for_level(level: int) -> float:
    return ex_base_exp * (pow(ex_growth_rate, level) - 1) / (ex_growth_rate - 1)

func _ready():
    print("升到 5 级需要总经验: %d" % get_total_exp_for_level(5))
    # 运行结果: 升到 5 级需要总经验: 1310

    print("升到 10 级需要总经验: %d" % get_total_exp_for_level(10))
    # 运行结果: 升到 10 级需要总经验: 5665

进阶用法：物理衰减、缩放动画与平方根

C#

using Godot;

public partial class PowAdvanced : Node
{
    public override void _Ready()
    {
        // 场景一：距离衰减——光照随距离变暗
        // 光照强度 = 初始强度 / 距离的 2 次方（物理上的平方反比定律）
        float lightIntensity = 100f;
        float distance = 5f;
        float intensityAtDistance = lightIntensity / Mathf.Pow(distance, 2f);
        GD.Print($"距离 {distance} 处的光照强度: {intensityAtDistance}");
        // 运行结果: 距离 5 处的光照强度: 4

        // 场景二：缓动函数——先快后慢的减速效果
        // 使用 pow(x, 3) 让数值变化先快后慢
        float t = 0.5f; // 进度 50%
        float eased = Mathf.Pow(t, 3f); // 三次方缓动
        GD.Print($"进度 {t} 经三次方缓动后: {eased}");
        // 运行结果: 进度 0.5 经三次方缓动后: 0.125

        // 场景三：用 pow 计算平方根（指数 0.5）
        float value = 16f;
        float squareRoot = Mathf.Pow(value, 0.5f);
        GD.Print($"{value} 的平方根: {squareRoot}");
        // 运行结果: 16 的平方根: 4
    }
}

GDScript

extends Node

func _ready():
    # 场景一：距离衰减——光照随距离变暗
    # 光照强度 = 初始强度 / 距离的 2 次方（物理上的平方反比定律）
    var light_intensity = 100.0
    var distance = 5.0
    var intensity_at_distance = light_intensity / pow(distance, 2)
    print("距离 %s 处的光照强度: %s" % [distance, intensity_at_distance])
    # 运行结果: 距离 5.0 处的光照强度: 4.0

    # 场景二：缓动函数——先快后慢的减速效果
    # 使用 pow(x, 3) 让数值变化先快后慢
    var t = 0.5  # 进度 50%
    var eased = pow(t, 3)  # 三次方缓动
    print("进度 %s 经三次方缓动后: %s" % [t, eased])
    # 运行结果: 进度 0.5 经三次方缓动后: 0.125

    # 场景三：用 pow 计算平方根（指数 0.5）
    var value = 16.0
    var square_root = pow(value, 0.5)
    print("%s 的平方根: %s" % [value, square_root])
    # 运行结果: 16.0 的平方根: 4.0

注意事项

1. 底数为负、指数为小数时会出错：pow(-2, 0.5) 这样的运算在实数范围内没有意义（负数没有实数平方根），会返回 NaN（Not a Number）。确保底数为负时指数是整数。

2. 指数可以是小数：pow(4, 0.5) 等同于求 4 的平方根，结果是 2.0。pow(8, 1.0/3) 等同于求 8 的立方根，结果是 2.0。

3. 指数可以是负数：pow(2, -3) 等同于 1 / (2^3) = 0.125。负指数就是取倒数。

4. 性能提示：对于简单的整数次方（如 x * x），直接乘法比 pow(x, 2) 更快。pow() 是通用函数，内部计算更复杂，适合指数不确定或为小数的场景。

5. 与 sqrt 的关系：pow(x, 0.5) 等价于 sqrt(x)，但 sqrt() 语义更清晰，推荐使用 sqrt() 来计算平方根。