La réponse expéditive serait : parce qu'il est fait pour cela et donc il est le mieux adapté !

En fait, il y a souvent confusion entre les données réellement stockées dans la base et le format d'affichage.
Pour simplifier, sachez que l'on stocke les données horaires (dates, heures, durées) dans des champs de type Date/Heure, mais que l'on affiche des chaînes de caractères (String).

Dans une application, quelquefois vous afficherez mardi 26 août 2003 et d'autres fois 26/08/03... Tous les formatages sont possibles. Mais du moment que l'on distingue correctement les notions de stockage et d'affichage, l'utilisation de plusieurs formats d'affichage n'empêche pas de stocker l'information suivant un seul et même principe : celui du type Date/Heure.

Utiliser un champ de type Date/Heure plutôt qu'un ou plusieurs champs texte ou numérique pour stocker vos données horaires rend votre système de données plus cohérent, plus performant et plus souple à maintenir.

En effet, les données de type Date étant en interne des valeurs numériques de type Réel double mais le type Date étant lui-même reconnu par Visual Basic, vous disposez de nombreuses fonctions permettant d'automatiser et réaliser vos traitements précis des données horaires (formatage, extraction d'une partie de la date, addition/soustraction de durées...).

Une date est en fait une valeur décimale en nombre de jours depuis le samedi 30 décembre 1899 à 00:00. Pour le vérifier, exécutez le code suivant :

MsgBox CDbl(#12/30/1899#)

Remarque : les durées constituent un cas un peu spécifique et peuvent ne pas être stockées dans un champ Date.

Par défaut MS Access formate les champs date/heure comme des dates et non comme des durées. Lorsque les valeurs sont supérieures à 24 heures on est obligé de passer par des fonctions car, contrairement à Excel, ce format n'existe pas dans MS Access.

Lorsqu'on utilise un champ de type date formaté pour afficher les heures, en fait MS Access ne donne pas le nombre d'heures au total mais il extrait de la date l'heure qui lui correspond.

MsgBox Format(Now,"hh:nn:ss")   '  Affiche l'heure courante dans une boîte de dialogue

Voici deux fonctions qui renvoient une chaîne de caractères. Elles ne doivent donc être utilisées que pour l'affichage.
Celle-ci renvoie la durée sous la forme Jour J Heures:minutes:secondes

Function JourHeure(dtm As Date) As String 
    JourHeure = "" 
    If CDbl(dtm) > 1 Then  
         ' On calcule le  nombre de jours
        JourHeure = CInt(dtm - 0.5) & " J " 
    End If 
    ' On ajoute les heures, minutes et secondes
    JourHeure = JourHeure & Format(dtm,"hh:nn:ss")
End Function

Tandis que celle-là renvoie la durée sous la forme Heures:minutes:secondes

Function HeureSup24(dtm As Date) As String
    ' Calcule le nombre d'heures
    HeureSup24 = DateDiff("h", 0, dtm)
    ' On ajoute les minutes et les secondes
    HeureSup24 = HeureSup24 & Format(dtm, ":nn:ss")
End Function

Comment stocker et gérer les informations relatives aux durées ?

MS Access gère les données des champs Date/Heure comme des dates et non comme des durées. Il n'existe pas, comme dans Excel, de type ou de format pour les durées.

Faut-il utiliser le type Date ou bien faut-il préférer un type Entier numérique pour stocker des durées ?

Pour savoir comment déterminer notre choix, détaillons nos besoins.

Une durée peut être exprimée en une ou plusieurs unités dont les plus utilisées sont :

• Centième
• Seconde
• Minute
• Heure
• Jour
• Semaine
• Mois
• Année

NOTE : une durée en mois ou en années est subjective, tout dépend de la convention prise. Par exemple en comptabilité, on définit : 1 Mois = 30 jours, une année = 360 jours. Donc dire que deux dates sont séparées d'un mois tout juste n'est pas vraiment exact.

De nombreuses combinaisons sont possibles pour représenter précisément une durée. Lorsqu'une durée est représentée à travers plusieurs unités, la plus grande de celles-ci peut ne pas avoir de limite dans sa valeur. Mais ce n'est pas le cas des unités inférieures qui, passées une certaine valeur, incrémentent l'unité immédiatement supérieure et reviennent à zéro.
Ces rappels élémentaires sont nécessaires pour bien comprendre comment utiliser le type Date/Heure afin de stocker des durées.

En effet, les formats de champs Date/Heure qu'autorise Access ne vous laisseront combiner que trois unités au maximum: Heure, Minute et Seconde.
En outre, chaque unité possède une limite de valeur qu'elle ne peut dépasser ; comme nous le savons tous : 23 pour les heures, 59 pour les minutes et les secondes.

Ce sont les deux limites qu'impose Access pour le formatage des heures. Et ces limites sont bien compréhensibles puisque les formats sont prévus pour être appliqués à des heures et non à des durées.

En conclusion, le type Date/Heure est pratique et "transparent" tant que vous ne devez pas sortir de ces limites.

Dans le cas contraire, l'utilisation de ce type revient à coder la durée sur un nombre décimal :
- la partie entière représentera le nombre de jours complètement écoulés depuis une date référence, fixée arbitrairement au 30/12/1899 ;
- la partie décimale représentera, le cas échéant, la fraction écoulée du dernier jour s'il n'est pas complètement écoulé.

Pour gérer des durées aux formats "sans limites", il est souvent plus pratique de recourir à un champ de type entier numérique.
Ce champ correspondra tout simplement à l'unité la plus petite nécessaire à vos formats d'affichage. Généralement, le type Long est suffisant.

Ceci dit, que vous ayez choisi de stocker vos données sous un type numérique entier ou sous le type Date/Heure, dès lors que les formats d'heure autorisés par Access pour les champs de type Date/Heure ne vous conviennent pas, vous serez obligés de développer vos propres fonctions pour afficher vos durées dans la/les unité(s) voulues.

Voici donc quelques exemples de telles fonctions.
Attention : ces fonctions renvoient une chaîne de caractères, elles ne doivent donc être utilisées que pour l'affichage.

Stockage des durées dans un champ de type Date/Heure.

Renvoyer la durée sous la forme Jour J Heures:minutes:secondes
Ici, l'unité des jours n'a pas de limite de valeur et les jours sont comptés à partir du 30/12/1899. (cf. lien en bas)

Function JourHeure(dtm As Date) As String
    JourHeure = ""
    If CDbl(dtm) > 1 Then 
         ' On calcule le  nombre de jours
JourHeure = CInt(dtm - 0.5) & " J "
    End If
    ' On ajoute les heures, minutes et secondes
    JourHeure = JourHeure & Format(dtm,"hh:nn:ss")
End Function

Renvoyer la durée sous la forme Heures:minutes:secondes
Ici, l'unité des heures n'a pas de limite de valeur et les heures sont comptées à partir du 30/12/1899. (cf. lien en bas)

Function HeureSup24(dtm As Date) As String
    ' Calcule le nombre d'heures
    HeureSup24 = DateDiff("h", 0, dtm)
    ' On ajoute les minutes et les secondes
    HeureSup24 = HeureSup24 &  Format(dtm, ":nn:ss")
End Function

À vous ensuite d'adapter ces fonctions à vos besoins exacts.

' Cette fonction vous renvoie la date du dernier jour du mois :</paragraph>
Function LastDayOfMonth(ByVal LaDate As Date) As Date
    LastDayOfMonth = CDate(DateSerial(Year(LaDate), Month(LaDate) + 1, 0))
End Function

Pour obtenir des informations plus précises, comme par exemple le nom ou le numéro du dernier jour, vous pouvez vous contenter d'utiliser cette partie de code :

DateSerial(Year(LaDate), Month(LaDate) + 1, 0)

comme argument Date d'une fonction Day() ou DatePart()...
Par exemple, ceci vous donnera uniquement le numéro du jour :

Dim derJour As Integer
LaDate = Date
derJour = Day(DateSerial(Year(LaDate), Month(LaDate) + 1, 0))
MsgBox derJour

Requête SQL
- Access et le moteur Jet utilisent toujours la notation US (format "mm/dd/yyyy") en interne, pour les calculs et opérations.
- Access traduit ces dates au format indiqué dans le panneau de contrôle Windows, uniquement dans l'interface QBE (Query By Example = création de requêtes, dans le mode Création).
Pour illustrer cela, pendant la création d'une requête :
- saisir "=#09/11/2004#" comme Critère, sous n'importe quel champ date d'une requête en mode création,
- passer en mode SQL : le texte contient "= #11/09/2004#", mode US, pour exécution de la requête par le moteur Jet.

Calculs VBA
N'utiliser que le format US, le seul que les fonctions de date peuvent interpréter.

Contrôles de formulaires : comme l'interface QBE pour les requêtes, Access affiche par défaut les dates au format défini dans le panneau de contrôle de Windows.
Pour nous, format français "dd/mm/yyyy".
La propriété Format du contrôle n'a aucune influence sur la valeur qui sera stockée dans les tables (voir ci-dessous : c'est un nombre Double qui est stocké). Donc, vous pouvez mettre n'importe quel format dans un contrôle, y compris le format japonais ("yyyy/mm/dd", très utilisé pour les tris alphabétiques).

Dernière règle : lors d'une saisie dans l'interface QBE, directement dans un champ de table, de requête ou dans un contrôle :
- il y a systématiquement interprétation/inversion des jours/mois, comme ci-dessus, si les deux chiffres sont <= 12 ;
- si l'un des deux est > 12, c'est obligatoirement un jour. Ça ne peut pas être un n° de mois.

Pour calculer la différence entre deux dates, il faut utiliser la fonction DateDiff.

DateDiff(interval, date1, date2)

Où interval est une chaîne de caractères correspondant à l'intervalle à prendre en compte.

• yyyy Année
• m Mois
• d Jour
• h Heure
• n Minute
• s Seconde
• q Trimestre
• w Semaine

DateDiff("s", #1/1/1990#, #1/1/1992#)

Première possibilité :

Function CalculAge(ByVal Dat1 As Date, ByVal Dat2 As Date) As Integer
If Month(Dat2) > Month(Dat1) Then
    CalculAge = DateDiff("yyyy", Dat1, Dat2)
ElseIf Month(Dat2) = Month(Dat1) Then
    If Day(Dat2) >= Day(Dat1) Then
        CalculAge = DateDiff("yyyy", Dat1, Dat2)
    Else
        CalculAge = DateDiff("yyyy", Dat1, Dat2) - 1
    End If
Else
    CalculAge = DateDiff("yyyy", Dat1, Dat2) - 1
End If
End Function

Seconde possibilité :

Function CalculAge2(dateNaissance As Date, Optional dateReference As Date)
If dateReference = 0 Then dateReference = Date
CalculAge2 = Year(dateReference) - Year(dateNaissance) + _
(Format(dateNaissance, "mmdd") > Format(dateReference, "mmdd"))
End Function

Le paramètre dateReference est optionnel. Ainsi, s'il n'est pas précisé, ce sera la date du système qui sera utilisée.

Exemples :
Âge aujourd'hui

MsgBox CalculAge2(#06/22/1983#)

Âge le 15 novembre 2005

MsgBox CalculAge2(#06/22/1983#,#11/15/2005#)

Voici le code VBA pour ajouter trois mois à la date :

DateAdd("m", 3, #05/20/2003#)

Ajouter trois jours :

DateAdd("d", 3, #05/20/2003#)

Ajouter trois années :

DateAdd("yyyy", 3, #05/20/2003#)

ATTENTION : la date doit être au format : mm/jj/aaaa.

Il faut aller dans les paramètres régionaux de Windows et changer le format de son choix.

Pour exécuter ce code, il faut activer la référence : Microsoft DAO 3.x Object Library.

À savoir : Access ne stocke en dur qu'un nombre entier long (le nombre de jours écoulés depuis le 30 décembre 1899). La date que vous voyez apparaître dans votre table est une valeur numérique, formatée avec les spécifications que vous avez données dans la définition de votre champ.
La conversion implicite que fait Access sur les dates est source d'erreurs.
Le plus simple reste d'insérer dans le champ table une valeur numérique de type double :

Dim madate As Date, monRs As DAO.Recordset 

madate = Date 
DoCmd.RunSQL "Insert into table1 (ladate) values(" & CDbl(madate) & ")"

ou

Dim madate As Date, monRs As DAO.Recordset 

madate = Date 
Set monRs = Application.CurrentDb.OpenRecordset("select * from table1") 
monRs.AddNew 
monRs.Fields("ladate").Value = CDbl(madate) 
monRs.Update

Vous avez un champ ou simplement une valeur contenant un nombre de secondes, et vous souhaitez changer son format.

Exemple pour 32 295 secondes :

Solution 1 : il faut diviser 32 295 par 3600 et garder la partie entière : 8. Nous avons le nombre d'heures. Ensuite il faut calculer le reste de : 32295 - 3600 * 8 = 3495 Il reste donc 3495 secondes. Pour avoir les minutes, c'est comme pour les heures, sauf que l'on divise par 60 : 3495/60 => 58 Puis : 3495 - 58 * 60 => 15 Donc le résultat est 8:58:15

Solution 2 : TimeSerial(0,0,32295) -> 08:58:15 ATTENTION ! Le nombre de secondes doit être inférieur à 32 768.

Il faut utiliser DatePart() :

PartDate("T",[LeChampDate])

Le premier argument donne l'intervalle voulu. En voici la liste :

Quelques calculs simples permettent ensuite d'obtenir ceux qui manquent.

Par exemple, pour avoir le premier semestre, il faut les deux premiers trimestres.

Il faut donc écrire :

Semestre = (PartDate("T",[LeChampDate])+1)\2

En dehors des fonctions Year(), Month(), Day(), Hour(), Minute(), Second() qui renvoient une partie de la date ou de l'heure, le moyen le plus simple est de considérer que les dates sont enregistrées dans la base sous la forme d'un nombre réel double (8 octets). Dans l'aide Access, voir le type de données Date.

La partie entière donne la date, la partie décimale donne l'heure.

Appuyez sur [Alt+F11] -> environnement VBA, puis [Ctrl-G] pour utiliser la fenêtre Exécution, et testez les commandes suivantes :

? now
07/04/2004 12:04:38 

' Date seule, SANS les heures, minutes et secondes.
? int(Now) 
07/04/2004 

' Juste pour rire, la même avec les fonctions de date !!!
? DateSerial(Year(Now), Month(Now), Day(Now))
07/04/2004 

' Heures, minutes et secondes seules, SANS la date. Affichage décimal.
? now - int(now) 
0,50459490740468 

' Idem, en renvoyant une date, pour l'affichage
? cdate(now - int(now)) 
12:05:57
? format(now - int(now), "hh:mm:ss"
12:06:08

Il faut un cDate() ou un Format() pour afficher l'heure correctement parce que l'opération de soustraction renvoie un nombre réel double. La soustraction "perd" la notion de date/heure.

Dans une procédure, vous pouvez déclarer une variable Date. Vous n'aurez pas besoin de convertir avec cDate(). Si DateHeure est une variable, un paramètre ou la valeur d'un contrôle de type Date :

Dim HeureSeule As Date    
     [...]    
     HeureSeule = DateHeure - int(DateHeure)

Noter que, dans une table ou un calcul, il n'y a aucune différence entre 0,50459490740468 et 12:05:57. C'est juste une question d'affichage (F1 sur la fonction Format(), le type de données Date, la fonction cDate()).

La différence entre deux dates indique le nombre de jours. La partie décimale indique une fraction de jour (Ex. 12 heures = 0,5 jour).

Ces nombres peuvent être utilisés dans tout calcul, sans utiliser aucune fonction, même dans une requête SQL.

Pour les calculs sur des heures, multipliez ce nombre par 24.

De même pour les minutes ou les secondes : multipliez par 24*60, ou par 24*60*60.

Exemple 1 : temps passé sur une activité ou un projet.

Si vous avez travaillé sur une activité quelconque, depuis la date/heure Debut jusqu'à la date/heure Fin. Utilisez la fenêtre d'exécution (Ctrl + G) pour tester :

Debut = #4/26/2004 22:07:32#
Fin = #4/27/2004 02:38:41#
Duree = (Fin - Debut)*24
? Duree 
4,51916666678153

Soit un peu plus de 4 heures et demie. Le résultat est un Numérique Double, et non plus une date.

Pour effectuer le même calcul avec DateDiff(), vous devrez extraire d'abord la différence en jours, puis en heures, puis en minutes, puis les ajouter les unes aux autres !

Si vous avez enregistré DebutTempsPasse et FinTempsPasse de chaque activité dans une table des Temps Passés, vous pouvez, dans une requête, calculer directement un total des heures par projet.

Par exemple, utiliser cette requête dans un état pour afficher un résumé des heures par projet :

Select TP.CLEPROJET, Sum([FIN_TEMPS_PASSE]-[DEBUT_TEMPS_PASSE])*24 As HeuresTotales
From TEMPSPASSE TP
Group By TP.CLEPROJET;

De même, vous pouvez ajouter directement des jours, entiers ou partiels, à une date. Utiliser la fenêtre Exécution (Ctrl + G) :

? now, now + 120
27/04/2004 12:14:04         25/08/2004 12:14:04

120 jours au-delà du 27 avril, nous serons le 25 août.

? now, now + (75/24)
27/04/2004 12:19:35         30/04/2004 15:19:35

75 heures au-delà du 27 avril à midi, nous serons le 30 avril, à 15 heures.

Exemple 2 : pour chronométrer l'exécution de deux procédures, et déterminer la plus efficace.

Nous pouvons également stocker le résultat dans une variable de type Date, afin de bénéficier immédiatement du format d'affichage Date/Heure.

Public Function CompareProcedures() As String
     Dim Debut As Date, Fin As Date
     Dim Duree1 As Date, Duree2 As Date
     Dim Pointeur As Long
     ' Commencez avec 1000 et augmentez ce nombre, 
     '    jusqu'à ce que les résultats soient significatifs.
     Const NBITERATIONS = 1000000    

     ' Tester la première procédure    
     Debut = Now    
     For Pointeur = 1 To NBITERATIONS
         Procedure1    
     Next    
     Fin = Now    
     Duree1 = Fin - Debut        
     ' Tester la seconde procédure    
     Debut = Now    
     For Pointeur = 1 To NBITERATIONS
          Procedure2 
     Next    
     Fin = Now    
     Duree2 = Fin - Debut    
     ' Renvoyer les résultats :    
     CompareProcedures = "Chaque procédure a été exécutée " & NBITERATIONS & " fois, en " _
        & vbCrLf & "1re : " & Duree1 _
        & vbCrLf & "2me : " & Duree2    
     Beep    
     MsgBox CompareProcedures
End Function

L'affichage de Duree1 et Duree2, variables de type Date, sera directement exprimé en hh:min:sec. Exemple, dans la fenêtre exécution (Ctrl + G) :

? CompareProcedures
Chaque procédure a été exécutée 1000000 fois, en 
1re : 00:00:42
2me : 00:00:29

La seconde procédure est plus efficace que la première. On a souvent des surprises ! :D

Vous ne devez pas utiliser la fonction Now(), récupérez la date du jour avec la fonction Date().

Ce type est en fait un numérique dans Access.
Une date de référence a été choisie de façon arbitraire : le 1/1/1900.
Un nombre correspondant lui a été associé : 2 (l'année 1900 n'étant pas bissextile, un décalage d'une journée a été pris en considération pour ce départ) donc, nous avons : 1/1/1900 = 2
Chaque jour vaut 1. Ainsi, on peut créer la suite :
1 = 31/12/1900
2 = 01/01/1900
3 = 02/01/1900
4 = 03/01/1900
5 = 04/01/1900
6 = 05/01/1900
7 = 06/01/1900
...

Cela est très appréciable, car ainsi, la différence entre deux dates donne le nombre de jours les séparant, et pour savoir quel jour on sera dans trois jours, il suffit d'ajouter 3 à la date en cours.

Maintenant, le type s'intitule Date/Heure. il doit donc aussi gérer les heures.
Puisqu'un jour vaut 1, et qu'il y a 24 heures dans une journée, une heure vaut 1/24.
On a donc :
1h = 1/24 1mn = (1/24)/60 1s = ((1/24)/60)/60

Petite réflexion : quand sommes-nous avec ce numérique-ci : 3,75 ?
Réponse : le 2 janvier 1900 à 18h00

À propos des fonctions
De nombreuses fonctions sont utilisées pour la gestion des données de type Date/heure.

Les plus importantes (les noms et usages US sont soulignés)
DATE()/date
Cette fonction renvoie la date système.
TEMPS()/time
Cette fonction renvoie l'heure système.
MAINTENANT()/now
Cette fonction renvoie la date ET l'heure système.

AJDATE(intervalle;Nbre;Date)/DateAdd
Cette fonction permet d'ajouter un nombre d'intervalles (Nbre) à une date (Date).
DIFFDATE(intervalle;Date1;Date2)/DateDiff
Cette fonction renvoie le nombre d'intervalles entre deux dates.
PARTDATE(intervalle;Date)/DatePart
Cette fonction renvoie l'intervalle correspondant à la date
Que signifie intervalle ?
Il s'agit d'une chaîne de caractères, qui caractérise une durée de temps, et qui peut prendre l'une des valeurs suivantes :
Pour
la notion d'année : "aaaa"/"yyyy"
la notion de mois : "m"/"m"
la notion de jour : "j"/"d"
la notion d'heure : 'h"/"h"
la notion de minute : "n"/"n"
la notion de seconde : "s"/"s"
la notion de trimestre : "t"/"q"
la notion de semaine : "ee"/"ww"
la notion de jour de la semaine : "e"/"w"
la notion de jour de l'année : "a"/"y"

FORMAT(Date;Format)/Format
Cette fonction renvoie le texte correspondant à la date mise en forme.
SÉRIEDATE(Année;Mois;Jour)/DateSerial
Cette fonction revoie une date reconstruite à partir des éléments passés dans les arguments.
SérieTemps(Heure;Minute;Seconde)/TimeSerial
Cette fonction revoie une heure reconstruite à partir des éléments passés dans les arguments.

"MonNombre" contient le nouveau jour :

Madate = DateSerial(Year([ChampDate],Month([ChampDate], MonNombre)

La fonction WeekDay() permet cela.
À savoir : 1 correspond au dimanche et 7 au samedi.

La fonction à appeler est EstFerie(). Celle-ci en appelle une autre fLundiPaques() qui renvoie la date du lundi de Pâques.

Function EstFerie(ByVal QuelleDate As Date) As Boolean
Dim anneeDate As Integer
Dim joursFeries(1 To 11) As Date
Dim I As Integer
  anneeDate = Year(QuelleDate)
 
  joursFeries(1) = DateSerial(anneeDate, 1, 1)
  joursFeries(2) = DateSerial(anneeDate, 5, 1)
  joursFeries(3) = DateSerial(anneeDate, 5, 8)
  joursFeries(4) = DateSerial(anneeDate, 7, 14)
  joursFeries(5) = DateSerial(anneeDate, 8, 15)
  joursFeries(6) = DateSerial(anneeDate, 11, 1)
  joursFeries(7) = DateSerial(anneeDate, 11, 11)
  joursFeries(8) = DateSerial(anneeDate, 12, 25)

  joursFeries(9) = fLundiPaques(anneeDate)
  joursFeries(10) = joursFeries(9) + 38 ' Ascension = lundi de Pâques + 38
  joursFeries(11) = joursFeries(9) + 49 ' Lundi Pentecôte = lundi de Pâques + 49
 
  For I = 1 To 11
    If QuelleDate = joursFeries(I) Then
      EstFerie = True
      Exit For
    End If
  Next
End Function
 
Private Function fLundiPaques(ByVal Iyear As Integer) As Date
        'Adapté de +ieurs scripts...
        Dim L(6) As Long, Lj As Long, Lm As Long
       
        L(1) = Iyear Mod 19: L(2) = Iyear Mod 4: L(3) = Iyear Mod 7
        L(4) = (19 * L(1) + 24) Mod 30
        L(5) = ((2 * L(2)) + (4 * L(3)) + (6 * L(4)) + 5) Mod 7
        L(6) = 22 + L(4) + L(5)
       
        If L(6) > 31 Then
                Lj = L(6) - 31
                Lm = 4
        Else
                Lj = L(6)
                Lm = 3
        End If
       
        ' Lundi de Pâques = Pâques + 1 jour
        fLundiPaques = DateAdd("d", 1, (Lj & "/" & Lm & "/" & Iyear))
       
End Function

Attention : cet article prend en compte le lundi de Pentecôte qui n'est à ce jour plus férié.

Pour convertir une expression en date, vous pouvez utiliser la fonction CDate(expression). Si l'expression à convertir n'est pas une date correcte d'après le format indiqué dans les paramètres régionaux de Windows, CDate essaie d'utiliser un autre format. Si la fonction ne réussit pas à faire la conversion, elle génère une erreur de type "Type Mismatch".
Dans l'exemple ci-dessous, une date est demandée à l'utilisateur. Sa réponse est alors convertie en date.

Dim Rep As String, DateDeNaissance As Date
Do
    Rep = InputBox("Quelle est votre date de naissance ?")
Loop While (Not IsDate(Rep))
DateDeNaissance = CDate(Rep)

Voici une petite fonction :

Public Function PremierJourSemaine(ByVal numSemaine As Byte, ByVal annee As Integer) As Date

    Dim d As Date
    Dim numS As Integer
   
    ' Premier jour de l'année
    d = DateSerial(annee, 1, 1)
   
    ' Numéro de la semaine du 1er janvier
    numS = DatePart("ww", d, vbMonday, vbFirstFourDays)
   
    ' Si le 1er janvier fait partie de la dernière semaine de l'année précédente
    ' alors passe à la semaine suivante (la première de la nouvelle année)
    If numS <> 1 Then d = DateAdd("d", 7, d)
   
    ' Calcule le premier jour de la première semaine de l'année
    d = DateAdd("d", 1 - Weekday(d, vbMonday), d)
           
    ' Ajoute (numSemaine-1) semaines
    PremierJourSemaine = DateAdd("ww", numSemaine - 1, d)

End Function

Utilisation :

Msgbox PremierJourSemaine(26, 2005)

Text1, Text2 et Text3 contiennent les deux valeurs à ajouter. zdtResult est la zone de texte affichant le résultat :

h = Val(Mid(Text1, 1, 2)) + Val(Mid(Text2, 1, 2)) + Val(Mid(Text3, 1, 2))
m = Val(Mid(Text1, 5, 3)) + Val(Mid(Text2, 5, 3)) + Val(Mid(Text3, 5, 3))

If m > 60 Then
    Hplus = Fix(m / 60)
    m = m Mod 60
End If
h = h + Hplus
zdtResult.Value = Str(h) & " h " & Str(m) & " min"

La question : comment faire pour passer de 02:15:47 à 135,78'

La réponse en français :

MsgBox Heure([ChampDate])*60+Minute([ChampDate]) & "," & Format(Seconde([ChampDate])/60*100;"00")

La réponse en anglais :

MsgBox Hour([ChampDate]) * 60 + Minute([ChampDate]) & "," & Format(Second([ChampDate]) / 60 * 100, "00")

Voici un code permettant de convertir une date de type julienne (ex. 107142) vers une date 2007/05/22.

Function cjulian(julian As Long) As Date
cjulian = DateSerial(1900 + CInt(Left(julian, 3)), 1, CInt(Right(julian, 3)))
End Function

Appel de la fonction :

Dim MaDate As Date
    
MaDate = Format(cjulian(107142), "yyyy/mm/dd")