se utiliza mucho para ver archivos que van aumentando de tamaño, añadiendo lo que va pasando al final(logs).
Las opciones más habituales son:
- -n nº: Indicamos cuantas líneas del final queremos ver. si no indicamos nada nos muestra 10
- +nº: nos muestra desde la línea nº hasta el final
- -f: Le indicamos que nos muestre las últimas líneas y tail se queda esperando, observando el archivo, en el momento que cambia nos muestra qué líneas ha añadido. Esta opción es útil si queremos ver cómo va aumentando un archivo.
SORT
Sirve para ordenar
Ejemplo:
$cat fichero
$sort fichero > ficheorden
Las opciones más habituales son:
-n: ordena teniendo en cuenta los números
-f : no tiene en cuenta las minúsculas o las mayúsculas (si no ponemos esta opción primero muestra las mayúsculas y luego las minúsculas)
-r: hace que invierta el resultado
ECHO:
La orden echo saca por pantalla el texto que le pasamos como argumento. Es útil cuando queremos saber el valor de una variable o introducirle un texto a un programa.
$Echo hola
hola
$echo $var
GREP
La orden GREP sirve para seleccionar las líneas que queremos mostrar, nos sirve para buscar dentro de archivos sin tener que verlos por completo.
Las opciones más habituales son:
-i : Ignora si la cadena está en mayúscula o minúsculas
-v: Muestra las líneas en las que no aparezca la cadena buscada
-p: Nos muestra las líneas que contienen las cadenas, solo los nombres de los archivos.
Ejemplo: [asi]$gedit fichero
Ej: hacer un fichero con las líneas de esta forma
$ touch fichero
$ gedit fichero
hola
Hola
Hola
$ grep hola fichero
$ grep –i Hola fichero
Ej:
$ touch fichero2
$ gedit fichero 2 :namespace prefix = v ns = "urn:schemas-microsoft-com:vml" /> poner que tal
Ej:
$ touch fichero3
$ gedit fichero3 poner hda y hola
Ej: búsqueda con los dos ejercicios anteriores
$ grep Hola fichero –i
$ grep hola fichero* -l
CUT
La orden cut nos deja elegir que parte de la linea queremos ver
Las 2 maneras mas habituales son:
Cut –f campos –d delimitador archivo
El programa divide cada linea utilizando el delimitador ( que es una letra o un símbolo como : o un espacio en blanco, y nos muestra solo los campos que le hayamos indicado en el argumento campos.
Ejemplos:
$cut –f1 –d ‘ ‘ fichero ------ 1 campo
$cut –f13 –d ‘ ‘ fichero ----- 1 y 3 campo
$cut –f135 –d ‘ ‘ fichero ---- 1,3,4,5
$cut –f-5 –d ‘ ‘ fichero ------ 1,2,3,4,5
$cut –f3,8 –d ‘ ‘ fichero ------ 3,8,9,10....
$cut –c –10 fichero
$ cut –c –11-20 fichero
SED
Sed nos permite hacer sustituciones cuando nos muestra un fichero. Con esta técnica no modificamos el fichero solo el resultado.
Sintaxis: sed “s/búsqueda/sustitución/g” archivo
Ejemplos:
$sed “s/hola/adiós/g” fichero
$sed “s/o/o/g” fichero fich*
$sed “s/_ _/_/g” fichero
Ejercicios
1) Crear un fichero llamado ejer1.txt dentro de asi/ejercicios que contenga más de 20 líneas y con la palabra chimenea repetida varias veces
[asi]$ mkdir ejercicios
[asi]$ cd ejercicios
[ejercicios]$ touch ejer1.txt
[ejercicios]$ gedit ejer1.txt
2) Guarda las 20 primeras líneas del archivo ejer1.txt en el archivo primero.txt
[ejercicios]$ head –n20 ejer1.txt>primero.txt
3) Guarda las línas del archivo ejer1.txt que contengan la cadena de texto `00´ en el archivo 005.txt
[ejercicios]$ grep 00 ejer1.txt >005.txt
4) Guarda el archivo ejer1.txt como claves.txt pero sustituyéndolo cada vez que aparezca la cadena `chimenea´ por `humo´
[ejercicios]$ sed “s/chimenea/humo/g”ejer1.txt >claves.txt
SEQ
Cuando necesitamos una lista de números utilizaremos la orden seq. Le podemos indicar el inicio, el incremento y el final. Si no le ponemos incremento supondrá que en 1. si no le ponemos inicio supondrá que empezaremos desde el 1.
Ejemplos:
$seq 10 2 20
$seq 38 42
$seq 15 FIND
Find sirve para buscar, pero también sirve para hacer algo con lo encontrado.
directorio: es el directorio donde vamos a empezar a buscar recursivamente, es obligatorio, si queremos buscar en el directorio actual tenemos que indicárselo mediante (.)
opciones: estas opciones cambian el modo en el que se realiza la búsqueda, como –daystart que hace que los tiempos se busquen teniendo en cuenta el comienzo del día, no por horas. –maxdepth que regula el nº de directorios donde busca.
comparaciones: nos permite elegir lo que queremos buscar. Podemos buscar por fechas (o minutos) de modificación o acceso, por tamaños, nombres o quien es el propietario.
acciones: lo habitual es mostrarlo en pantalla, pero también podemos hacer que saque los datos de ese archivo de una manera diferente, o que ejecute una orden unix, como run, cat, Grez, etc..., sobre los archivos encontrados.
$find . –name fichero à búsqueda por nombre desde el directorio actual
$find / -name fichero à búsqueda por nombre en todo el disco duro
$find / -name “*.mp3” à búsqueda por nombre en todo el disco duro como comodines entre comillas
$find asi –mnin – 10 à búsqueda por fecha de modificación en minutos menos de 10 en el directorio ASI
$find asi –size +100k à búsqueda por tamaño: archivos de más de 100k
$find asi –type f –size 0 –exec rm {}; à búsqueda por nombre del fichero que se está procedando
$find . –name “fich*” –print – exec grep para {}; à búsqueda de archivos que se llaman “fich” y algo más. sacamos el nombre del archivo y sacamos las líneas que contienen la cadena “para”
1) Crea un fichero llamado fichero. Búsqueda por nombre del directorio actual
[asi]$ touch fichero
[asi]$ find . -name fichero
TAR
Sirve para agrupar varios archivos en un único archivo, archivo con o sin compresión. también sirve para ver el contenido de archivos con formato “tar” o extraer los archivos de este formato.
Cuando se agrupan con esta orden a los archivos generados les solemos poner las extensiones
- .tar
- .tra.gz
- .tgz
Se utiliza mucho para hacer copias de seguridad, copiar directorios para trasladarlos y es el formato en el que se distribuyen la mayor parte de los programas para Linux.
Sintaxis: Tar opciones archivos
Opciones:
c à crear un archivo “tar”
x à extraer de un archivo “tar”
t à listar de un archivo “tar”
v à va mostrando qué está haciendo el programa
z à el fichero que creamos o del que sacamos archivos está comprimido (con el algoritmo gzip)
f fichero à para indicarle el archivo donde metemos los archivos que queremos agrupar.
Ejemplos: nos tenemos que situar en home
$ tar –c –z –v –f asi.tar.gz asi
$ tar c z v f asi.tar.gz asi
c: crear fichero
z: estará comprimido
v: que nos muestre que está haciendo
f: le indicamos el nombre del fichero (asi.tar.gz) donde vamos a meter el directorio asi
$ tar tzl asi.tar.gz ver el contenido del fichero
t para ver su contenido
$ tar xzvf asi.tar.gz restaurar el directorio desde el archivo tar
Ejercicios de Unix
5) Realizad los siguientes ejercicios sobre fichero y directorios
a) Cread en vuestro directorio de origen cinco subdirectorios llamados dir1, dir2, dir3, dir4 y dir5
d) Cread en dir2 un fichero llamado lista que contenga la lista de todos los ficheros que hay en ese directorio
[dir1]$ cd..
[asi]$ cd dir2
[dir2]$ touch lista
[dir2]$ ls>lista
[asi]$ cat lista para ver lo que contiene
Otra forma: [dir1]$ ls /home/asi/dir2> /home/asi/dir2/lista
Para pasar de un directorio a otro [dir1]$ cd.. /dir4
e) Cread en dir4 un fichero llamado concatenación que contenga la concatenación de todos los ficheros de dir2
[dir2]$ cd..
[asi]$ cd dir4
[dir4]$ touch concatenación
[dir4]$ ls /home/asi/dir2>concatenación
g) Verificad cuál es el contenido de concatenación
[dir4]$ cat concatenación
h) Haced que el directorio de trabajo sea el de origen y borrad todos los ficheros y directorios que habéis creado
[dir4]$ cd
[asi]$ rm -r dir 1
[asi]$ rm -r dir 2
[asi]$ rm -r dir 3 [asi]$ rm –r dir1 dir2 dir3 dir4 dir5 o rm –r dir*
[asi]$ rm -r dir 4
[asi]$ rm -r dir 5
6) Realizad los siguientes ejercicios sobre ficheros y directorios
a) Cread un subdirectorio de vuestro directorio de origen llamado trabajo y colocaos en él
[asi]$ mkdir trabajo
[asi]$ cd trabajo
[trabajo]$
b) Cread un fichero de nombre fichero con algunas frases
[trabajo]$ touch fichero
[trabajo]$ gedit fichero
c) Buscad en dicho fichero la cadena HOLA
[trabajo]$ grep HOLA fichero
d) Añadir HOLA al final del fichero usando el comando echo
[trabajo]$ echo HOLA>>fichero
e) Ordenad las líneas de fichero y guardad la salida en fichero.orden.
[trabajo]$ sort fichero>fichero.orden
f) Escribid en fichero.palabra el número de palabras de fichero
[trabajo]$ wc –w fichero>fichero.palabra
g) Comprobad que todos los ficheros contienen lo indicado y después borradlo todo
[trrabajo]$ cat fichero
[trabajo]$ cat fichero.orden
[trabajo]$ cat fichero.palabra
[trabajo]$ cd..
[asi]$ rm –r trabajo
7) Realizad los siguientes ejercicios sobre ficheros y directorios
a) En vuestro directorio de origen, cread un directorio llamado almacén. Haced que sea el directorio de trabajo
[asi]$ mkdir almacén
[asi]$ cd almacén
[almacén]$
b) Cread tres ficheros llamados fichero1, fichero2 y fichero3 con el contenido que queráis. (Procurad que la palabra albarán aparezca en cada uno de ellos en algunas líneas).
[almacén]$ touch fichero1 fichero2 fichero3
[almacén]$ gedit fichero1
[almacén]$ gedit fichero2
[almacén]$ gedit fichero3
c) Cread un subdirectorio del directorio de origen llamado prueba
Ejemplo: Buscamos en el archivo /etc/passwd los usuarios que se llaman knoppix y lo guardamos para su posterior tratamiento
$ cat /etc/passwd
$ mkdir tmp
$ grep knoppix /etc/passwd>tmp/knoppix.txt
$ cat tmp /knoppix.txt
$ cut .d ´:´ -f3 tmp/knoppix.txt
$ rm tmp/knoppix.txt
Todo lo anterior lo podemos escribir de forma mucho más resumida utilizando tuberías (mediante el símbolo | ) que pasa la salida de una orden a la siguiente
$ grep knoppix /etc/passwd | cut –d ´:´ -f3
*se pueden concatenar varias tuberías
Ejercicio: - Buscar en el directorio raíz todos los archivos que acaben en .h
- Nos quedamos con los que contengan el texto sys
- Nos quedamos con los 30 primeros
- Lo veremos poco a poco con un programa interactivo
$ find / ´*.h´ o $ find / -name ´*.h´ | grep “sys” | head –n30 | less
CONCATENAR ÓRDENES:
Normalmente cuando tenemos que poner varias órdenes se escriben en diferentes líneas. El mismo resultado se produce si las escribimos en la misma línea, separadas por punto y coma (;).
Ejemplo:
$ ls tmp/ *.txt
$ date $ ls tmp /*.txt; date
Tanto la separación en diferentes líneas como con punto y coma hacen que se ejecuten las órdenes, una después de otra independientemente de si se han ejecutado bien o mal.
A veces queremos que una orden se ejecute solo si la orden anterior se ha realizado con éxito
Ejemplo:
$ tar czvf usuario.tar.gz proyecto; rm –r proyecto
Realiza una copia de seguridad de ´proyecto´ y a continuación lo borra
EJECUCIÓN CONDICIONAL
* Para asegurarnos de que una orden se ejecuta solo si la anterior se ha relizado las concatenaremos con el símbolo && sin separar.
Ejemplo: $ tar czvf usuario.tar.gz proyecto && rm –r proyecto
Con este código crearemos el archivo donde guardamos la copia de seguridad y sólo en el caso de que todo haya ido bien borraremos el directorio.
* Para concatenar órdenes y que se ejecute la segunda sólo cuando falle la primera se utiliza el símbolo | |
Si se puede abrir la segunda orden no se ejecuta. Si no la podemos abrir, por el motivo que sea, ejecutaremos la orden echo, que guardará un texto en el archivo ´errores.txt´
AGRUPAR ÓRDENES CON PARÉNTESIS
Hay veces que queremos agrupar varias órdenes si se cumple una condición o queremos que el resultado de todos ellos vaya a un único archivo. Para hacer esto se ponen las órdenes entre paréntesis.
Ejemplo: $ echo escribe el año; read a; cal –y $a || (echo el año $a no es correcto; cal –y)
echo escribe el año mostrar el mensaje
read a capturar el valor de una variable
cal –y $a muestra el calendario, en este caso de m determinado año
cal –y muestra el calendario del año actual
Ejemplo: $ (date; echo; cal –m; pwd)> /tmp/estado.txt
Otra forma de hacerlo:
$ date> /tmp/estado.txt
$ echo>> /tmp/estado.txt
$ cal –m>> /tmp/estado.txt
$ pwd>> /tmp/estado.txt
$ cal mes actual
$ cal –m lunes como primer día de la semana
USO DE VARIABLES
Las variables sirven para almacenar valores para utilizarlos más adelante .
Las variables se pueden establecer de dos maneras:
$a=32 à asigna un valor a una variable (no puede haber espacios ni delante ni detrás del igual)
$ read b à para leer el valor de la variable interactivamente
Para utilizar el valor de una variable tenemos que añadirle el símbolo dola /$) antes del nombre:
$ echo $a
$ echo el valor de la variable b es $b
Ejemplo:
$ t = /tmp/temporal.txt
$ find / -size +10000k > st
$ wc $t
$ head $t
$ rm-f $t
VARIABLES DEL SISTEMA
El sistema define y utiliza varias variables que podemos ver y utilizar.
Por ejemplo, la variable HOME indica cual es nuestro directorio personal.
Podemos ver su valor:
$echo $home:
$path à el interprete usa la variable de entorno path para localizar los ficheros ejecutables u ordenes que se teclean.
Ejemplo: la variable PATH puede inicializarse a:
/bin: /urs/bin: /urs/local/bin:
Para ver las variables del sistema utilizaremos la orden SET COMILLAS, 3 tipos de comillas:
à Comilla simple (´) à sirve para escribir texto lineal
à Comilla doble (“) à si dentro de estas comillas hay una variable se sustituye por su valor
à Comilla grave (‘) à su contenido se ejecuta y es sustituido por el resultado de la ejecución.
Ejemplos: v = “¿Qué tal estas?”
Echo `no sustituyo las variables ($v)` à no sustituye las variables ($v)
Echo “con comillas dobles si ($v)” à con comillas dobles “¿Qué tal estas?”
Echo “hoy es ‘date’” à hoy es 12/05/06
[titulo]ESTRUCTURAS DE CONTROL[/titulo]
FOR
La estructura FOR hace que se repitan una serie de ordenes asignando a una variable un valor diferente cada vez que se repite el bucle.
Ejemplo:
for i in pepe juan ana cada vez que se entra al for coge el valor de uno de ellos
do
tar czvf /var /bac sp /$i.tar.gz/home/$i ff && rm –rf /home/$i comprimimos la carpeta de home
1º agrupa y comprime pepe.tar.gz
2º agrupa y comprime el contenido de home en juan.tar.gz
3º agrupa y comprime ana.tar.gz
Por último borra todo el directorio sin pedir confirmación
&& si todo ha ido bien lo borrará
Ejercicio:
1. Crear 4 ficheros llamados “enero”, “febrero”, “marzo”, “abril” con algún contenido. Mostrar, por cada mes: (utilizando el FOR)
tiene letras
gedit enero, febrero, marzo, abril
for i in enero, febrero, marzo, abril;
do
echo $i tiene ‘cat $i|wc-c’letras;done
2. Hacer que aparezca con la instrucción FOR lo siguiente: (SEQ)
hola 1
hola 2
hola 3
...
hola 10
for i in ´seq 1 10´; do echo hola $i; done
3. Mete en un único archivo (completo.txt) lo siguiente:
- Fecha y hora actual
- Nombre de tu directorio actual
- El primer campo de todas las líneas del archivo /etc/passwd
