ÓRDENES “FILTRO” cat, more, less, sort, grep, head, tail, wc, tee, tr, cut,

paste, join, nl, uniq.

ÓRDENES “BUSCAR”,
find, locate (slocate) y updatedb, which, whereis, file,
“TIPO ORDEN/FICHERO”,
type, cmp, comm, diff, script.
“COMPARAR”,...

COMANDOS “m” mdir, mcd, mmd, mrd, mdeltree, mren, mtype, mcopy, mmove,
(“mtools”) mdel, mformat, mattrib,...

ÓRDENES “FILTRO” cat, more, less, sort, grep, head, tail, wc, tee, tr, cut,
paste, join, nl, uniq.

1. Leen los datos de la “entrada estándar” (por defecto, el teclado: /dev/stdin,

descriptor nº “0”) o leen los datos de un(os) “fichero(s)” (redirección de la
entrada) o leen los datos de la “salida de una orden” (canalización).
2. Procesan (filtran) los datos (por ejemplo: paginan, ordenan, buscan, cortan,...).
3. Escriben el resultado en la “salida estándar” (por defecto, la pantalla: “salida
normal” en /dev/stdout, descriptor nº “1”; “salida de error” en /dev/stderr,
descriptor nº “2”) o escriben el resultado en un “fichero” (redirección de la
salida).

1. ENTRADA 2. PROCESO 3. SALIDA

ENTRADA ESTÁNDAR SALIDA ESTÁNDAR NORMAL
TECLADO (Por defecto) PANTALLA (Por defecto)
/dev/stdin /dev/stdout
Nº descriptor “0” Nº descriptor “1”

SALIDA ESTÁNDAR DE ERROR

FICHERO
Redirección entrada: < (0<) FILTRO PANTALLA (Por defecto)
/dev/stderr
Nº descriptor “2”

FICHERO
Redirección salida: > (1>)
ORDEN CON SALIDA >> (1>>)
Canalización: | 2>
2>>
&> (2>&1)

Formatos entrada:
- Leer los datos de la “entrada estándar” (teclado) (No tiene utilidad):
filtro [-opciones] [argumentos]
- Leer los datos de un(os) “fichero(s)” (redirección entrada) (Se asume “<”):
filtro [-opciones] [argumentos] [<] fichero(s)
- Leer los datos de la “salida de una orden” (canalización):
orden con S | filtro [-opciones] [argumentos] | filtro [-opciones] [argumentos]...
Formatos salida:
- Escribir el resultado de “salida normal” en un “fichero” (redirección salida
normal):
orden-filtro > fichero-salida-normal
- Escribir el resultado de “salida de error” en un “fichero” (redirección salida de
error):
orden-filtro 2> fichero-salida-error
- Escribir el resultado de “salida normal” y de “salida de error” en el mismo
“fichero” (redirección ambas salidas al mismo fichero):
orden-filtro &> fichero-salida o orden-filtro 2>&1 fichero-salida

2001-2003 Virgilio Silva Martín 1/1

=> cat
Filtro:
- Mostrar el contenido de un fichero.
- Unir varios ficheros.
- Crear un fichero (^D para terminar). (Mejor usar un editor como “vi” o “joe”).
cat [-opciones] [fichero(s)]
Opciones:
-n numerar líneas
Ejemplos:
Mostrar contenido de un fichero:
cat [<] /etc/passwd
Unir ficheros en pantalla:
cat /etc/passwd /etc/group
Unir ficheros en otro fichero:
cat /etc/passwd /etc/group > ~/passwd-group
Crear un fichero (^D para terminar):
cat > $HOME/practicas/prueba.txt

=> more
Filtro: Paginar un fichero o la salida de una orden (sólo hacia delante).
more [-opciones] [fichero(s)]
orden con S | more [-opciones]
Ejemplos:
Paginar un fichero:
more /etc/passwd
cat /etc/passwd | more
Paginar la salida de orden:
ls –laiR | more

=> less
Filtro: Paginar un fichero o la salida de una orden (hacia delante y hacia atrás).
less [-opciones] [fichero(s)]
orden con S | less [-opciones]
Ejemplos:
Paginar un fichero:
less /etc/passwd
cat /etc/passwd | less
Paginar la salida de una orden:
ls –laiR | less

=> sort
Filtro: Ordenar las líneas de un fichero o la salida de una orden por el primer
carácter (y por los siguientes caracteres si fuera necesario).
(Para una misma letra, min antes que MAY). (Números ordenados por su representación
ASCII, no por su valor, de modo que, por ejemplo, “100” está antes que “40”, ya que
“1” antes que “4”).
sort [-opciones] [fichero(s)]
orden con S | sort [-opciones]
Opciones:
Globales, [pueden escribirse de forma independiente (“–opción”, con guión) o pueden
formar parte de un campo clave (“opción”, sin guión) (tienen preferencia sobre las
opciones escritas de forma independientes)]:
-b Ignorar “blancos” al principio.
-d Ordenar tipo “diccionario” (sólo tiene en cuenta letras,
dígitos y “blancos”).
-f Convertir min a MAY al comparar (ignorar diferencia
MAY/min para la misma letra). (Para una misma letra, min
antes que MAY).
-n Ordenar por el valor numérico, no por su representación
ASCII. (Números ordenados por su representación ASCII, no

2001-2003 Virgilio Silva Martín 2/2

 por su valor, de modo que, por ejemplo, “100” está antes
que “40”, ya que “1” antes que “4”).
-r Ordenar en sentido inverso.
Opciones específicas:
-k POS1[,POS2][-k ...] Clave de ordenación. Puede ser más de una clave de
ordenación, separadas por espacio, que se tendrían en
cuenta en caso de igualdad de las claves anteriores.
POS1 = nºcampo[.nºcarácterdesdeprincipiocampo]. Comienzo
de la clave (por defecto, desde el principio de la línea).
POS2 = nºcampo[.nºcarácterdesdeprincipiocampo]. Final de
la clave. (por defecto, hasta el final de la línea).
POS1 y POS2 pueden llevar opciones globales (sin “-”), en
cuyo caso las opciones globales no son usadas para dicho
campo.
-t carácter Carácter delimitador (separador) de campos (por defecto,
“ESPACIO” o “TAB”).
-o fichero Sustituir el fichero de entrada por el resultado ordenado
(no vale usar simplemente la redirección de la salida, ya
que como el fichero de salida se crea antes de ejecutar la
orden, se destruiría el fichero de entrada).
-u Mostrar líneas “únicas” (eliminar líneas repetidas).
Ejemplos:
Fichero de ejemplo “agenda.dat”:
Nombre(1º) Apellidos(2º) Ciudad(3º) Edad(4º) Teléfono(5º)
---------- ---------- --------- ------------- -- ---------
------- -------- ------ ------- -- ---------
Ordenar fichero “agenda.dat” por “nombre” (por defecto, campo 1º). Si “nombres”
iguales, se comprueban siguientes campos (hasta final de línea):
sort ~/agenda.dat
Ordenar fichero “agenda.dat” por “apellidos” (campo 2º). Si “apellidos” iguales, se
comprueban siguientes campos (hasta final de línea):
sort –k 2 ~/agenda.dat
Ordenar fichero “agenda.dat” por “apellidos” (campo 2º) y “ciudad” (campo 3º). Si
“apellidos” y “ciudad” iguales, no se comprueban siguientes campos y se dejan las
líneas en el orden actual:
sort –k 2,3 ~/agenda.dat
Ordenar fichero “agenda.dat” por “apellidos” (campo 2º). Si “apellidos” iguales,
ordenar por “nombre” (campo 1). Si “nombres” iguales, ordenar por valor numérico
(“n”) “edad” (campo 4). Si “apellidos”, “nombre” y “edad” iguales, no se comprueban
siguientes campos y se dejan las líneas en el orden actual:
sort –k 2,2 –k 1,1 –k 4,4n ~/agenda.dat (-k 4,4n = -k 4n,4 = -k 4n,4n)
Ordenar fichero “agenda.dat” por “apellidos” (campo 2º). Si “apellidos” iguales, se
comprueban siguientes campos (hasta final de línea). El resultado se guarda en el
fichero “agenda.dat.ordenado”:
sort –k 2 ~/agenda.dat > ~/agenda.dat.ordenado
sort –k 2 –o ~/agenda.dat.ordenado ~/agenda.dat
Ordenar fichero “agenda.dat” por “apellidos” (campo 2º). Si “apellidos” iguales, se
comprueban siguientes campos (hasta final de línea). El resultado se guarda en el
mismo fichero “agenda.dat” (hay que usar opción “-o”; no vale redirigir la salida, ya
que en tal caso, antes de ordenar, se crearía el fichero “agenda.dat”, con lo que se
perderían sus datos):
sort –k 2 –o ~/agenda.dat ~/agenda.dat
Ordenar fichero “/etc/passwd” por valor numérico (“-n”) “UID” (campo 3º). Separador
de campos carácter “:”:
sort –k 3,3 –n –t : /etc/passwd
Ordenar fichero “/etc/passwd” por “datos personales” (campo 5º), ignorando blancos
(“b”)). Si “datos personales” iguales, ordenar por valor numérico (“n”) de “UID”
(campo 3º). Separador de campos carácter “:”:
cat /etc/passwd | sort –k 5,5b –k 3,3n –t “:”
Ordenar un fichero numéricamente por el 2º campo y, si iguales, ordenar
alfabéticamente por los caracteres 3º y 4º del campo 5º, carácter separador “:”:
sort –t : –k 2,2n –k 5.3,5.4 ~/fich.txt
Ordenar los usuarios conectados por su “login”:
who | sort

2001-2003 Virgilio Silva Martín 3/3

=> grep (Global Regular Expression and Print)(General Regular Expression Parser)
(fgrep “f”=fast/rápido) (egrep “e”=extend/extendido)
Filtro: Buscar un texto o un “patrón” (“expresión regular”: texto que contiene
caracteres “normales” y caracteres “especiales” que describen diferentes conjuntos de
texto) en las líneas de un(os) fichero(s) o en la salida de una orden y mostrar las
líneas que lo contienen. (Si varios ficheros, se muestran los nombres de los ficheros
antes de las líneas).
“grep” (“grep –G”) Múltiples búsquedas. “Expresiones regulares” básicas (“^”,
“$”, “\<”, “\>”, “[caracteres]”, “[^caracteres]”, “.”).
“fgrep” (“grep –F”) Búsquedas múltiples en líneas diferentes (después de “ENTER”)
y entrecomillados. No “expresiones regulares”.
“egrep” (“grep –E”) Múltiples búsquedas. “Expresiones regulares” extendidas
(caracteres “|”, “()”, “?”, “*”, “+”, {n}, {n,}, {,m},{n,m}).
grep [-opciones] texto o “patrón” [fichero(s)]
orden con S | grep [opciones] texto o “patrón”
Opciones:
-v Mostrar las líneas que “no” contienen el texto.
-n Mostrar cada línea con el número de línea que ocupa en el fichero de entrada.
-c Mostrar sólo la cantidad (nº) de líneas (“no” las líneas).
-i Ignorar diferencia MAY/min.
-l Mostrar los nombres de ficheros que contienen el texto (“no” las líneas).
-L Mostrar los nombres de ficheros que “no” contienen el texto (“no” las líneas).
-w Mostrar las líneas que contienen el texto como palabra completa (ver más
adelante: equivale a “\<caracteres\>”).
-x Mostrar las líneas que contienen el texto como único contenido de la línea (ver
más adelante: equivale a “^caracteres$”).
Patrones (sólo algunos):
^caracteres Línea empieza por “caracteres”
caracteres$ Línea termina por “caracteres”
\<caracteres Palabra empieza por “caracteres”
caracteres\> Palabra termina por “caracteres”
[caracteres] Línea contiene cualquier “caracteres” de una lista (por
ejemplo: [aeiou], [AaZz], [A-Z]) o de un rango (por
ejemplo: [a-z], [0-9], [a-z0-9]). Existen clases de
caracteres predefinidos (ver man grep): [:alpha:],
[alnum:], [digit:], [:lower:], [:upper:],...( Por ejemplo,
[:alnum:] equivale a [A-Za-z0-9]).
[^caracteres] Línea no contiene ningún “caracteres” de la lista o rango.
caracteres-1\|caracteres-2 Línea contiene “cadena-1” o “cadena-2” (sin espacios para
que no formen parte de ninguno de los conjuntos de
caracteres).
(caracteres) Caracteres se tratan como grupo.
. (Punto) Cualquier carácter.
Nota:
Usar “entrecomillado” (caracteres \ o “” o ‘’) para que los caracteres “<”, “>”, “|”,
“*”... pierdan su significado especial para el shell y tengan el significado usado
por la orden “grep”.
Ejemplos de texto o “patrones”:
gato Línea contiene “gato” o “gatos” o “maragatos” (es decir,
palabra entera o parte de palabra).
^gato Línea empieza por “gato”.
gato$ Línea termina por “gato”.
^gato$ Línea empieza y termina por “gato” (es decir, línea sólo
contiene “gato”).
[Gg]at[oa] Línea contiene “Gato”, “gato”, “Gata” o ““gata”.
ga[^aeiou]o Tercer carácter no es vocal
ga.o Tercer carácter cualquiera
^....$ Línea empieza y termina por 4 caracteres cualesquiera
(es decir, línea sólo contiene 4 caracteres
cualesquiera).
\<ga Línea contiene palabra que empieza por “ga”.
to\> Línea contiene palabra que termina en “to”.

2001-2003 Virgilio Silva Martín 4/4

 \<gato\> Línea contiene la palabra “gato” (es decir, palabra
entera).
^[.] Línea comienza por “punto”.
^[^.] Línea no comienza por “punto”.
[.]$ Línea termina en “punto”.
[Aa]lgun[ao]\|[Nn]ingun[ao] Línea contiene “Alguna” o “Alguno” o “alguna” o “alguno”
o “Ninguna” o “Ninguno” o “ninguna” o “ninguno”.
([Aa]l\|[Nn]in)gun[ao] Idem.
Ejemplos:
Buscar usuario “jmartin” (todo en minúscula):
grep jmartin /etc/passwd
Buscar usuario “jmartin” (en MAY o min):
grep –i jmartin /etc/passwd
Buscar usuarios que no sean del grupo “alumnos” (grupo “1001”):
grep –v “:1001:” /etc/passwd
Buscar cuántos usuarios (nº) no son del grupo “alumnos” (grupo “1001”):
grep –v –c “:1001:” /etc/passwd
Líneas comienzan por “d” (directorios). (Las “” no son necesarias):
ls –l /usr | grep “^d”
Ficheros ejecutables (*) que terminan en “s”:
ls –lF /bin | grep ‘s\*$’
Buscar “elementos” que sean de “Gran Canaria” o de “Tenerife”:
cat ~/agenda.dat | grep –i “Gran Canaria” \| Tenerife
Buscar los archivos del directorio “home” que contienen el texto “gato”:
grep gato ~/*
Ejemplos de búsqueda con “fgrep”, “grep” y “egrep”. Buscar “gato” o “triste” en un
fichero:
$ fgrep “gato[ENTER]
> triste” ~/gatos.txt[ENTER]
$ grep “gato\|triste” ~/gatos.txt
$ egrep gato\|triste ~/gatos.txt o $ egrep “gato|triste” ~/gatos.txt

=> head
Filtro: Mostrar la primera parte de un fichero o de la salida de una orden, por
defecto, las 10 primeras líneas.
head [-opciones] [fichero(s)]
orden con S | head [-opciones]
Opciones:
-n nº o -nº Primeras nº líneas.
-c nº Primeros nº caracteres (bytes).
-c nºb Primeros nº bloques (512 bytes).
-c nºk Primeros nº kb (1 kb = 1.024 bytes).
-c nºm Primeros nº mb (1 mb = 1.024 kb= 1.048.576 bytes).
Ejemplos:
Primeras 10 líneas de un fichero:
head /etc/passwd
Primeras 20 líneas de un fichero:
head -n 20 /etc/passwd
Primeros 2.048 kb de un fichero:
head -c 2k ~/datos.txt
Primeras 5 líneas de un listado:
ls -l /etc | head -5

=> tail
Filtro: Mostrar la última parte de un fichero o de la salida de una orden, por
defecto, las 10 últimas líneas. Si antes del “nº” se pone un “+” (por ejemplo,
-n +nº), mostrar desde dicha parte hasta el final.
tail [-opciones] [fichero(s)]
orden con S | tail [-opciones]
Opciones:
-n nº o –nº Últimas nº líneas.
-c nº Últimos nº caracteres (bytes).

2001-2003 Virgilio Silva Martín 5/5

 -c nºb Últimos nº bloques (512 bytes).
-c nºk Últimos nº kb (1 kb = 1.024 bytes).
-c nºm Últimos nº mb (1 mb = 1.024 kb= 1.048.576 bytes).
Ejemplos:
Últimas 10 líneas de un fichero:
tail /etc/passwd
Últimas 20 líneas de un fichero:
tail -n 20 /etc/passwd
Últimos 1024 kb de un fichero:
tail -c 1k ~/datos.txt
Últimas 5 líneas de un listado:
ls -l /etc | tail –5
Desde la línea 20 hasta el final de un fichero:
tail -n +20 /etc/passwd
Último GID:
cut –f 3 –t “:” /etc/group | sort –n | tail -1
Penúltimo GID:
cut –f 3 –t “:” /etc/group | sort –n | tail -2 | head –1
Añadir el grupo “gdos” con “GID = Último-GID + 2”
groupadd –g $(expr `cut –f 3 –t “:” /etc/group | sort –n | tail –1` + 2) gdos
NOTA:
Sustitución de órdenes:
- Las comillas inversas (francesas) colocan el resultado de una orden en su lugar
(obsoleto): `orden`.
- En su lugar se recomienda usar el formato siguiente: $(orden).
En el ejemplo anterior se usan los dos formatos. Si se usa en el más externo el
formato de las comillas inversas, da error. Se puede (debe) usar en ambos el formato
recomendado.
Fichero de mayor tamaño:
ls –lS | tail +2 | head –1
Combinando “head” y “tail” se puede obtener cualquier parte de un fichero:

head –n nº

tail –n +nº1 | head –n nº2

tail –n +nº
tail –n nº

=> wc
Filtro: Mostrar el nº de caracteres (bytes) y/o palabras y/o líneas de un fichero o
de la salida de una orden, por defecto, los tres valores.
wc [-opciones] [fichero(s)]
orden con S | wc [-opciones]
Opciones:
-c nº caracteres
-w nº palabras
-l nº líneas
Ejemplos:
Nº de usuarios del sistema:
wc -l /etc/passwd
Nº de grupos del sistema:
cat /etc/group | wc –l
Cantidad de caracteres, palabras y líneas de un fichero:
wc ~/datos.txt
Nª de usuarios conectados:
who | wc –l
Nº de ficheros de un listado:
ls -l | tail -n +2 |wc –l

2001-2003 Virgilio Silva Martín 6/6

=> tee
Filtro: Lee un fichero (usar explícitamente la redirección de la entrada: “< fichero)
o la salida de una orden y escribe la salida en la pantalla y en el (los) fichero(s)
de salida especificado(s).
tee [-opciones] [fichero(s)-salida] [< fichero-entrada]
orden con S | tee [-opciones] [fichero(s)-salida]
Opciones:
-a Añadir al (a los) fichero(s) de salida (en vez de sobreescribir)
Ejemplos:
Mostrar en pantalla y guardar en fichero un listado:
ls –l | tee fich.lista
Guardar en fichero y contar las líneas de un listado:
ls –l | tee fich.lista | wc –l

=> tr
Filtro:
- Sin opción “-d” y con “caracteres1” y “caracteres2”: Traducir (cambiar)
“caracteres1” a “caracteres2”.
- Con opción “-d” y “caracteres1”: Eliminar “caracteres1”.
- Con opción “-s” y “caracteres1”: Reemplazar secuencia de “caracteres1” repetidos
por un solo “carácter1”.
- Sin opción “-d” y con opción “-s” y “caracteres1” y “caracteres2”: Traducir
“caracteres1” a “caracteres2” y, luego, reemplazar secuencia de “caracteres2”
repetidos a uno solo”.
- Con opciones “-d” y “-s” y con “caracteres1” y “caracteres2”: Eliminar
“caracteres1” y, luego, reemplazar secuencia de “caracteres2” repetidos a uno
solo”.
Para trabajar con un fichero hay que usar explícitamente la redirección de la
entrada: “< fichero”.
tr [-opciones] caracteres1 [caracteres2] [ < fichero]
orden con S | tr [-opciones] caracteres1 [caracteres2]
Opciones:
-d Eliminar “caracteres1”.
-s Eliminar caracteres repetidos, dejando uno.
-c Caracteres complementarios de “caracteres1” (los que “no” son). Por ejemplo,
-c A-Za-z0-9 son caracteres no alfanuméricos (mejor usar –c ‘[:alnum:]’).
Notas:
- “caracteres2” se expande a la misma longitud que “caracteres1”, si fuera necesario,
repitiendo su último carácter.
- Caracteres en exceso en “caracteres2” se ignoran.
Caracteres especiales y clases de caracteres (van entrecomillados)(man tr):
‘\nnn’ Carácter cuyo nº octal es “nnn” (nº octal de 3 dígitos).
‘\\’ Carácter “barra inversa” (“backslash”) “\”.
‘\b’ Carácter “retroceso” (“backspace”) (“^H”).
‘\n’ Carácter “avance de línea” (LF, ASCII: 10dec, 12oct ) (“^J”).
‘\r’ Carácter “enter” (“return”) (CR, ASCII: 13dec, 15oct) (“^M”).
‘\t’ Carácter “tabulador horizontal” (“^I”).
‘[:alpha:]’ Letras.
‘[:alnum:]’ Letras y números (dígitos).
‘[:upper:]’ Letras mayúsculas.
‘[:lower:]’ Letras minúsculas.
‘[:space:]’ Espacio horizontal o vertical.
‘[caracter*nº]’ “nº” veces el carácter “carácter”. Por ejemplo: [x*6]=xxxxxx.
‘[carácter*]’ En “caracteres2” tantas veces “carácter” hasta tener la misma
longitud que “caracteres1”.
Listas de caracteres y rangos de caracteres [GNU no soporta la sintaxis con corchetes
como System V (por ejemplo, tr -d ‘[0123456789]’ eliminaría los corchetes y los
números)] (man tr):
c1c2c3... Lista caracteres “c1”, “c2”, “c3”,.... (sin corchetes).
carácter1-carácter2 Rango caracteres de “carácter1” a “carácter2” en orden
ascendente (sin corchetes).

2001-2003 Virgilio Silva Martín 7/7

 Ejemplos:
Cambiar las MAY a min en un fichero:
tr A-Z a-z < ~/fich.txt (sin corchetes)
tr ‘[:upper:]’ ‘[:lower:]’ < ~/fich.txt
Cambiar las min a MAY en un fichero:
tr a-z A-Z < ~/fich.txt (sin corchetes)
Cambiar números por “X” en un fichero:
tr 0-9 ‘[X*]’ < ~/fich.txt
Eliminar las MAY en un fichero:
tr –d A-Z < ~/fich.txt
Cambiar letras MAY o min por “espacio” en un fichero:
tr –c A-Za-z ‘[:space:]’ < ~/fich.txt
Reemplazar letras MAY y min repetidas a una sola en un fichero:
tr –s A-Za-z < ~/fich.txt
Cambiar carácter “:” por carácter “TAB” en un fichero:
tr : “\t” < ~/agenda.dat
Cambiar cada letra por la que ocupa 13 lugares más adelante (codificar) en un
fichero:
tr a-mn-zA-MN-Z n-za-mN-ZA-M < ~/fich.txt
Reemplazar “avance de línea” (“enter”) (LF) repetidos a uno solo:
tr –s ‘\n’
Transformar cada palabra de un fichero en una línea [traducir cada carácter no
alfanumérico a “avance de línea” (LF) (‘\012’ o ‘\n’) y, luego, reemplazar los
“avance de línea” repetidos a uno solo]:
tr –cs ‘[:alnum:]’ ‘[\n*]’ < ~/fixh.txt
(Mejor que tr –cs A-Za-z0-9 ‘\012’)
(Mejor que tr –s ‘[:space:]’ ‘\012’)
Eliminar el “retorno de carro” (CR) (‘\015’ o ’\r’) de un fichero de MS-DOS:
tr –d “\015” < ~/fich.msdos > ~/fich.linux
Número de veces que aparece la palabra “gato” en un fichero:
cat ~/gatos.txt | tr –s ‘[:space:]’ ‘\n’ | grep “\<gato\>”
Eliminar el “resalte” (^H) (opción “\b”), los caracteres repetidos y los caracteres
“-” de la ayuda de la orden “ls” (falta quitar carácter “subrayado”):
man ls | tr –d ‘\b’ | tr –s A-Za-z | tr –s ‘-’ > ~/ayuda.ls
Número de veces que aparecen las palabras en un fichero, ordenadas en orden de
frecuencia ascendente:
tr –s ‘[:space:]’ ‘\012’ < ~/fixh.txt | sort | uniq –c | sort –rn
uniq –c -> Mostrar antes de la línea el nº de líneas repetidas
Palabras dobles repetidas (por ejemplo “el” “el” separadas por “enter”):
cat “$@” | tr –s ‘[:punct:][:blank:]’ ‘\n’ |tr ‘[:upper:]’ ‘[:lower:]’ | uniq –d
[:punct:] -> Caracteres de puntuación
uniq –d -> Mostrar líneas repetidas (Ver más adelante).

=> cut (cortar)

Filtro: Cortar (extraer) por caracteres o campos partes de las líneas de un(os)
fichero(s) o de la salida de una orden.
cut [-opciones] [fichero(s)]
orden con S | cut [-opciones]
Opciones:
-c nºcaracteres Cortar por caracteres.
-f nºcampos Cortar por campos. (Incluir también la opción “-s” para no mostrar
líneas que no contienen carácter separador).
Los nºcaracteres/nºcampos pueden especificarse del siguiente modo:
n El número “n”.
n,m Los números “n” y “m”.
n-m Del número “n” al “m”.
n- Del “n” hasta el final.
-m Desde el principio hasta el número “m”.
combinación de n y m Por ejemplo, 1,5-9,12,15-: el 1, del 5 al
9, el 12 y del 15 hasta el final.
-d carácter Carácter delimitador (separador) de campos (por defecto, "TAB").

2001-2003 Virgilio Silva Martín 8/8

 Ejemplos:
Cortar los campos 3 y 4 de un fichero (separador “:”):
cut -f 3,4 -d : /etc/passwd
Cortar los tres primeros campos de un fichero (separador "espacio"):
cut -f -3 -d " " ~/prueba.txt
Cortar los campos 1, 2, 3 y del 7 al final (separador "TAB") de un fichero:
cut -f 1-3,7- ~/datos/agenda.dat
Cortar el tamaño (columnas 35 a 43, terminando con espacio separador) y el nombre de
un listado (columnas 57 hasta final):
ls -la | cut -c 35-43,57-
Notas:
- Los números de columnas en un listado largo, terminando cada campo con espacio
separador, son:
1 1112 1617 2526 3435 4344 5051 5657 100
-rw-r--r-- 1 virgilio profesor 1079 may 21 01:02 fich.dat
- Los números de columnas en un listado largo y con número de inodo, terminando cada
campo con espacio separador, son:
1 89 1920 2425 3334 4243 5152 5859 6465 100
4017 -rw-r--r-- 1 virgilio profesor 1079 may 21 01:02 fich.dat

=> paste (pegar)

Filtro: Pegar (en pantalla) las líneas de dos o más fichero, en forma de campos,
separadas por “TAB”:
línea1-resultante=línea1-fichero1TABlínea1-fichero2TABlinea1-fichero3...
línea2-resultante=línea2-fichero1TABlínea2-fichero2TABlinea2-fichero3...
...
paste [-opciones] [fichero(s)]
orden con S | paste [-opciones]
Opciones:
-d carácter Carácter delimitador (separador) de campos en el fichero de salida (por
defecto, “TAB”).
-s Pegar en una única línea las líneas de cada fichero (transformar filas
en columnas).
Ejemplos:
-Fichero “letras”:
línea-a
línea-b
línea-c
-Fichero “numeros”:
línea-1
línea-2
línea-3
línea-4
línea-5
Pegar dos ficheros, separados por “TAB”:
paste letras numeros
Resultado:
línea-aTABlinea-1
línea-bTABlinea-2
línea-bTABlinea-3
TABlinea-4
TABlinea-5
Pegar dos ficheros, separados por “:”:
paste -d : numeros letras
Resultado:
linea-1:línea-a
linea-2:línea-b
linea-3:línea-b
linea-4:
linea-5:

2001-2003 Virgilio Silva Martín 9/9

 Pegar “en línea” las líneas de un fichero, separadas por “TAB”:
paste -s letras
Resultado:
línea-aTABlínea-bTABlínea-c
Pegar “en línea” las líneas cada fichero, separadas por “TAB”:
paste -s -d : letras numeros
Resultado:
línea-a:línea-b:línea-c
línea-1:línea-2:línea-3:línea-4:línea-5
Pegar (añadir) a un fichero un nuevo campo entrado por teclado, hasta pulsar “^D”
(cada línea del teclado se añade al final de cada línea del fichero):
paste ~/datos/agenda.dat - > ~/datos/agenda2.dat
Ejemplo de “cut” y “paste” (“cortar” y “pegar”) para reorganizar los campos de un
fichero: intercambiar los campos 2º y 3º:
Cortar los campos 1º y 3º, guardándolos en un fichero temporal:
cut -f 1,3 ~/datos/agenda.dat > ~/datos/agenda.13
Cortar del campo 4º hasta el final, guardándolos en un fichero temporal:
cut -f 4- ~/datos/agenda.dat > ~/datos/agenda.4fin
Cortar el campo 2º, guardándolo en un fichero temporal:
cut -f 2 ~/agenda.dat > ~/datos/agenda.2
Unir los tres ficheros temporales en un nuevo fichero:
paste ~/datos/agenda.13 ~/datos/agenda.2 ~/datos/agenda.4fin >
~/datos/agenda2.dat
Las dos últimas órdenes se pueden sustituir por “cortar el campo 2º y pegar el
fichero temporal que contiene los campos 1º y 3º con la entrada estándar
procedente del corte del campo 2º (“-”) y el fichero temporal que contiene los
campos desde el 4º hasta el final”:
cut -f 2 ~/datos/agenda.dat | paste ~/datos/agenda.13 - ~/datos/agenda.4fin >
~/agenda2.dat
Si el fichero sólo contiene cuatro campos se puede hacer de la forma:
- Cortar campos 1º y 3º en un fichero temporal.
- Cortar campos 2º y 4º en otro fichero temporal.
- Unir ambos ficheros temporales.

=> join (unir)

Filtro: Unir (en pantalla), las líneas de dos ficheros (sólo dos ficheros), sobre la
base de un campo clave común, en forma de campos, separadas por “TAB”: por cada par
de líneas, una de cada fichero, con el mismo valor en el campo clave común, se
mostrará en pantalla una línea que contiene el campo clave común, los restantes
campos del fichero1 y los restantes campos del fichero2:
línea1-resultante=campo-clave-comúnTABcampos-fichero1TABcampos-fichero2...
línea2-resultante=campo-clave-comúnTABcampos-fichero1TABcampos-fichero2...
...
(Para el correcto funcionamiento del filtro, los ficheros deben estar ordenados en
modo creciente por el campo clave común).
(El filtro trabaja del siguiente modo: compara cada línea de fichero1 con la línea1
de fichero2: si hay coincidencia, la muestra en pantalla; si no, el filtro termina).
join [-opciones] fichero1 fichero2
Opciones:
-j1 nºcampoclavecomun Campo clave común fichero1 (por defecto, campo 1º).
(Mejor: -1 en vez de –j1).
-j2 nºcampoclavecomun Campo clave común fichero2 (por defecto, campo 1º).
(Mejor: -2 en vez de –j2).
-o nºfichero.nºcampo ... Lista de campos del fichero de salida (separados por "," o
"ESPACIO"). (Sin esta opción: campo clave común, restantes
campos del fichero1 y restantes campos del fichero2).
-t carácter Carácter delimitador (separador) de campos para los
ficheros de entrada y salida (Por defecto, “ESPACIO” o
“TAB”).
-i Ignorar diferencia entre MAY/min al comparar.

2001-2003 Virgilio Silva Martín 10/10

Ejemplos:
-Fichero “mercancias”:
Identificador Nombre Descripción
A-1----------- ------- ----------
A-2---------- ----- ------------
C-2---------- ------ ------
F-1---------- ------ -----------
-Fichero “precios”:
Identificador Precio
A-2------------ -----
F-1---------- ------
G-3-------- ---
Unir con “join” los ficheros “mercancias” y “precios” por el campo clave 1º (sólo las
líneas que tienen el campo clave igual):
join mercancías precios (join –j1 1 –j2 1 mercancias precios)
Resultado:
Identificador Nombre Descripción Precio
A-2---------- ----- ------------TAB -----
F-1---------- ------ -----------TAB ------
Pegar con “paste” los ficheros “mercancias” y “precios” (todas las líneas)(diferencia
con “join”):paste mercancías precios
Resultado:
Identificador Nombre Descripción Identificador Precio
A-1----------- ------- ----------TAB A-2------------ -----
A-2---------- ----- ------------TAB F-1---------- ------
C-2---------- ------ ------TAB G-3-------- ---
F-1---------- ------ -----------TAB
-Fichero “agenda1.dat”:
DNI Nombre Apellidos Teléfono
111111111 ------- ---------- ---------
222222222 ----- ------------ ---------
333333333 ------ -------- ---------
444444444 ------ ------ ---------
777777777 ------ ----------- ---------
-Fichero “agenda2.dat”:
Ciudad Edad DNI
-------- -- 222222222
------- -- 444444444
------- -- 888888888
Unir el fichero “agenda1.dat”, campo clave 1º, con el fichero “agenda2.dat”, campo
clave 3º, mostrando en pantalla las líneas con campo clave común formadas con todos
los campos:
join –j1 1 –j2 3 agenda1.dat agenda2.dat
Resultado:
DNI Nombre Apellidos Teléfono Ciudad Edad
222222222 ----- ------------ ---------TAB -------- --
444444444 ------ ------ ---------TAB ------- --
Unir el fichero “agenda1.dat”, campo clave 1º, con el fichero “agenda2.dat”, campo
clave 3º, mostrando en pantalla y guardando en el fichero “agenda12.dat”, las líneas
con campo clave común formadas por los campos 2º, 3º y 4º del fichero primero y el
campo 1º del fichero segundo:
join –j1 1 –j2 3 –o 1.2 1.3 1.4 2.1 agenda1.dat agenda2.dat | tee agenda12.dat
Resultado:
Nombre Apellidos Teléfono Ciudad
----- ------------ ---------TAB --------
------ ------ ---------TAB -------

2001-2003 Virgilio Silva Martín 11/11

 Unir el fichero “fich1.txt”, campo clave 2º, con el fichero “fich2.txt”, campo clave
3º, guardando en el fichero “fich12.txt” de salida, las líneas con campo clave común
formadas por los campos 2º y 3º del fichero primero y el campo 1º del fichero
segundo:
join –j1 2 –j2 3 –o 1.1 1.2 1.3 2.1 fich1.txt fich2.txt > fich12.txt
Resultado:
Fichero1-Campo1 Fichero1-Campo2 Fichero1-Campo3 Fichero2-Campo1
--------- --------- --------- ---------
------------ ------- ------------ ---------
-Fichero “articulos”:
Código-art Nombre-art Descripción-art Precio-art
H-3 -------- -------- -----
A-3 --------- ------ ---
-Fichero “proveedores”:
Código-prov Nombre-prov Datos-prov Código-art
------------ --------- ------------ M-4
------- ----- --------- H-3
-Fichero “clientes”:
Código-cli Nombre-cli Datos-cli Código-art
--------- ------- ---------- C-5
-------- ----- -------- A-3
------- --- ------ H-3
Unir los ficheros “articulos”, “proveedores” y “clientes”, por el campo “código-art”,
ordenándolos previamente por dicho campo, mostrando los resultados en pantalla y
guardándolos en ficheros:
head –1 articulos | tee articulos.ord
tail +2 articulos | sort | tee –a articulos.ord
head –1 proveedores | tee proveedores.ord
tail +2 proveedores | sort –k 4 | tee –a proveedores.ord
head –1 clientes | tee clientes.ord
tail +2 clientes | sort –k 4 | tee –a clientes.ord
join –1 1 –2 4 articulos.ord proveedores.ord | tee ariculos-proveedores.ord
join –1 1 –2 4 articulos-proveedores.ord clientes.ord | tee articulos-proveedores-
clientes.ord

=> nl
Filtro: Numerar las líneas de un fichero o de la salida de una orden.
nl [-opciones] [fichero(s)]
orden con S | nl [-opciones]
Ejemplos:
Numerar las líneas de un fichero:
nl ~/fich.txt

=> uniq
Filtro: Mostrar líneas únicas de un fichero ordenado (eliminar líneas repetidas de un
fichero ordenado).
uniq [-opciones] [fichero(s)]
orden con S | uniq [-opciones]
Opciones:
-c Mostrar antes de la línea el nº de líneas repetidas.
-d Mostrar solamente las líneas repetidas.
-u Mostrar solamente líneas únicas.
-i Ignorar diferencia MAY/min.
Ejemplos:
Número de veces que aparece un código postal (cortar el campo del código postal,
ordenar el resultado, eliminar líneas repetidas contando las veces repetidas, ordenar
en orden numérico decreciente):
cut –f 6 direcciones.dat | sort | unic –c | sort –rn
Códigos postales que aparecen sólo una vez:
cut –f 6 direcciones.dat | uniq –u

2001-2003 Virgilio Silva Martín 12/12

 ÓRDENES “BUSCAR”,
find, locate (slocate) y updatedb, which, whereis, file,
“TIPO ORDEN/FICHERO”,
type, cmp, comm, diff, script.
“COMPARAR”,...

=> find
Orden: Buscar en una estructura de directorios ficheros/directorios que cumplan
una(s) condición(es) y ejecutar con los ficheros encontrados una acción. Por defecto,
se busca en el directorio actual y en sus subdirectorios (directorio-inicial) y se
muestra el resultado en pantalla (acción).
find [directorio-inicial...] [-opciones] condición(es) [acción]
directorio-inicial... Directorio desde el que se empieza a buscar (por defecto,
directorio actual y sus subdirectorios). Pueden ser varios
separados por espacio.
Opciones:
-maxdepth nºnivel Nº de niveles descendentes en la estructura de directorios en los
que se busca (por defecto, todos). (-maxdepth 2 significa que
busca en el directorio especificado en la orden -el actual, por
defecto- y en los dos siguientes niveles de subdirectorios;
-maxdepth 0 significa que sólo busca en el directorio
especificado en la orden -el actual, por defecto).
-mindepth nºnivel Nº de niveles que se desciende en la estructura de directorios
antes de empezar la búsqueda (por defecto, ninguno).
Condiciones:
-name nombre o ‘plantilla’ Ficheros tienen el nombre o encajan en la plantilla (se
diferencia MAY/min).
-iname nombre o ‘plantilla’ Ficheros tienen el nombre o encajan en la plantilla (no
se diferencia MAY/min).
-user usuario Ficheros pertenecen al usuario (nombre o nº).
-group grupo Ficheros pertenecen al grupo (nombre o nº).
-nouser Ficheros no pertenecen al usuario.
-nogroup Ficheros no pertenecen al grupo del usuario.
-perm modo Ficheros tienen los permisos (modo simbólico o modo
octal).
-inum nº Ficheros tienen el nº de inodo.
-links nº Ficheros tienen el nº de enlaces duros.
-atime nº Ficheros tienen fecha de "acceso" hace "nº" días.
-ctime nº Ficheros tienen fecha de "cambio" hace "nº" días.
-mtime nº Ficheros tienen fecha de "modificación" hace "nº" días.
-size nº[carácter] Ficheros tienen tamaño “nº [Carácter: “b” -> bloques
(512 bytes ¿o 1.024 bytes?) (por defecto); “k” -> kb;
“c” -> bytes o caracteres].
-type carácter Ficheros son del tipo (“f”: fichero, “d”: directorio,
"l": enlace simbólico,...).
-empty Ficheros/directorios vacíos.
...
Los valores numéricos (nº) de las condiciones pueden tener el formato:
+nº Mayor que.
-nº Menor que.
nº Igual que.
Operadores de condiciones (de mayor a menor “prioridad”):
(condicion1 condicion2) Operador “paréntesis”: Cambiar prioridad operadores. Sin
paréntesis, las condiciones se evalúan según la
prioridad y para igual prioridad, de izquierda a
derecha.
! condición Operador “no” (“not”): Verdad si “condición” es falsa.
not condición
condición1 condición2 Operador “y” (“and”): Verdad si ambas condiciones son
verdad (“condición2” no se evalúa si “condición1” es
falsa). Operador por defecto.
condición1 –a condición2
condición1 –and condición2

2001-2003 Virgilio Silva Martín 13/13

condición1 –o condición2 Operador “o” (“or”): Verdad si una condición o la otra
condición o ambas condiciones son verdad (“condición2”
no se evalúa si “condición1” es verdad).
condición1 –or condición2
condición1, condición2 Operador “lista” (“list”): Verdad si “condición2” es
verdad (se evalúan ambas condiciones; el valor de
“condición1” se descarta; el valor de la lista es el
valor de la “condición2”). (This operator lets you do
multiple independent operations on one traversal,
without depending on whether other operations
succeeded).
Nota:
Cumplir las condiciones cd1 o cd2 y cd3 (hay que “escapar” los paréntesis):
\( cd1 –o cd2 \) –a cd3
Acciones:
-print Mostrar el resultado en pantalla (formato: trayectoria y
nombre). Acción por defecto.
-fprint fichero-salida Como la anterior, guardando el resultado en un fichero.
-ls Mostrar el resultado en pantalla (formato: como “ls –ilds”).
-fls fichero-salida Como la anterior, guardando el resultado en un fichero.
-exec orden {} \; Ejecutar “orden” para cada fichero encontrado, preguntando.
(“{}” se va sustituyendo por cada fichero encontrado; después
de un “espacio”, “\;” indica el final de la orden).
-ok orden {} \; Idem, sin preguntar.
Ejemplos:
Buscar, empezando en el directorio actual, ficheros llamados “prueba.txt”,
diferenciando MAY/min, y mostrar el resultado en pantalla:
find –name prueba.txt [-print]
Idem, empezando en el directorio “/home”, sin diferenciar MAY/min:
find /home –iname prueba.txt
Buscar, desde el directorio “/”, ficheros terminados en “.txt”, diferenciando
MAY/min, y guardar el resultado en un fichero y eliminar los mensajes de error:
find / -name ‘*.txt’ > ~/fich.txt 2> /dev/null
Buscar, desde el directorio “/home”, ficheros, terminados en “.txt” sin diferenciar
MAY/min, y que pertenezcan al usuario “jmartin” y ejecutar con ellos un listado
largo:
find /home –type f [and] –iname ‘*.txt’ [–and] –user jmartin –exec ls –l {} \;
Buscar, desde dos directorios antes del actual, empezando la búsqueda después de
descender un nivel, ficheros (sólo ficheros), no vacíos, que pertenezcan al grupo
alumnos y mostrar el resultado en la pantalla:
find ../.. –mindepth 1 –type f –a ! -empty –a –group alumnos
Copiar en un subdirectorio del directorio “home”, los ficheros contenidos en el
directorio “home”:
find $HOME –maxdepth 0 –type f –ok cp {} /$HOME/varios \;
Mostrar los permisos de los subdirectorios del directorio “home”:
find ~ –type –d –ok –ls –ld {} \;
Buscar todos los directorios de “/usr/share”:
find $HOME –maxdepth 0 –type f –ok cp {} /$HOME/varios \;
Buscar en el directorio “/var/www/html” todos los archivos de extensión “.html” o
“.htm” y que no hayan sido modificados en el último mes y crear enlaces en el
directorio “var/www/html/antiguos”:
find /var/www/html \( -name “*.html” –o –name “*.htm” \) –a –ctime –30 –exec ln {}
/var/www/html/antiguos \;

2001-2003 Virgilio Silva Martín 14/14

=> locate (slocate); updatedb
- Orden locate (slocate): Buscar de forma rápida ficheros contenidos en una base de
datos.
locate (slocate) [-opciones] texto-a-buscar
Opciones:
-i Ignorar diferencias MAY/min.
-q Suprimir mensajes de error.
-u Crear la base de datos.
-e /dir1,/dir2,... Directorios a excluir del fichero de base de datos.
- Orden updatedb: Actualiza la base de datos de búsqueda para locate (slocate).
updatedb [-opciones]
Opciones:
--output=fichero-de-base-datos Fichero de base de datos a actualizar. Por
defecto, /usr/local/var/locatedb.
--prunepaths=’dir1 dir2 ...’ Directorios que no se hande incluir en el fichero
de base de datos y se pondrían si no se incluye
esta opción. Por defecto, /tmp, /usr/tmp y
/var/tmp.
Ejemplos:
Buscar los ficheros “/etc/passwd”:
locate /etc/passwd
Buscar los ficheros que tienen “passwd” en su nombre:
locate passwd
Resultado:
agenda1.dat agenda2.dat differ: char 15, line 3
Actualizar el fichero de base de datos:
update
Comparar dos ficheros y mostrar el código de salida:
cmp –s ~/agenda1.dat ~/agenda2.dat;echo $?
Resultado:
1

=> which
Orden: Mostrar la trayectoria (directorios) de una(s) orden(es), buscando en los
directorios de la variable PATH.
which [-opciones] orden(es)
Opciones:
-a Mostrar todas las órdenes que se encuentran, no sólo la primera.
Ejemplos:
Mostrar los directorios de algunas órdenes:
which pwd -> /bin/pwd
which useradd cd -> /usr/sbin/useradd
-> which: no cd in (/usr/local/bin:/bin:/usr/bin:…)

=> whereis
Orden: Mostrar la trayectoria (directorios) de una(s) orden(es), su(s) fichero(s) de
página(s) de manual en inglés y su(s) fichero(s) fuente(s), buscando en los
directorios especificados en el propio programa.
whereis [-opciones] orden(es)
Opciones:
-b Mostrar sólo los ficheros binarios.
-m Mostrar sólo los ficheros de páginas de manual.
-s Mostrar sólo los ficheros fuentes.
Ejemplos:
Mostrar los directorios de algunas órdenes:
whereis pwd -> pwd: /bin/pwd /usr/share/man/man1/pwd.1.bz2 /usr/share/...
whereis –b pwd -> pwd: /bin/pwd
whereis useradd cd -> useradd: /usr/sbin/useradd /usr/share/man/man8/useradd.8.bz2
-> cd: /usr/share/man/man1/cd.1.bz2 /usr/share/man/mann/cd.n.bz2

2001-2003 Virgilio Silva Martín 15/15

=> file
Orden: Mostrar el tipo de un(os) fichero(s).
file [-opciones] fichero(s)
Opciones:
-z Comprobar ficheros comprimidos.
Ejemplos:
Mostrar los tipos de algunos ficheros:
file /etc/passwd -> /etc/passwd: ASCII text
file /usr/sbin/useradd /usr/sbin/adduser -> /usr/sbin/useradd: ELF 32-bit LSB
executable,...
-> /usr/sbin/adduser: symbolic link to
useradd

=> type
Orden: Mostrar si una orden es una "función" (function), un "alias", un "comando
interno" (builtin), un “comando externo” (file) o nada (unfound).
type [-opciones] orden(es)
Opciones:
-t Mostrar una sola palabra.
-a Mostrar todos los valores.
Ejemplos:
Mostrar el tipo de algunas órdenes:
type pwd -> pwd is a shell builtin
type –t pwd -> builtin
type chmod -> chmod is /bin/chmod
type –t chmod -> file
type ls -> ls is aliased to `ls –F –color=auto`
type –t ls -> alias
type –a pwd -> pwd is a shell builtin
-> pwd is /bin/pwd

=> cmp
Orden: Comparar dos ficheros y mostrar el resultado en pantalla. Si los ficheros son
iguales, no muestra nada; si diferentes, muestra el nº de byte (carácter) y nº de
línea en el que ocurre la primera diferencia (la numeración empieza en "1").
cmp [-opciones] fichero1 fichero2
Opciones:
-l Mostrar el nº de byte (decimal) y los valores de byte diferentes (octal) para
cada diferencia.
-s No mostrar nada para ficheros diferentes; se produce el código de salida ("0":
ficheros iguales; "1": ficheros diferentes; ">1": error).
Ejemplos:
Comparar dos ficheros (iguales):
cmp ~/fich1.dat ~/fich2.dat
Comparar dos ficheros (diferentes):
cmp ~/agenda1.dat ~/agenda2.dat
Resultado:
agenda1.dat agenda2.dat differ: char 15, line 3
Comparar dos ficheros:
cmp –l ~/agenda1.dat ~/agenda2.dat
Resultado:
15 141 101
21 124 106
...
cmp: EOF on agenda1.dat
Comparar dos ficheros y mostrar el código de salida:
cmp –s ~/agenda1.dat ~/agenda2.dat;echo $?
Resultado:
1

2001-2003 Virgilio Silva Martín 16/16

=> comm
Orden: Comparar dos ficheros ordenados línea a línea y mostrar en pantalla las líneas
que son comunes y las líneas que son únicas. Sin opciones, muestra una salida en tres
columnas: columna1 contiene las líneas únicas del fichero1, columna2 contiene las
líneas únicas del fichero2 y columna3 contiene las líneas comunes a ambos ficheros.
comm [-opciones] fichero1 fichero2
Opciones:
-1 No mostrar la columna1.
-2 No mostrar la columna2.
-3 No mostrar la columna3.
Ejemplos:
Comparar dos ficheros:
comm ciudades.1 ciudades.2
Resultado:
Madrid
Sevilla
Málaga
Tenerife
Comparar dos ficheros, mostrando las líneas del primer fichero:
comm –23 ciudades.1 ciudades.2
Resultado:
Madrid

=> diff
Orden: Comparar el contenido de dos ficheros y mostrar cómo ha de cambiarse el texto
del primer fichero para que coincida con el segundo fichero. También, comparar los
ficheros correspondientes de dos directorios.
diff [-opciones] fichero1 fichero2
Opciones:
-q Mostrar solamente si los ficheros son diferentes, no las diferencias.
-s Mostrar solamente si los ficheros son iguales.
Ejemplos:
Comparar dos ficheros:
diff ~/fich1.txt ~/fich2.txt
Resultado:
3,7c3,4 -> (c)ambiar las líneas 3 a 7 del primer fichero por las líneas 3 a 4 del
segundo fichero. Otros códigos: (a) -> añadir; (d) -> borrar;...
...

=> script
Orden: Escribir en un fichero (por defecto, fichero “~/typescript”) todas las órdenes
y resultados de una sesión, hasta que se pulsa “^D”.
script [-opciones] [fichero]
Opciones:
-a Añadir al final del fichero.
Ejemplos:
Escribir las órdenes de una sesión:
script -> En el fichero “~/typescript”.
script ~/sesion.1 -> En el fichero “~/sesion.1”.

2001-2003 Virgilio Silva Martín 17/17

 COMANDOS “m” (“mtools”) mdir, mcd, mmd, mrd, mdeltree, mren, mtype,
(man mtools; man morden; info mtools) mcopy, mmove, mdel, mformat, mattrib,...

=> LOS COMANDOS “m” (HERRAMIENTAS “mtools”)

Linux incorpora los comandos “m” (herramientas “mtools”; “man mtools”), llamados
igual que los correspondientes comandos de MS-DOS/Windows, pero empezando por “m”,
que permiten trabajar “igual” que aquellos (las restricciones y rarezas de
MS-DOS/Windows no se emulan), por ejemplo, se pueden usar nombres largos, se pueden
usar letras de unidades “A:”, “C:” (sin montarlas), se pueden intercambiar archivos
de texto entre MS-DOS/Windows y Linux,...
- Principales comandos “m”:
mdir, mcd, mmd, mrd, mdeltree, mren, mtype, mcopy, mmove, mdel, mformat,
mattrib,...
- Ficheros de configuración (por ejemplo, para establecer la equivalencia entre
“/dev/fd0” y “a:”):
* Global -> “/etc/mtools.conf” (-|rw-|r--|r-- root root). Líneas de equivalencia
para el disquete y la partición de “MS-DOS/Windows”:
drive a: file=“/dev/fd0” exclusive
drive c: file=“/dev/hda1”
...
* Local -> “~/.mtoolsrc”.
Notas:
- Para las “mtools”, los nombres de ficheros sin letra de unidad se refieren a
ficheros de Linux.
- Las trayectorias pueden emplear el separador “/” o “\” (este último debe
entrecomillarse: “\” o ‘\’ o \\).
- No se distingue MAY/min.
- “mcd” muestra o cambia el dispositivo y directorio de trabajo para todas las
unidades de MS-DOS/Windows (por defecto, “a:/”).
Ejemplos:
Mostrar el contenido del directorio activo de un disquete (debe estar establecida la
equivalencia entre “a:” y “/dev/hda1” en el fichero de configuración de las “mtools”)
(no es necesario montar el disquete):
$ mdir a:
Mostrar el contenido del directorio “Mis documentos” del disco “c:” de
MS-DOS/Windows, paginado (debe estar establecida la equivalencia “c:” y “/dev/hda1”
en el fichero de configuración de las “mtools”) (ser “root”) (entrecomillar el
directorio debido al “espacio”):
# mdir c:/“Mis documentos” | less
Mostrar el directorio activo de MS-DOS/Windows:
$ mcd
Cambiar el directorio a “Mis documentos” del disco “c:” de MS-DOS/Windows:
# mcd c:/“Mis documentos”
Crear el directorio “datos” en el directorio activo de MS-DOS/Windows:
# mmd datos
Crear el directorio “datos” en el disquete:
$ mmd a:/datos
Copiar el fichero “prueba.txt” del directorio “trabajos” en el directorio “datos” del
disquete:
$ mcopy trabajos/prueba.txt a:/datos
Borrar el fichero “prueba.txt” del directorio “datos” del disquete:
$ mdel a:/datos/prueba.txt
Formatear un disquete de MS-DOS/Windows a “alto nivel” (crear la estructura lógica:
sector de arranque, zona FAT, directorio raíz y zona de datos) (antes debe estar
formateado a “bajo nivel” -> $ fdformat /dev/fd0u1440):
$ mformat a:

2001-2003 Virgilio Silva Martín 18/18

Poner el atributo “sólo lectura” al fichero “apuntes.doc” del directorio “Mis
documentos” del disco “c:” de MS-DOS/Windows:
$ mattrib +r c:/”mis documentos”/apuntes.doc
MS-DOS/Windows y Linux tratan de forma diferente el final de línea en los archivos de
texto, por lo que habrá problemas para intercambiar archivos de texto entre ellos:
- MS-DOS/Windows: “Avance de línea” (LF, ASCII: 10dec, 12oct ) + “Retorno de carro”
(CR, ASCII: 13dec, 15oct).
- Linux: “Avance de línea”.
Si se muestran o copian archivos de texto entre MS-DOS/windows <-> Linux, en Linux
aparece el carácter CR al final de la línea (se muestra “^M” con el “joe”), y en
MS-DOS/Windows aparecen las líneas juntas. Los comandos “mtype” y “mcopy” incorporan
la opción “-t” para “traducir” (intercambiar) “LF+CR” <-> “LF”.
Ejemplos:
Copiar el fichero “apuntes.doc” del directorio “Mis documentos” del disco “c:” de
MS-DOS/Windows al directorio activo del disquete (no se elimina el carácter CR):
$ mcopy c:/”mis documentos”/apuntes.doc a:
Copiar el fichero “apuntes.doc” del directorio “Mis documentos” del disco “c:” de
MS-DOS/Windows al directorio activo del disquete (sí se elimina el carácter CR):
$ mcopy –t c:/”mis documentos”/apuntes.doc a:
Copiar todos los archivos que empiezan por “linux” del directorio “home” de la
partición de Linux al directorio activo del disquete (no se añade el carácter CR)
(las líneas se muestran juntas en MS-DOS/Windows):
$ mcopy $HOME/linux* a:
Copiar todos los archivos que empiezan por “linux” del directorio “home” de la
partición de Linux al directorio activo del disquete (sí se añade el carácter CR)
(las líneas se muestran separadas en MS-DOS/Windows):
$ mcopy –t $HOME/linux* a:
Nota:
Se puede montar la partición de Windows en el árbol de directorios de Linux si no se
monta durante el arranque, de la siguiente forma:
Montar la partición de “Windows” en Linux (usuario normal: debe estar preparada para
montarse en el fichero de configuración “/etc/fstab”):
$ mount /mnt/windows (o $ mount /dev/hda1)
Montar la partición de “Windows” en Linux (usuario root: aunque no esté preparada
para montarse en el fichero de configuración “/etc/fstab”):
# mount –t vfat /dev/hda1 /mnt/windows

2001-2003 Virgilio Silva Martín 19/19