common-lisp
format

Paramètres

Remarques

Utilisation de base et directives simples

Les deux premiers arguments à formater sont un flux de sortie et une chaîne de contrôle. L'utilisation de base ne nécessite pas d'arguments supplémentaires. Passer t comme le flux écrit dans *standard-output* .

> (format t "Basic Message")
Basic Message
nil

Cette expression va écrire Basic Message sur la sortie standard et renvoyer la valeur nil .

nil le flux est nil , le flux crée une nouvelle chaîne et la renvoie.

> (format nil "Basic Message")
"Basic Message"

La plupart des directives de chaîne de contrôle nécessitent des arguments supplémentaires. La ~a directive ("esthétique") imprimera tout argument comme par la procédure princ . Ceci imprime le formulaire sans aucun caractère d'échappement (les mots-clés sont imprimés sans les deux-points principaux, les chaînes sans les guillemets qui les entourent, etc.).

> (format nil "A Test: ~a" 42)
"A Test: 42"
> (format nil "Multiples: ~a ~a ~a ~a" 1 (list 2 3) "four five" :six)
"Multiples: 1 (2 3) four five SIX"
> (format nil "A Test: ~a" :test)
"A Test: TEST"
> (format nil "A Test: ~a" "Example")
"A Test: Example"

~a entrée optionnelle droite ou gauche basée sur des entrées supplémentaires.

> (format nil "A Test: ~10a" "Example")
"A Test: Example   "
> (format nil "A Test: ~10@a" "Example")
"A Test:    Example"

La directive ~s est comme ~a , mais elle imprime des caractères d'échappement.

> (format nil "A Test: ~s" 42)
"A Test: 42"
> (format nil "Multiples: ~s ~s ~s ~s" 1 (list 2 3) "four five" :six)
"Multiples: 1 (2 3) \"four five\" :SIX"
> (format nil "A Test: ~s" :test)
"A Test: :TEST"
> (format nil "A Test: ~s" "Example")
"A Test: \"Example\""

Itérer sur une liste

On peut parcourir une liste en utilisant les directives ~{ et ~} .

CL-USER> (format t "~{~a, ~}~%" '(1 2 3 4 5))
1, 2, 3, 4, 5, 

~^ peut être utilisé pour échapper s'il ne reste plus d'éléments.

CL-USER> (format t "~{~a~^, ~}~%" '(1 2 3 4 5))
1, 2, 3, 4, 5

Un argument numérique peut être donné à ~{ pour limiter le nombre d'itérations pouvant être effectuées:

CL-USER> (format t "~3{~a~^, ~}~%" '(1 2 3 4 5))
1, 2, 3, 

~@{ va parcourir les arguments restants au lieu d'une liste:

CL-USER> (format t "~a: ~@{~a~^, ~}~%" :foo 1 2 3 4 5)
FOO: 1, 2, 3, 4, 5

Les sous-listes peuvent être répétées en utilisant ~:{ :

CL-USER> (format t "~:{(~a, ~a) ~}~%" '((1 2) (3 4) (5 6)))
(1, 2) (3, 4) (5, 6) 

Expressions conditionnelles

Les expressions conditionnelles peuvent être effectuées avec ~[ et ~] . Les clauses de l'expression sont séparées en utilisant ~; .

Par défaut, ~[ prend un entier dans la liste des arguments et sélectionne la clause correspondante. Les clauses commencent à zéro.

(format t "~@{~[First clause~;Second clause~;Third clause~;Fourth clause~]~%~}"
        0 1 2 3)
; First clause
; Second clause
; Third clause
; Fourth clause

La dernière clause peut être séparée avec ~:; au lieu de faire la clause sinon.

(format t "~@{~[First clause~;Second clause~;Third clause~:;Too high!~]~%~}"
        0 1 2 3 4 5)
; First clause
; Second clause
; Third clause
; Too high!
; Too high!
; Too high!

Si l'expression conditionnelle commence par ~:[ , elle attendra un booléen généralisé au lieu d'un entier. Il ne peut avoir que deux clauses; le premier est imprimé si le booléen est NIL et le second si c'est vrai.

(format t "~@{~:[False!~;True!~]~%~}"
        t nil 10 "Foo" '())
; True!
; False!
; True!
; True!
; False!

Si l'expression conditionnelle commence par ~@[ , il ne devrait y avoir qu'une seule clause, qui est imprimée si l'entrée, un booléen généralisé, était véridique. Le booléen ne sera pas consommé s'il est véridique.

(format t "~@{~@[~s is truthy!~%~]~}"
        t nil 10 "Foo" '())
; T is truthy!
; 10 is truthy!
; "Foo" is truthy!