Anniversaire de la gigaseconde

Date et heure

En Common Lisp, le temps est représenté de quatre manières, dont deux seront abordées ici.

• Le temps universel est un temps absolu, un entier qui représente le nombre de secondes depuis 1900-01-01T00:00:00Z (c'est-à-dire minuit le 1er janvier 1900 en UTC).
• Le temps décodé est un tuple de 9 valeurs qui, ensemble, représentent un instant précis du calendrier : secondes, minutes, heure, jour du mois, mois, année, jour de la semaine, indicateur d'heure d'été, fuseau horaire. (On en parle en détail plus bas.)

Temps universel

Pour obtenir le temps universel actuel, on utilise get-universal-time ou get-decoded-time. La première renvoie le nombre de secondes écoulées depuis 1900-01-01T00:00Z et la seconde renvoie les mêmes données au format décodé.

Temps décodé

decode-universal-time et encode-universal-time sont les fonctions principales pour manipuler le temps. La première prend un temps universel et renvoie une valeur de temps décodé sous forme de valeurs multiples, tandis que la seconde prend les valeurs de temps décodé en arguments et renvoie un temps universel.

Toutes deux prennent un argument de fuseau horaire facultatif. Voir plus bas le format du fuseau horaire.

Un temps décodé est un ensemble de valeurs :

• secondes : un entier entre 0 et 59
• minutes : un entier entre 0 et 59
• heure : un entier entre 0 et 23
• jour du mois : un entier entre 1 et 31 (la limite supérieure dépend bien sûr du mois et de l'année)
• mois : un entier entre 1 et 12
• année : un entier indiquant l'année.
• jour de la semaine : un entier entre 0 et 6. 0 signifie lundi, 1 signifie mardi, etc. ... 6 signifie dimanche.
• indicateur d'heure d'été : une valeur vraie indique que l'heure d'été est en vigueur.
• fuseau horaire : un nombre d'heures entre -24 et 24 qui indique le décalage par rapport à UTC. Ce nombre est un nombre rationnel et doit être un multiple de 1/3600

(encode-universal-time 1 2 3 4 5 2000 0) ; => 3166398121
(decode-universal-time 3166398121)       ; => 1
                                         ;    2
                                         ;    3
                                         ;    4
                                         ;    5
                                         ;    2000
                                         ;    3 (Thursday)
                                         ;    NIL
                                         ;    0
(decode-universal-time 2208988800) ; => 0
                                   ;    0
                                   ;    0
                                   ;    1
                                   ;    1
                                   ;    1970
                                   ;    3
                                   ;    NIL
                                   ;    0

Valeurs multiples

En Common Lisp, une fonction peut non seulement renvoyer une valeur, mais aussi plusieurs. Par exemple, floor, qui arrondit vers zéro, renvoie deux valeurs : la première est la valeur arrondie et la seconde est le reste.

(floor 3.5) ; => 3
            ;    0.5

(Nous afficherons les valeurs multiples renvoyées sur des lignes séparées de la sortie.)

Renvoie plusieurs valeurs

Si tu veux qu'une fonction renvoie plusieurs valeurs, tu utilises l'accesseur values :

(defun three-numbers () (values 1 2 3))
(three-numbers) ; => 1
                ;    2
                ;    3

Gérer les valeurs multiples

Si seule la première valeur t'intéresse, rien de particulier n'est à faire, le langage s'en charge :

(+ (values 1 2 3) (values 10 20 30)) ; => 11

Cependant, si tu veux accéder aux autres valeurs, plusieurs fonctions te seront nécessaires. Les deux macros principales sont multiple-value-list et multiple-value-bind. Elles servent à englober une expression qui renvoie plusieurs valeurs et à capturer toutes ces valeurs. La première crée une liste de toutes les valeurs. La seconde te permet de lier des variables à chacune des valeurs.

(multiple-value-list (values 1 2 3))                   ; => (1 2 3)
(multiple-value-bind (a b c) (values 1 2 3) 
   (+ a b c)) ; => 6

Une autre fonction utile est nth-value