Unity脚本生命周期函数详解

1
using UnityEngine;
2

3
public class MyScript : MonoBehaviour
4
{
5
    // 脚本逻辑
6
}

1
public class ComponentExample : MonoBehaviour
2
{
3
    private Rigidbody rb;
4
    private Renderer meshRenderer;
5

6
    void Awake()
7
    {
8
        // 获取组件引用
9
        rb = GetComponent<Rigidbody>();
10
        meshRenderer = GetComponent<Renderer>();
11
    }
12
}

1
public class InspectorExample : MonoBehaviour
2
{
3
    // 公开变量，直接在Inspector中显示和修改
4
    public float moveSpeed = 5f;
5
    public GameObject targetObject;
6

7
    // 私有变量但仍显示在Inspector
8
    [SerializeField] private float rotationSpeed = 90f;
9
    [SerializeField] private bool isActive = true;
10
}

1
┌─────────────────────────────────────────────────────────────┐
2
│                      脚本实例创建                            │
3
└─────────────────────────────────────────────────────────────┘
4
                              │
5
                              ▼
6
┌─────────────────────────────────────────────────────────────┐
7
│  Awake()         — 脚本实例被创建时立即调用（最早执行）      │
8
│                     即使脚本未启用也会调用，整个生命周期只执行一次│
9
└─────────────────────────────────────────────────────────────┘
10
                              │
11
                              ▼
12
┌─────────────────────────────────────────────────────────────┐
13
│  OnEnable()      — 每次脚本被启用时调用                      │
14
│                     （组件被勾选 或 所在对象被激活）            │
15
└─────────────────────────────────────────────────────────────┘
16
                              │
17
                              ▼
18
┌─────────────────────────────────────────────────────────────┐
19
│  Start()         — 首次启用后，Update之前调用               │
20
│                     只执行一次                                 │
21
└─────────────────────────────────────────────────────────────┘
22
                              │
23
              ┌───────────────┴───────────────┐
24
              ▼                               ▼
25
┌─────────────────────────┐     ┌─────────────────────────────┐
26
│  FixedUpdate()          │     │  Update()                   │
27
│  固定时间间隔调用        │     │  每帧调用，频率不固定         │
28
│  默认0.02秒             │     │                             │
29
│  用于物理计算            │     │  用于非物理逻辑：             │
30
│                         │     │  - 输入检测                  │
31
│                         │     │  - 角色状态                  │
32
│                         │     │  - 游戏逻辑                  │
33
└─────────────────────────┘     └─────────────────────────────┘
34
              │                               │
35
              └───────────────┬───────────────┘
36
                              ▼
37
┌─────────────────────────────────────────────────────────────┐
38
│  LateUpdate()      — 所有Update执行完毕后调用               │
39
│                      常用于摄像机跟随等需要后处理的逻辑          │
40
└─────────────────────────────────────────────────────────────┘
41
                              │
42
                              ▼
43
┌─────────────────────────────────────────────────────────────┐
44
│  OnDisable()       — 脚本被禁用时调用                        │
45
│                      取消事件监听、停止协程、清理资源           │
46
└─────────────────────────────────────────────────────────────┘
47
                              │
48
                              ▼
49
┌─────────────────────────────────────────────────────────────┐
50
│  OnDestroy()       — 脚本被销毁时调用（对象销毁或场景切换）   │
51
│                      进行最终的清理工作                        │
52
└─────────────────────────────────────────────────────────────┘

1
void Awake()
2
{
3
    // 初始化变量、获取组件引用
4
    // 整个生命周期内只执行一次，执行顺序最早
5
    rb = GetComponent<Rigidbody>();
6
    health = maxHealth;
7
}

1
void OnEnable()
2
{
3
    // 注册事件监听、启动协程
4
    GameEvents.OnEnemyKilled += HandleEnemyKilled;
5
    StartCoroutine(UpdateHealthBar());
6
}

1
void Start()
2
{
3
    // 进行依赖于其他组件已初始化完成的逻辑
4
    // 或者游戏开始前的最终设置
5
    target = GameObject.FindWithTag("Player").transform;
6
    animator = GetComponent<Animator>();
7
}

1
void Update()
2
{
3
    // 处理非物理相关的实时游戏逻辑
4
    float horizontal = Input.GetAxis("Horizontal");
5
    float vertical = Input.GetAxis("Vertical");
6

7
    transform.Translate(horizontal * moveSpeed * Time.deltaTime, 0,
8
                        vertical * moveSpeed * Time.deltaTime);
9
}

1
void FixedUpdate()
2
{
3
    // 执行与物理计算相关的操作
4
    // 固定时间间隔调用（默认0.02秒），不受渲染帧率影响
5
    rb.AddForce(physicsInput * thrustForce);
6
}

1
void LateUpdate()
2
{
3
    // 常用语摄像机跟随，确保在目标对象移动完成后再更新
4
    targetPosition = target.position + offset;
5
    transform.position = Vector3.SmoothDamp(transform.position,
6
                                           targetPosition,
7
                                           ref velocity,
8
                                           smoothTime);
9
}

1
void OnDisable()
2
{
3
    // 取消事件监听、停止协程、清理资源
4
    GameEvents.OnEnemyKilled -= HandleEnemyKilled;
5
    StopAllCoroutines();
6
}

1
void OnDestroy()
2
{
3
    // 进行最终的清理工作
4
    Debug.Log($"{gameObject.name} 已被销毁");
5
}

1
public class BadExample : MonoBehaviour
2
{
3
    void Update()
4
    {
5
        // ❌ 每帧都GetComponent，开销大
6
        Rigidbody rb = GetComponent<Rigidbody>();
7
        rb.AddForce(Vector3.forward);
8
    }
9
}
10

11
public class GoodExample : MonoBehaviour
12
{
13
    private Rigidbody rb;
14

15
    void Awake()
16
    {
17
        // ✅ 缓存引用，只获取一次
18
        rb = GetComponent<Rigidbody>();
19
    }
20

21
    void Update()
22
    {
23
        // ✅ 使用缓存的引用
24
        rb.AddForce(Vector3.forward);
25
    }
26
}