标准周期

http://docs.cocos.com/creator/manual/zh/scripting/life-cycle-callbacks.html

creator提供了7种生命周期函数，分别是：
onLoad,start,update,lateUpdate,onDestroy,onEnable,onDisable。
其中：
onDestroy,onEnable,onDisable为触发式调用，可以参考官方文档，此处不说明。
另外4种的调用顺序是onLoad -> start -> update -> lateUpdate。

在标准周期中插入方法

结论：onload -> test-function -> start -> update = > lateupdate
例子：有1个prefab和挂载在prefab上的脚本test，1个主脚本

  1. // test.ts
  3. const { ccclass, property } = cc._decorator;
  5. @ccclass
  6. export class test extends cc.Component {
  8.     onLoad() {
  9.         cc.log("onload")
  10.     }
  12.     start() {
  13.         cc.log("start")
  14.     }
  16.     flag_update = true
  17.     update() {
  18.         if (this.flag_update) {
  19.             this.flag_update = false
  20.             cc.log("update")
  21.         }
  22.     }
  24.     flag_late_update = true
  25.     lateUpdate() {
  26.         if (this.flag_late_update) {
  27.             this.flag_late_update = false
  28.             cc.log("lateupdate")
  29.         }
  30.     }
  32.     test() {
  33.         cc.log("test-function")
  34.     }
  35. }
  1. // 主脚本
  3. ******
  4.     onLoad() {
  5.         this.create_some_node()
  6.     }
  8.     @property(cc.Prefab)
  9.     some_prefab: cc.Prefab = null
  11.     create_some_node() {
  12.         let n = cc.instantiate(this.some_prefab)
  13.         n.parent = this.node
  14.         n.getComponent(test).test()
  15.     }
  16. ******

拖入后执行，执行的结果为：
微信截图_20190603130625.png

scheduleOnce()在update()之前还是之后?

结论：update -> scheduleOnce

  1. // 修改脚本 test.ts
  3. ******
  4.     onLoad() {
  5.         this.scheduleOnce(() => {
  6.             cc.log("onload")
  7.         }, 0)
  8.     }
  10.     start() {
  11.         this.scheduleOnce(() => {
  12.             cc.log("start")
  13.         }, 0)
  14.     }
  15. ******

执行结果为：
1.png

原理浅析：帧

  1. 游戏内所有的逻辑以帧为基础。
  2. 引擎可以做到渲染帧、逻辑帧、物理帧等分离。cocos-creator中渲染帧和逻辑帧未分离。
  1. // 将test.ts改回去，无schedule
  1. // 修改主脚本，以3帧为例子
  3. ******
  5.     onLoad() {
  6.         // this.create_some_node()
  7.     }
  9.     count = 0
  10.     update() {
  11.         if (this.count < 3) {
  12.             cc.log("update:", this.count)
  13.             for (let i = 0; i < 1000; i += 1) {
  14.                 cc.log(1) // 本项目是为了阻塞帧的执行
  15.             }
  16.             if (this.count === 1) {
  17.                 this.create_some_node()
  18.             }
  19.             this.count += 1
  20.         }
  21.     }
  22. ******

执行结果为：
2.png
可以从结果看出，除了循环会阻碍帧的进程以外，子函数create_some_node也会阻碍帧的进程，并且在此帧内会执行到子脚本的start方法。

优化方向1：减少单帧内的计算，放到多帧去执行

这点的逻辑很容易理解，即将一些无关的计算从单帧放到多帧中去执行。
creator中的api：schedule()中参数interval=0是为间隔帧执行，或者传入时间也可以了。

（错误的）优化方向2：异步化

由于js单线程的原因，即使是异步的promise也会一定程度上的阻塞执行。
在creator中则体现在：在某一帧中使用的promise，一定会在当前帧中执行完毕。

  1. // 清理主脚本，仅创建，无其他调用或者输出
  2. // 修改test.ts
  4. ******
  5.     onLoad() {
  6.         cc.log("onload")
  7.     }
  9.     start() {
  10.         cc.log("start")
  11.     }
  13.     count = 0
  14.     update() {
  15.         if (this.count < 5) {
  16.             cc.log("update", this.count)
  17.             if (this.count === 0) {
  18.                 this.test()
  19.             }
  20.             this.count += 1
  21.         }
  22.     }
  24.     test() {
  25.         Promise.resolve().then(() => {
  26.             for (let i = 0; i < 1000; i += 1) {
  27.                 cc.log(1)
  28.             }
  29.         })
  30.         cc.log("test-function")
  31.     }
  32. ******

执行结果为：
3.png
可以看到，1000次输出被卡在第1帧中了。