Il n'existe pas de fonctions intégrées et dédiées à la manipulation des dates dans Word. On doit ruser et se servir du champ QUOTE pour faire interpréter un texte comme une date.
⚠️ Cet article contient des formules pouvant choquer un jeune public (d'utilisateur), il est conseillé de consulter préalablement Introduction à l'utilisation des champs dans Word.
Quelques tests préliminaires
Ajoutons la date du jour et l'heure dans un document. Pour cela on a deux solutions en utilisant les champs DATE et TIME.
Test avec le champ Date
Rappel : Le champ DATE renvoie une date mais aussi une heure avec heures, minutes et secondes.
{ DATE \@ "dd/MM/yyyy HH:mm:ss" } => 27/06/26 10:56:48On va tenter d'afficher le résultat sous forme numérique avec \# pour déduire du résultat obtenu la manière dont Word gère le temps.
{ DATE \# "0,00000000" }
26/06/26 à 11h => 0,00213886
26/06/26 à 11h05 => 0,00213886La valeur ne change pas alors que 5 minutes sont passées. On ne peut donc rien en déduire de ce résultat.
On tente l'opération inverse en générant une date à partir d'une valeur numérique
On tente de transformer la valeur 0,00213886 (26/07/26 à 11h) en date
{ = 0,00213886 \@ "dd/MM/yyyy HH:mm:ss" } => 0,00213886 Échec !
{ = "26/06/26" \@ "MMMM" } => !Erreur de syntaxe
{ = { DATE \# "0,00000000" } \@ "dd/MM/yyyy HH:mm:ss" } => 0,00213886 Échec !
{ = { DATE \@ "dd/MM/yyyy HH:mm:ss" } \@ "MMMM" } => !Erreur de syntaxeOn ne peut donc pas générer directement une date à partir d'une valeur numérique, textuelle ou même le résultat du champ DATE !
Une hypothèse : Ces résultats sont peut-être dû au fait que Word ferait simplement/bêtement l'opération 26 ÷ 6 ÷ 2026 = 0,00213886 d'où l'inutilité de ces valeurs 😰.
Test avec le champ TIME
Rappel : Le champ TIME renvoie une heure avec heures, minutes et secondes mais aussi une date. On aura peut être plus de chance avec lui !
{ TIME \@ "dd/MM/yyyy HH:mm:ss" } => 27/06/26 10:56:48On va tenter d'afficher le résultat sous forme numérique avec \# pour déduire du résultat obtenu la manière dont Word gère le temps.
{ TIME \# "0,00000000" }
=> 10h56 066,00000000
=> 10h57 067,00000000
=> 15h48 051,00000000Avec simplement 66 et 67 comme résultat, il est impossible d'en déduite l'information sur la date, l'heure, les minutes, les secondes.
Une hypothèse : Ces résultats sont peut-être dû au fait que Word ferait simplement/bêtement, là aussi, une simple opération comme 10 + 56 = 66 pour 10h56 et 3 + 48 = 51 pour 15h48 (3 PM : 48) d'où l'inutilité de ces valeurs 😰.
Conclusion
Contrairement à Excel où l'on peut facilement manipuler les dates par simple addition/soustraction étant des nombres de jours, dans Word, les dates résultant des champs DATE et TIME ne sont pas manipulables ainsi.
Donc fin de l'article, c'était rapide !
Merci pour votre attention bienveillante. 😁
Ok on tente d'aller plus loin !
⚠️Prérequis de configuration : Les formules présentées dans cet article sont faites pour une configuration française. Elle utilise le point-virgule (;) comme séparateur d'arguments (ex: MOD(m_nb;12)) et la virgule (,) pour les décimales (ex: 365,25). Si votre système Windows ou votre version d'Office est configurée en anglais, vous devrez remplacer les ; (point-virgules) par des , (virgules) et les , (virgules) par des . (points).
Le champ QUOTE (Citation, "belle" traduction littérale 😰)
Selon l'aide : Insère un texte spécifié. Super, avec ça on avance !
L'intérêt réel de ce champ est de forcer Word à tenter d'interpréter le texte fournit comme étant du texte, une valeur numérique ou une date (via la présence du commutateur \@).
Avec lui on va pouvoir faire quelques manipulations sur les dates (accrochez-vous !).
Syntaxe
{ QUOTE "TexteLittéral" }Mise en œuvre du champ QUOTE pour manipuler des dates
Astuce pour importer plus facilement les formules de cet article dans Word
Les exemples de formules ne sont pas utilisables directement, les accolades "{", "}" symbolisent celles des champs Word mais elles doivent être générées via le raccourcis Ctrl+F9 !
Exemple :
{SET m_nb {={dt \@M}+decM-1}}Méthode manuelle :
- Copier-coller la formule,
- Sélectionner la plage du champ, accolades comprises ou non (Conseil : commencer par les champs les plus "profonds"),
- Pour sélectionner précisément le point de départ de la sélection (annuler le mode automatique), il suffit de faire un petit retour en arrière quand on commence la sélection par cliquer-glisser.
- 1 > {dt \@M}.
- Ctrl+F9,
- Continuer en refaisant les étapes 2 et 3 sur les autres champs,
- 2 > {={dt \@M}+decM-1}.
- 3 > {SET m_nb {={dt \@M}+decM-1}}.
- Sélectionner tout le texte du champ,
- Ctrl+H (commande Remplacer),
- Remplacer "{" par rien puis le bouton Remplacer tout.
- Refaire pour la manipulation pour l'autre accolade.
Méthode automatique :
Je vous propose d'utiliser 2 macros pour faire les importations/exportations des champs.
Macro de conversion de champ vers texte (cliquer ici).
Sub FieldCodeToString()
' Objectif : Convertir le code du champ sélectionné en simple texte et le placer dans le presse-papier
' Utilisation : Sélectionner le champ, exécuter le code puis coller le résultat.
' Retour : Néant. Le texte est placé dans le presse-papier (des guillemets sont présents en début et fin de texte).
' Auteur : Arnaud (www.1forme.fr).
' Licence : CC-BY-NC-SA (Vous pouvez diffuser/partager/modifier cette macro dans les
' même conditions, seulement à titre personnel et citant l'auteur/site d'origine.
Dim boConfigView As Boolean ' Mémorisation du mode d'affichage
Dim strResult As String ' Texte résultat
Application.ScreenUpdating = False
If Selection.Type <> wdSelectionNormal Then _
MsgBox "Pas de texte sélectionné !", vbExclamation, "Exécution impossible": Exit Sub
If Selection.Range.Fields.Count = 0 Then _
MsgBox "Pas de champ détecté !", vbExclamation, "Exécution impossible": Exit Sub
boConfigView = ActiveWindow.View.ShowFieldCodes
ActiveWindow.View.ShowFieldCodes = True
strResult = Replace(Selection.Range.Text, Chr(19), "{")
strResult = Replace(strResult, Chr(21), "}")
ActiveWindow.View.ShowFieldCodes = boConfigView
CreateObject("WScript.Shell").Run "cmd.exe /c echo " & Chr(34) & strResult & Chr(34) & " | clip", 0, True
MsgBox "Texte copier dans le presse-papier.", vbInformation, "Fin de l'exécution"
End SubMacro de conversion de texte vers champ (cliquer ici).
Sub FieldStringToCode()
' Objectif : Convertir un simple texte représentant le code d'un champ en un champ Word
' Utilisation : Sélectionner le texte puis exécuter la macro.
' Le texte hors accolade sera ignoré, le texte dans l'accolade sera transformé en champ
' Attention : Toute accolade sera considérée comme symbolisant un champ donc le texte du champ
' ne doit contenir que des accolades ayant ce rôle !
' Retour : Un champ qui remplace le texte sélectionné.
' Auteur : Arnaud (www.1forme.fr).
' Licence : CC-BY-NC-SA (Vous pouvez diffuser/partager/modifier cette macro dans les
' même conditions, seulement à titre personnel et citant l'auteur/site d'origine.
Dim boConfigView As Boolean ' Mémorisation du mode d'affichage
Dim RgFld As Range ' Plage à traiter
Dim lgInitialEnd As Long ' Mémorisation de la fin de la plage (info perdue par le Find)
Dim lgStartPos As Long ' Début effectif de la plage (après nettoyage)
Dim lgEndPos As Long ' Fin effective de la plage (après nettoyage)
Dim strMessage As String ' Message utilisateur
Dim BmkEnd As Bookmark ' Signet pour mémoriser la fin de la plage
Dim RngLoop As Range ' Plage de travail
Dim lgClosePos As Long ' Position d'une accolade fermante
Dim lgOpenPos As Long ' Position de l'accolade ouvrante correspondante
Dim RgInsideRange As Range ' Texte interne du champ
Dim fld As Field ' Champ
Const bmkName As String = "Fin_du_champ" ' Nom du signet repérant la fin du texte
Application.ScreenUpdating = False
boConfigView = ActiveDocument.ActiveWindow.View.ShowFieldCodes
' --- 1. Contrôles de la plage ---
If Selection.Type <> wdSelectionNormal Then _
MsgBox "Pas de texte sélectionné !", vbExclamation, "Exécution impossible": Exit Sub
If Len(Replace(Selection.Text, "{", "")) <> Len(Replace(Selection.Text, "}", "")) Then _
MsgBox "Pas le même nombre de { et de } !", vbCritical, "Exécution impossible": Exit Sub
ActiveDocument.ActiveWindow.View.ShowFieldCodes = True
Set RgFld = Selection.Range
lgInitialEnd = RgFld.End
' --- 2. Recentrage sur les accolades extrêmes de la SÉLECTION ---
With RgFld.Find
.Text = "{"
.Forward = True
.Wrap = wdFindStop
If .Execute Then lgStartPos = RgFld.Start Else strMessage = "Aucune accolade ouvrantes trouvée.": GoTo fin
End With
RgFld.End = lgInitialEnd
With RgFld.Find
.Text = "}"
.Forward = False
.Wrap = wdFindStop
If .Execute Then lgEndPos = RgFld.End Else strMessage = "Aucune accolade fermante trouvée.": GoTo fin
End With
If lgStartPos < lgEndPos Then
RgFld.SetRange lgStartPos, lgEndPos
Else
MsgBox "Structure des accolades incohérentes !", vbCritical: Exit Sub
End If
' --- 3. Création d'un signet pour mémoriser la fin de la plage utile ---
' Fin pouvant varier selon les remplacements
If ActiveDocument.Bookmarks.Exists(bmkName) Then ActiveDocument.Bookmarks(bmkName).Delete
Set BmkEnd = ActiveDocument.Bookmarks.Add(bmkName, ActiveDocument.Range(RgFld.End, RgFld.End))
' --- 4. Traitement de l'intérieur vers l'extérieur ---
Do
' Recherche entre le début et la position du signet
Set RngLoop = ActiveDocument.Range(RgFld.Start, BmkEnd.Range.Start)
With RngLoop.Find
.Text = "}"
.Forward = True
.Wrap = wdFindStop
If Not .Execute Then Exit Do ' Si rien n'est trouvé dans la zone
' SÉCURITÉ ANTI-DEBORDEMENT : Si Word a anormalement trouvé un "}" au-delà du signet
If RngLoop.End > BmkEnd.Range.Start Then Exit Do
lgClosePos = RngLoop.End
End With
' On remonte depuis l'accolade fermante pour trouver l'ouvrante "{" correspondante
Set RngLoop = ActiveDocument.Range(RgFld.Start, lgClosePos)
With RngLoop.Find
.Text = "{"
.Forward = False ' Recherche arrière
.Wrap = wdFindStop
If Not .Execute Then Exit Do
End With
lgOpenPos = RngLoop.Start
' Remplacement
Set RgInsideRange = ActiveDocument.Range(lgOpenPos + 1, lgClosePos - 1)
Set fld = ActiveDocument.Fields.Add(ActiveDocument.Range(lgOpenPos, lgOpenPos), wdFieldEmpty, "", False) 'Ajout au début
fld.Code.FormattedText = RgInsideRange.FormattedText ' Injection du texte dans le champ
RgInsideRange.SetRange RgInsideRange.Start - 1, RgInsideRange.End + 1
RgInsideRange.Delete ' Suppression du texte apres le champ
Loop
strMessage = "La conversion de la sélection est terminée."
fin:
' --- 5. Nettoyage du signet et Finalisation ---
If ActiveDocument.Bookmarks.Exists(bmkName) Then ActiveDocument.Bookmarks(bmkName).Delete
ActiveDocument.ActiveWindow.View.ShowFieldCodes = boConfigView
RgFld.Fields.Update
Set fld = Nothing
Set RgInsideRange = Nothing
Set RngLoop = Nothing
Set BmkEnd = Nothing
Set RgFld = Nothing
Application.ScreenUpdating = True
MsgBox strMessage, vbInformation, "Fin du traitement"
End SubIllustration de la simple interprétation une chaine comme une date
{ = "26/06/26" \@ "MMMM" } => !Erreur de syntaxe
mais
{ QUOTE "26/06/26" \@ "MMMM" } => juin- Attention : "MMMM" et pas "mmmm" (voir Introduction a l'utilisation des champs dans Word (mise en forme des valeurs de type date et heure).)
Remarques :
- Quand l'interprétation échoue, QUOTE renvoie le texte.
{ QUOTE "31/02/26" \@ "MMMM" } => 31/02/26Le formatage "MMMM" est donc ignoré.
- Par défaut, c'est l'année en cours qui est utilisée.
{ QUOTE "10/11" \@dd/MM/yyyy } => 10/11/2026- Par défaut, une année sur 2 caractères bascule du 21ème siècle au 20ème siècle à partir de 30 (classique).
{ QUOTE "10/11/29" \@dd/MM/yyyy } => 10/11/2029
{ QUOTE "10/11/30" \@dd/MM/yyyy } => 10/11/1930Décaler une date de plusieurs années
Cas le plus facile !
On décale la date du jour (27/06/2026) de 4 ans.
{ QUOTE { DATE \@ "dd/MM/" }{ = { DATE \@ "yyyy"} + 4 } \@ "dd/MM/yyyy" } => 27/06/2030
Étapes résolution de la formule :
{ QUOTE "27/06/" { = 2026 + 4 } \@ "dd/MM/yyyy" }
{ QUOTE "27/06/2030" \@ "dd/MM/yyyy" }- L'année résultante doit être supérieur ou égale à 100.
Cette logique de formule est applicable sur toutes dates (champ de fusion, date de création, date de modification...).
Décaler une date de plusieurs mois
Problématiques :
- Il faut gérer un changement d'année quand on bascule après le mois de décembre.
- Il faut gérer un changement de jour dans la date tombe sur une date inexistante (fin de mois).
- Exemple : le 31/07 décalé de 2 mois est généralement le 30/09 et non le 31/09 (ni le 1/10) !
- Gérer la même problématique pour le mois de février et les années bissextiles.
Ne fonctionne que pour des dates supérieures à 1582.
{QUOTE ↵
{SET dt {QUOTE "29/01/2030" \@dd/MM/yyyy}}↵
{SET decM -13}↵
{SET m_nb {={dt \@M}+decM-1}}↵
{SET m_dt {=(m_nb<0)*12+MOD(m_nb;12)+1}}↵
{SET y_dt {={dt \@yyyy}+INT(m_nb/12)-(m_nb<0)}}↵
{SET d_dt {=IF(({dt \@d}>28)*(m_dt=2)=1;↵
28+(MOD(y_dt;4)=0)+(MOD(y_dt;400)=0)-(MOD(y_dt;100)=0);↵
IF(((m_dt=4)+(m_dt=6)+(m_dt=9)+(m_dt=11)+({dt \@d}>30))=2;30;{dt \@d}))}}↵
{d_dt}/{m_dt}/{y_dt} \@dd/MM/yyyy}Interprétation de la formule et remarques :
- Les retours à la ligne (↵) ne sont pas obligatoires, ils sont là par souci de lisibilité de la formule (créé par MAJ + ENTRER).
- La création de signet (SET) est là pour simplifier le formule (joue le rôle de variable comme en programmation).
Les formules sont ainsi :- Plus courtes, on évite de répéter les mêmes calculs quand leurs résultats doivent être utilisés plusieurs fois (exemple : m_nb qui est utilisé 4 fois),
- Plus lisibles, car plus courtes et le nom du signet peut fournir une information sur le rôle de ces portions de formule,
- En affichant les valeurs de ces signets on peut plus facilement déboguer les formules.
- {QUOTE "29/01/2030" \@dd/MM/yyyy} est là pour faciliter les tests permettant une saisie directe de la date à décaler et pourrait être remplacé ainsi :
- {SET dt { DATE }} => Décalage de la date du jour.
- {SET dt { MERGEFIELD MaDate }} => Décalage de la date provenant d'un champ de fusion.
- J'ai condensé la syntaxe (suppression des espaces guillemets classiquement présents).
- decM : Décalage en mois (ici -13 mois).
- m_nb : Calcul du nombre de mois (1-13-1 soit -13).
- L'utilisation du nom du signet directement sans accolade est possible étant dans un champ formule {=...}.
- m_dt : Calcul du nouveau mois (-13 mois = -1 an et 1 mois).
- Pour les mois, on travaille sur une base 0-11 et non 1-12 sinon pour décembre on aurait MOD(12;12)=0 d'où le -1 de m_nb et le +1 de m_dt.
- (m_nb<0)*12 <=> IF(m_nb<0;12;0) est pour gérer le cas ou decM est négatif ET provoque un changement d'année.
- Si m_nb<0 est vérifié (VRAI), on obtient 1,
- Si m_nb<0 n'est pas vérifié (FAUX), on obtient 0,
- MOD(-13;12) = -1 et non 11 comme dans Excel.
- Avec -13 : 1*12 + -1 +1 =12.
- y_dt : Calcul de la nouvelle année.
- -(m_nb<0) est pour gérer le cas ou decM est négatif ET provoque un changement d'année.
- 2030+ -1 - 1 = 2028.
- d_dt : Calcul du nouveau jour.
- Si c'est un 29 février on vérifie si y_dt est bien bissextile sinon on passe au 28 février.
- Doit être multiple de 4 et pas multiple de 100 sauf si multiple de 400 (voir https://fr.wikipedia.org/wiki/Ann%C3%A9e_bissextile).
- Si c'est un 31 mais d'un mois qui ne compte que 30 jours alors on passe a 30.
- Remarquer l'utilisation de fonctions IF, à ne pas confondre avec le champ IF (syntaxes différentes).
- Rappel : MOD renvoie le reste de la division.
- Si c'est un 29 février on vérifie si y_dt est bien bissextile sinon on passe au 28 février.
- Résultat :
- {d_dt}/{m_dt}/{y_dt} génère un texte correspondant à la date.
- Avec "1/"{m_dt}/{y_dt}, on pourrait ainsi forcer la date au 1er du mois.
- On pourrait aussi intégré "1/" à m_dt ainsi : {SET m_dt "1/{=(m_nb<0)*12+MOD(m_nb;12)+1}"} et utiliser comme résultat {m_dt}/{y_dt}.
- \@dd/MM/yyyy est le format d'affichage utilisé par le champ QUOTE (Exemple de résultat : 29/12/2028).
- Avec \@"MMMM yyyy" (guillemets obligatoires dû à l'espace) on aurait comme résultat : décembre 2028.
Décaler une date de plusieurs jours
Par exemple pour calculer une date butoir, une date de péremption...
Problématiques :
- Il faut gérer un changement d'année quand on bascule après le mois de décembre.
- Il faut gérer un changement de mois quand on bascule après le dernier jour du mois.
- Il faut gérer la problématique pour les années bissextiles.
Pour ce faire, je vous propose une formule suivant cette logique :
- Conversion de la date (utilisant le calendrier grégorien) en date du calendrier juliens,
- Application du décalage de date,
- Conversion de la date du calendrier juliens en date du calendrier grégorien.
{QUOTE ↵
{SET dt {QUOTE "28/06/2026" \@dd/MM/yyyy}}↵
{SET decJ 45}↵
{SET m {dt \@M}}↵
{SET a_c {={dt \@yyyy}-(m<3)}}↵
{SET s {=INT(a_c/100)}}↵
{SET jjn {=INT(365,25*a_c)+INT(30,60001*(m+(m<3)*12+1))+{dt \@d}-s+INT(s/4)+1720996,5+decJ+1}}↵
{SET z {=INT(jjn)}}↵
{SET alph {=INT((z-1867216,25)/36524,25)}}↵
{SET b {=z+alph-INT(alph/4)+1525}}↵
{SET c {=INT((b-122,1)/365,25)}}↵
{SET d {=INT(365,25*c)}}↵
{SET e {=INT((b-d)/30,6001)}}↵
{SET jr {=INT(b-d-INT(30,6001*e)+MOD(jjn;1))}}↵
{SET mr {=e-(e>14)*12-1}}↵
{SET ar {=c-4715-(mr>2)}}↵
{jr}/{mr}/{ar} \@dd/MM/yyyy}Interprétation de la formule et remarques : (est-ce nécessaire ? 😁)
- Je me suis basé sur les algorithmes de cette page : Jour julien — Wikipédia.
- Ne fonctionne que pour des dates supérieures à 1582.
- Rappel : INT renvoie la partie entière de la valeur.
Calculer le nombre de jours entre 2 dates
On va là aussi convertir les dates (utilisant le calendrier grégorien) en date du calendrier juliens puis calculer l'écart entre ces 2 dates.
{QUOTE ↵
{SET dt_1 {QUOTE "28/06/2026" \@dd/MM/yyyy}}↵
{SET dt_2 {QUOTE "30/06/2026" \@dd/MM/yyyy}}↵
{SET m_1 {dt_1 \@M}}↵
{SET m_2 {dt_2 \@M}}↵
{SET a_c1 {={dt_1 \@yyyy}-(m_1<3)}}↵
{SET a_c2 {={dt_2 \@yyyy}-(m_2<3)}}↵
{SET s_1 {=INT(a_c1/100)}}↵
{SET s_2 {=INT(a_c2/100)}}↵
{SET jjn_1 {=INT(365,25*a_c1)+INT(30,60001*(m_1+(m_1<3)*12+1))+{dt_1 \@d}-s_1+INT(s_1/4)}}↵
{SET jjn_2 {=INT(365,25*a_c2)+INT(30,60001*(m_2+(m_2<3)*12+1))+{dt_2 \@d}-s_2+INT(s_2/4)}}↵
{=jjn_2-jjn_1}}Décaler une date à la fin du mois
Un classique comme les dates butoirs d'exécution "n jours fin de mois".
{QUOTE ↵
{SET dt {QUOTE "20/01/2026" \@dd/MM/yyyy}}↵
{SET decM 2}↵
{SET m_nb {={dt \@M}+decM-1}}↵
{SET m_dt {=(m_nb<0)*12+MOD(m_nb;12)+1}}↵
{SET y_dt {={dt \@yyyy}+INT(m_nb/12)-(m_nb<0)}}↵
{SET d_dt {=IF(m_dt=2;↵
28+(MOD(y_dt;4)=0)+(MOD(y_dt;400)=0)-(MOD(y_dt;100)=0);↵
31-(m_dt=4)-(m_dt=6)-(m_dt=9)-(m_dt=11))}}↵
{d_dt}/{m_dt}/{y_dt} \@dd/MM/yyyy}Interprétation de la formule et remarques :
- Basée sur la formule de décalage de mois. On fait le décalage en mois puis on force le jour avec 28, 29, 30 ou 31 selon les cas.
- Simplification du IF pour le choix du jour entre 31 et 30.
- decM : Décalage en mois (ici 2 mois).
- m_nb : Calcul du nombre de mois (1+2-1 soit 2).
- m_dt : Calcul du nouveau mois (2 mois = 0 an et 2 mois soit 2+1).
- y_dt : Calcul de la nouvelle année (2026 + 0 an soit 2026).
- d_dt : Calcul du jour 28, 29, 30, 31.
- 28+0 ou 28+1 pour février.
- 30+0 ou 30+1 pour les autres mois.
Calculer un âge, une ancienneté...
{QUOTE ↵
{SET dt_1 {QUOTE "20/01/2000" \@dd/MM/yyyy}}↵
{SET dt_2 {DATE \@dd/MM/yyyy}}↵
{SET a_1 {dt_1 \@yyyy}}↵
{SET m_1 {dt_1 \@M}}↵
{SET j_1 {dt_1 \@d}}↵
{SET a_2 {dt_2 \@yyyy}}↵
{SET m_2 {dt_2 \@M}}↵
{SET j_2 {dt_2 \@d}}↵
{SET a {=a_2-a_1-(m_2<m_1)-(m_2=m_1)*(j_2<j_1)}}↵
{SET m {=MOD(12+m_2-m_1-(j_2<j_1);12)}}↵
{SET nbj_mp {=31-((m_2-1=4)+(m_2-1=6)+(m_2-1=9)+(m_2-1=11))-(m_2-1=2)*(3-(MOD(a_2;4)=0)-(MOD(a_2;400)=0)+(MOD(a_2;100)=0))}}↵
{SET j {=MOD(2*nbj_mp-j_1+j_2;nbj_mp)}}↵
{a}160 an{IF {a} > 1 "s" ""}," "{m}160 mois" "et" "{j}160 jour{IF {j} > 1 "s" ""}}Interprétation de la formule et remarques :
- nbj_mp : Nombre de jour du mois précédents.
- On part de 31 et on retire 1 si c'est un mois en 30 jours, 3 ou 2 si c'est févier (selon si bissextile).
- On évite d'imbriquer de fonction IF, OR et AND via cette syntaxe,
- Rappel : VRAI <=> 1 et FAUX <=> 0,
- Les + remplacent des OU,
- Les * remplace des ET.
- j : Le 2 de 2*nbj_mp est pour éviter de faire un MOD sur une valeur négative.
- "{a}160 an" : le 160 sera interprété par QUOTE comme le code ASCII 160 (espace insécable).
Exemple :
{QUOTE 190ab c} => ¾c (ab ignoré)
{QUOTE 190 ab c} => ¾abc (1er espace permet la prise en compte de 190, 2ème non pris comme le caractère espace)
{QUOTE ab190c} => ab190c (190 non interprété comme un code ASCII)
{QUOTE ab 190 c} => ab¾c
{QUOTE "ab "190" c"} => ab ¾ c
{QUOTE ab" "190" "c} => ab ¾ c (on force la prise en compte des espaces comme caractère espace en utilisant des guillemets)
{QUOTE 1000} => d (Prend uniquement en compte les 3 premiers chiffres donc ici le code pris en compte est 100)Calculer le numéro de semaine
On va diviser le nombre de jour écoulés depuis le début de la semaine 1 par 7.
- Pour les dates de début d'année avant la semaine 1, on détermine s'il s'agit de la semaine 52 ou 53.
- Pour les dates de fin d'année, on détermine s'il s'agit de la semaine 1 de l'année suivante.
{QUOTE ↵
{SET dt {QUOTE "20/01/2026" \@dd/MM/yyyy}}↵
{SET m {dt \@M}}↵
{SET a {dt \@yyyy}}↵
{SET j_m {=31*((m>1)+(m>3)+(m>5)+(m>7)+(m>8)+(m>10)+(m>12))+30*((m>4)+(m>6)+(m>9)+(m>11))+28*(m>2)}}↵
{SET j4j {QUOTE "4/1/"{a} \@ddd}}↵
{SET jsem {={COMPARE j4j = "lun."}+{COMPARE j4j = "mar."}*2+{COMPARE j4j = "mer."}*3+{COMPARE j4j = "jeu."}*4+{COMPARE j4j = "ven."}*5+{COMPARE j4j = "sam."}*6+{COMPARE j4j = "dim."}*7-1}}↵
{SET a_b {=((MOD(a;4)=0)+(MOD(a;400)=0)-(MOD(a;100)=0))}}↵
{SET n_s {=(j_m+{dt \@d}-4+jsem+a_b*(m>2))/7+1}}↵
{SET a_i {=a-1}}↵
{SET j4j_i {QUOTE "4/1/"{a_i} \@ddd}}↵
{SET jsem_i {={COMPARE j4j_i = "lun."}+{COMPARE j4j_i = "mar."}*2+{COMPARE j4j_i = "mer."}*3+{COMPARE j4j_i = "jeu."}*4+{COMPARE j4j_i = "ven."}*5+{COMPARE j4j_i = "sam."}*6+{COMPARE j4j_i = "dim."}*7-1}}↵
{SET n_s_i {=(365+(MOD(a_i;4)=0)+(MOD(a_i;400)=0)-(MOD(a_i;100)=0)-4+jsem_i)/7+1}}↵
{SET dj {QUOTE "31/12/"{a} \@ddd}}↵
{SET bas {={COMPARE dj = "lun."}+{COMPARE dj = "mar."}+{COMPARE dj = "mer."}}}↵
{=INT(IF(n_s<1;n_s_i;IF(n_s>=53;(bas=0)*52+1;n_s)))}}Interprétation de la formule et remarques :
- j_m : Somme des jours des mois précédents à dt.
- Avec m=5 : 31*(1+1+0+0+0+0+0)+30*(1+0+0+0)+28*1
- La correction due aux années bissextiles se fera plus loin dans la formule.
- j4j : Le 4 janvier de l'année (par définition toujours en semaine 1).
- jsem : Jour de la semaine du 4 janvier (chiffre de 1 pour Lundi à 7 pour dimanche).
- COMPARE j4j = "lun." : Espaces obligatoires de part et d'autre du signe égale pour toutes les comparaisons avec COMPARE.
- a_b : 1 si c'est une Année Bissextile sinon 0.
- Divisible par 4 et pas par 100 sauf si divisible par 400.
- n_s : Numéro de la Semaine brute.
- Division du nombre de jours depuis le début de l'année avec correction (départ de la semaine 1 + année bissextile) par 7.
- a_i : Année précédente servant à calculer la semaine intercalaire (dernière semaine de l'année précédente).
- j4j_i : Le 4 janvier de l'année précédente servant à calculer la semaine intercalaire.
- jsem_i : Jour de la semaine du 4 janvier de l'année précédente (chiffre de 1 pour Lundi à 7 pour dimanche) servant à calculer la semaine intercalaire.
- n_s_i : Numéro de la Semaine intercalaire (52 ou 53).
- Prise en compte si l'année précédente est bissextile.
- dj : Dernier Jour de l'année précédente (31/12) servant à gérer le cas où la semaine 1 commence l'année d'avant (de 1 à 3 jours).
- bas : Flag pour savoir s'il a cette bascule.
- Résultat : Si la date est avant la semaine 1.
- Alors on renvoie 52 ou 53 selon les cas (n_s_i),
- Sinon si le numéro de semaine d'avant est 53 (supérieur ou égale pour ne pas être gêné par les décimales).
- Alors on renvoie 53 ou 1 (ici l'expression remplace un 3ème IF : IF(bas=0;53;1)
- Sinon on renvoie le numéro de semaine (cas pour les semaines différentes des semaines 1, 52, 53).
- Attention remplacer "≽" par ">=" (problème d'affichage sur le site).
Calculer la date de Pâques
Date liée au cycle de la lune (le dimanche qui suit la première pleine lune du printemps) et servant de base à de nombreuses autres dates de fêtes (liste de 26 fêtes mobiles liées à Pâsques : Fête mobile — Wikipédia).
{QUOTE ↵
{SET a 2026}↵
{SET n {=MOD(a;19)}}↵
{SET c {=INT(a/100)}}↵
{SET u {=MOD(a;100)}}↵
{SET e {=MOD(19*n+c-INT(c/4)-INT((c-INT((c+8)/25)+1)/3)+15;30)}}↵
{SET l {=MOD(2*MOD(c;4)+2*INT(u/4)-e-MOD(u;4)+32;7)}}↵
{SET z {=e+l-7*INT((n+11*e+22*l)/451)+114}}↵
{=MOD(z;31)+1}/{=INT(z/31)}/{a} \@dd/MM/yyyy}Interprétation de la formule et remarques :
- Formule basée sur Excel et les dates (Partie 1) (algorithme de Butcher-Meeus).
- Pour calculer les dates des fêtes mobiles liées (l'Ascension, la Pentecôte...), utiliser la formule de décalage de dates en jour.
Téléchargement des exemples

Conclusions
- La manipulation des dates est complexe par la structure même de notre calendrier Grégorien, on doit dans Word ruser et utiliser des algorithmes, des conversions et astuces afin d'atteindre le résultat attendu débouchant sur des formules assez complexes.
- L'intérêt de ces formules et d'éviter l'utilisation de macro, de fonctionner lors d'un publipostage si ces résultats ne peuvent être disponible dans la source de données.
- Il existe surement d'autres formule et logique pour atteindre ces résultats. N'hésitez pas à m'en faire part en commentaire.
Merci pour votre attention bienveillante.
