common-lisp
format
Recherche…
Paramètres
| Liste Lambda | (format DESTINATION CONTROL-STRING &REST FORMAT-ARGUMENTS) |
|---|---|
DESTINATION | la chose à écrire. Cela peut être un flux de sortie, t (raccourci pour *standard-output* ) ou nil (qui crée une chaîne à écrire) |
CONTROL-STRING | la chaîne de template. Il peut s'agir d'une chaîne primitive ou de directives de commande avec préfixe tilde spécifiant et transformant d'une manière ou d'une autre des arguments supplémentaires. |
FORMAT-ARGUMENTS | arguments supplémentaires potentiels requis par le CONTROL-STRING . |
Remarques
La documentation CLHS pour les directives FORMAT se trouve à la Section 22.3 . Avec SLIME, vous pouvez taper Cc Cd ~ pour rechercher la documentation CLHS d'une directive de format spécifique.
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!
