common-lisp
formato

Parámetros

Observaciones

Uso básico y directivas simples

Los primeros dos argumentos para dar formato son una secuencia de salida y una cadena de control. El uso básico no requiere argumentos adicionales. Al pasar t como la secuencia se escribe en *standard-output* .

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

Esa expresión escribirá el Basic Message en la salida estándar y devolverá nil .

Al pasar nil como la secuencia crea una nueva cadena y la devuelve.

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

La mayoría de las directivas de cadenas de control requieren argumentos adicionales. La directiva ~a ("estética") imprimirá cualquier argumento como por el procedimiento de princ . Esto imprime el formulario sin caracteres de escape (las palabras clave se imprimen sin los dos puntos iniciales, las cadenas sin las comillas circundantes, 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 opcionalmente derecha o izquierda de pads basada en entradas adicionales.

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

El ~s directiva es como ~a , pero imprime caracteres de 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\""

Iterando sobre una lista

Uno puede iterar sobre una lista usando las directivas ~{ y ~} .

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

~^ puede usarse para escapar si no quedan más elementos.

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

Se puede dar un argumento numérico a ~{ para limitar cuántas iteraciones se pueden hacer:

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

~@{ iterará sobre los argumentos restantes, en lugar de una lista:

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

Las sublistas pueden ser iteradas usando ~:{ :

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

Expresiones condicionales

Las expresiones condicionales se pueden hacer con ~[ y ~] . Las cláusulas de la expresión se separan usando ~; .

De forma predeterminada, ~[ toma un número entero de la lista de argumentos y selecciona la cláusula correspondiente. Las cláusulas comienzan en cero.

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

La última cláusula se puede separar con ~:; en su lugar para que sea la cláusula 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!

Si la expresión condicional comienza con ~:[ , esperará un booleano generalizado en lugar de un entero. Solo puede tener dos cláusulas; el primero se imprime si el valor booleano es NIL , y la segunda cláusula si es veraz.

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

Si la expresión condicional comienza con ~@[ , solo debería haber una cláusula, que se imprime si la entrada, un booleano generalizado, era veraz. El booleano no se consumirá si es veraz.

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