使用动作脚本3.0的Cron作业

Question

有没有一种方法可以在一个给定的日期/时间使用动作脚本3.0来执行任务（函数）？我的意思是像schedule(myFunction:Function, dateTime:Date)。谢谢

Answer 1

本身不是本身。

在另一个答案中概述的SetTimeout可能是最简单的赌注。但是，如果你已拥有想要的安排很多事情，这里是一类可以管理它：如下（它可以被修改，而不是使用一个计时器setTimeout的，但我更喜欢计时器）

public class Scheduler { 
    public var time:Date; 
    public var action:Function; 
    public var parameters:Array; 

    private var checkInterval:Number = NaN; 
    public function get interval():Number { return checkInterval; }; 
    public function set interval(val:Number):void { 
     checkInterval = val; 
     if (schedules && (mainTimer && mainTimer.delay > val)) { 
      mainTimer.delay = val; 
     } 
    } 

    public function Scheduler(time_:Date, action_:Function, interval_:Number = NaN, parameters_:Array = null):void { 
     time = time_; 
     action = action_; 
     checkInterval = interval_; 
     parameters = parameters_; 
    } 

    //static stuff 

    private static var mainTimer:Timer; 
    public static function stop():void { 
     if (mainTimer) { 
      mainTimer.stop(); 
     } 
    } 

    public static function start():void { 
     if (mainTimer && !mainTimer.running) { 
      mainTimer.start(); 
     } 
    } 

    public static function get curInterval():Number { return (mainTimer) ? mainTimer.delay : 0; }; 

    private static var scheduleList:Vector.<Scheduler>; 
    public static function get schedules():Vector.<Scheduler> { return scheduleList; }; 


    /** 
    * Schedules a function to run at a certain time (with the margin of the interval) 
    * @param time - what time to run this passed action 
    * @param action - a function to call between the time passing, and the next interval 
    * @param interval - how often to check if the time has come, default is 1 second 
    * @param ... rest - parameters to pass to the action method 
    * @return 
    */ 
    public static function scheduleAction(time:Date, action:Function, interval:Number = NaN, ... rest):Scheduler { 
     var s:Scheduler = new Scheduler(time, action, interval, rest); 

     //if already old 
     if (time.time < new Date().time) { 
      action.apply(null, rest); 
      return s; 
     } 

     if (!scheduleList) { 
      scheduleList = new Vector.<Scheduler>(); 
     } 

     scheduleList.push(s); 

     if (!mainTimer) { 
      mainTimer = new Timer(1000); 
      mainTimer.addEventListener(TimerEvent.TIMER, timerTick); 
      mainTimer.start(); 
     } 

     if (!isNaN(interval) && interval < mainTimer.delay) { 
      mainTimer.delay = interval; 
     } 

     return s; 
    } 

    private static function timerTick(e:TimerEvent):void { 
     var tmpDate:Date = new Date(); 
     for (var i:int = scheduleList.length-1; i >= 0;i--){ 
      if (tmpDate.time >= scheduleList[i].time.time) { 
       scheduleList[i].action.apply(null, scheduleList[i].parameters); 
       removeSchedule(i); 
      } 
     } 

     checkTimerNeeded(); 
    } 

    private static function checkTimerNeeded():void { 
     if (scheduleList && scheduleList.length < 1) { 
      mainTimer.stop(); 
      mainTimer.removeEventListener(TimerEvent.TIMER, timerTick); 
      mainTimer = null; 
      scheduleList = null; 
     } 
    } 

    private static function removeSchedule(index:int):void { 
     scheduleList.splice(index, 1); 
     checkTimerNeeded(); 
    } 

    /** 
    * Cancels a scheduled item 
    * @param s - the item to cancel 
    * @return returns true if the item was scheduled, false if the item wasn't scheduled 
    */ 
    public static function cancelSchedule(s:Scheduler):Boolean { 
     if (scheduleList) { 
      var index:int = scheduleList.indexOf(s); 
      if (index > 0) { 
       removeSchedule(index); 
       return true; 
      } 
     } 

     return false; 
    } 

    public static function status():void { 
     trace("isRunning:", (mainTimer) ? mainTimer.running : null); 
     trace("List Length:", scheduleList ? scheduleList.length : null); 
    } 
} 

用途：

Scheduler.scheduleAction(myDateToRunTheFunction, myFunctionToRun, howOftenToCheckTime, functionParameter1, functionParameter2, functionParameter2); 

Answer 2

这里是一个办法做到这一点，它需要在日期运行的功能，并发现了长有是如何运行的功能，然后调用setTimeout的

var date:Date = new Date(2012,9,13); 
schedule(myFunction,date); 

private function myFunction():void 
{ 
    trace("Schedule function run"); 
} 

private function schedule(func:Function,date:Date):void 
{ 
    var now:Date = new Date(); 

    if (date.time < now.time) 
     return; 
    var timetorun:Number = date.time - now.time; 
    setTimeout(func, timetorun); 
}