Date et heure ConvertSeconds

[Magic_Doctor]

J'en avais besoin, donc je l'ai fait. Mais je pense que l'on peut faire plus simple.

Function ConvertSeconds(sec#) As String
'Converti des desondes en années | jours | heures | minutes | secondes
'Magic_Doctor

    Dim a#, j#, h As Byte, mn As Byte, s As Byte, suf1$, suf2$
    
    j = Int(sec / 86400)
    a = Int(j / 365)
    h = Int((sec - j * 86400) / 3600)
    mn = Int(((sec - j * 86400) / 3600 - h) * 60)
    s = Int((((sec - j * 86400) / 3600 - h) * 60 - mn) * 60)
    j = j - a * 365
    suf1 = IIf(a = 0, "", IIf(a = 1, " an", " ans"))
    suf2 = IIf(j = 0, "", IIf(j = 1, " jour", " jours"))
    
    ConvertSeconds = IIf(a = 0, "", a & suf1 & " ") & IIf(j = 0, "", j & suf2 & " ") & IIf(h < 10, "0", "") & h & ":" & IIf(mn < 10, "0", "") & mn & ":" & IIf(s < 10, "0", "") & s
End Function

 

[Staple1600]

Bonjour le fil, Magic_Doctor

Effectivement , plus simple

 

[Magic_Doctor]

Bonjour Staple1600,

Effectivement, en Format c'est nettement plus simple.
Ce que je voulais, c'est obtenir une chaîne de caractères et, en plus, aller jusqu'aux années. Que peut bien représenter 10^9 secondes, par exemple ?

 

[Magic_Doctor]

Quelques améliorations dans la précision avec, en plus, la possibilité de tenir compte des mois.
Entendons nous bien, quand la durée dépasse celle d'un "mois moyen" (voir dans la fonction), fatalement, n'ayant pas de date de départ, le résultat ne sera qu'une estimation.

Function ConvertSeconds(Nbsec#, Optional m As Boolean = False) As String
'************************************************************************************
'Converti des secondes en années | jours | heures | minutes | secondes ou
'                         années | mois | jours | heures | minutes | secondes
'Magic_Doctor
'************************************************************************************
'- Nbsec : un nombre de secondes
'- m     : si False ou omis --> années | jours | heures | minutes | secondes
'          si True          --> années | mois | jours | heures | minutes | secondes
'************************************************************************************
   
    Dim nbtj#, a%, j%, mois As Byte, h As Byte, mn As Byte, sec As Byte, suf1$, suf2$
   
    nbtj = Nbsec / 86400                   'nombre total de jours
    a = Int(nbtj / 365.25)                 'nombre entier d'années (365,25 = nombre moyen de jours dans une année)
    j = Int((nbtj / 365.25 - a) * 365.25)  'nombre entier de jours dans la fraction d'année
   
    If m = False Then  'on ne tient pas compte des mois
        h = Int(((nbtj / 365.25 - a) * 365.25 - j) * 24)                                                                      'nombre entier d'heures dans la fraction de jour
        mn = Int((((nbtj / 365.25 - a) * 365.25 - j) * 24 - Int(((nbtj / 365.25 - a) * 365.25 - j) * 24)) * 60)               'nombre entier de minutes dans la fraction d'heure
        sec = Int(((((nbtj / 365.25 - a) * 365.25 - j) * 24 - Int(((nbtj / 365.25 - a) * 365.25 - j) * 24)) * 60 - mn) * 60)  'nombre entier de secondes dans la fraction de minute
        suf1 = IIf(a = 0, "", IIf(a = 1, " an", " ans"))
        suf2 = IIf(j = 0, "", IIf(j = 1, " jour", " jours"))
        ConvertSeconds = IIf(a = 0, "", a & suf1 & " ") & IIf(j = 0, "", j & suf2 & " ") & IIf(h < 10, "0", "") & h & ":" & IIf(mn < 10, "0", "") & mn & ":" & IIf(sec < 10, "0", "") & sec
    Else  'on tient compte des mois
        mois = Int(j / 30.47)  'nombre entier de mois (30,47 = nombre moyen de jours dans un mois)
        h = Int(((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j - Int((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j)) * 24)  'nombre entier d'heures dans la fraction de jour
        mn = Int((((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j - Int((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j)) * 24 - h) * 60)  'nombre entier de minutes dans la fraction d'heure
        sec = Int(((((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j - Int((j / 30.47 - Int(j / 30.47)) * 30.47 + (nbtj / 365.25 - a) * 365.25 - j)) * 24 - h) * 60 - mn) * 60)  'nombre entier de secondes dans la fraction de minute
        j = Int((nbtj / 365.25 - a) * 365.25 - j + (j / 30.47 - Int(j / 30.47)) * 30.47)  'nombre entier de jours dans la fraction d'année + la fraction de mois
        suf1 = IIf(a = 0, "", IIf(a = 1, " an", " ans"))
        suf2 = IIf(j = 0, "", IIf(j = 1, " jour", " jours"))
        ConvertSeconds = IIf(a = 0, "", a & suf1 & " ") & IIf(mois = 0, "", mois & " mois ") & IIf(j = 0, "", j & suf2 & " ") & IIf(h < 10, "0", "") & h & ":" & IIf(mn < 10, "0", "") & mn & ":" & IIf(sec < 10, "0", "") & sec
    End If
End Function

 

[patricktoulon]

Bonjour
juste en passant comme ça
avec (x secondes / 86400) on obtient bien le numéro de série d'une date à partir du 01/01/1900 non ????
avec cdate et au format dd/mm/yyyy hh:nn:ss obtenue par cdate

Sub tests()
Sec = 12000000
MsgBox CDate(Sec / 86400)
End Sub

parti de là on peut très bien et surtout !!!très simplement disséquer la date et de faire la soustraction de l'année de la date obtenue à 1900 pour avoir le nombre d'année le reste c'est les éléments de la date tout simplement

je ne suis pas sur qu'il y est besoins de tout ses calculs
je dis ça moi je dis rien
@+

 

[Magic_Doctor]

Re,

Welcome in the "passade"!
Ce que je voulais, c'est obtenir une chaîne qui me renvoie, suivant une quantité de secondes, le nombre d'années, mois, jours, heures, minutes & secondes correspondants.
Ton truc me renvoie une date bizarre et une heure bizarre . Rien à voir avec ma fonction. Il faut bien lire à quoi est destinée la fonction dans son intro.
Entre temps, j'ai revu cette fonction. Maintenant elle semble marcher correctement.

Exemple :
1.000.000.000 secondes correspondent à (suivant l'option choisie dans le paramétrage de la fonction) :
- 11574 jours 01:46:40
- 31 ans 251 jours 07:46:40
- 31 ans 8 mois 7 jours 19:46:40

En somme, on dépasse rarement les 3 * 10^9 sec dans une existence.
Qui l'eût cru ?

Version explicite :

Function ConvertSeconds(Nbsec#, Optional chx As Byte = 1) As String
'************************************************************************************
'Converti des secondes en jours | heures | minutes | secondes ou
'                         années | jours | heures | minutes | secondes ou
'                         années | mois | jours | heures | minutes | secondes
'Magic_Doctor
'************************************************************************************
'- Nbsec : un nombre de secondes
'- chx   : si 1 ou omis --> jours | heures | minutes | secondes
'          si 2         --> années | jours | heures | minutes | secondes
'          si 3         --> années | mois | jours | heures | minutes | secondes
'************************************************************************************

    Dim tj#, A%, M As Byte, J#, H As Byte, Mn As Byte, sec As Byte
    Dim sufAns$, sufJours$, ta#, fa#, jfa#, tm#, fm#, jfm#, fj#, sfj#, hfj#, fh#, mfh#
 
    tj = Nbsec / 86400         'nombre (décimal) total de jours (secondes converties en jours)
    ta = tj / 365.25           'nombre (décimal) total d'années (365,25 = nombre moyen de jours dans une année)
    A = Int(ta)                'nombre entier d'années
    fa = ta - A                'fraction d'année
    jfa = fa * 365.25          'nombre (décimal) de jours dans la fraction d'année
 
    If chx = 1 Then            'jours | heures | minutes | secondes
        J = Int(tj)            'nombre entier de jours dans Nbsec
        fj = tj - J            'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(Int(tj) = 0, "", Int(tj) & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    ElseIf chx = 2 Then        'années | jours | heures | minutes | secondes
        J = Int(jfa)           'nombre entier de jours dans la fraction d'année
        fj = jfa - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    Else                       'années | mois | jours | heures | minutes | secondes
        tm = jfa / 30.4375     'nombre (décimal) total de mois (30,4375 = nombre moyen de mois dans une année)
        M = Int(tm)            'nombre entier de mois
        fm = tm - M            'fraction de mois
        jfm = fm * 30.4375     'nombre de jours dans la fraction de mois
        J = Int(jfm)           'nombre entier de jours dans la fraction de mois
        fj = jfm - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(M = 0, "", M & " mois ") & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    End If
End Function

Même version plus concise, mais schizophrénique :

Function ConvertSeconds(Nbsec#, Optional chx As Byte = 1) As String
'************************************************************************************
'Converti des secondes en jours | heures | minutes | secondes ou
'                         années | jours | heures | minutes | secondes ou
'                         années | mois | jours | heures | minutes | secondes
'Magic_Doctor
'************************************************************************************
'- Nbsec : un nombre de secondes
'- chx   : si 1 ou omis --> jours | heures | minutes | secondes
'          si 2         --> années | jours | heures | minutes | secondes
'          si 3         --> années | mois | jours | heures | minutes | secondes
'************************************************************************************

    Dim A%, M As Byte, J#, H As Byte, Mn As Byte, sec As Byte, sufAns$, sufJours$
 
    A = Int(Nbsec / 86400 / 365.25)
 
    If chx = 1 Then
        J = Int(Nbsec / 86400)
        H = Int((Nbsec / 86400 - J) * 24)
        Mn = Int(((Nbsec / 86400 - J) * 24 - H) * 60)
        sec = ((((Nbsec / 86400 / 365.25 - A) * 365.25 - J) * 24 - H) * 60 - Mn) * 60
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(Int(Nbsec / 86400) = 0, "", Int(Nbsec / 86400) & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    ElseIf chx = 2 Then
        J = Int((Nbsec / 86400 / 365.25 - A) * 365.25)
        H = Int(((Nbsec / 86400 / 365.25 - A) * 365.25 - J) * 24)
        Mn = Int((((Nbsec / 86400 / 365.25 - A) * 365.25 - J) * 24 - H) * 60)
        sec = ((((Nbsec / 86400 / 365.25 - A) * 365.25 - J) * 24 - H) * 60 - Mn) * 60
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    Else
        M = Int((Nbsec / 86400 / 365.25 - A) * 365.25 / 30.4375)
        J = Int(((Nbsec / 86400 / 365.25 - A) * 365.25 / 30.4375 - M) * 30.4375)
        H = Int((((Nbsec / 86400 / 365.25 - A) * 365.25 / 30.4375 - M) * 30.4375 - J) * 86400 / 3600)
        Mn = Int(((((Nbsec / 86400 / 365.25 - A) * 365.25 / 30.4375 - M) * 30.4375 - J) * 86400 / 3600 - H) * 60)
        sec = (((((Nbsec / 86400 / 365.25 - A) * 365.25 / 30.4375 - M) * 30.4375 - J) * 86400 / 3600 - H) * 60 - Mn) * 60
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(M = 0, "", M & " mois ") & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    End If
End Function

 

[patricktoulon]

re
Bonjour @Magic_Doctor
désolé d'insister mais on a pas le même résultat
je commence par ta fonction
ou j'ai ajouté un simple debug.print d'un cdate (tj)
et la date parle d'elle même donc le résultat est faux

Sub testMAGICD()
    Debug.Print ConvertSeconds(3 * 10 ^ 9, 0)
End Sub

Function ConvertSeconds(Nbsec#, Optional chx As Byte = 1) As String
'************************************************************************************
'Converti des secondes en jours | heures | minutes | secondes ou
'                         années | jours | heures | minutes | secondes ou
'                         années | mois | jours | heures | minutes | secondes
'Magic_Doctor
'************************************************************************************
'- Nbsec : un nombre de secondes
'- chx   : si 1 ou omis --> jours | heures | minutes | secondes
'          si 2         --> années | jours | heures | minutes | secondes
'          si 3         --> années | mois | jours | heures | minutes | secondes
'************************************************************************************

    Dim tj#, A%, M As Byte, J#, H As Byte, Mn As Byte, sec As Byte
    Dim sufAns$, sufJours$, ta#, fa#, jfa#, tm#, fm#, jfm#, fj#, sfj#, hfj#, fh#, mfh#

    tj = Nbsec / 86400         'nombre (décimal) total de jours (secondes converties en jours)
    '----------------------------------
    '----------------------------------
    Debug.Print CDate(tj)
    '----------------------------------
    '----------------------------------

    ta = tj / 365.25           'nombre (décimal) total d'années (365,25 = nombre moyen de jours dans une année)
    A = Int(ta)                'nombre entier d'années
    fa = ta - A                'fraction d'année
    jfa = fa * 365.25          'nombre (décimal) de jours dans la fraction d'année

    If chx = 1 Then            'jours | heures | minutes | secondes
        J = Int(tj)            'nombre entier de jours dans Nbsec
        fj = tj - J            'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(Int(tj) = 0, "", Int(tj) & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    ElseIf chx = 2 Then        'années | jours | heures | minutes | secondes
        J = Int(jfa)           'nombre entier de jours dans la fraction d'année
        fj = jfa - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    Else                       'années | mois | jours | heures | minutes | secondes
        tm = jfa / 30.4375     'nombre (décimal) total de mois (30,4375 = nombre moyen de mois dans une année)
        M = Int(tm)            'nombre entier de mois
        fm = tm - M            'fraction de mois
        jfm = fm * 30.4375     'nombre de jours dans la fraction de mois
        J = Int(jfm)           'nombre entier de jours dans la fraction de mois
        fj = jfm - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
        sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
        ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(M = 0, "", M & " mois ") & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
    End If
End Function

le résultat de ta fonction
il est clair que c'est pas bon

ma méthode maintenant

Sub tests()
    Debug.Print ConvertSecondsPatricktoulon(3 * 10 ^ 9)
End Sub


Function ConvertSecondsPatricktoulon(Nbsec#, Optional chx As Byte = 1) As String
Dim res, d, secondes, minutes, jours, heure, mois, an, ss, ms, hs, ass

    res = Format(CDate(Nbsec / 86400) + 2, "dd/mm/yyyy hh:nn:ss")
    d = CDate(res)
    secondes = Second(d): ss = IIf(secondes > 1, "s", "")
    minutes = Minute(d): ms = IIf(minutes > 1, "s", "")
    heure = Hour(d): hs = IIf(heure > 1, "s", "")
    jours = Day(d) - 1: jours = IIf(jours = 1, 0, jours): js = IIf(jours >= 2, "s", "")
    mois = Month(d) - 1
    an = Year(d) - 1900: ass = IIf(an > 1, "s", "")
   '----------------------------------
    '----------------------------------
    Debug.Print d
    '----------------------------------
    '----------------------------------
   ConvertSecondsPatricktoulon = an & " an" & ass & " " & mois & " mois " & jours & " jour" & js & " " & heure & " heure" & hs & " " & minutes & " minute" & ms & " " & secondes & " seconde" & ss
End Function

le résultat du mien

et pour t'en donner la preuve fait le chemin a l'envers

Sub test()
Debug.Print CDate("01/01/1900") + CLng(CDate("01/01/1900")) + ((3 * 10 ^ 9) / 86400)
End Sub

 

[patricktoulon]

re
je viens de me rendre compte que dans ton enoncé meme tu est dans l'erreur
je te cite

Exemple :
1.000.000.000 secondes correspondent à (suivant l'option choisie dans le paramétrage de la fonction) :
- 11574 jours 01:46:40
- 31 ans 251 jours 07:46:40
- 31 ans 8 mois 7 jours 19:46:40

donc pour toi
31 ans 251 jours 07:46:40 et 31 ans 8 mois 7 jours 19:46:40 c'est la même chose?????

heu.....

je te laisse analyser ceci :

Sub truc()
Debug.Print Format(CDate("01/01/1900"), "dd/mm/yyyy hh:nn:ss")
Debug.Print "on est bien là  le 01/01/1900 a 00:00:00:du matin "
Debug.Print "je rajoute maintenant  251 jours"
Debug.Print "on arrive donc au " & CDate("01/01/1900 07:46:40") - 2 + 251
Debug.Print "ça fait bien 0 an  8 mois révolus et 6 jour et 07:46:40 du 9 eme mois "
Debug.Print "voyons voir maintenant si  le chemin inverse nous donne bien le <<01/01/1900 07:46:40>>"
Debug.Print "CDate(""07/09/1900 07:46:40"") + 2 - 251 est egal à " & CDate("07/09/1900 07:46:40") + 2 - 251
End Sub

résultat

 

[Magic_Doctor]

Bonjour patricktoulon,

Au départ, j’ai rédigé cette fonction pour résoudre un problème fort simple. Je veux lister, dans un dossier, tous les fichiers Audio/Vidéo s’y trouvant et faire la somme de la durée de l’ensemble de ces fichiers. Le résultat étant en secondes, on le convertit en heures:minutes:secondes. S’il y a beaucoup de fichiers, on passe fatalement à des jours: heures:minutes:secondes. Je me suis dit que pendant qu’on y était pourquoi ne pas pousser la fonction plus loin en allant jusqu’aux années:jours:heures:minutes:secondes et, dans un esprit jeune, pop et Rock ‘N’ Roll, oser années:mois:jours:heures:minutes:secondes.
Tant qu’on en reste aux jours, le résultat sera toujours juste. En revanche, si l’on veut des années et mois, ce sera forcément à la louche. Mais on s’approche quand même de la vérité. Du reste, dans le post #4 je précise bien ce fait. Pour avoir un nombre d’années et de mois exacts, il faudrait avoir une date de départ, or ce n’est pas le but de la fonction. Son but est, ni plus ni moins, de savoir grosso modo ce que représente x secondes.
La limite de la fonction me semble être 10^12 secondes (1 billion de secondes), soit 31688 ans 1 mois 1 jour 15:16:40, ce qui est déjà pas mal temporellement parlant. Peut-être qu’on peut l’améliorer pour que ça aille plus loin, mais pour ce que je voulais au départ, ce sera largement suffisant.
En somme, au-delà des jours, ce n’est plus de la précision suisse mais une estimation très proche de la réalité.

Enfin, tu dis :

donc pour toi
31 ans 251 jours 07:46:40 et 31 ans 8 mois 7 jours 19:46:40 c'est la même chose?????

heu.....

Comme, dans la fonction, les mois ont 30,4375 jours (il s'agit d'une moyenne), bien évidemment les résultats ne concorderont pas. Une chose est certaine, c'est que 251 jours ça représente environ 8 mois.

 

[patricktoulon]

re
si tu utilise les fonctions date en vba tu aura l'exact et non une approximation
avec ton calcul tu a plus d'une journée et demie en moins de 6 mois quand on va plus loin tu a plusieurs jours

 

[Magic_Doctor]

Re,

Je viens de regarder ta fonction et l'ai comparée avec la mienne.
Ta fonction repose sur une date de départ, en l'occurrence le 01/01/1900, et renvoie donc un résultat exact. C'est un point de vue. Il serait intéressant que tu mettes dans le paramétrage de la fonction une date de départ (bien sûr, postérieure ou égale au 01/01/1900, sinon Excel risque d'avoir des problèmes) mais aussi que tu tiennes compte des chx ; manifestement tu ne tiens compte que du 3ème choix (années mois jours heure minutes secondes). En mettant en paramètre une date de départ, fatalement le résultat sera différent chaque fois que choisiras une nouvelle date de départ.
Ma fonction, elle, renvoie un résultat qui ne dépend d'aucune date de départ, raison pour laquelle les années sont des années moyennes (365,25 jours) et les mois des mois moyens (30,4375 jours).

J'ai fait une petite correction dans ma fonction qui affichait une erreur quand on décidait de n'avoir que les jours (chx = 1).

Function ConvertSeconds(Nbsec#, Optional chx As Byte = 1) As String
'************************************************************************************
'Converti des secondes en jours | heures | minutes | secondes ou
'                         années | jours | heures | minutes | secondes ou
'                         années | mois | jours | heures | minutes | secondes
'Magic_Doctor
'************************************************************************************
'- Nbsec : un nombre de secondes
'- chx   : si 1 ou omis --> jours | heures | minutes | secondes
'          si 2         --> années | jours | heures | minutes | secondes
'          si 3         --> années | mois | jours | heures | minutes | secondes
'************************************************************************************

    Dim tj#, A%, M As Byte, J#, H As Byte, Mn As Byte, sec As Byte
    Dim sufAns$, sufJours$, ta#, fa#, jfa#, tm#, fm#, jfm#, fj#, sfj#, hfj#, fh#, mfh#
 
    tj = Nbsec / 86400         'nombre (décimal) total de jours (secondes converties en jours)
    ta = tj / 365.25           'nombre (décimal) total d'années (365,25 = nombre moyen de jours dans une année)
    A = Int(ta)                'nombre entier d'années
    fa = ta - A                'fraction d'année
    jfa = fa * 365.25          'nombre (décimal) de jours dans la fraction d'année
 
    If chx = 1 Then            'jours | heures | minutes | secondes
        A = 0
        J = Int(tj)            'nombre entier de jours dans Nbsec
        fj = tj - J            'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
    ElseIf chx = 2 Then        'années | jours | heures | minutes | secondes
        J = Int(jfa)           'nombre entier de jours dans la fraction d'année
        fj = jfa - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
    Else                       'années | mois | jours | heures | minutes | secondes
        tm = jfa / 30.4375     'nombre (décimal) total de mois (30,4375 = nombre moyen de mois dans une année)
        M = Int(tm)            'nombre entier de mois
        fm = tm - M            'fraction de mois
        jfm = fm * 30.4375     'nombre de jours dans la fraction de mois
        J = Int(jfm)           'nombre entier de jours dans la fraction de mois
        fj = jfm - J           'fraction de jour
        sfj = fj * 86400       'nombre de secondes dans la fraction de jour
        hfj = sfj / 3600       'nombre (décimal) d'heures dans la fraction de jour
        H = Int(hfj)           'nombre entier d'heures dans la fraction de jour
        fh = hfj - H           'fraction d'heure
        mfh = fh * 60          'nombre (décimal) de minutes dans la fraction d'heure
        Mn = Int(mfh)          'nombre entier de minutes dans la fraction d'heure
        sec = (mfh - Mn) * 60  'nombre de secondes dans la fraction de minute
        sufAns = IIf(A = 0, "", IIf(A = 1, " an ", " ans "))
    End If
    sufJours = IIf(J = 0, "", IIf(J = 1, " jour ", " jours "))
    ConvertSeconds = IIf(A = 0, "", A & sufAns) & IIf(M = 0, "", M & " mois ") & IIf(J = 0, "", J & sufJours) & IIf(H < 10, "0", "") & H & ":" & IIf(Mn < 10, "0", "") & Mn & ":" & IIf(sec < 10, "0", "") & sec
End Function

Avec ma fonction le résultat ne sera toujours exact qu'avec les jours (chx = 1).
Dans les 2 fonctions les années semblent concorder. La discordance, c'est pour les mois, ce qui est logique, une fonction imposant une date de départ et l'autre aucune date. Mais dans le fond, ça n'a absolument aucune importance. Enfin, ma fonction arrive jusqu'au billion de secondes, la tienne non. Mais là aussi ça n'a aucune importance : 1 billion de secondes, soit plus de 31688 ans... On sera tous morts d'ici là !

 

[patricktoulon]

re
tu n'a pas compris mes remarques visiblement
je ne remet pas en cause l’utilité ou les choix possible de ta fonction
ce que je remet en cause (et pour cause!!!) c'est que tes calculs sont faux
je répète donc
fait le avec le fonctions date a partir de 01/01/1900 et choisi après le format de sorti que tu veux
avec mon principe tu a
le nombre d'année
le nombre de mois
le nombre de jour
le nombre d'heures
de minute et de secondes
et pour chaque unité c'est révolu!!!

libre après a toi de le présenter sous la forme que tu veux
c'est simple,propre

je suis parti de ta base en fait (pour que tu comprenne mon point de vue )

avec d= cdate( (x secondes /86400))+2


on obtient tout simplement le numéro de série d'une date + time depuis 01/01/1900 00:00:00
c'est simple le reste non ?????? et au moins c'est exact

pourquoi va tu chercher avec des diviseurs qui sont des moyennes approximatives !!??? tu n'en a pas besoins


je reprends ton exemple
1000000000 de secondes

parti de la rien de plus facile de dire combien d'année /mois/jours etc.....
et cela avec exactitude
et on est loin de ton exemple que je cite d'ailleurs

- 11574 jours 01:46:40 faux !!!!
- 31 ans 251 jours 07:46:40 faux!!!!
- 31 ans 8 mois 7 jours 19:46:40 faux!!!

le msgbox parle de lui même

d'ailleurs dans mes démos précédentes je fait l’opération inverse
et on retombe bien au 01/01/1900 00:00:00

après tu fait comme tu veux mais je pense que quand on propose une fonction perso ou une resource vaut mieux s'assurer que les résultats obtenus soient exats
je te fait confiance pour méditer sur ce point

 

[Magic_Doctor]

OK !
Ton principe est le meilleur et, comme dab, ta vision des choses unique et définitive.

Buenas noches.

 

[patricktoulon]

re
non je te dis seulement que ton calcul est faux c'est tout
il y a une ou plusieurs données qui ne sont pas bonne

comment peux tu te satisfaire en disant que ceci

- 11574 jours 01:46:40
- 31 ans 251 jours 07:46:40
- 31 ans 8 mois 7 jours 19:46:40

c'est la même chose exprimé différemment ???
c'est faux bien sur
et il n'y a pas besoins de méthode pour le comprendre

 

[TooFatBoy]

Bonjour,

Je ne sais pas si ma macro fait exactement le même travail que celle du Doc (j'ai pas tout compris aux variables du genre fjg, dhe, sope, zux, fo, paz et autres tydu ), mais elle trouve exactement les mêmes résultats.

​

Sub test2()
'
'    1 minute = 60 secondes
'    1 heure = 60 * 60 = 3 600 secondes
'    1 jour = 3600 * 24 = 86 400 secondes
'    1 an = 365,25 jours = 365,25 * 86 400 = 31 557 600 secondes
'    1 mois = 1 an / 12 = 31 557 600 / 12 = 2 629 800 secondes
Dim DureeEnSecondes As Double, Reste As Double
Dim Nb_Annees As Double, Nb_Mois As Byte, Nb_Jours As Double
Dim Nb_Heures As Byte, Nb_Minutes As Byte, Nb_Secondes As Byte

Choix = 3

    DureeEnSecondes = 1000000000

    Reste = DureeEnSecondes
    If Choix > 1 Then Nb_Annees = Int(Reste / 31557600): Reste = Reste Mod 31557600: Msg = Nb_Annees & " an(s)   "
    If Choix = 3 Then Nb_Mois = Int(Reste / 2629800): Reste = Reste Mod 2629800: Msg = Msg & Nb_Mois & " mois   "
    Nb_Jours = Int(Reste / 86400): Reste = Reste Mod 86400
    Nb_Heures = Int(Reste / 3600): Reste = Reste Mod 3600
    Nb_Minutes = Int(Reste / 60)
    Nb_Secondes = Reste Mod 60
    Msg = Choix & "-   " & Msg & Nb_Jours & " jour(s)   " & Nb_Heures & " heure(s)   " & Nb_Minutes & " minute(s)   " & Nb_Secondes & " seconde(s)"

    MaReponse = MsgBox(Msg, vbOKOnly, Format(DureeEnSecondes, "### ### ### ##0") & " secondes")

End Sub