Imprimir salida y leer entrada en R (print, cat, readline)

Cómo funciona la impresión en R

R tiene una costumbre que ningún otro lenguaje popular comparte: en la consola no necesitas ninguna instrucción de impresión. Escribe el nombre de una variable, pulsa intro y R imprime su valor. Eso es la impresión automática, y por eso los tutoriales de R están llenos de expresiones sueltas.

Pero la impresión automática tiene una frontera estricta: solo se dispara con expresiones en el nivel superior. Dentro de un bucle for o del cuerpo de una función, un valor suelto se evalúa y se tira en silencio:

x <- 42
x

for (i in 1:3) {
    i
}

for (i in 1:3) {
    print(i)
}

La x solitaria se imprime (está en el nivel superior), el primer bucle no imprime absolutamente nada y el segundo imprime 1, 2, 3 porque lo pide explícitamente. "Mi bucle se ejecuta pero no muestra nada" es una de las preguntas más frecuentes sobre R, y esta es toda la respuesta: dentro de bucles y funciones, imprimir siempre es tarea tuya. (Lo mismo aplica cuando ejecutas un script con Rscript - lo que funcionaba línea a línea en la consola puede quedarse mudo dentro de un bucle.)

print(): la formal

print() muestra un valor tal y como R lo ve - lo que la convierte en la herramienta correcta para inspeccionar datos y en la equivocada para una salida pulida:

print("hello")
print(c(10, 20, 30))
print(1:50)

Destacan dos cosas. Las cadenas conservan sus comillas - print() te está enseñando una representación fiel, y las comillas te dicen que es un valor de tipo carácter. Y cada línea empieza con un número entre corchetes como [1]: ese es el índice del primer elemento de esa línea, así que cuando un vector largo se reparte en varias líneas, el corchete de cada una te dice por qué elemento retoma. Es una ayuda de lectura para vectores, no ruido.

Si quieres salida al estilo de print() sin las comillas, tanto print(x, quote = FALSE) como noquote(x) lo hacen - pero normalmente lo que de verdad quieres a esas alturas es cat().

cat(): salida para personas

cat() (concatenar e imprimir) escribe texto en bruto: sin comillas, sin prefijos de índice y con sus argumentos unidos por espacios. El precio de ese control es que no se añade nada por ti - incluido el salto de línea:

cat("no newline here...")
cat("see how this ran on?\n")
cat("Name:", "Ada", "| Score:", 97, "\n")

Olvidar el "\n" es el rito de paso universal de cat() - sin él, la siguiente salida se pega en la misma línea. Que terminar las llamadas a cat() con "\n" se convierta en un reflejo.

La diferencia de comillas entre las dos funciones es en realidad una diferencia en lo que muestran. print() muestra las secuencias de escape tal y como las escribiste; cat() las interpreta:

s <- "col1\tcol2\nval1\tval2"
print(s)
cat(s, "\n")

print() muestra el \t y el \n literalmente entre comillas - útil cuando depuras exactamente qué contiene una cadena. cat() los convierte en un tabulador real y un salto de línea real - útil cuando estás produciendo salida. Elige según la intención: print() para inspeccionar, cat() para presentar.

Informes con formato: sprintf() + cat()

Los argumentos separados por espacios de cat() solo llegan hasta cierto punto. Para una salida alineada y con formato - decimales fijos, contadores rellenados - construye la cadena con sprintf() y pásasela a cat():

scores <- c(88.5, 92.25, 79)
students <- c("Ada", "Grace", "Edsger")

for (i in 1:3) {
    cat(sprintf("%-8s %6.2f\n", students[i], scores[i]))
}

%-8s rellena cada nombre hasta 8 caracteres y %6.2f da a cada puntuación el mismo ancho y dos decimales, así que las columnas quedan alineadas. Esta pareja es el caballo de batalla de R base para mensajes de progreso e informes de texto pequeños (los códigos de formato se cubren en cadenas).

message() y warning(): el otro canal

cat() y print() escriben en la salida estándar - el flujo que contiene los resultados de tu programa. message() y warning() escriben en el error estándar, el flujo para los comentarios sobre la ejecución:

cat("42\n")
message("finished computing the answer")

En pantalla ambos se parecen, pero la separación importa en cuanto rediriges la salida: canaliza el stdout de tu script a un archivo y el 42 acaba en el archivo mientras la nota de estado se queda en el terminal. Esa es la regla general - los resultados a stdout con cat(), los comentarios a stderr con message(). También es la razón por la que message() (y no cat()) es la forma educada en que las funciones y los paquetes hablan con sus usuarios: quien llama puede silenciarlo con suppressMessages() sin perder la salida real.

warning() es más fuerte - "algo no cuadra, pero seguí adelante" - y cuando un script se ejecuta con Rscript, los avisos se recopilan y se muestran juntos al final en lugar de en su sitio (mira errores y depuración para saber leerlos).

Leer la entrada del usuario: readline() y readLines()

Para hacerle una pregunta al usuario en una sesión interactiva (la consola de R o RStudio), usa readline(). Estos ejemplos no se pueden ejecutar en el editor incrustado - el ejecutor de la página no tiene panel de entrada -, así que pruébalos en una consola local:

# Interactive sessions only:
name <- readline("What is your name? ")
cat("Hello,", name, "\n")

age <- as.numeric(readline("Your age? "))
cat("Next year you'll be", age + 1, "\n")

Dos cosas que recordar. readline() siempre devuelve una cadena - conviértela con as.numeric() antes de hacer cálculos y comprueba si el resultado es NA por si el usuario escribió algo que no es un número. Y en un script no interactivo, readline() no espera ninguna entrada; devuelve "" al instante.

Para un script ejecutado con Rscript que deba leer entrada canalizada o escrita, lee de la entrada estándar:

# In a script run as: echo "Ada" | Rscript greet.R
line <- readLines(con = "stdin", n = 1)
cat("Hello,", line, "\n")

readLines(con = "stdin") sin n lee todas las líneas hasta que la entrada termina - la forma estándar de los scripts tipo filtro. Leer archivos de datos es otra tarea con mejores herramientas; empieza por leer CSV cuando tu entrada sea un conjunto de datos y no un teclado.

Lo que te llevas

• La impresión automática solo ocurre en el nivel superior - dentro de bucles y funciones, llama tú a print() o cat().
• print() inspecciona: comillas en las cadenas, prefijos de índice [1], escapes mostrados literalmente.
• cat() presenta: texto en bruto, argumentos unidos por espacios y el "\n" lo pones tú.
• sprintf() + cat() es el patrón de R base para una salida con formato y alineada.
• Los resultados van a stdout (cat), los comentarios a stderr (message, warning).
• readline() para entrada interactiva (¡siempre una cadena!); readLines(con = "stdin") para Rscript.

Lo siguiente: los operadores - aritméticos, de comparación y los lógicos que impulsan cada condición que escribirás.