sqrt

EVOCOSMOS2026/4/14大约 5 分钟

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

sqrt

定义

sqrt() 是一个平方根函数（"sqrt" 是 "square root" 的缩写）。它的作用是回答这样一个问题："什么数乘以自己，等于给定的数？"

打个比方：如果你有一块正方形的农田，面积是 64 平方米，那每条边有多长？答案就是 sqrt(64) = 8 米。因为 8 x 8 = 64。

再比如：你往银行存了一笔钱，年利率 4%（即 1.04 倍），多少年后能翻倍？就是 sqrt(1.04) 没法直接算，但 sqrt(4) = 2，因为 2 x 2 = 4。平方根就是问"谁乘以自己等于这个数"。

函数签名

// Mathf.Sqrt 返回 float 类型
public static float Sqrt(float s)

GDScript

func sqrt(x: float) -> float

参数说明

参数	类型	必需	说明
x / s	float	是	需要计算平方根的非负浮点数

返回值

类型： float

返回 x 的平方根，即满足 结果 * 结果 == x 的那个非负数。

输入值	返回值	说明
`4`	`2.0`	2 x 2 = 4
`9`	`3.0`	3 x 3 = 9
`2`	`1.4142135...`	根号 2，无理数
`1`	`1.0`	1 的平方根是 1
`0`	`0.0`	0 的平方根是 0
`-1`	`NaN`	负数没有实数平方根，返回 NaN

代码示例

基础用法

using Godot;

public partial class SqrtExample : Node
{
    public override void _Ready()
    {
        // 基本平方根
        GD.Print(Mathf.Sqrt(4f));    // 运行结果: 2（因为 2 x 2 = 4）
        GD.Print(Mathf.Sqrt(9f));    // 运行结果: 3（因为 3 x 3 = 9）
        GD.Print(Mathf.Sqrt(16f));   // 运行结果: 4（因为 4 x 4 = 16）

        // 特殊值
        GD.Print(Mathf.Sqrt(1f));    // 运行结果: 1
        GD.Print(Mathf.Sqrt(0f));    // 运行结果: 0

        // 非完全平方数——返回无理数（近似值）
        GD.Print(Mathf.Sqrt(2f));    // 运行结果: 1.4142135...
    }
}

GDScript

func _ready():
    # 基本平方根
    print(sqrt(4))      # 运行结果: 2.0（因为 2 x 2 = 4）
    print(sqrt(9))      # 运行结果: 3.0（因为 3 x 3 = 9）
    print(sqrt(16))     # 运行结果: 4.0（因为 4 x 4 = 16）

    # 特殊值
    print(sqrt(1))      # 运行结果: 1.0
    print(sqrt(0))      # 运行结果: 0.0

    # 非完全平方数——返回无理数（近似值）
    print(sqrt(2))      # 运行结果: 1.4142135623730951

实际场景：计算两点之间的距离

using Godot;

public partial class DistanceCalc : Node2D
{
    // 手动计算两点之间的距离（勾股定理）
    // 公式：distance = sqrt((x2-x1)^2 + (y2-y1)^2)
    private float CalcDistance(Vector2 a, Vector2 b)
    {
        float dx = b.X - a.X;
        float dy = b.Y - a.Y;
        return Mathf.Sqrt(dx * dx + dy * dy);
    }

    public override void _Ready()
    {
        Vector2 player = new Vector2(0, 0);
        Vector2 enemy = new Vector2(3, 4);

        float dist = CalcDistance(player, enemy);
        GD.Print($"玩家位置: {player}, 敌人位置: {enemy}, 距离: {dist}");
        // 运行结果: 玩家位置: (0, 0), 敌人位置: (3, 4), 距离: 5

        // Godot 内置方法也可以直接算距离（推荐使用）
        float builtInDist = player.DistanceTo(enemy);
        GD.Print($"内置方法计算距离: {builtInDist}");
        // 运行结果: 内置方法计算距离: 5
    }
}

GDScript

extends Node2D

# 手动计算两点之间的距离（勾股定理）
# 公式：distance = sqrt((x2-x1)^2 + (y2-y1)^2)
func calc_distance(a: Vector2, b: Vector2) -> float:
    var dx = b.x - a.x
    var dy = b.y - a.y
    return sqrt(dx * dx + dy * dy)

func _ready():
    var player = Vector2(0, 0)
    var enemy = Vector2(3, 4)

    var dist = calc_distance(player, enemy)
    print("玩家位置: %s, 敌人位置: %s, 距离: %s" % [player, enemy, dist])
    # 运行结果: 玩家位置: (0, 0), 敌人位置: (3, 4), 距离: 5.0

    # Godot 内置方法也可以直接算距离（推荐使用）
    var built_in_dist = player.distance_to(enemy)
    print("内置方法计算距离: %s" % built_in_dist)
    # 运行结果: 内置方法计算距离: 5.0

进阶用法：归一化向量与速度控制

using Godot;

public partial class SqrtAdvanced : Node
{
    public override void _Ready()
    {
        // 场景一：手动归一化向量（让向量长度变为 1，只保留方向）
        Vector2 velocity = new Vector2(3f, 4f);
        float length = Mathf.Sqrt(velocity.X * velocity.X + velocity.Y * velocity.Y);
        Vector2 normalized = velocity / length;
        GD.Print($"原始向量: {velocity}, 长度: {length}, 归一化后: {normalized}");
        // 运行结果: 原始向量: (3, 4), 长度: 5, 归一化后: (0.6, 0.8)

        // 场景二：判断是否在攻击范围内
        float attackRange = 6f;
        Vector2 playerPos = new Vector2(0, 0);
        Vector2 targetPos = new Vector2(4, 3);
        float distToTarget = Mathf.Sqrt(
            (targetPos.X - playerPos.X) * (targetPos.X - playerPos.X) +
            (targetPos.Y - playerPos.Y) * (targetPos.Y - playerPos.Y)
        );
        bool inRange = distToTarget <= attackRange;
        GD.Print($"目标距离: {distToTarget}, 攻击范围: {attackRange}, 是否可攻击: {inRange}");
        // 运行结果: 目标距离: 5, 攻击范围: 6, 是否可攻击: True
    }
}

GDScript

extends Node

func _ready():
    # 场景一：手动归一化向量（让向量长度变为 1，只保留方向）
    var velocity = Vector2(3.0, 4.0)
    var length = sqrt(velocity.x * velocity.x + velocity.y * velocity.y)
    var normalized = velocity / length
    print("原始向量: %s, 长度: %s, 归一化后: %s" % [velocity, length, normalized])
    # 运行结果: 原始向量: (3, 4), 长度: 5.0, 归一化后: (0.6, 0.8)

    # 场景二：判断是否在攻击范围内
    var attack_range = 6.0
    var player_pos = Vector2(0, 0)
    var target_pos = Vector2(4, 3)
    var dist_to_target = sqrt(
        (target_pos.x - player_pos.x) * (target_pos.x - player_pos.x) +
        (target_pos.y - player_pos.y) * (target_pos.y - player_pos.y)
    )
    var in_range = dist_to_target <= attack_range
    print("目标距离: %s, 攻击范围: %s, 是否可攻击: %s" % [dist_to_target, attack_range, in_range])
    # 运行结果: 目标距离: 5.0, 攻击范围: 6.0, 是否可攻击: True

注意事项

负数输入会返回 NaN：sqrt(-1) 在实数范围内没有意义，会返回 NaN（Not a Number）。如果你的输入可能为负数，需要先取绝对值或做判断：sqrt(Mathf.Max(0, x))。
与 pow() 的关系：sqrt(x) 等价于 pow(x, 0.5)。但 sqrt() 的语义更清晰，而且性能更好，计算平方根时推荐使用 sqrt() 而不是 pow()。
Godot 内置方法更方便：在 Godot 中，很多常用场景不需要手动调用 sqrt()。比如计算两点距离可以用 Vector2.DistanceTo()，向量归一化可以用 Vector2.Normalized()。了解 sqrt() 的原理有助于理解这些内置方法的底层逻辑。
性能提示：如果只需要比较距离大小（不需要知道具体距离值），可以省略 sqrt()，直接比较距离的平方。比如判断 distSq <= rangeSq 比 sqrt(distSq) <= range 更快，因为省去了开方运算。
精度问题：浮点数计算存在精度误差。sqrt(4) 理论上是 2，但实际结果可能是 1.9999999 或 2.0000001。如果需要精确比较，使用 is_equal_approx() 或 is_zero_approx()。