GameObject / Component / Transform

GameObject、Component、Transform 的关系是什么？

GameObject 是场景里的对象容器，Component 是挂在它身上的功能模块，Transform 是每个 GameObject 必带的特殊 Component，负责位置、旋转、缩放和父子层级。

GameObject
  ├── Transform
  ├── Renderer
  ├── Collider
  └── 自定义 MonoBehaviour 脚本

关系可以这样理解：

GameObject go = new GameObject("Player");

Transform t = go.transform;              // GameObject 必带 Transform
Rigidbody rb = go.AddComponent<Rigidbody>(); // 添加功能组件

GameObject owner = rb.gameObject;        // Component 能找到宿主 GameObject
Transform tr = rb.transform;             // Component 也能快捷访问 Transform

重点：

• GameObject 自己更像一个“空壳节点”，有名字、Tag、Layer、active 状态。
• Component 给 GameObject 提供能力，比如渲染、碰撞、物理、脚本逻辑。
• MonoBehaviour 脚本本质上也是一种 Component。
• Transform 是特殊组件，每个普通 GameObject 都有，不能像普通组件一样随便移除。
• UI 对象上的通常是 RectTransform，它继承自 Transform。

底层/面试加分点：Unity 的父子层级关系不是直接挂在 GameObject 上，而是挂在 Transform 上。

child.transform.parent = parent.transform;

所以你在 Hierarchy 里看到的父子结构，本质是 Transform 的 parent/children 关系。

面试高分说法：GameObject 是实体和组件容器，Component 是功能组合单元，Transform 是必带组件，负责空间信息和层级结构。Unity 的设计是组合优先，一个对象有什么能力，不靠继承 GameObject，而是靠挂不同 Component。

为什么每个 GameObject 都有 Transform？

因为 Unity 里的 GameObject 不只是一个逻辑对象，它还是场景层级树里的一个节点；而 Transform 负责这个节点的位置、旋转、缩放和父子层级关系。

更底层一点说，Transform 不只是“坐标组件”，它还承担了 Scene Graph 节点 的职责：

Transform
  ├── position / rotation / scale
  ├── parent / children
  ├── local 坐标
  ├── world 坐标
  └── localToWorld 矩阵关系

所以就算是空物体，也需要 Transform。比如：

出生点 SpawnPoint
相机挂点 CameraPivot
特效挂点 EffectRoot
UI 分组节点
场景逻辑节点

它们可能没有 Renderer、Collider、脚本，但仍然需要在 Hierarchy 里有父子关系和空间位置。

关键点：Unity 的父子关系其实挂在 Transform 上。

child.transform.parent = parent.transform;

不是：

child.gameObject.parent = parent.gameObject; // 没有这种关系

另外，所有 Component 都可以安全地访问：

transform
gameObject.transform
component.transform

因为 Unity 保证每个 GameObject 都有一个 Transform。这样引擎和脚本系统就不需要每次判断“这个对象有没有空间节点”。

UI 里也一样，只是普通 Transform 换成了：

RectTransform

它继承自 Transform，额外增加锚点、尺寸、Pivot 等 UI 布局信息。

面试高分说法：每个 GameObject 都有 Transform，是因为 Unity 的对象模型把 GameObject 设计成场景层级中的实体节点。Transform 提供空间变换和父子层级，是渲染、物理、脚本查找、坐标换算的基础。GameObject 是组件容器，Transform 是它必带的场景树节点。

transform.position 和 localPosition 区别是什么？

transform.position 是世界坐标，transform.localPosition 是相对父物体的局部坐标。

transform.position      // 世界空间中的位置
transform.localPosition // 相对 parent 的位置

例子：

parent.position = new Vector3(10, 0, 0);
child.localPosition = new Vector3(2, 0, 0);

如果父物体没有旋转和缩放，那么：

child.position == new Vector3(12, 0, 0);

区别：

属性	含义	适合场景
position	世界坐标	把物体放到世界某个位置
localPosition	相对父物体的坐标	做挂点、子物体偏移、UI/模型层级跟随

底层理解：

worldPosition = parentTransformMatrix * localPosition
localPosition = inverse(parentTransformMatrix) * worldPosition

也就是说，子物体最终世界位置是沿着父子 Transform 链一层层矩阵变换算出来的。父物体的 position、rotation、scale 都会影响子物体的世界位置。

没有父物体时：

transform.parent == null

通常：

transform.position == transform.localPosition

面试高分说法：position 是 Transform 经过父子层级矩阵计算后的世界空间结果；localPosition 是存储在当前 Transform 上、相对父 Transform 的局部偏移。设置 position 时 Unity 会反算局部坐标，设置 localPosition 时世界坐标会随父节点变换而变化。

localScale 在父子层级下有什么影响？

localScale 是相对父物体的缩放倍率；父物体的缩放会传递给子物体，影响子物体的世界尺寸，也会影响子物体 localPosition 对应的世界偏移。

比如：

parent.localScale = new Vector3(2, 2, 2);
child.localPosition = new Vector3(1, 0, 0);
child.localScale = Vector3.one;

如果父物体没有旋转，那么子物体大致表现为：

子物体世界尺寸：2 倍
子物体世界偏移：(2, 0, 0)

底层理解：

child world matrix = parent world matrix * child local matrix

而 local matrix 里面包含：

localPosition
localRotation
localScale

所以父级的 scale 会参与矩阵计算，影响子级的最终世界变换。

常见影响：

• 父物体放大，子物体也会跟着放大。
• 父物体缩小，子物体也会跟着缩小。
• 子物体的 localPosition 是在父坐标系里，父缩放会改变它在世界中的距离。
• 缩放会继续向更深层子节点传递。
• Transform.lossyScale 可以近似查看最终世界缩放，但复杂父子旋转和非等比缩放下不一定完全直观。

坑点：

父级非等比缩放 + 子级旋转

可能导致视觉上出现拉伸、倾斜感，碰撞体、特效、UI、模型挂点都可能变得难调。

建议：逻辑根节点、角色根节点、对象池根节点尽量保持 localScale = Vector3.one。 真正要改大小时，优先缩放模型子节点或视觉节点，避免影响整套层级逻辑。

面试高分说法：localScale 是当前 Transform 相对父 Transform 的局部缩放，最终世界缩放来自整条 Transform 链的矩阵叠乘。父级 scale 不只影响子物体大小，也会影响子物体 localPosition 转成世界坐标后的偏移距离，所以复杂层级里要谨慎使用父级缩放。

欧拉角和四元数区别是什么？

欧拉角是用 X/Y/Z 三个角度描述旋转，直观但有万向节锁和角度跳变问题；四元数用 x/y/z/w 四个分量表示旋转，不直观但稳定，适合引擎内部存储、旋转组合和插值。

Unity 里：

transform.eulerAngles // 欧拉角，Vector3，方便人看
transform.rotation    // 四元数，Quaternion，Unity 内部实际使用

欧拉角优点：

直观
Inspector 里好编辑
适合手动设置角度

欧拉角缺点：

有旋转顺序问题
可能出现万向节锁
角度可能 0/360 跳变
插值可能不自然

四元数优点：

不会出现万向节锁
适合旋转叠加
适合平滑插值
数值更稳定

四元数缺点：

不直观
x/y/z/w 不适合人直接编辑
q 和 -q 可以表示同一个旋转

常见写法：

// 欧拉角转四元数
transform.rotation = Quaternion.Euler(0, 90, 0);

// 四元数插值
transform.rotation = Quaternion.Slerp(
    transform.rotation,
    targetRotation,
    Time.deltaTime * speed
);

不要频繁这样写：

var euler = transform.eulerAngles;
euler.y += 10f;
transform.eulerAngles = euler;

不是绝对不能用，而是频繁读写 eulerAngles 可能遇到角度换算、0/360 跳变、旋转顺序带来的问题。更稳定的旋转通常用：

transform.Rotate(0, 10f, 0);

或者直接操作四元数。

面试高分说法：欧拉角更像是给人看的表示方式，四元数更像是给引擎计算用的表示方式。Unity 内部用 Quaternion 存旋转，Inspector 和 eulerAngles 只是把它转换成欧拉角展示。实际项目中手配角度可以用欧拉角，旋转插值、朝向计算和连续旋转更推荐用四元数。

为什么旋转推荐用 Quaternion？

旋转推荐用 Quaternion，因为它比欧拉角更适合程序计算：不会万向节锁，旋转组合更稳定，插值更自然，也更符合 Unity 内部存储旋转的方式。

Unity 内部旋转主要用：

transform.rotation // Quaternion

欧拉角更多是给人看和编辑：

transform.eulerAngles // Vector3

为什么不用欧拉角长期计算？

transform.eulerAngles += new Vector3(0, 10, 0);

这种写法可能遇到：

• 0 和 360 跳变
• 三个轴旋转顺序不同导致结果不同
• 万向节锁
• 插值时绕远路或不平滑

四元数更适合这些场景：

// 朝向某个方向
transform.rotation = Quaternion.LookRotation(direction);

// 平滑转向
transform.rotation = Quaternion.Slerp(
    transform.rotation,
    targetRotation,
    Time.deltaTime * speed
);

// 叠加旋转
transform.rotation = Quaternion.AngleAxis(30f, Vector3.up) * transform.rotation;

底层理解：欧拉角是把旋转拆成 X/Y/Z 三次旋转；四元数更像是用“一个旋转轴 + 一个旋转角”来描述整体旋转。它直接表示朝向，不容易在某个角度丢失自由度。

面试高分说法：欧拉角适合输入和展示，Quaternion 适合计算和存储。Unity 的 Transform.rotation 本身就是 Quaternion，eulerAngles 只是转换出来给人看的结果。实际项目里，手动配置角度可以用欧拉角，但连续旋转、朝向计算、插值和组合旋转更推荐用 Quaternion。

Find、GetComponent、FindObjectOfType 性能如何？

性能大致看查找范围：缓存引用最快，GetComponent 查当前对象组件，GameObject.Find 按名字扫场景，FindObjectOfType / FindAnyObjectByType 按类型扫场景，越往后越不适合频繁调用。

大致排序：

缓存字段
> GetComponent
> GameObject.Find
> FindObjectOfType / FindAnyObjectByType

GetComponent<T>()：

private Rigidbody _rb;

void Awake()
{
    _rb = GetComponent<Rigidbody>();
}

void Update()
{
    _rb.AddForce(Vector3.forward);
}

它不是全场景搜索，只是在当前 GameObject 的组件列表里找。可以用，但不要在 Update、大量对象循环里反复调用。

GameObject.Find：

GameObject player = GameObject.Find("Player");

它按名字在场景里找 active 对象，性能更差，而且名字字符串很脆弱。适合启动时偶尔查一次，不适合每帧查。

FindObjectOfType：

var manager = FindObjectOfType<GameManager>();

这是场景级按类型搜索，旧版常见，新版 Unity 已不推荐。现在通常用：

var manager = FindAnyObjectByType<GameManager>();

但本质还是搜索加载对象，也不适合高频调用。

更推荐：

[SerializeField] private Player player; // Inspector 拖引用

或者：

public static GameManager Instance { get; private set; }

void Awake()
{
    Instance = this;
}

面试高分说法：这些 API 的性能差异来自搜索范围。GetComponent 只查当前对象组件表，成本相对可控；Find 和 FindObjectOfType 要在场景对象里搜索，复杂度和场景对象数量相关。项目里我会在 Awake/Start 或加载阶段查一次并缓存，运行时高频逻辑尽量用序列化引用、单例、注册表或依赖注入。

参考：Unity 官方文档明确提示 GameObject.Find 不建议每帧使用；FindObjectOfType 已过时，新版建议使用 FindFirstObjectByType 或 FindAnyObjectByType，其中不需要确定实例时 FindAnyObjectByType 更快。 来源：GameObject.Find、Object.FindObjectOfType、Object.FindAnyObjectByType

如何缓存组件引用？

缓存组件引用就是：不要在 Update 或循环里反复 GetComponent/Find，而是在初始化阶段查一次，存到字段里，后面直接用字段。

自身组件常这样写：

public class PlayerMove : MonoBehaviour
{
    private Rigidbody _rb;
    private Animator _animator;

    void Awake()
    {
        _rb = GetComponent<Rigidbody>();
        _animator = GetComponent<Animator>();
    }

    void FixedUpdate()
    {
        _rb.AddForce(Vector3.forward);
    }
}

外部依赖优先用 Inspector 拖引用：

public class CameraFollow : MonoBehaviour
{
    [SerializeField] private Transform target;

    void LateUpdate()
    {
        transform.position = target.position + new Vector3(0, 5, -10);
    }
}

如果组件可能不存在，用 TryGetComponent：

void Awake()
{
    if (TryGetComponent(out Rigidbody rb))
    {
        _rb = rb;
    }
}

强依赖组件可以加约束：

[RequireComponent(typeof(Rigidbody))]
public class PlayerMove : MonoBehaviour
{
    private Rigidbody _rb;

    void Awake()
    {
        _rb = GetComponent<Rigidbody>();
    }
}

底层理解：GetComponent 会在当前 GameObject 的组件列表里查找；缓存后只是普通字段访问，成本更低，也让依赖关系更清楚。

面试高分说法：我一般把自身组件在 Awake 里缓存，外部对象优先用 [SerializeField] 显式引用，动态生成对象在 Instantiate 或对象池取出时初始化绑定。运行时高频逻辑里避免反复 GetComponent、Find，同时注意场景切换、Destroy 和对象池复用时引用可能失效，需要重新绑定或清理。

Prefab 是什么？Prefab Variant 是什么？

Prefab 是 Unity 里的可复用对象模板；Prefab Variant 是基于某个 Prefab 派生出来的变体，继承原 Prefab 的结构，同时可以覆盖部分属性。

比如普通 Prefab：

Enemy.prefab
  ├── Transform
  ├── Animator
  ├── Collider
  └── EnemyAI

你可以在场景里反复生成：

Instantiate(enemyPrefab);

这样所有敌人都来自同一个模板。改 Enemy.prefab 的通用结构，比如加一个 AudioSource，它的实例通常都会跟着更新。

Prefab Variant 适合做同类对象的差异版本：

Enemy.prefab           // 基础怪物
Enemy_Elite.prefab     // 变体：血量更高、颜色不同
Enemy_Boss.prefab      // 变体：模型更大、技能不同

它继承 Base Prefab，但可以覆盖部分内容：

Base Enemy:
Hp = 100
Speed = 3
Model = Normal

Boss Variant:
Hp = 5000       // override
Speed = 2       // override
Model = Boss    // override

核心区别：

类型	是什么	用途
Prefab	原始模板资产	复用对象结构
Prefab Instance	场景里的实例	由 Prefab 生成，可有实例覆盖
Prefab Variant	继承某个 Prefab 的新 Prefab	做同类对象差异化

面试高分说法：Prefab 解决的是对象复用和模板化管理，Prefab Variant 解决的是同一类对象的继承式差异配置。Base Prefab 放通用结构和逻辑，Variant 只覆盖差异属性，这样改通用能力时不用每个 Prefab 都改一遍。

坑点：Variant 覆盖太多会变得难维护。如果一个 Variant 已经改到和 Base 几乎没关系，可能应该拆成独立 Prefab，而不是继续继承。

参考：Unity Prefabs、Unity Prefab Variants

如何设计一个可复用的角色 Prefab？

可复用角色 Prefab 的核心是：Root 管逻辑和碰撞，Visual 管表现和挂点，Config 管数值，Prefab Variant 管差异。

推荐结构：

Character_Root
  ├── Visual_Root
  │   ├── Model
  │   ├── Animator
  │   ├── WeaponSocket
  │   └── HitEffectSocket
  ├── Collider
  ├── Health
  ├── Movement
  ├── Combat
  ├── AnimationBridge
  └── AI / PlayerInput

设计原则：

1. 逻辑和表现分离

Character_Root 放移动、碰撞、生命值、战斗逻辑；Visual_Root 放模型、Animator、特效挂点、武器挂点。这样换皮、换模型不会影响移动和战斗。

2. 数值走配置，不写死在 Prefab

[SerializeField] private CharacterConfig config;

比如 HP、速度、攻击力、技能列表、音效、特效，都可以放到 ScriptableObject 或配置表里。

3. 组件职责单一

不要写一个巨大的 CharacterController 包所有逻辑。可以拆成：

Health
Movement
Combat
SkillCaster
AnimationBridge
AIController
PlayerInputController

玩家和怪物可以共用 Health/Movement/Combat，只替换输入层：玩家用 PlayerInput，怪物用 AIController。

4. 引用要缓存或注入

自身组件在 Awake 缓存，外部依赖通过 Init 或 Inspector 注入：

void Awake()
{
    _animator = GetComponentInChildren<Animator>();
    _health = GetComponent<Health>();
}

public void Init(CharacterConfig config, Transform target)
{
    _config = config;
    _target = target;
}

5. 用 Prefab Variant 做差异化

Character_Base.prefab
  -> Player.prefab
  -> Enemy_Normal.prefab
  -> Enemy_Elite.prefab
  -> Enemy_Boss.prefab

Base 里放通用结构；Variant 里覆盖模型、配置、AI、技能、特效。

面试高分说法：我会把角色 Prefab 设计成稳定骨架加可替换数据。Root 层负责物理、状态和通用能力，Visual 层负责模型、动画和挂点，数值通过配置驱动，不同角色用 Prefab Variant 覆盖差异。这样能支持换皮、对象池复用、玩家/怪物共用组件，也方便后续扩展和热更新。