ActionScript 3
टाइमर के साथ काम करना

उलटी गिनती टाइमर उदाहरण

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);
    }

}
}

यह CountdownTimer Timer बढ़ाता है, और बिल्कुल उसी तरह से उपयोग किया जाता है, सिवाय इसके कि समय नीचे गिना जाता है।

उदाहरण उपयोग:

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");
}

ऊपर का उदाहरण आउटपुट होगा:

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

अंतराल और टाइमआउट

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() का उपयोग निर्दिष्ट अंतराल के रूप में बार-बार असंगत रूप से कार्य करने के लिए किया जाता है। आंतरिक Timer ऑब्जेक्ट का उपयोग किया जाता है, प्रकार uint का लौटाया गया मूल्य इसकी आंतरिक आईडी है, जिसके द्वारा आप clearInterval() कॉल करके दोहराव तक पहुंच सकते हैं और रोक सकते हैं। setTimeout() और clearTimeout() समान रूप से काम करते हैं, लेकिन सप्लाई फ़ंक्शन को कॉल केवल एक बार किया जाता है। आप दोनों सेट फ़ंक्शंस में अतिरिक्त तर्क दे सकते हैं, इन्हें फंक्शन में पास किया जाएगा। तर्कों की संख्या और उनके प्रकार की संकलन समय पर जाँच नहीं की जाती है, इसलिए क्या आपको तर्कों के एक अजीब संयोजन की आपूर्ति करनी चाहिए, या एक फ़ंक्शन जो उन्हें आवश्यकता होती है और कोई नहीं प्राप्त करता है, एक त्रुटि "त्रुटि # 1063: तर्क गिनती बेमेल" को उठाया जाता है।

आप नियमित Timer ऑब्जेक्ट्स के साथ setInterval और setTimeout की दोनों गतिविधियां कर सकते हैं, या तो repeatCount संपत्ति के लिए 0 या 1 का उपयोग करके, अनिश्चित काल के लिए 0, 1 के लिए 1।

रैंडम टाइमर उदाहरण

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();
        }
    }
}

यह RandomTimer Timer बढ़ाता है, और बिल्कुल उसी तरह से उपयोग किया जाता है, सिवाय इसके कि यह रैंडम अंतराल पर डिस्पैच करता है।

उदाहरण का उपयोग, 1 और 5-सेकंड के बीच बेतरतीब ढंग से प्रेषण:

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();
}

ऊपर का उदाहरण आउटपुट होगा:

[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