common-lisp
Format

Parameter

Bemerkungen

Grundlegende Verwendung und einfache Anweisungen

Die ersten beiden zu formatierenden Argumente sind ein Ausgabestrom und eine Steuerzeichenfolge. Grundlegende Verwendung erfordert keine zusätzlichen Argumente. Übergabe von t als Stream schreibt an *standard-output* .

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

Dieser Ausdruck schreibt Basic Message in die Standardausgabe und gibt nil .

Wenn Sie als Stream nil wird eine neue Zeichenfolge erstellt und zurückgegeben.

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

Die meisten Steuerzeichenfolgenanweisungen erfordern zusätzliche Argumente. Die ~a Direktive ("ästhetisch") gibt jedes Argument wie mit dem princ Verfahren aus. Dadurch wird das Formular ohne Escape-Zeichen gedruckt (Schlüsselwörter werden ohne führenden Doppelpunkt, Zeichenfolgen ohne Anführungszeichen usw. gedruckt)

> (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 optionaler rechter oder linker Pad-Eingang basiert auf zusätzlichen Eingängen.

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

Die Direktive ~s ist wie ~a , druckt jedoch Escape-Zeichen.

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

Iteration über eine Liste

Man kann eine Liste mit den Direktiven ~{ und ~} durchlaufen.

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

~^ kann verwendet werden, wenn es keine weiteren Elemente mehr gibt.

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

Ein numerisches Argument kann ~{ , um die Anzahl der Iterationen einzuschränken:

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

~@{ wird anstelle einer Liste über verbleibende Argumente iterieren:

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

Sublisten können mit ~:{ durchlaufen werden.

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

Bedingte Ausdrücke

Bedingte Ausdrücke können mit ~[ und ~] . Die Klauseln des Ausdrucks werden mit ~; getrennt ~; .

Standardmäßig nimmt ~[ eine Ganzzahl aus der Argumentliste und wählt die entsprechende Klausel aus. Die Klauseln beginnen bei Null.

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

Die letzte Klausel kann mit ~:; stattdessen, um es die else-Klausel zu machen.

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

Wenn der Bedingungsausdruck mit ~:[ beginnt, erwartet er einen generalisierten Booleschen Wert anstelle einer Ganzzahl. Es kann nur zwei Klauseln enthalten. Die erste wird gedruckt, wenn der Boolean NIL , und die zweite Klausel, wenn sie wahr ist.

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

Wenn der bedingte Ausdruck mit ~@[ beginnt, sollte es nur eine Klausel geben, die gedruckt wird, wenn die Eingabe, ein verallgemeinerter Boolean, wahr ist. Das Boolean wird nicht verbraucht, wenn es wahr ist.

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