#Cocos Creator 生命周期详解

#一、前言

Cocos Creator 作为主流的游戏开发引擎，其组件化架构的核心就是生命周期回调函数。理解这些回调的触发时机、执行顺序和使用场景，是写出高质量游戏逻辑的基础。

本文基于 Cocos Creator 3.x，系统梳理从引擎启动到场景切换、从节点创建到销毁的完整生命周期。

#二、组件生命周期回调总览

Cocos Creator 的生命周期回调按触发顺序排列如下：

注意：constructor（构造函数）不是 Cocos 的生命周期回调，而是 TypeScript/JavaScript 类的构造器。虽然可以在其中写初始化代码，但此时组件尚未被引擎挂载，很多引擎 API 不可用。

#三、各回调详解

#3.1 onLoad

触发时机：当节点及其所有子节点加载完成后，引擎会按照节点树的顺序依次调用每个组件的 onLoad。

复制import { _decorator, Component, Node } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('Player')
export class Player extends Component {
    onLoad() {
        // 初始化引用、获取其他组件
        const health = this.node.getChildByName('Health');
        console.log('节点加载完成，可以安全访问子节点');
    }
}

关键特性：

• 每个组件只触发一次
• 所有节点的 onLoad 在第一帧 update 之前全部执行完毕
• 在 onLoad 中可以安全地访问子节点和组件引用
• 节点激活状态下，onLoad 在节点激活时触发；禁用的节点，其 onLoad 会延迟到节点激活时才触发

典型用途：

• 获取组件引用和子节点引用
• 初始化变量
• 注册事件监听

#3.2 start

触发时机：在 onLoad 之后、第一帧 update 之前调用。

复制@ccclass('Enemy')
export class Enemy extends Component {
    start() {
        // 在这里开始寻路逻辑
        this.scheduleOnce(() => {
            this.findPath();
        }, 0.5);
    }
}

start 与 onLoad 的区别：

最佳实践：如果组件 A 需要访问同节点上组件 B 的初始化结果，把 A 的逻辑放在 start 中。

#3.3 update(dt)

触发时机：游戏运行期间，每帧都会被调用。

复制@ccclass('Bullet')
export class Bullet extends Component {
    private speed: number = 500;

    update(dt: number) {
        const pos = this.node.position;
        this.node.setPosition(pos.x, pos.y + this.speed * dt, pos.z);
    }
}

注意事项：

• dt 参数是上一帧到当前帧的时间间隔（秒），不是固定值
• 不要在 update 中做内存分配（创建对象、拼字符串等），会造成 GC 压力
• 频繁访问属性（如 this.node.position）会触发组件脏标记更新，能缓存就缓存
• 禁用的组件不会调用 update

#3.4 lateUpdate(dt)

触发时机：在所有组件的 update 之后调用。

复制@ccclass('CameraFollow')
export class CameraFollow extends Component {
    @property(Node)
    target: Node = null;

    lateUpdate(dt: number) {
        // 跟随玩家移动
        if (this.target) {
            this.node.setPosition(
                this.target.position.x,
                this.target.position.y,
                this.node.position.z
            );
        }
    }
}

典型用途：

• 摄像机跟随（确保玩家位置更新后再移动摄像机）
• 粒子系统与角色动画的同步
• 在所有逻辑更新完成后做统一的后处理

#3.5 onEnable / onDisable

复制@ccclass('UIPanel')
export class UIPanel extends Component {
    onEnable() {
        // 面板显示时注册事件
        this.node.on(Node.EventType.TOUCH_START, this.onTouch, this);
    }

    onDisable() {
        // 面板隐藏时注销事件，防止内存泄漏
        this.node.off(Node.EventType.TOUCH_START, this.onTouch, this);
    }
}

触发场景：

• node.active = true/false 时
• component.enabled = true/false 时
• 节点首次被添加到场景树且处于激活状态时（onEnable）
• 节点被移除前（onDisable）

重要：onDisable 在 onDestroy 之前调用。这意味着节点销毁时，先执行所有组件的 onDisable，再执行 onDestroy。

#3.6 onDestroy

触发时机：节点从场景树中移除并被销毁时。

复制@ccclass('Tower')
export class Tower extends Component {
    onDestroy() {
        // 清理所有定时器
        this.unscheduleAllCallbacks();
        // 清理事件监听
        this.node.off(Node.EventType.TOUCH_START, this.onTouch, this);
        console.log('塔被摧毁');
    }
}

注意事项：

• onDestroy 中不要再访问其他可能已被销毁的节点
• 不要在 onDestroy 中重新创建节点或启动新的动画
• 如果在 onDestroy 中通过 director.loadScene 切换场景，需要注意时序

#四、场景切换的生命周期

当你调用 director.loadScene() 切换场景时，流程如下：

实际案例：

复制// 玩家死亡后切换到结算场景
@ccclass('GameManager')
export class GameManager extends Component {
    onPlayerDead() {
        // 先执行结算逻辑
        this.showResult();
        // 1 秒后切换场景
        this.scheduleOnce(() => {
            director.loadScene('ResultScene');
        }, 1);
    }
}

#五、节点创建与销毁的生命周期

#动态创建节点

复制const node = new Node('NewEnemy');
this.node.addChild(node);
// 此时引擎会：
// 1. 调用 node 上所有组件的 onLoad
// 2. 如果 node 处于激活状态，下一帧调用 start

#动态销毁节点

复制node.destroy();
// 此时引擎会：
// 1. 调用 node 上所有组件的 onDisable
// 2. 调用 node 上所有组件的 onDestroy
// 3. 从场景树中移除

#从场景树移除但不销毁

复制node.removeFromParent();
// 只是从父节点移除，不触发 onDestroy
// 可以之后重新 addChild 到其他节点

#六、常用生命周期模式

#模式 1：对象池

复制@ccclass('BulletPool')
export class BulletPool extends Component {
    private pool: Node[] = [];

    getBullet(): Node {
        let bullet: Node;
        if (this.pool.length > 0) {
            bullet = this.pool.pop();
            bullet.active = true;  // 触发 onEnable
        } else {
            bullet = instantiate(this.bulletPrefab);
            this.node.addChild(bullet);  // 触发 onLoad
        }
        return bullet;
    }

    putBullet(bullet: Node) {
        bullet.active = false;  // 触发 onDisable
        // 不调用 destroy()，留着复用
    }
}

#模式 2：事件驱动的状态机

复制@ccclass('StateComponent')
export class StateComponent extends Component {
    private currentState: string = 'idle';

    changeState(newState: string) {
        if (this.currentState === newState) return;
        this.exitState(this.currentState);
        this.currentState = newState;
        this.enterState(newState);
    }

    onEnable() {
        this.enterState(this.currentState);
    }

    onDisable() {
        this.exitState(this.currentState);
    }
}

#模式 3：延迟初始化

复制@ccclass('LazyInit')
export class LazyInit extends Component {
    private initialized = false;

    update(dt: number) {
        if (!this.initialized) {
            // 确保所有依赖都已就绪
            this.doInit();
            this.initialized = true;
        }
        // 正常逻辑
    }
}

#七、常见陷阱

#陷阱 1：onLoad 中访问未加载的资源

复制// 错误示例
onLoad() {
    // texture 可能还未加载完成
    this.getComponent(Sprite).spriteFrame = this.texture;
}

// 正确示例：使用资源加载 API
start() {
    resources.load('textures/hero', SpriteFrame, (err, asset) => {
        this.getComponent(Sprite).spriteFrame = asset;
    });
}

#陷阱 2：update 中频繁创建对象

复制// 错误示例
update(dt) {
    const pos = `${this.node.position.x},${this.node.position.y}`;
    this.label.string = pos;
}

// 正确示例
private tempVec = new Vec3();
update(dt) {
    Vec3.copy(this.tempVec, this.node.position);
    this.label.string = `${this.tempVec.x.toFixed(1)},${this.tempVec.y.toFixed(1)}`;
}

#陷阱 3：销毁后访问节点

复制// 错误示例
onDestroy() {
    const parent = this.node.parent;
    parent.removeChild(this.node);  // 节点可能已经不在场景树中
}

// 正确示例：不需要手动移除，destroy() 已经处理
onDestroy() {
    // 只做清理逻辑
    this.unscheduleAllCallbacks();
}

#陷阱 4：onDisable 中触发新的生命周期

复制// 危险操作
onDisable() {
    this.node.active = true;  // 可能导致无限循环
}

#八、生命周期执行顺序图

复制场景加载
  │
  ├─ 所有节点 onLoad（从根到叶）
  │
  ├─ 所有节点 start（从根到叶）
  │
  ├─ [游戏循环开始]
  │   │
  │   ├─ update(dt)        ← 每帧执行
  │   ├─ lateUpdate(dt)    ← 每帧执行
  │   │
  │   └─ [下一帧...]
  │
  └─ 场景卸载
      ├─ 所有节点 onDisable
      └─ 所有节点 onDestroy

#九、总结

掌握生命周期是 Cocos Creator 开发的基础。建议在实际项目中多观察日志输出，加深对执行顺序的理解。