ActionScript 3.0 + calculer la durée entre deux dates?

dans ActionScript 3.0, existe-t-il un moyen automatique de calculer le nombre de jours, d'heures, de minutes et de secondes entre deux dates spécifiées?

fondamentalement, ce dont j'ai besoin est l'équivalent ActionScript de la classe.net Timespan.

une idée?

16
demandé sur FlySwat 2008-10-04 02:49:19

9 réponses

j'ai créé une classe de durée ActionScript avec une API similaire à System.Temps nécessaire pour combler ce vide, mais il existe des différences dues à l'absence de surcharge de l'opérateur. Vous pouvez l'utiliser comme ceci:

TimeSpan.fromDates(later, earlier).totalDays;

ci - dessous est le code pour la classe (désolé pour le gros post-Je ne vais pas inclure les tests unitaires ;)

/**
 * Represents an interval of time 
 */ 
public class TimeSpan
{
    private var _totalMilliseconds : Number;

    public function TimeSpan(milliseconds : Number)
    {
        _totalMilliseconds = Math.floor(milliseconds);
    }

    /**
     * Gets the number of whole days
     * 
     * @example In a TimeSpan created from TimeSpan.fromHours(25), 
     *          totalHours will be 1.04, but hours will be 1 
     * @return A number representing the number of whole days in the TimeSpan
     */
    public function get days() : int
    {
         return int(_totalMilliseconds / MILLISECONDS_IN_DAY);
    }

    /**
     * Gets the number of whole hours (excluding entire days)
     * 
     * @example In a TimeSpan created from TimeSpan.fromMinutes(1500), 
     *          totalHours will be 25, but hours will be 1 
     * @return A number representing the number of whole hours in the TimeSpan
     */
    public function get hours() : int
    {
         return int(_totalMilliseconds / MILLISECONDS_IN_HOUR) % 24;
    }

    /**
     * Gets the number of whole minutes (excluding entire hours)
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(65500), 
     *          totalSeconds will be 65.5, but seconds will be 5 
     * @return A number representing the number of whole minutes in the TimeSpan
     */
    public function get minutes() : int
    {
        return int(_totalMilliseconds / MILLISECONDS_IN_MINUTE) % 60; 
    }

    /**
     * Gets the number of whole seconds (excluding entire minutes)
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(65500), 
     *          totalSeconds will be 65.5, but seconds will be 5 
     * @return A number representing the number of whole seconds in the TimeSpan
     */
    public function get seconds() : int
    {
        return int(_totalMilliseconds / MILLISECONDS_IN_SECOND) % 60;
    }

    /**
     * Gets the number of whole milliseconds (excluding entire seconds)
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(2123), 
     *          totalMilliseconds will be 2001, but milliseconds will be 123 
     * @return A number representing the number of whole milliseconds in the TimeSpan
     */
    public function get milliseconds() : int
    {
        return int(_totalMilliseconds) % 1000;
    }

    /**
     * Gets the total number of days.
     * 
     * @example In a TimeSpan created from TimeSpan.fromHours(25), 
     *          totalHours will be 1.04, but hours will be 1 
     * @return A number representing the total number of days in the TimeSpan
     */
    public function get totalDays() : Number
    {
        return _totalMilliseconds / MILLISECONDS_IN_DAY;
    }

    /**
     * Gets the total number of hours.
     * 
     * @example In a TimeSpan created from TimeSpan.fromMinutes(1500), 
     *          totalHours will be 25, but hours will be 1 
     * @return A number representing the total number of hours in the TimeSpan
     */
    public function get totalHours() : Number
    {
        return _totalMilliseconds / MILLISECONDS_IN_HOUR;
    }

    /**
     * Gets the total number of minutes.
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(65500), 
     *          totalSeconds will be 65.5, but seconds will be 5 
     * @return A number representing the total number of minutes in the TimeSpan
     */
    public function get totalMinutes() : Number
    {
        return _totalMilliseconds / MILLISECONDS_IN_MINUTE;
    }

    /**
     * Gets the total number of seconds.
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(65500), 
     *          totalSeconds will be 65.5, but seconds will be 5 
     * @return A number representing the total number of seconds in the TimeSpan
     */
    public function get totalSeconds() : Number
    {
        return _totalMilliseconds / MILLISECONDS_IN_SECOND;
    }

    /**
     * Gets the total number of milliseconds.
     * 
     * @example In a TimeSpan created from TimeSpan.fromMilliseconds(2123), 
     *          totalMilliseconds will be 2001, but milliseconds will be 123 
     * @return A number representing the total number of milliseconds in the TimeSpan
     */
    public function get totalMilliseconds() : Number
    {
        return _totalMilliseconds;
    }

    /**
     * Adds the timespan represented by this instance to the date provided and returns a new date object.
     * @param date The date to add the timespan to
     * @return A new Date with the offseted time
     */     
    public function add(date : Date) : Date
    {
        var ret : Date = new Date(date.time);
        ret.milliseconds += totalMilliseconds;

        return ret;
    }

    /**
     * Creates a TimeSpan from the different between two dates
     * 
     * Note that start can be after end, but it will result in negative values. 
     *  
     * @param start The start date of the timespan
     * @param end The end date of the timespan
     * @return A TimeSpan that represents the difference between the dates
     * 
     */     
    public static function fromDates(start : Date, end : Date) : TimeSpan
    {
        return new TimeSpan(end.time - start.time);
    }

    /**
     * Creates a TimeSpan from the specified number of milliseconds
     * @param milliseconds The number of milliseconds in the timespan
     * @return A TimeSpan that represents the specified value
     */     
    public static function fromMilliseconds(milliseconds : Number) : TimeSpan
    {
        return new TimeSpan(milliseconds);
    }

    /**
     * Creates a TimeSpan from the specified number of seconds
     * @param seconds The number of seconds in the timespan
     * @return A TimeSpan that represents the specified value
     */ 
    public static function fromSeconds(seconds : Number) : TimeSpan
    {
        return new TimeSpan(seconds * MILLISECONDS_IN_SECOND);
    }

    /**
     * Creates a TimeSpan from the specified number of minutes
     * @param minutes The number of minutes in the timespan
     * @return A TimeSpan that represents the specified value
     */ 
    public static function fromMinutes(minutes : Number) : TimeSpan
    {
        return new TimeSpan(minutes * MILLISECONDS_IN_MINUTE);
    }

    /**
     * Creates a TimeSpan from the specified number of hours
     * @param hours The number of hours in the timespan
     * @return A TimeSpan that represents the specified value
     */ 
    public static function fromHours(hours : Number) : TimeSpan
    {
        return new TimeSpan(hours * MILLISECONDS_IN_HOUR);
    }

    /**
     * Creates a TimeSpan from the specified number of days
     * @param days The number of days in the timespan
     * @return A TimeSpan that represents the specified value
     */ 
    public static function fromDays(days : Number) : TimeSpan
    {
        return new TimeSpan(days * MILLISECONDS_IN_DAY);
    }

    /**
     * The number of milliseconds in one day
     */ 
    public static const MILLISECONDS_IN_DAY : Number = 86400000;

    /**
     * The number of milliseconds in one hour
     */ 
    public static const MILLISECONDS_IN_HOUR : Number = 3600000;

    /**
     * The number of milliseconds in one minute
     */ 
    public static const MILLISECONDS_IN_MINUTE : Number = 60000;

    /**
     * The number of milliseconds in one second
     */ 
    public static const MILLISECONDS_IN_SECOND : Number = 1000;
}
26
répondu Richard Szalay 2012-01-22 14:27:59

Vous pouvez cacher les deux dates en millisecondes depuis l'époque, effectuer vos calculs et ensuite utiliser les millisecondes résultantes pour calculer ces nombres plus élevés.

var someDate:Date = new Date(...);
var anotherDate:Date = new Date(...);
var millisecondDifference:int = anotherDate.valueOf() - someDate.valueOf();
var seconds:int = millisecondDifference / 1000;
....

LiveDocs sont utiles pour ce genre de chose aussi. Désolé si le code est un peu hors sujet, mais il a été un certain temps.

je recommande également de créer un ensemble de méthodes de classe statique qui peuvent effectuer ces opérations si vous faites beaucoup de ce type de mathématiques. Malheureusement, cette fonctionnalité de base n'existe pas dans les API standard.

20
répondu Russell Myers 2008-10-03 22:59:43

pour certains une seule fonction comme ceci mon être préférable... [condensé du code de Richard Szalay]

public function timeDifference(startTime:Date, endTime:Date) : String
{
if (startTime == null) { return "startTime empty."; }
if (endTime   == null) { return "endTime empty."; }
var aTms = Math.floor(endTime.valueOf() - startTime.valueOf());
return "Time taken:  "  
    + String( int(aTms/(24*60*+60*1000))     ) + " days, "
    + String( int(aTms/(    60*60*1000)) %24 ) + " hours, "
    + String( int(aTms/(       60*1000)) %60 ) + " minutes, "
    + String( int(aTms/(        1*1000)) %60 ) + " seconds.";
}
4
répondu kam 2011-08-09 23:13:36

il n'y a pas de façon automatique de faire cela. Le mieux que vous puissiez faire avec les classes fournies est de récupérer date1.heure et date2.temps, pour donner le nombre de millisecondes depuis le 1er janvier 1970 pour deux nombres. Vous pouvez ensuite calculer le nombre de millisecondes entre eux. Avec quelques mathématiques de base, vous pouvez alors calculer les secondes, les heures, les jours, etc.

1
répondu David Arno 2008-10-03 23:03:37

par souci de précision, le message de Russell ci-dessus est correct jusqu'à ce que vous obteniez une différence de 25 jours, puis le nombre devient trop grand pour la variable int. Déclarez donc la milliseconde différence: nombre;

Il peut y avoir une certaine différence entre le documentée getTime() et valueOf(), mais en effet je ne peux pas le voir

1
répondu 2009-01-18 09:01:07
var timeDiff:Number = endDate - startDate;
var days:Number     = timeDiff / (24*60*60*1000);
var rem:Number      = int(timeDiff % (24*60*60*1000));
var hours:Number    = int(rem / (60*60*1000));
rem                 = int(rem % (60*60*1000));
var minutes:Number  = int(rem / (60*1000));
rem                 = int(rem % (60*1000));
var seconds:Number  = int(rem / 1000);

trace(days + " << >> " +hours+ " << >> " +minutes+ " << >> " +seconds);

ou

var time:Number = targetDate - currentDate;
var secs:Number = time/1000;
var mins:Number = secs/60;  
var hrs:Number  = mins/60;
var days:Number = int(hrs/24);

secs = int(secs % 60);
mins = int(mins % 60);
hrs  = int(hrs % 24);

trace(secs + "  << >> " + mins + " << >> " + hrs + " << >> " + days);
1
répondu kumling 2012-06-09 01:41:41

ArgumentValidation est une autre classe de M. Szalays qui fait quelques vérifications pour s'assurer que chaque méthode a les bonnes valeurs pour effectuer ses tâches sans jeter des erreurs méconnaissables. Ils ne sont pas essentiels pour faire fonctionner la classe TimeSpan afin que vous puissiez les commenter et que la classe fonctionne correctement.

Rich peut afficher la classe de validation des arguments ici aussi bien que c'est très pratique mais je vais laisser cela à lui ;P

0
répondu James Hay 2009-05-22 07:47:58

regardez http://aplikasiflash.blogspot.com/ Il y a DateHelper et MathParser... testé

0
répondu icesflash 2010-03-03 17:10:55

j'ai porté la fonction RoR distance_of_time_in_words sur AS3 et je l'ai ajoutée à la classe TimeSpan. il est disponible sur mon blog http://denisvolokh.blogspot.com/2010/04/distanceoftimeinwords-on-as3.html

0
répondu Denis VOlokh 2010-04-14 04:40:28