Recherche…


Exemple de compte à rebours

package {
import flash.events.TimerEvent;
import flash.utils.Timer;

public class CountdownTimer extends Timer {

    public var time:Number = 0;

    public function CountdownTimer(time:Number = Number.NEGATIVE_INFINITY, delay:Number = 1000) {
        super(delay, repeatCount);

        if (!isNaN(time))
            this.time = time;

        repeatCount = Math.ceil(time / delay);

        addEventListener(TimerEvent.TIMER, timerHandler);
        addEventListener(TimerEvent.TIMER_COMPLETE, timerCompleteHandler);
    }

    override public function start():void {
        super.start();
    }

    protected function timerHandler(event:TimerEvent):void {
        time -= delay;
    }

    protected function timerCompleteHandler(event:TimerEvent):void {
    }

    override public function stop():void {
        super.stop();
    }

    public function dispose():void {
        removeEventListener(TimerEvent.TIMER, timerHandler);
        removeEventListener(TimerEvent.TIMER_COMPLETE, timerCompleteHandler);
    }

}
}

Ce CountdownTimer étend le Timer et est utilisé exactement de la même façon, sauf que le temps est compté.

Exemple d'utilisation:

var timer:CountdownTimer = new CountdownTimer(5000);
timer.addEventListener(TimerEvent.TIMER, timerHandler);
timer.addEventListener(TimerEvent.TIMER_COMPLETE, completeHandler);
timer.start();

function timerHandler(event:TimerEvent):void {
    trace("Time remaining: " + event.target.time);
}

function completeHandler(event:TimerEvent):void {
    trace("Timer complete");
}

L'exemple ci-dessus produirait:

[trace] Time remaining: 4000
[trace] Time remaining: 3000
[trace] Time remaining: 2000
[trace] Time remaining: 1000
[trace] Time remaining: 0
[trace] Timer complete

Intervalles et délais

import flash.utils.*;
var intervalId:uint=setInterval(schroedingerCat,1000); 
// execute a function once per second and gather interval ID
trace("Cat's been closed in the box.");
function schroedingerCat():void {
    if (Math.random()<0.04) {
        clearInterval(intervalId); // stop repeating by ID
        trace("Cat's dead.");
        return;
    }
    trace("Cat's still alive...");
}

var bombId:uint;
function plantBomb(seconds:Number):uint {
    trace("The bomb has been planted, and will blow in "+seconds.toFixed(3)+" seconds!");
    var id:uint=setTimeout(boom,seconds*1000); // parameter is in milliseconds
    return id;
}
function defuseBomb(id:uint):void {
    clearTimeout(id);
    trace("Bomb with id",id,"defused!");
}
function boom():void {
    trace("BOOM!");
}

setInterval() est utilisé pour effectuer des tâches répétées de manière asynchrone en tant qu'intervalles spécifiés. L'objet Timer interne est utilisé, la valeur renvoyée de type uint est son ID interne, grâce à laquelle vous pouvez accéder et arrêter la répétition en appelant clearInterval() . setTimeout() et clearTimeout() fonctionnent de la même manière, mais l'appel à la fonction fournie n'est effectué qu'une seule fois. Vous pouvez fournir des arguments supplémentaires aux deux fonctions définies, celles-ci seront transmises à la fonction dans l'ordre. Le nombre d'arguments et leur type ne sont pas vérifiés au moment de la compilation. Par conséquent, si vous fournissez une étrange combinaison d'arguments ou une fonction qui les requiert et n'en reçoit aucune, une erreur "Erreur # 1063: incompatibilité des arguments" est générée.

Vous pouvez effectuer les deux activités de setInterval et de setTimeout avec des objets Timer standard, en utilisant 0 ou 1 pour la propriété repeatCount , 0 pour les répétitions indéfinies et 1 pour les répétitions indéfinies.

Exemple de minuterie aléatoire

package {
    import flash.events.TimerEvent;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class RandomTimer extends Timer {

        public var minimumDelay:Number;
        public var maximumDelay:Number;
        private var _count:uint = 0;
        private var _repeatCount:int = 0;

        public function RandomTimer(min:Number, max:Number, repeatCount:int = 0) {
            super(delay, repeatCount);

            minimumDelay = min;
            maximumDelay = max;
            _repeatCount = repeatCount;
        }

        override public function start():void {
            delay = nextDelay();
            addEventListener(TimerEvent.TIMER, timerHandler);
            super.start();
        }

        private function nextDelay():Number {
            return (minimumDelay + (Math.random() * (maximumDelay - minimumDelay)));
        }

        override public function stop():void {
            removeEventListener(TimerEvent.TIMER, timerHandler);
            super.stop();
        }

        protected function timerHandler(event:TimerEvent):void {
            _count++;
            if ((_repeatCount > 0) && (_count >= _repeatCount)) {
                stop();
                dispatchEvent(new TimerEvent(TimerEvent.TIMER_COMPLETE));
            }
            delay = nextDelay();
        }
        
        override public function reset():void {
            _count = 0;
            super.reset();
        }
    }
}

Ce RandomTimer étend Timer et est utilisé exactement de la même manière, sauf qu'il distribue à des intervalles aléatoires.

Exemple d'utilisation, répartition aléatoire entre 1 et 5 secondes:

var t:int = getTimer();

var timer:RandomTimer = new RandomTimer(1000, 5000);
timer.addEventListener(TimerEvent.TIMER, timerHandler);
timer.start();

function timerHandler(event:TimerEvent):void {
    trace("Time since last dispatch: " + (getTimer() - t));
    t = getTimer();
}

L'exemple ci-dessus produirait:

[trace] Time since last dispatch: 1374
[trace] Time since last dispatch: 2459
[trace] Time since last dispatch: 3582
[trace] Time since last dispatch: 1335
[trace] Time since last dispatch: 4249


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow