common-lisp
formato

Parametri

Osservazioni

Uso di base e direttive semplici

I primi due argomenti da formattare sono un flusso di output e una stringa di controllo. L'uso di base non richiede argomenti aggiuntivi. Passando a t mentre lo stream scrive in *standard-output* .

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

Quell'espressione scriverà il Basic Message standard output e restituirà nil .

Passando nil mentre lo stream crea una nuova stringa e la restituisce.

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

La maggior parte delle direttive string di controllo richiedono argomenti aggiuntivi. La direttiva ~a ("estetica") stamperà qualsiasi argomento come se fosse la procedura del princ . Stampa il modulo senza caratteri di escape (le parole chiave vengono stampate senza i due punti iniziali, le stringhe senza le virgolette circostanti e così via).

> (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 input opzionale a destra o a sinistra basato su input aggiuntivi.

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

La direttiva ~s è come ~a , ma stampa caratteri di escape.

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

Iterare su una lista

Si può scorrere su un elenco usando le direttive ~{ e ~} .

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

~^ può essere usato per uscire se non ci sono più elementi rimasti.

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

Un argomento numerico può essere dato a ~{ per limitare il numero di iterazioni che possono essere eseguite:

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

~@{ itererà su argomenti rimanenti, invece di una lista:

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

Le sottoliste possono essere ripetute usando ~:{ :

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

Espressioni condizionali

Le espressioni condizionali possono essere fatte con ~[ e ~] . Le clausole dell'espressione sono separate usando ~; .

Per impostazione predefinita, ~[ prende un numero intero dall'elenco degli argomenti e seleziona la clausola corrispondente. Le clausole partono da zero.

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

L'ultima clausola può essere separata con ~:; invece di renderlo la clausola else.

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

Se l'espressione condizionale inizia con ~:[ , si aspetterà un booleano generalizzato invece di un intero. Può avere solo due clausole; il primo viene stampato se il booleano era NIL , e la seconda clausola se era veritiera.

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

Se l'espressione condizionale inizia con ~@[ , dovrebbe esserci una sola clausola, che viene stampata se l'input, un booleano generalizzato, è veritiero. Il booleano non sarà consumato se è vero.

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