– Aprendamos GNU/Linux 01

Gente: me tomo mucho tiempo escribir esto, por lo tanto, todo lo que sea fuera de lugar sera eliminado.



De que va esto?

En cada una de estas entregas, creare diferentes temas para conocer GNU /Linux. En un principio, el tutorial, estará orientado a la consola, sus comandos, editores de texto, y hasta llegar a archivos de configuraciones. Luego, si se puede, emprenderemos con la creación de algunos script y programación.

Contenido

- Empecemos
- Comando: ls (Muestra el contenido de un directorio)
- Directorios: cd, mkdir, rmdir, tree
- Comando: rm (Borrar archivos)
- Comando: cp y mv (Copiar y mover archivos/directorios)
- Ver el contenido de archivos por pagina: more y less
- Contador de palabras, lineas, caracteres, etc. en archivos de texto: wc
- Ver el inicio y fin de un archivo de texto: head y tail





Empecemos

En mucho de los casos, no voy a poner todas las opciones o argumentos de cada comando, ya que se aria muy largo el tutorial, por otra parte les cuento, que ustedes mismos pueden verlas con el nombre del comando, seguidos de la opción o argumento –help.




Comando: ls

El comando ls nos sirve para ver el contenido de un directorio. Este comando es uno de los más usados, y al igual que en la mayoría de los comandos de linux , podemos ponerles argumentos.
Por ejemplo, si tecleamos en nuestra consola ls y presionamos enter, podremos observar el contenido (directorios y archivos) del directorio en el que estamos posicionados.


dire             ocho_alas_pcman/  ochoalas_lxde_i~        ochoalas_lxde~*
lib/             ochoalas_lxde*    ochoalas_lxde_pcmanfm*  terminado/
ocho_alas_lxde/  ochoalas_lxde_i*  ochoalas_lxde_pcmanfm~



Podremos diferenciar entre un archivo, un archivo ejecutable, un backup y un directorio, que: los directorios, terminan con una barra / , los ejecutables terminan con un asterisco * al final, los backup terminan en un ~ y los archivos comunes (datos, texto, música, fotos, etc) el nombre no tiene ningún carácter antes mencionado (/ y *).

Entonces tenemos:

4 directorios:

ocho_alas_pcman/
lib/
terminado/
ocho_alas_lxde/



4 archivos ejecutables:

ochoalas_lxde~*
ochoalas_lxde*
ochoalas_lxde_pcmanfm*
ochoalas_lxde_i*



2 archivos backup:

ochoalas_lxde_i~
ochoalas_lxde_pcmanfm~



1 archivo comune:

dire



por otro lado, si ejecutamos ls -B veremos que nos muestra lo anterior, excepto los backup

ls -B


dire  ocho_alas_lxde/   ochoalas_lxde*    ochoalas_lxde_pcmanfm*
lib/  ocho_alas_pcman/  ochoalas_lxde_i*  terminado/



-a: Muestra todos los archivos, mas los ocultos. Veremos que los archivos ocultos, comienzan con un punto . .

-l: Muestra el contenido de un directorio, más el tamaño de los archivos, fecha y hora de creación, permiso de usuario (que lo veremos en otro tutorial).


-rw-r--r-- 1 root root  2715 dic  5 14:33 dire
drwxr-xr-x 4 root root  4096 dic  5 18:16 lib/
drwxr-xr-x 3 root root 12288 dic  5 14:43 ocho_alas_lxde/
drwxr-xr-x 2 root root  4096 dic  5 19:07 ocho_alas_pcman/
-rwxr-xr-x 1 root root  3213 dic  5 14:41 ochoalas_lxde*
-rwxr-xr-x 1 root root   652 dic  5 14:38 ochoalas_lxde_i*
-rw-r--r-- 1 root root    12 dic  5 14:34 ochoalas_lxde_i~
-rwxr-xr-x 1 root root  1059 dic  5 19:06 ochoalas_lxde_pcmanfm*
-rw-r--r-- 1 root root    12 dic  5 18:55 ochoalas_lxde_pcmanfm~
-rwxr-xr-x 1 root root  2573 dic  5 12:57 ochoalas_lxde~*
drwxr-xr-x 2 root root  4096 dic  5 19:14 terminado/



Eso que se ve al principio, son los permisos de usuarios.


-rw-r--r-- 
drwxr-xr-x
-rwxr-xr-x



-lh: Igual que -l, pero nos muestra en Kbytes, Mbytes, etc...

Tenemos muchos comandos más, que los podemos ver escribiendo ls –help.




Directorios

cd

Cuando iniciamos en nuestra consola, veremos algo como esto:

root@leo:~#

Observemos que luego de “root@leo:” hay un símbolo ~, siempre que lo veamos, es porque estamos en nuestro home o directorio inicial. Si por ejemplo, en nuestra consola ponemos:

cd /usr

veremos como cambia este ~ por /usr, esto quiere decir que estamos dentro del directorio usr que pertenece a la raiz.
Que es la raíz, o mejor dicho, nuestro directorio raíz, es de donde nacen todos los directorios.


 /
 |--usr
 |     |
 |     |--bin
 |     |
 |     |--lib
 |
 |--boot
 |
 |--etc
 |
 |--home
 |     |
 |     |--~
 |
 |--root



si vemos este arbol o estructura de directorios, nuestro ~ pertenece a la ruta /home/~, esto quiere decir que home esta dentro de la raíz ( / ), y que nuestra carpeta de inicio ( ~ ), esta dentro de home.

Siempre, pero siempre que pongamos / , nos estamos refiriendo a un directorio o archivo que este en raíz.

Pongan ls y enter, luego pongan cd y el nombre del directorio que quieran, y verán que si tilde ( ~ ) cambia a ~/nombre_de_directorio_que_pusieron.

Si quieren regresar, o salir del directorio en donde entraron, para retroceder un nivel en los directorios, introducimos nuevamente el comando cd separado de dos puntos seguidos ( .. ). Si ponemos cd.. (cd punto punto todo junto no funciona)

mkdir

Esto se les aclarará con la práctica, pero ahora vamos a crear un directorio dentro de nuestro ~

Lo que vamos a hacer, es teclear cd ~ para que nos aseguremos de trabajar dentro de nuestro directorio personal y de inicio.

cd ~

Luego creamos un directorio llamado taringa. Acá hago un alto, porque quiero aclarar que en Linux , no es lo mismo escribir un archivo o directorio en minúscula que en mayúscula. No es lo mismo “taringa” que “TARINGA” o que “Taringa”, las 3 son diferentes. Y si escribo “TaringA” ya tenemos una cuarta opción.

Para crear el directorio antes mencionado escribimos mkdir taringa

mkdir taringa

veamos que todo esta bien, tecleando ls

root@leo:~# ls

vemos que existe nuestro directorio, entonces entramos en el

root@leo:~# cd taringa

supongamos que queremos crear 3 directorios, uno que se llame newfull, otro novato y otro usuario. Lo podemos hacer de dos maneras, una, crear uno por uno (opción_1) y el otro escribiendo el comando mkdir y los tres nombres separados por espacios (opción_2). De cualquiera de las dos formas es lo mismo, pero nos ahorramos mucho tiempo a la hora de crear varios directorios con la opción_2 y ni les cuento si hay que hacer un programa, nos ahorramos código y espacio también.

Opción_1

root@leo:~/taringa# mkdir newfull
root@leo:~/taringa# mkdir novato
root@leo:~/taringa# mkdir usuario

Opción_2

root@leo:~/taringa# mkdir newfull novato usuario

Vemos que todo este bien con ls. Ahora entramos a novato y luego creamos otro que se llame tu:

root@leo:~/taringa# ls
root@leo:~/taringa# cd novato
root@leo:~/taringa/novato# mkdir tu
root@leo:~/taringa/novato# ls


Observen que la ruta de trabajo va cambiando, primero aparecía root@leo:~#, despues root@leo:~/taringa# y ahora root@leo:~/taringa/novato#

Para regresar rápidamente a nuestro directorio inicial, tecleamos nuevamente cd ~ y vemos que aparecemos nuevamente en root@leo:~#. Luego entremos a taringa -> novato -> tu de una sola, esto sería escribiendo lo siguiente:

root@leo:~#cd taringa/novato/tu

y veremos que rápidamente cambia a root@leo:~/taringa/novato/tu#

rmdir

salgamos de tu para que lo borremos con rmdir:

root@leo:~/taringa/novato/tu# cd ..
root@leo:~/taringa/novato# rmdir tu
root@leo:~/taringa/novato# ls

Para poder borrar un directorio, este siempre debe de estar vacío, si no lo esta, primero debemos borrar su contenido para luego eliminarlo. Como el directorio tu estaba vacío, no tuvimos problema en eliminarlo.

tree

simplemente telceamos tree y vemos que pasa.

root@leo:~/taringa/novato# cd..
root@leo:~/taringa# tree


.
|-- newfull
|-- novato
`-- usuario


El punto, es nuestra posición o la que especifiquemos.

Ejercicio 01

Dentro de ~/taringa hacer:

1- Entrar en newfull y crear el directorio new1 new2 new3.
2- Dentro de new2 crear dos directorios a y el directorio A.
3- Ahora dentro de usuario, crear un directorio llamado linux.
4- Dentro de linux crear dos directorios tux grub.
5- Dentro de tux, crear uno llamado animal.
6- Ver la estructura de directorios de [/b]~/taringa[/b].
7- Borrar A que se encuentra dentro de new2.
8- Borrar novato
9- Borrar new2
10- Ver nuevamente la estructura de directorios de ~/taringa






Comando: rm

Para borrar un archivo simplemente escribimos el comando rm y el nombre del archivo o archivos que quieran borrar. El uso es muy similar al comando rmdir.

Supongamos que queremos borrar el archivo llamado arch1.txt

rm arch1.txt

Si queremos borrar varios a la ves, simplemente escribimos los nombres seguidos de estos archivos con su ruta y los borramos:

rm arch1.txt arch2.txt ~/taringa/arch3.txt

Para ver algunos argumentos de este comando, tecleamos rm –help




Comando: cp y mv

cp

Con este comando podemos copiar archivo/s o directorio/s.

cp archivos_origen directorio_destino/
cp arch1.txt ~/taringa/newfull

Argumentos:

-d: Mantiene los enlaces simbólicos en lugar de copiar los archivos a los que apuntan.
-p: Mantiene los permisos y los propietarios de los archivos a copiar.
-R: Copiar un directorio recursivamente entrando en todos los subdirectorios.

Aclaro que si queremos copiar el contenido de un directorio y este tambien tiene directorios dentro, si no ponemos este argumento, solo copia los archivos sin tener en cuenta los otros subdirectorios que se encuentren dentro y mucho menos el contenido de estos subdirectorios.

-a: Es equivalente a las opciones -dpR.
-f : Borrar los archivos ya existentes en el destino.
-u: No copia los archivos que ya existan en el destino siempre y cuando la fecha de modificación de éstos sea igual o más reciente que la del destino.
-v: verbose, se muestra en pantalla lo que se está copiando.

Ejemplo:

Supongamos que tenemos muchos archivos para copiar en el directorio ~/taringa/newfull/new1 y los queremos copiar (o sea duplicarlos) a ~/taringa/newfull/new3

cp ~/taringa/newfull/new1/* ~/taringa/newfull/new3

Con esto lo que hacemos al poner el * es que dice que todo lo que este en new1 se copie a su destino, que en este caso es new3.

Supongamos que estamos pocicionados en ~/taringa, tenemos un archivo llamado sapito.txt y lo queremos copiar a ~/taringa/usuario/ linux /tux/animal

cp sapito.txt /usuario/linux/tux/animal
ls /usuario/linux/tux/animal


mv

Este comando nos sirve tanto para mover archivos o directorios, o como para cambiar su nombre.

mv origen destino

Cuando usamos este comando, el archivo es copiado al destino y luego se borra de donde estaba, a esto se le llama mover, ya que no se genera una copia, se mueve, quedando siempre en un solo lugar.

Por ejemplo, tengo el archivo sapito.txt en ~/taringa/usuario/ linux /tux/animal y lo quiero mover a ~/taringa/usuario/ linux /tux

mv ~/taringa/usuario/ linux /tux/animal/sapito.txt ~/taringa/usuario/ linux /tux/sapito.txt

De esta manera sapito.txt se encuentra dentro de tux.

Argumentos:

-v Muestra el nombre de cada archivo a ser movido

más argumentos mv –help




Ver el contenido de archivos por pagina: more y less

Estos dos comandos hacen lo mismo, la diferencia es que less podemos subir o bajar con las flechitas del cursor.

Por ejemplo, queremos ver el contenido de un archivo que tiene varias paginas. Si lo viéramos normalmente, estas paginas pasarían volando y solo veríamos el final del documento. Con cualquiera de estos dos comandos, nos muestra en pantalla el contenido por hoja sin dejarnos perder nada del documento.

También se puede combinar con otros comandos y estos dos comandos al final separados por una barrita vertical “|”.

* En teclado español manteniendo presionada “alt Gr” + “1” = |
* En teclado latinoamericano simplemente tocando la tecla alfanumérica que esta a la izquierda del “1” o debajo del “Esc”


Un ejemplo:

tree /usr | more

Verán el arbol de /usr y con la barra espaciadora podrán avanzar para ver lo que sigue, con la letra “q” salen.

Ahora hacemos lo mismo, pero con less y veran que podemos hacer lo mismo que con more, pero con el cursos adelantamos y retrocedemos. También salimos con la “q”.

tree /usr | less

Y por último tipeen esto para ver la diferencia:

tree /usr




Contador de palabras, lineas, caracteres, etc. en archivos de texto: wc

Con este comando podemos no solo contar palabras de un archivo, también podemos hacer otras cosas dependiendo de su argumento.

wc nombre_archivo

Argumentos:

-c Contar bytes.
-l Contar líneas.
-w Contar palabras.




Ver el inicio y fin de un archivo de texto: head y tail

head

head nombre_archivo

Con este comando podemos ver el inicio de un archivo y combinarlo con los siguientes argumentos:

-c N Escribe los primeros N bytes.
-n N Escribe las primeras N líneas en vez de las primeras 10 (que es el valor predeterminado).


tail

tail nombre_archivo

-c N Escribe los últimos N bytes.
-n N Escribe las últimas N líneas.
-f Escribir la última parte del archivo a medida que va creciendo. Esta opción es muy útil para monitorear archivos de registro que van creciendo con el tiempo.




SOLUCION Ejercicio 01

Dentro de ~/taringa hacer:

cd ~/taringa


1- Entrar en newfull y crear el directorio new1 new2 new3.

cd newfull
mkdir new1 new2 new3


2- Dentro de new2 crear dos directorios a y el directorio A.

cd new2
mkdir a A


3- Ahora dentro de usuario, crear un directorio llamado linux.

cd  ..
cd ..
cd usuario
mkdir linux


4- Dentro de linux crear dos directorios tux grub.

cd linux
mkdir tux grub


5- Dentro de tux, crear uno llamado animal.

Opción_1


cd tux
mkdir animal


Opción_2


mkdir tux/animal


6- Ver la estructura de directorios de [/b]~/taringa[/b].

Opción_1


tree ~/taringa


Opción_2


cd ~/taringa
tree


7- Borrar A que se encuentra dentro de new2.

Opción_1

cd ~/taringa
cd newfull
cd new2
rmdir A


Opción_2


cd ~/taringa/newfull/new2
rmdir A


Opción_3


cd ~/taringa
rmdir newfull/new2/A


8- Borrar novato

cd ~/taringa
rmdir novato


9- Borrar new2

Primero vaciamos new2 y luego lo borramos:

Opción_1


cd ~/taringa/newfull/new2
rmdir a
cd ..
rmdir new2


Opción_2


cd ~/taringa
rmdir newfull/new2/a newfull/new2


10- Ver nuevamente la estructura de directorios de ~/taringa

cd ~/taringa
tree


cxs00 dijo:

como hacer los directorios de la 1 en 1 linea
mkdir -p ~/{taringa/{novato,usuario,newfull/new{1,2/{a,A},3}},linux/{tux/animal,grub}}

Gracias por participar, me encanto



Un abrazo y espero les sirva

Próximo tutorial: Vim