common-lisp
formaat

parameters

Opmerkingen

Basisgebruik en eenvoudige richtlijnen

De eerste twee te formatteren argumenten zijn een outputstroom en een controlereeks. Basisgebruik vereist geen aanvullende argumenten. Doorgeven t terwijl de stream schrijft naar *standard-output* .

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

Die uitdrukking schrijft Basic Message naar standaarduitvoer en keert terug naar nil .

Passing nil aangezien de stroom creëert een nieuwe string, en keert terug het.

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

De meeste richtlijnen voor besturingsreeksen vereisen aanvullende argumenten. De ~a richtlijn ("esthetiek") drukt elk argument af alsof door de princ procedure. Hiermee wordt het formulier afgedrukt zonder escape-tekens (trefwoorden worden afgedrukt zonder de dubbele punt, tekenreeksen zonder aanhalingstekens, enzovoort).

> (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 optionele rechter- of linkerpad-ingang op basis van extra ingangen.

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

De ~s richtlijn is als ~a , maar het drukt vluchttekens af.

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

Een lijst doornemen

Men kan een lijst herhalen met behulp van ~{ en ~} richtlijnen.

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

~^ kan worden gebruikt om te ontsnappen als er geen elementen meer over zijn.

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

Een numeriek argument kan worden gegeven aan ~{ om te beperken hoeveel iteraties kunnen worden gedaan:

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

~@{ zal de resterende argumenten herhalen in plaats van een lijst:

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

Sublijsten kunnen worden herhaald met ~:{ :

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

Voorwaardelijke uitdrukkingen

Voorwaardelijke uitdrukkingen kunnen worden gedaan met ~[ en ~] . De clausules van de uitdrukking worden gescheiden met ~; .

Standaard neemt ~[ een geheel getal uit de lijst met argumenten en kiest de bijbehorende clausule. De clausules beginnen bij nul.

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

De laatste clausule kan worden gescheiden met ~:; in plaats daarvan om het de else-clausule te maken.

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

Als de voorwaardelijke uitdrukking begint met ~:[ , verwacht deze een gegeneraliseerde Booleaanse in plaats van een geheel getal. Het kan slechts twee clausules hebben; de eerste is afgedrukt als de Boolean NIL , en de tweede clausule als deze waar was.

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

Als de voorwaardelijke uitdrukking begint met ~@[ , zou er slechts één clausule moeten zijn die wordt afgedrukt als de invoer, een gegeneraliseerde Booleaanse, waarheidsgetrouw was. De Boolean wordt niet geconsumeerd als deze waarheidsgetrouw is.

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