common-lisp
formatera

parametrar

Anmärkningar

Grundläggande användning och enkla direktiv

De två första argumenten som ska formateras är en utgångsström och en kontrollsträng. Grundläggande användning kräver inte ytterligare argument. Vidarebefordras t som strömmen skriver till *standard-output* .

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

Det uttrycket kommer att skriva Basic Message till standardutdata och returnera nil .

Att passera nil när strömmen skapar en ny sträng och returnerar den.

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

De flesta styrsträngsdirektiv kräver ytterligare argument. Den ~a direktiv ( "estetiska") kommer att skriva ut något argument som om den princ förfarande. Detta skriver ut formen utan flyktecken (sökord skrivs ut utan den ledande kolon, strängar utan deras omgivande citat och så vidare).

> (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 valfri höger- eller vänsterknappsingång baserat på ytterligare ingångar.

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

~s direktivet är som ~a , men det skriver ut flyktecken.

> (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\""

Iterera över en lista

Man kan iterera över en lista med hjälp av ~{ och ~} direktiv.

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

~^ kan användas för att fly om det inte finns fler element kvar.

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

Ett numeriskt argument kan ges till ~{ att begränsa hur många iterationer som kan göras:

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

~@{ kommer att upprepas över återstående argument istället för en lista:

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

Underannonser kan itereras med ~:{ :

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

Villkorliga uttryck

Villkorliga uttryck kan göras med ~[ och ~] . Klausulerna i uttrycket separeras med ~; .

Som standard tar ~[ ett heltal från argumentlistan och väljer motsvarande klausul. Klausulerna börjar på noll.

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

Den sista klausulen kan separeras med ~:; istället för att göra det till den andra klausulen.

(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!

Om villkorsuttrycket börjar med ~:[ , förväntar det sig ett generaliserat boolean istället för ett heltal. Det kan bara ha två klausuler; den första skrivs ut om booleanen var NIL , och den andra klausulen om den var sanningen.

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

Om det villkorliga uttrycket börjar med ~@[ , bör det bara finnas en klausul, som skrivs ut om ingången, en generaliserad booleska, var sanningen. Booleanerna kommer inte att konsumeras om det är sant.

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