El comando Linux Cat es una de las órdenes más usadas de Linux. Se usa sobre todo para emitir el contenido de un archivo en la línea de comandos, aunque hay una gran cantidad de apli­ca­cio­nes que te mo­s­tra­re­mos en este artículo.

¿Qué es Linux-Cat?

A pesar de su nombre, Linux Cat no tiene nada que ver con gatos. En realidad, este comando hace algo más profano: Linux Cat lee el contenido de archivos y lo emite a la línea de comandos. El origen del nombre viene del concepto “co­n­ca­te­nar”, aunque esto lo ex­pli­ca­re­mos más abajo.

Veamos el modelo básico de una re­pro­du­c­ción de un Linux Cat. Tal y como puedes observar, es­cri­bi­mos primero “cat”, seguido de las opciones si es necesario, y luego el nombre o las rutas de los archivos que se van a emitir:

cat [Opciones] <Nombre(s) del archivo>

Linux Cat es una parte de “GNU Core Utilities” (Coreutils). Esto se trata de una colección de líneas de comando básicas. Los Coreutils son “Free and Open Source Sofware” (FOSS, en español “software libre y de código abierto”) y están di­s­po­ni­bles tan bien como todas las di­s­tri­bu­cio­nes de Linux. El comando Linux Cat está además di­s­po­ni­ble tanto para macOS como para Windows mediante la apli­ca­ción “Su­b­si­s­te­ma de Windows para Linux” (WSL/WSL2).

Consejo

Para de­te­r­mi­nar si el comando Linux Cat está di­s­po­ni­ble en tu sistema, haz lo siguiente: abre una línea de comandos y ejecuta ahí el comando 'which cat'. Si Linux Cat se encuentra en tu sistema, se te mostrará la ruta del archivo binario de cat (p.ej. '/bin/cat'). Si aparece una no­ti­fi­ca­ción de error, significa que Linux Cat no está di­s­po­ni­ble en tu sistema.

Opciones de Linux Cat

Como la mayoría de líneas de comando, Linux Cat se controla por pa­rá­me­tros op­cio­na­les cuando se reproduce. Estas opciones siguen al nombre del comando. Debes tener en cuenta que hay que di­s­ti­n­guir entre ma­yú­s­cu­las y mi­nú­s­cu­las. No­r­ma­l­me­n­te hay dos no­ta­cio­nes para la mayoría de las opciones:

1. Forma corta: -, p.ej. 'cmd -h'

La forma corta es menos relevante. Para ello se pueden combinar varias opciones en una, p.ej. 'ls -la' en lugar de 'ls -l -a'. La forma corta es adecuada para trabajos rápidos con órdenes ya conocidas de la lista de comandos.

2. Forma larga: --, p.ej. 'cmd --help'

La forma larga es fácil de entender, necesita más tiempo para es­cri­bi­r­la y ocupa más espacio. Es adecuada para la creación de scripts. Los nombres re­le­va­n­tes de las opciones sirven de do­cu­me­n­ta­ción.

Aquí te mostramos las opciones de Linux Cat más im­po­r­ta­n­tes:

Opción Ex­pli­ca­ción
-h, --help Ayuda a mostrar el comando Linux Cat
-n Enumera las líneas de salida
-s Combina varias líneas en blanco en una sola
-b Enumera todas las líneas de salida excepto las líneas en blanco
-v Emite ca­ra­c­te­res in­vi­si­bles
-e Igual que -v, pero in­clu­ye­n­do el marcador de fin de línea
-t Igual que -v, pero in­clu­ye­n­do el marcador de pestañas
-et Co­m­bi­na­ción de -e y -t; emite todos los ca­ra­c­te­res in­vi­si­bles

¿Qué significa realmente co­n­ca­te­nar?

El nombre de Linux Cat viene de “co­n­ca­te­nar”, que a su vez proviene del término en latín “catena” (cadena). Co­n­ca­te­nar es un concepto im­po­r­ta­n­te en la in­fo­r­má­ti­ca, ya que describe la co­n­ca­te­na­ción, el en­ca­de­na­mie­n­to o la unión de elementos de es­tru­c­tu­ras de datos co­n­te­ne­do­res similares. En pa­r­ti­cu­lar, en la mayoría de los idiomas se pueden combinar varias matrices o cadenas en una sola matriz o cadena. Con ello, los elementos in­di­vi­dua­les de los co­n­te­ne­do­res co­n­ca­te­na­dos se combinan en un nuevo co­n­te­ne­dor ma­n­te­nie­n­do el orden.

Un ejemplo simple en pseu­do­có­di­go en el pasamos varias cadenas a la función cat y se combinan en una sola cadena:

cat("Pedro ", "y ", "Pablo") -> "Pedro y Pablo"

Linux Cat hace co­n­ce­p­tua­l­me­n­te lo mismo: utiliza como elementos las líneas agrupadas dentro de los archivos.

Los distintos lenguajes de pro­gra­ma­ción utilizan diversos símbolos para el operador de co­n­ca­te­na­ción de cadenas. Aquí te mostramos algunos ejemplos de los lenguajes de pro­gra­ma­ción más populares. En todos los casos, el resultado de la co­n­ca­te­na­ción es la cadena “Pedro y Pablo”:

Operador Lenguaje(s) Ejemplo
+ Java, Ja­va­S­cri­pt, Python Pedro + "y" + " Pablo"
. PHP, Perl Pedro . "y" . " Pablo"
.. Lua Pedro .. "y" .. " Pablo"
~ Twig Pedro ~ "y" ~ " Pablo"
& Vi­sua­l­Ba­sic Pedro & "y" & " Pablo"

En algunos lenguajes, es­pe­cia­l­me­n­te en Python, se utiliza el mismo operador para co­n­ca­te­nar otras es­tru­c­tu­ras de datos, como las listas:

# Concatenar listas
[1, 2, 3] + [45, 56, 67]
# -> [1, 2, 3, 45, 56, 67]
# SIN constituir:
# [[1, 2, 3], [45, 56, 67]]
# Concatenar registro
(1, 2) + (33, 44)
# -> (1, 2, 33, 44)

El lenguaje es­ta­dí­s­ti­co “R” es in­te­re­sa­n­te: no conoce ningún operador de co­n­ca­te­na­ción. En su lugar, usa la opción 'c()'. La “c” ahí significa “co­n­ca­te­nar”. Aquí te mostramos una co­n­ca­te­na­ción anidada en varios valores:

c(c(1, 2, 3), c(45, 56, 67))
# -> 1, 2, 3, 45, 56, 67

¿Cómo se utiliza Linux Cat en la práctica?

Los usos reales de Linux Cat son limitados, ya que sigue la filosofía UNIX “do one thing and do it well” (“haz una cosa y hazla bien”). La mayoría de los es­ce­na­rios de apli­ca­ción resultan de la en­ca­de­na­ción de la orden con otros comandos. Con ello, se utilizan re­di­re­c­cio­na­mie­n­tos de la entrada y salida estándar. En concreto, se trata de las llamadas tuberías y re­di­re­c­cio­na­mie­n­tos. Estos son pro­po­r­cio­na­dos por el shell (también llamado “in­té­r­pre­te de comandos”) y su uso se extiende a todos los comandos:

De­s­via­ción Símbolo Apli­ca­ción Ex­pli­ca­ción
Pipe | cmd1 | cmd2 Reenvía la salida del comando cmd1 a la entrada del comando cmd2
Input-Redirect < cmd < data Lee los datos de entrada del comando cmd del archivo
Output-Redirect > cmd > data Escribe los datos de salida del comando cmd en el archivo; si es necesario, se so­bre­s­cri­be el archivo ya existente
Output-Redirect >> cmd >> data Escribe los datos de salida del comando cmd en el archivo; si es necesario, se amplía el archivo ya existente

Linux Cat suele comenzar con una sucesión de otros comandor Linux. Aquí te mostramos los más usados:

Comando Linux Ex­pli­ca­ción
split Divide el archivo en trozos; la operación se puede invertir con cat
uniq Elimina las líneas de entrada que aparecen más de una vez
sort Ordena las líneas de entrada de forma al­fa­nu­mé­ri­ca
head, tail Limita la salida a las líneas al principio/final

Veamos ahora los es­ce­na­rios de apli­ca­ción comunes de Linux Cat:

Di­s­tri­bu­ción de archivos en la línea de comandos con Linux Cat

El uso más común de Linux Cat es el de mostrar todo el contenido de un archivo en la línea de comandos. Esto es útil para echar un vistazo rápido a un archivo. A di­fe­re­n­cia de lo que ocurre al abrir el archivo en un editor, no tienes que preo­cu­par­te por cambiar el archivo ac­ci­de­n­ta­l­me­n­te. Aquí tienes un ejemplo de salida de un archivo en la línea de comandos:

cat ./path/to/file.txt

Veamos un par de es­ce­na­rios comunes. Imagina que has iniciado sesión a través de SSH en un servidor que funciona mediante WordPress. Te en­cue­n­tras en el di­re­c­to­rio raíz de WordPress y quieres mostrar el contenido del archivo de co­n­fi­gu­ra­ción 'wp-config.php'. Entonces tendrás que utilizar el siguiente comando de Linux Cat:

cat wp-config.php

A menudo es su­fi­cie­n­te con la salida de un archivo en la línea de comandos. En algunos casos, sin embargo, queremos copiar el contenido del archivo en el po­r­ta­pa­pe­les. La salida visible en la línea de comandos puede suponer un riesgo con los datos sensibles. En ambos casos, es una buena idea reenviar la salida de Linux Cat a un programa que escriba los datos en el po­r­ta­pa­pe­les. En macOS, la he­rra­mie­n­ta de línea de comandos 'pbcopy' está di­s­po­ni­ble para esta finalidad; en Windows con WSL/2 y las diversas di­s­tri­bu­cio­nes de Linux, están di­s­po­ni­bles he­rra­mie­n­tas equi­va­le­n­tes como 'clip' o 'xclip'.

Veamos el siguiente ejemplo: queremos copiar nuestra clave pública SSH para la co­n­fi­gu­ra­ción de un re­po­si­to­rio de software GitHub. Su­po­nie­n­do que la clave con el nombre 'id_rsa.pub' se encuentra en el di­re­c­to­rio '.ssh/' en nuestro di­re­c­to­rio de usuario, podemos hacer el truco en macOS con el siguiente comando de Linux Cat:

cat ~/.ssh/id_rsa.pub > pbcopy

Tal y como indica el nombre de Linux Cat, éste deja que se combinen varios archivos y que se emitan en uno solo. Ima­gi­ne­mos que tenemos una lista con frutas, verduras y productos lácteos en tres archivos guardados bajo el nombre 'food/'. De la siguiente manera podremos combinar las tres listas en una sola y es­cri­bi­r­las en un archivo llamado 'food.txt':

cat ./food/fruit.txt ./food/veggies.txt ./food/dairy.txt > food.txt

Como es habitual en la línea de comandos, podemos usar el marcador de posición '*' para elegir todos los archivos de un di­re­c­to­rio:

cat ./food/*.txt > food.txt

Escribir un texto en un archivo con Linux Cat

Con el uso de las de­s­via­cio­nes de salidas que se han me­n­cio­na­do an­te­rio­r­me­n­te, puedes escribir un texto en un archivo con Linux Cat. Esto se puede hacer de tres formas:

  1. Crear un archivo nuevo en el que vas a escribir el texto in­tro­du­ci­do.
  2. So­bre­s­cri­bir un archivo que ya existe con el texto in­tro­du­ci­do.
  3. Adjuntar el texto in­tro­du­ci­do en un archivo ya existente.

Veamos los tres es­ce­na­rios. En primer lugar, vamos a escribir un texto de la línea de comandos en un archivo que no existe:

  1. Emitir Linux Cat y reenviar la salida a un archivo que no existe. El comando cogerá los datos de la entrada estándar hasta que se lea el carácter de fin de archivo (“End-of-file”, EOF):
cat > new.txt
  1. Meter el texto que deseas en la línea de comandos.
  2. Finalizar la entrada pulsando la co­m­bi­na­ción de teclas [Ctrl] + [D]. Esta co­m­bi­na­ción de teclas co­rre­s­po­n­de al carácter de fin de archivo.

El texto in­tro­du­ci­do se encuentra en el archivo 'new.txt'. Esto se puede comprobar a través del comando 'cat new.txt'.

Para adjuntar un texto in­tro­du­ci­do en un archivo ya existente usamos el mismo método:

  1. Emitir Linux Cat y reenviar la salida a un archivo que existe:
cat >> existing.txt
  1. Meter el texto que deseas en la línea de comandos.
  2. Finalizar la entrada pulsando la co­m­bi­na­ción de teclas [Ctrl] + [D].

Si usamos el símbolo '>' en lugar del reenvío de salida '>>', se so­bre­s­cri­be el archivo existente con el texto in­tro­du­ci­do. Ten cuidado con esto: el contenido anterior del archivo se pierde de manera irre­vo­ca­ble.

Preparar datos para otros trabajos con Linux Cat

Un uso común de Linux Cat es combinar datos de varios archivos. A menudo, los datos co­m­bi­na­dos se pasan por filtros para pre­pa­rar­los para su posterior pro­ce­sa­mie­n­to. Este patrón siempre se encuentra cuando hay datos similares re­pa­r­ti­dos en varios archivos. Cada uno de los archivos contiene una entrada por línea. Piensa, por ejemplo, en listas de nombres, di­re­c­cio­nes IP o similares.

Para tener una visión general de todas las ca­ra­c­te­rí­s­ti­cas de los datos, se plantea la siguiente tarea: queremos combinar todas las entradas y eliminar las que estén du­pli­ca­das. Por último, deben cla­si­fi­car­se las entradas y es­cri­bi­r­se en un archivo nuevo. Como ejemplo concreto, ima­gi­ne­mos que tenemos un conjunto de archivos de texto. Cada archivo contiene los nombres de los actores de un de­te­r­mi­na­do episodio de la serie de cómics “Los Simpsons”. Si co­m­bi­na­mos las entradas de todos los archivos como se ha descrito, obtenemos una lista de todos los actores de Los Simpsons.

Los archivos descritos en nuestro ejemplo con los actores de Los Simpsons de los episodios in­di­vi­dua­les se verían de una manera es­que­má­ti­ca parecida a esta:

simpsons-1.txt simpsons-2.txt simpsons-3.txt
Lisa Bart Bart
Marge Lisa Maggie
Homer Homer Nelson
Flanders Milhouse

Ima­gi­ne­mos que los archivos de texto in­di­vi­dua­les se en­cue­n­tran en el di­re­c­to­rio 'simpsons/'. Entonces solo será su­fi­cie­n­te el uso de Linux Cat, co­n­ca­te­na­do con los comandos 'uniq' y 'sort', para escribir la lista con todos los actores de Los Simpsons en el archivo 'simpsons.txt'.

cat ./simpsons/*.txt | uniq | sort > simpsons.txt

Numerar líneas de un archivo de texto con Linux Cat

Un uso común de Linux Cat es el de numerar las líneas en un archivo de texto. Ima­gi­ne­mos que tenemos un archivo de texto con una entrada por línea, pero queremos escribir delante de cada línea el número de esta. Esto es útil, por ejemplo, cuando damos el archivo re­su­l­ta­n­te a otra parte para que lo revise. De este modo, ambas partes pueden referirse a líneas es­pe­cí­fi­cas en la co­rre­s­po­n­de­n­cia.

Con Linux Cat es muy fácil nu­me­rar­las. Usamos la opción '-n' y una re­di­re­c­ción de la salida:

cat -n doc.txt > doc.numbered.txt

En el escenario descrito tiene sentido numerar todas las líneas, excepto las vacías. Además, co­m­bi­na­mos varias líneas en blanco en una sola. Para ello, uti­li­za­mos la co­m­bi­na­ción de las opciones '-s' y '-b':

cat -sb doc.txt > doc.numbered.txt

Combinar archivos de plantilla con Linux Cat

Un patrón conocido de la pro­gra­ma­ción web consiste en ensamblar do­cu­me­n­tos a partir de piezas de conjunto. La co­m­bi­na­ción de las llamadas partes de la plantilla con las partes únicas da lugar a diversos do­cu­me­n­tos con una es­tru­c­tu­ra coherente. Para esto no­r­ma­l­me­n­te se utiliza PHP con la orden 'include' o un lenguaje especial de pla­n­ti­llas como Twig, pero el mismo principio se puede im­ple­me­n­tar con Linux Cat.

Su­po­n­ga­mos que tenemos varias partes de pla­n­ti­llas en el di­re­c­to­rio 'parts/'. La cabecera y el pie de página tienen que ser idénticos en todos los do­cu­me­n­tos creados. La es­tru­c­tu­ra y el contenido de la cabecera y del pie de página se definen en los archivos 'header.html' y 'footer.html'. Además, hay varios archivos con el contenido real de los do­cu­me­n­tos en el di­re­c­to­rio 'main/'. Los do­cu­me­n­tos te­r­mi­na­dos se almacenan en el di­re­c­to­rio de salida 'www/'. Para crear un documento solamente tienes que hacer uso de Linux Cat:

cat ./parts/header.html ./main/home.html ./parts/footer.html > ./www/index.html

Otro escenario: hay que pro­po­r­cio­nar un texto de licencia a una base de códigos para poder pu­bli­car­lo. La licencia debe in­se­r­tar­se al principio de cada archivo de código. Ima­gi­ne­mos la co­m­po­si­ción de di­re­c­to­rios siguiente:

  • Archivos de código fuente de Python con extensión '.py' en el di­re­c­to­rio 'src/'
  • Un archivo de licencia 'license.py' en el di­re­c­to­rio 'inc/'
  • Un di­re­c­to­rio 'dist/' vacío al principio para almacenar los archivos pro­ce­sa­dos

Usamos Linux Cat dentro de un bucle for. En cada ejecución del bucle, el mismo archivo de licencia se concatena con uno de los archivos de código fuente. El resultado se escribe en un nuevo archivo de código fuente con el mismo nombre:

for file in ./src/*.py ; do
    cat ./inc/license.py "$file" > "./dist/${file}"
done

Fusionar archivos divididos con Linux Cat

Linux Cat se usa ma­yo­ri­ta­ria­me­n­te para el pro­ce­sa­mie­n­to de archivos de texto planos, aunque el comando también funciona con archivos binarios. Esto es útil es algunos es­ce­na­rios. Por un lado, los comandos de Linux 'split' o 'csplit' pueden uti­li­zar­se para volver a montar archivos que han sido divididos en varias partes. Aquí te mostramos el enfoque general:

# Nombre del archivo que hay que descomponer
file_name="./path/to/file"
# Especificamos de manera explícita la extensión del archivo para añadirla después de la fusión
extension="txt"
# Dividimos el archivo original en trozos de 10 kilobytes con el prefijo 'part_'
split -b 10k "${file_name}.${extension}" part_
# Fusionamos las piezas individuales en el archivo nuevo
cat part_* > combined
# Restauramos la extensión original del archivo
mv combined "combined.${extension}"

Por otro lado, Linux Cat se ofrece a combinar descargas parciales. Muchas he­rra­mie­n­tas pueden in­te­rru­m­pir las descargas y reanu­dar­las más tarde. Esto es es­pe­cia­l­me­n­te útil cuando se descarga un archivo grande a través de una conexión de red débil. Prueba el ejemplo en tu propio sistema:

# Creamos una carpeta de prueba en el escritorio
mkdir ~/Desktop/cat-test/
# Lo cambiamos a la carpeta de prueba
cd ~/Desktop/cat-test/
# Imagen de un gato de dominio público de WikiMedia
image=https://upload.wikimedia.org/wikipedia/commons/f/fa/Cat_using_computer.jpg
# Descargamos la imagen en dos partes con 'curl'
curl -s -r 0-500000 "$image" -o first-half &
curl -s -r 500001- "$image" -o second-half &
wait
# Combinar las partes y escribir en el archivo JPGE
cat first-half second-half > image.jpg

Combinar flujos de datos con Linux Cat

Linux Cat se puede usar para combinar flujos de datos en el pro­ce­sa­mie­n­to de vídeo. Aquí te mostramos el patrón general. En primer lugar, creamos varios flujos de vídeo cortos a partir de una imagen JPEG con el comando ffmpeg y luego los co­m­bi­na­mos en un vídeo continuo:

# Creamos un bucle a partir de la imagen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1 \
    still.ts
# Creamos un fundido claro en la imagen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=in:0:75 \
    fadein.ts
# Creamos un fundido oscuro en la imagen
ffmpeg -y -loop 1 -i image.jpg -t 3 \
    -c:v libx264 -vf scale=w=800:h=-1,fade=out:0:75 \
    fadeout.ts
# Combinamos ambos fundidos y el bucle
cat fadein.ts still.ts fadeout.ts > video.ts

¿Cuándo no hay que utilizar Linux Cat?

El uso in­ne­ce­sa­rio de Linux Cat es un conocido “an­ti­pa­trón”. Esto se describe en numerosos artículos; incluso hay un “Useless Use of Cat Award”. Como regla de oro, se debe utilizar Linux Cat cuando se combinan varios archivos. Si quieres procesar un solo archivo, puedes hacerlo sin un cat.

Echemos un vistazo al enfoque general con cuya ayuda podemos minimizar el uso in­ne­ce­sa­rio de Linux Cat. El siguiente ejemplo se puede encontrar a menudo en mensajes de foros y artículos de blogs:

cat example.txt | less

Linux Cat se utiliza para leer un solo archivo. La salida se pasa a través de la re­di­re­c­ción de tuberías al comando less para mostrar el contenido del archivo página por página. Sin embargo, esto también puede hacerse de forma más sencilla:

less < example.txt

Usamos el commando less y la re­di­re­c­ción de entrada del shell para leer el archivo. E incluso este pla­n­tea­mie­n­to puede si­m­pli­fi­car­se aún más:

less example.txt

En lugar de usar una re­di­re­c­ción de entrada, tra­n­s­fe­ri­mos a procesar el archivo al comando less. Esto se debe a que casi todos los comandos de Linux reciben los nombres de los archivos como pa­rá­me­tros.

¿Qué al­te­r­na­ti­vas a Linux Cat existen?

Como hemos descrito an­te­rio­r­me­n­te, Linux Cat se utiliza a menudo de forma in­ne­ce­sa­ria. Para algunos de los es­ce­na­rios de uso más comunes existen al­te­r­na­ti­vas. Aquí te mostramos tres ejemplos:

Comando Uso al­te­r­na­ti­vo Ejemplo
less / more Emitir el contenido del archivo página por página en la línea de comandos less file.txt, more file.txt
touch Crear un archivo nuevo y vacío touch new.txt
echo Escribir un texto en el archivo echo "Text" > file.txt

¿Qué otros comandos se parecen a Linux Cat?

Hay una serie de comandos de Linux que son similares al comando cat. De hecho, los nombres de estos comandos a menudo se basan en “cat”. En primer lugar, está el comando tac, cuyo nombre es si­m­ple­me­n­te cat invertido. Y así es como funciona el comando tac: como el comando cat de Linux, sólo que con la salida invertida. Así, cuando se llama al comando tac con un solo archivo, se emite primero la última línea, en lugar de la primera como con cat.

Otro comando con un nombre similar a Linux Cat es el comando nc, abreviado como “Netcat”. Este comando se suele denominar como la "navaja suiza de TCP/IP". En lugar de operar en archivos locales como cat, Netcat lee y escribe datos a través de co­ne­xio­nes de red. Si quieres saber más sobre esto, puedes leer nuestro artículo sobre el tema.

Una al­te­r­na­ti­va más reciente a Linux Cat es el comando bat. En la página de GitHub del comando, se llama “un clon de cat con alas” (en inglés, “A cat clone with wings”). El comando bat conserva la fu­n­cio­na­li­dad básica de Linux Cat, pero pro­po­r­cio­na algunas funciones de comodidad. En pa­r­ti­cu­lar, provee de la salida de los archivos de código fuente a través del comando bat con resaltado de sintaxis.

Ir al menú principal