Changes

Jump to: navigation, search

User talk:Arlesy

30,670 bytes added, 3 years ago
Sintaxis de comodín: * y ?
Para ver el directorio de trabajo actual de bash, puede escribir:
{{console|body=$ ##i##pwd 
$ /
}}
En el ejemplo anterior, el argumento / a {{c|cd }} se llama ''ruta''. Le dice a cd dónde queremos ir. En particular, el argumento / es una ruta ''absoluta'', lo que significa que especifica una ubicación relativa a la raíz del árbol del sistema de archivos.
Rutas absolutas
=== Rutas absolutas ===
Aquí hay otras rutas absolutas:
<pre>
/dev
 
/usr
 
/usr/bin
 
/usr/local/bin
</pre>
Como puede ver, la única cosa que todos los rutas absolutas tienen en común es que comienzan con /. Con una ruta de acceso a /usr/local/bin, estamos diciendo a cd que entre en el directorio /, a continuación al directorio usr, luego local y bin. Las rutas absolutas se evalúan siempre comenzando en / primero.
Rutas relativas
=== Rutas relativas ===
El otro tipo de ruta se llama una ruta relativa. Bash, cd y otros comandos siempre interpretan estas rutas en relación con el directorio actual. Las rutas relativas nunca comienzan con un /. Por lo tanto, si estamos en /usr:
{{console|body=$ ##i##cd /usr}}
Entonces, podemos usar una ruta relativa para cambiar al directorio /usr/local/bin:
{{console|body=$ ##i##cd local/bin $ ##i##pwd/usr/local/bin}}
/usr/local/bin=== Utilizando ..===
Las rutas relativas también pueden contener uno o más directorios. El directorio .. es un directorio especial que apunta al directorio padre. Así, continuando desde el ejemplo anterior:
<pre>
$ pwd
 
/usr/local/bin
 
$ cd ..
 
$ pwd
 
/usr/local
</pre>Como puede ver, nuestro directorio actual es ahora /usr/local. Pudimos ir "al revés" ''retroceder'' un directorio, relativo al directorio actual en el que estábamos.
Además, también podemos añadir .. a una ruta relativa existente, lo que nos permite entrar en un directorio que está junto a uno en el que ya estamos, por ejemplo:
<pre>
$ pwd
 
/usr/local
 
$ cd ../share
 
$ pwd
/usr/share
</pre>
/usr/share=== Ejemplos de ruta relativa===
Las rutas relativas pueden ser bastante complejas. Aquí hay algunos ejemplos, todos sin el directorio de destino resultante mostrado. Trate de averiguar dónde terminará después de escribir estos comandos:
<pre>
$ cd /bin
$ cd ../usr/share/zoneinfo
 
$ cd /usr/X11R6/bin $ cd ../usr/sharelib/zoneinfoX11
$ cd /usr/X11R6/bin $ cd ../lib/X11
$ cd /usr/bin $ cd ../bin/../bin</pre>
Ahora, probarlos y ver si los tienes bien :)
Entendiendo el "."
Antes de terminar nuestra cobertura de cd, hay algunas cosas más que necesito mencionar. En primer lugar, hay otro directorio especial llamado., Que significa "=== Entendiendo el directorio actual". Aunque este directorio no se utiliza con el comando cd, a menudo se utiliza para ejecutar algún programa en el directorio actual, de la siguiente manera:" ===
Antes de terminar nuestra cobertura de cd, hay algunas cosas más que necesito mencionar. En primer lugar, hay otro directorio especial llamado., Que significa ''el directorio actual''. Aunque este directorio no se utiliza con el comando cd, a menudo se utiliza para ejecutar algún programa en el directorio actual, de la siguiente manera:
<pre>
$ ./myprog
</pre>
En el ejemplo anterior, se ejecutará el ejecutable myprog residente en el directorio de trabajo actual.
cd y el directorio de inicio
=== cd y el directorio de inicio ===
Si queremos cambiar a nuestro directorio personal, podríamos escribir:
<pre>
$ cd
</pre>
Sin argumentos, cd cambiará a su directorio de inicio, que es /root para el superusuario y normalmente /home/nombre de usuario para un usuario normal. Pero ¿qué pasa si queremos especificar un archivo en nuestro directorio personal? Tal vez queramos pasar un argumento de archivo al comando <span style="color:green">myprog</span>. Si el archivo reside en nuestro directorio personal, podemos escribir:
<pre>
$ ./myprog /home/drobbins/myfile.txt
</pre>
Sin embargo, usar un camino absoluto como ese no siempre es conveniente. Afortunadamente, podemos usar el carácter ~ (tilde) para hacer lo mismo:
<pre>
$ ./myprog ~/myfile.txt
</pre>
 
=== Directorios de inicio de otros usuarios ===
 
Bash expandirá un solo ~ para apuntar a su directorio personal, pero también puede usarlo para apuntar a los directorios de inicio de otros usuarios. Por ejemplo, si queremos hacer referencia a un archivo llamado fredsfile.txt en el directorio personal de Fred, podríamos escribir:<pre>
$ ./myprog ~fred/fredsfile.txt
</pre>
 
== Usando comandos de Linux ==
 
=== Introduciendo ls ===
Ahora, echaremos un vistazo al comando ls. Es muy probable que ya esté familiarizado con ls y sabe que al escribirlo por sí mismo se lista el contenido del directorio de trabajo actual:
<pre>
$ cd /usr
$ ls
X11R6 doc i686-pc-linux-gnu lib man sbin ssl
bin gentoo-x86 include libexec portage share tmp
distfiles i686-linux info local portage.old src
</pre>
Al especificar la opción -a, puede ver todos los archivos de un directorio, incluidos los archivos ocultos: los que comienzan con (.). Como se puede ver en el ejemplo siguiente, ls -a revela los archivo . y .. directorio especial de enlaces:
 
<pre>
$ ls -a
. bin gentoo-x86 include libexec portage share tmp
.. distfiles i686-linux info local portage.old src
X11R6 doc i686-pc-linux-gnu lib man sbin ssl
</pre>
 
=== Listados largos del directorio ===
 
También puede especificar uno o más archivos o directorios en la línea de comandos de <span style="color:green">ls</span>. Si especifica un archivo, <span style="color:green">ls</span> mostrará ese archivo solamente. Si especifica un directorio, <span style="color:green">ls</span> mostrará el contenido del directorio. La opción -l resulta muy útil cuando necesita ver los permisos, la propiedad, la hora de modificación y la información de tamaño en su lista de directorios.
 
En el ejemplo siguiente, usamos la opción -l para mostrar una lista completa de mi directorio /usr.
<pre>
$ ls -l /usr
drwxr-xr-x 7 root root 168 Nov 24 14:02 X11R6
drwxr-xr-x 2 root root 14576 Dec 27 08:56 bin
drwxr-xr-x 2 root root 8856 Dec 26 12:47 distfiles
lrwxrwxrwx 1 root root 9 Dec 22 20:57 doc -> share/doc
drwxr-xr-x 62 root root 1856 Dec 27 15:54 gentoo-x86
drwxr-xr-x 4 root root 152 Dec 12 23:10 i686-linux
drwxr-xr-x 4 root root 96 Nov 24 13:17 i686-pc-linux-gnu
drwxr-xr-x 54 root root 5992 Dec 24 22:30 include
lrwxrwxrwx 1 root root 10 Dec 22 20:57 info -> share/info
drwxr-xr-x 28 root root 13552 Dec 26 00:31 lib
drwxr-xr-x 3 root root 72 Nov 25 00:34 libexec
drwxr-xr-x 8 root root 240 Dec 22 20:57 local
lrwxrwxrwx 1 root root 9 Dec 22 20:57 man -> share/man
lrwxrwxrwx 1 root root 11 Dec 8 07:59 portage -> gentoo-x86/
drwxr-xr-x 60 root root 1864 Dec 8 07:55 portage.old
drwxr-xr-x 3 root root 3096 Dec 22 20:57 sbin
drwxr-xr-x 46 root root 1144 Dec 24 15:32 share
drwxr-xr-x 8 root root 328 Dec 26 00:07 src
drwxr-xr-x 6 root root 176 Nov 24 14:25 ssl
lrwxrwxrwx 1 root root 10 Dec 22 20:57 tmp -> ../var/tmp
</pre>
 
La primera columna muestra información de permisos para cada elemento del listado. Voy a explicar cómo interpretar esta información más adelante. La siguiente columna muestra el número de enlaces a cada objeto del sistema de archivos, que pasaremos por alto ahora, pero volveremos a ello más tarde. Las columnas tercera y cuarta listan el propietario y el grupo, respectivamente. La quinta columna muestra el tamaño del objeto. La sexta columna es el tiempo de ''última modificación'' o ''mtime'' del objeto. La última columna es el nombre del objeto. Si el archivo es un enlace simbólico, verá un apuntador -> y la ruta a la que apunta el enlace simbólico.
 
=== Mirando los directorios ===
 
A veces, usted querrá mirar un directorio, en lugar de dentro de él. Para estas situaciones, puede especificar la opción <span style="color:green">-d</span>, que le dirá a ls que busque en cualquier directorio que normalmente buscaría en su interior:
<pre>
$ ls -dl /usr /usr/bin /usr/X11R6/bin ../share
drwxr-xr-x 4 root root 96 Dec 18 18:17 ../share
drwxr-xr-x 17 root root 576 Dec 24 09:03 /usr
drwxr-xr-x 2 root root 3192 Dec 26 12:52 /usr/X11R6/bin
drwxr-xr-x 2 root root 14576 Dec 27 08:56 /usr/bin
</pre>
 
=== Listados recursivos e inode ===
Así que puede usar <span style="color:green">-d</span> para buscar en un directorio, pero también puede usar <span style="color:green">-R</span> para hacer lo contrario: no sólo mirar dentro de un directorio, sino recursivamente buscar dentro de todos los archivos y directorios dentro de ese directorio! No incluiremos ningún ejemplo de salida para esta opción (ya que generalmente es voluminosa), pero es posible que desee probar algunos comandos <span style="color:green">ls -R</span> y <span style="color:green">ls -Rl</span> para obtener una idea de cómo funciona.
 
Finalmente, la opción ls <span style="color:green">-i</span> se puede usar para mostrar los números de inodo de los objetos del sistema de archivos en el listado:
<pre>
$ ls -i /usr
1409 X11R6 314258 i686-linux 43090 libexec 13394 sbin
1417 bin 1513 i686-pc-linux-gnu 5120 local 13408 share
8316 distfiles 1517 include 776 man 23779 src
43 doc 1386 info 93892 portage 36737 ssl
70744 gentoo-x86 1585 lib 5132 portage.old 784 tmp
</pre>
 
=== Comprensión de los inodos ===
A cada objeto de un sistema de archivos se le asigna un índice único, denominado número de inodo. Esto puede parecer trivial, pero entender los inodes es esencial para entender muchas operaciones del sistema de archivos. Por ejemplo, considere los enlaces . y .. que aparecen en cada directorio. Para entender completamente lo que realmente es un directorio, primero echaremos un vistazo al número de inodo de /usr/local:
 
<pre>
$ ls -id /usr/local
5120 /usr/local
</pre>
El directorio /usr/local tiene un número de inodo de 5120. Ahora echemos un vistazo al número de inodo de /usr/local/bin/ ..:
<pre>
$ ls -id /usr/local/bin/..
5120 /usr/local/bin/..
</pre>
 
Como puede ver, /usr/local/bin/ tiene el mismo número de inode que /usr/local! Así es como podemos enfrentarnos a esta sorprendente revelación. En el pasado, hemos considerado a / usr / local como el propio directorio. Ahora, descubrimos que el inode 5120 es de hecho el directorio, y hemos encontrado dos entradas de directorio (llamadas "enlaces") que apuntan a este inodo. Ambos /usr/local y /usr/local/bin/.. son enlaces a inode 5120. Aunque inode 5120 sólo existe en un lugar en el disco, varias cosas enlazan a él. Inode 5120 es la entrada real en el disco.
 
De hecho, podemos ver el número total de veces que el inodo 5120 se referenciado usando el comando <pre>ls -dl</pre>:
<pre>
$ ls -dl /usr/local
drwxr-xr-x 8 root root 240 Dec 22 20:57 /usr/local
</pre>
 
Si echamos un vistazo a la segunda columna de la izquierda, vemos que el directorio / usr / local (inode 5120) se hace referencia ocho veces. En mi sistema, aquí están los varios caminos que hacen referencia a este inodo:
<pre>
/usr/local
/usr/local/.
/usr/local/bin/..
/usr/local/games/..
/usr/local/lib/..
/usr/local/sbin/..
/usr/local/share/..
/usr/local/src/..
</pre>
 
=== mkdir ===
Echemos un rápido vistazo al comando <span style="color:green">mkdir</span>, que se puede utilizar para crear nuevos directorios. El siguiente ejemplo crea tres nuevos directorios, tic, tac y toe, todos bajo <pre>
$ cd /tmp
$ mkdir tic tac toe
</pre>
De forma predeterminada, el comando <span style="color:green">mkdir</span> no crea directorios principales para usted; toda la ruta desde el primer elemento hasta el último necesita existir. Por lo tanto, si desea crear los directorios ganados ''won/der/ful'', necesitará emitir tres comandos <span style="color:green">mkdir</span> independientes:
<pre>
$ mkdir won/der/ful
mkdir: cannot create directory `won/der/ful': No such file or directory
$ mkdir won
$ mkdir won/der
$ mkdir won/der/ful
</pre>
Sin embargo, mkdir tiene una opción práctica -p que le dice a mkdir que cree cualquier directorio padre faltante, como puede ver aquí:
<pre>
$ mkdir -p easy/as/pie
</pre>
En general, es bastante sencillo. Para obtener más información sobre el comando mkdir, escriba <span style="color:green">man mkdir</span> para leer la página de manual. Esto funcionará para casi todos los comandos cubiertos aquí (por ejemplo, <span style="color:green">man ls</span>), excepto para <span style="color:green">cd</span>, que está incorporado en bash.
 
=== touch ===
Ahora, vamos a echar un vistazo rápido a los comandos cp y mv, utilizados para copiar, cambiar el nombre y mover archivos y directorios. Para comenzar esta descripción, primero usaremos el comando touch para crear un archivo en /tmp:
<pre>
$ cd /tmp
$ touch copyme
</pre>
El comando touch actualiza el ''mtime'' de un archivo si existe (recuerde la sexta columna en la salida <span style="color:green">ls -l</span>). Si el archivo no existe, se creará un nuevo archivo vacío. Ahora debe tener un archivo ''/tmp/copyme'' con un tamaño de cero.
 
=== echo ===
Ahora que el archivo existe, vamos a agregar algunos datos al archivo. Podemos hacerlo usando el comando echo, que toma sus argumentos y los imprime a la salida estándar. En primer lugar, el comando de eco en sí mismo:
<pre>
$ echo "firstfile"
firstfile
</pre>
Ahora, el mismo comando de eco con redirección de salida:
<pre>
$ echo "firstfile" > copyme
</pre>
El signo mayor que indica al shell que escriba la salida de eco en un archivo llamado copyme. Este archivo se creará si no existe y se sobrescribirá si existe. Escribiendo <span style="color:green">ls -l</span>, podemos ver que el archivo copyme tiene 10 bytes de largo, ya que contiene la palabra firstfile y el caracter newline:
 
<span style="color:green">ls -l</span>, we can see that the copyme file is 10 bytes long, since it contains the word firstfile and the newline character:
<pre>
$ ls -l copyme
-rw-r--r-- 1 root root 10 Dec 28 14:13 copyme
</pre>
 
=== cat y cp ===
Para mostrar el contenido del archivo en el terminal, utilice el comando cat:
<pre>
$ cat copyme
firstfile
</pre>
Ahora, podemos usar una invocación básica del comando <span style="color:green">cp</span> para crear un archivo copiedme copiado del archivo original:
<pre>
$ cp copyme copiedme
</pre>
Tras la investigación, encontramos que son archivos verdaderamente separados; sus números de inodo son diferentes:
<pre>
$ ls -i copyme copiedme
648284 copiedme 650704 copyme
</pre>
 
=== mv ===
Ahora, vamos a usar el comando mv para cambiar el nombre de ''copiedme'' a ''movedme''. El número de inodo permanecerá igual; sin embargo, el nombre de archivo que apunta al inodo cambiará.
<pre>
$ mv copiedme movedme
$ ls -i movedme
648284 movedme
</pre>
 
El número de inodo de un archivo movido permanecerá igual mientras el archivo de destino resida en el mismo sistema de archivos que el archivo de origen. Echaremos un vistazo a los sistemas de archivos en [[Linux Fundamentals, Part 3]] de esta serie de tutoriales.
Mientras hablamos de <span style="color:green">mv</span>, veamos otra forma de usar este comando. <span style="color:green">mv</span>, además de permitirnos cambiar el nombre de los archivos, también nos permite mover uno o más archivos a otra ubicación en la jerarquía de directorios. Por ejemplo, para mover '''/var/tmp/myfile.txt''' a '''/home/drobbins''' (que pasa a ser mi directorio personal), podría escribir:<pre>$ mv /var/tmp/myfile.txt /home/drobbins</pre>Después de escribir este comando, myfile.txt se moverá a '''/home/drobbins/myfile.txt'''. Y si '''/home/drobbins''' está en un sistema de archivos diferente de /var/tmp, el comando <span style="color:green">mv</span> controlará la copia de myfile.txt al nuevo sistema de archivos y lo borrará del antiguo sistema de archivos. Como se puede adivinar, cuando myfile.txt se mueve entre sistemas de archivos, myfile.txt en la nueva ubicación tendrá un nuevo número de inodo. Esto se debe a que cada sistema de archivos tiene su propio conjunto independiente de números de inodo. También podemos usar el comando <span style="color:green">mv</span> para mover varios archivos a un único directorio de destino. Por ejemplo, para mover myfile1.txt y myarticle3.txt a /home/drobbins, podría escribir:<pre>$ mv /var/tmp/myfile1.txt /var/tmp/myarticle3.txt /home/drobbins</pre> == Creando Enlaces y Removiendo Archivos == === Enlaces duros ===Hemos mencionado el término ''enlace'' cuando nos referimos a la relación entre las entradas de directorio (los ''nombres'' que escribimos) y los inodos (los números de índice en el sistema de archivos subyacente que normalmente podemos ignorar). En realidad hay dos tipos de enlaces disponibles en Linux. El tipo que hemos discutido hasta ahora se llama enlaces duros. Un inodo dado puede tener cualquier número de enlaces duros, y el inodo persistirá en el sistema de archivos hasta que todos los enlaces duros desaparezcan. Cuando el último vínculo duro desaparezca y ningún programa mantenga abierto el archivo, Linux eliminará el archivo automáticamente. Se pueden crear nuevos vínculos duros mediante el comando <span style="color:green">ln</span>:<pre>$ cd /tmp$ touch firstlink$ ln firstlink secondlink$ ls -i firstlink secondlink 15782 firstlink 15782 secondlink</pre>Como puede ver, los enlaces duros funcionan en el nivel de inodo para apuntar a un archivo en particular. En sistemas Linux, los enlaces duros tienen varias limitaciones. Por un lado, sólo puede hacer enlaces duros a los archivos, no a los directorios. Está bien; aunque . y .. son enlaces duros a los directorios creados por el sistema, usted (incluso como el usuario ''root)'' no están autorizados a crearlos por cuenta propia. La segunda limitación de los enlaces duros es que no pueden abarcar los sistemas de archivos; que sería el caso si los sistemas de archivos se encuentran en particiones de disco independientes. Esto significa que no puede crear un enlace desde /usr/bin/bash a /bin/bash si sus directorios / y /usr existen en particiones de disco separadas. === Enlaces simbólicos === En la práctica, los enlaces simbólicos (o symlinks) se utilizan con más frecuencia que los enlaces duros. Los enlaces simbólicos son un tipo de archivo especial donde el vínculo se refiere a otro archivo por nombre, en lugar de directamente al inodo. Los enlaces simbólicos no impiden que se elimine un archivo; Si el archivo de destino desaparece, entonces el enlace simbólico sólo será inutilizable o roto. Se puede crear un enlace simbólico pasando la opción -s a <span style="color:green">ln</span>.<pre>$ ln -s secondlink thirdlink$ ls -l firstlink secondlink thirdlink-rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 firstlink-rw-rw-r-- 2 agriffis agriffis 0 Dec 31 19:08 secondlinklrwxrwxrwx 1 agriffis agriffis 10 Dec 31 19:39 thirdlink -> secondlink</pre> Los enlaces simbólicos se pueden distinguir en <span style="color:green">ls -l</span> salida de archivos normales de tres maneras. En primer lugar, observe que la primera columna contiene un carácter l para indicar el enlace simbólico. En segundo lugar, el tamaño del enlace simbólico es el número de caracteres en el destino (segundo enlace, en este caso). En tercer lugar, la última columna de la salida muestra el nombre de archivo de destino precedido por una flecha ->. === Symlinks en profundidad ===Los enlaces simbólicos son generalmente más flexibles que los enlaces duros. Puede crear un vínculo simbólico con cualquier tipo de objeto del sistema de archivos, incluidos los directorios. Y debido a que la implementación de enlaces simbólicos se basa en rutas (no en inodos), está perfectamente bien crear un enlace simbólico que apunte a un objeto en otro sistema de archivos físico; es decir, una partición de disco diferente. Sin embargo, este hecho también puede hacer que los enlaces simbólicos sean difíciles de entender. Considere una situación donde queremos crear un enlace en /tmp que apunte a /usr/local/bin. Deberíamos escribir esto:<pre>$ ln -s /usr/local/bin bin1$ ls -l bin1lrwxrwxrwx 1 root root 14 Jan 1 15:42 bin1 -> /usr/local/bin</pre>O alternativamente:<pre>$ ln -s ../usr/local/bin bin2$ ls -l bin2lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin</pre>Como puede ver, ambos enlaces simbólicos apuntan al mismo directorio. Sin embargo, si nuestro segundo enlace simbólico es movido a otro directorio, se "romperá" debido a la ruta relativa:<pre>$ ls -l bin2lrwxrwxrwx 1 root root 16 Jan 1 15:43 bin2 -> ../usr/local/bin$ mkdir mynewdir$ mv bin2 mynewdir$ cdmynewdir$ cd bin2bash: cd: bin2: No such file or directory</pre>Debido a que el directorio /tmp/usr/local/bin no existe, ya no podemos cambiar los directorios en bin2; en otras palabras, bin2 está ahora roto. Por esta razón, a veces es una buena idea evitar crear enlaces simbólicos con la información de ruta relativa. Sin embargo, hay muchos casos donde los enlaces simbólicos relativos son muy útiles. Considere un ejemplo en el que desea crear un nombre alternativo para un programa en /usr/bin:<pre># ls -l /usr/bin/keychain -rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain</pre>Como usuario root, puede crear un nombre alternativo para ''keychain'', como ''kc''. En este ejemplo, tenemos acceso de root, como lo demuestra nuestro indicador bash cambiando a "#". Necesitamos acceso root porque los usuarios normales no pueden crear archivos en /usr/bin. Como root, podríamos crear un nombre alternativo para keychain de la siguiente manera:<pre># cd /usr/bin# ln -s /usr/bin/keychain kc# ls -l keychain-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/bin/keychain# ls -l kc lrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> /usr/bin/keychain</pre>En este ejemplo, creamos un enlace simbólico llamado kc que apunta al archivo /usr/bin/keychain. Si bien esta solución funcionará, creará problemas si decidimos que queremos mover ambos archivos, /usr/bin/keychain y /usr/bin/kc a /usr/local/bin:<pre># cd /usr/bin# ln -s keychain kc# ls -l kclrwxrwxrwx 1 root root 8 Jan 5 12:40 kc -> keychain# mv keychain kc /usr/local/bin# ls -l /usr/local/bin/keychain-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain# ls -l /usr/local/bin/kclrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> keychain</pre>Debido a que usamos un camino absoluto en nuestro enlace simbólico, nuestro enlace simbólico kc sigue apuntando a /usr/bin/ keychain, que ya no existe desde que movimos /usr/bin/keychain a /usr/local/bin. Eso significa que kc es ahora un enlace simbólico roto. Tanto las rutas relativas como las absolutas en los enlaces simbólicos tienen sus méritos, y debe usar un tipo de ruta que sea apropiado para su aplicación particular. A menudo, un camino relativo o absoluto funcionará bien. El ejemplo siguiente habría funcionado incluso después de mover ambos archivos:<pre># cd /usr/bin# ln -s keychain kc# ls -l kclrwxrwxrwx 1 root root 8 Jan 5 12:40 kc -> keychain# mv keychain kc /usr/local/bin# ls -l /usr/local/bin/keychain-rwxr-xr-x 1 root root 10150 Dec 12 20:09 /usr/local/bin/keychain# ls -l /usr/local/bin/kclrwxrwxrwx 1 root root 17 Mar 27 17:44 kc -> keychain</pre>Ahora, podemos ejecutar el programa keychain escribiendo /usr/local/bin/kc. /usr/local/bin/kc apunta al llavero del programa en el mismo directorio que kc. === rm === Ahora que sabemos cómo usar cp, mv y ln, es hora de aprender a eliminar objetos del sistema de archivos. Normalmente, esto se hace con el comando rm. Para eliminar archivos, simplemente especifíquelos en la línea de comandos: <pre>$ cd /tmp$ touch file1 file2$ ls -l file1 file2-rw-r--r-- 1 root root 0 Jan 1 16:41 file1-rw-r--r-- 1 root root 0 Jan 1 16:41 file2$ rm file1 file2$ ls -l file1 file2ls: file1: No such file or directoryls: file2: No such file or directory</pre>Tenga en cuenta que bajo Linux, una vez que un archivo es removido, normalmente se va para siempre. Por esta razón, muchos administradores de sistema junior utilizarán la opción -i al eliminar archivos. La opción -i le dice a rm que elimine todos los archivos en modo interactivo, es decir, antes de quitar cualquier archivo. Por ejemplo: <pre>$ rm -i file1 file2rm: remove regular empty file `file1'? yrm: remove regular empty file `file2'? y</pre>En el ejemplo anterior, el comando rm indicó si los archivos especificados deberían *realmente* eliminarse. Para que se eliminaran, tuve que escribir "y" y presionar Enter dos veces. Si hubiera escrito ''n'', el archivo no se habría eliminado. O, si hubiera hecho algo realmente mal, podría haber tecleado Control-C para abortar el comando rm -i enteramente - todo antes de poder hacer cualquier daño potencial a mi sistema. Si todavía se está acostumbrando al comando rm, puede ser útil agregar la siguiente línea al archivo ~ / .bashrc usando su editor de texto favorito y luego cerrar la sesión y volver a iniciarla. Entonces, cada vez que escriba rm, El shell de bash lo convertirá automáticamente en un comando rm -i. De esta manera, rm siempre funcionará en modo interactivo: <pre>alias rm="rm -i"</pre> === rmdir === Para quitar directorios, tiene dos opciones. Puede quitar todos los objetos dentro del directorio y luego usar <span style="color:green">rmdir</span> para quitar el propio directorio: <pre>$ mkdir mydir$ touch mydir/file1$ rm mydir/file1$ rmdir mydir</pre>Este método se conoce comúnmente como ''eliminación de directorios para bobos''. Todos los usuarios avanzados y administradores reales, #worth their salt utilizan el comando rm -rf mucho más conveniente, que se describe a continuación. La mejor manera de eliminar un directorio es utilizar las opciones de ''fuerza recursiva'' del comando rm para indicar a rm que elimine el directorio especificado, así como todos los objetos contenidos en el directorio: <pre>$ rm -rf mydir</pre>Generalmente, rm -rf es el método preferido para eliminar un árbol de directorios. Tenga mucho cuidado al usar rm -rf, ya que su poder puede ser usado tanto para el bien como para el mal :) == Uso de comodines == === Presentación de comodines === En tu uso cotidiano de Linux, muchas veces necesitas realizar una sola operación (como rm) en muchos objetos del sistema de archivos a la vez. En estas situaciones, a menudo puede resultar engorroso escribir muchos archivos en la línea de comandos: <pre>$ rm file1 file2 file3 file4 file5 file6 file7 file8</pre>Para solucionar este problema, puede aprovechar el soporte de comodines incorporado de Linux. Este soporte, también llamado ''globbing'' (por razones históricas), le permite especificar múltiples archivos a la vez usando un patrón comodín. Bash y otros comandos de Linux interpretarán este patrón buscando en el disco y encontrando cualquier archivo que coincida con él. Por lo tanto, si tenía archivos de archivo1 a archivo8 en el directorio de trabajo actual, podría eliminar estos archivos escribiendo: <pre>$ rm file[1-8]</pre>O si simplemente quería eliminar todos los archivos cuyos nombres empiezan por archivo, así como cualquier archivo con nombre archivo, podría escribir: <pre>$ rm file*</pre>El comodín * coincide con cualquier carácter o secuencia de caracteres, o incluso ''sin carácter''. Por supuesto, los comodines glob pueden usarse para algo más que simplemente eliminar archivos, como veremos en el siguiente panel. === Entendiendo las no coincidencias === Si desea listar todos los objetos del sistema de archivos en /etc que comienzan con g, así como cualquier archivo llamado g, podría escribir: <pre>$ ls -d /etc/g*/etc/gconf /etc/ggi /etc/gimp /etc/gnome /etc/gnome-vfs-mime-magic /etc/gpm /etc/group /etc/group-</pre>Ahora, ¿qué ocurre si especifica un patrón que no coincide con ningún objeto del sistema de archivos? En el ejemplo siguiente, intentamos listar todos los archivos en /usr/bin que comienzan con asdf y terminan con jkl, incluyendo potencialmente el archivo asdfjkl: <pre>$ ls -d /usr/bin/asdf*jklls: /usr/bin/asdf*jkl: No such file or directory</pre>Esto es lo que pasó. Normalmente, cuando especificamos un patrón, ese patrón coincide con uno o más archivos en el sistema de archivos subyacente, y bash reemplaza el patrón con una lista separada por espacios de todos los objetos coincidentes . Sin embargo, cuando el patrón no produce ninguna coincidencia, bash deja el argumento, wild cards y todos, tal cual . Por lo tanto, entonces ls no puede encontrar el archivo / usr / bin / asdf * jkl y nos da un error. La regla operativa aquí es que los patrones glob se expanden sólo si coinciden con los objetos del sistema de archivos . De lo contrario, permanecen como están y se pasan literalmente al programa que está llamando.  === Sintaxis de comodín: * y ? === Ahora que hemos visto cómo globbing funciona, debemos ver la sintaxis de comodines. Puede utilizar caracteres especiales para la expansión de comodines:  <nowiki>*</nowiki> coincidirá con cero o más caracteres. Significa "cualquier cosa puede ir aquí, incluyendo nada". Ejemplos:  * /etc/g * hace coincidir todos los archivos de /etc que comienzan con g, o un archivo llamado g. * /tmp/my * 1 coincide con todos los archivos en /tmp que comienzan con mi y terminan con 1, incluido el archivo my1.  ? coincide con cualquier carácter. Ejemplos:  * mi_archivo? Coincide con cualquier archivo cuyo nombre consta de mi_archivo seguido de un solo carácter * /tmp/notes?txt coincidiría con /tmp/notes.txt y /tmp/notes_txt, si existen === Sintaxis de comodín: [] === Este comodín es como un ?, Pero permite una mayor especificidad. Para utilizar esta tarjeta comodín, coloque los caracteres que desee coincidir dentro de []. La expresión resultante coincidirá con una sola ocurrencia de cualquiera de estos caracteres. También puede utilizar - para especificar un rango e incluso combinar rangos. Ejemplos: * myfile[12] coincidirá myfile1 y myfile2. El comodín se expandirá siempre que al menos uno de estos archivos exista en el directorio actual. * [Cc]hange[Ll]og coincidirá con Changelog, ChangeLog, changeLog y changelog. Como puede ver, el uso de comodines puede ser útil para hacer coincidir variaciones en mayúsculas. * ls/etc/[0-9] * mostrará todos los archivos de / etc que comiencen con un número. * ls/tmp/[A-Za-z] * mostrará todos los archivos en /tmp que comienzan con una letra mayúscula o minúscula.
Sin argumentosEl constructor [!] es similar al constructor [], cd cambiará a su directorio excepto que en lugar de iniciocoincidir con cualquier carácter dentro de los corchetes, que es /root para el superusuario coincidirá con cualquier caracter, siempre y normalmente /home/nombre de usuario para un usuario normalcuando no se encuentra entre la lista [! and]. Pero ¿qué pasa si queremos especificar Ejemplo: * rm myfile [! 9] eliminará todos los archivos llamados myfile más un archivo en nuestro directorio personal? Tal vez queramos pasar un argumento de archivo al comando myprog. Si el archivo reside en nuestro directorio personalsolo carácter, podemos escribir:excepto myfile9
=== Advertencias de comodines === Aquí hay algunas advertencias a tener en cuenta cuando se usan comodines. Dado que bash trata los caracteres comodín (?, [,] y *) especialmente, debe tener especial cuidado al escribir un argumento en un comando que contenga estos caracteres. Por ejemplo, si desea crear un archivo que contenga la cadena [fo] *, el siguiente comando no puede hacer lo que desea: <pre>$ echo [fo]* > /tmp/mynewfile.txt</pre>Si el patrón [fo] * coincide con cualquier archivo del directorio de trabajo actual, encontrarás los nombres de esos archivos dentro de /tmp/mynewfile.txt en lugar de un literal [fo] * como esperabas.¿La solución? Bueno, un enfoque es rodear a sus caracteres con comillas simples, que dicen a bash que no realizar absolutamente ninguna expansión de comodín en ellos: <pre>$ echo '[fo]*' > /myprog tmp/homemynewfile.txt</drobbinspre>Utilizando este enfoque, su nuevo archivo contendrá un literal [fo] * como se esperaba. Alternativamente, puede usar la barra invertida para decirle a bash que [,], y * deberían ser tratados literalmente en lugar de como comodines: <pre>$ echo \[fo\]\* > /tmp/myfilemynewfile.txt</pre>
Sin embargoAmbos enfoques (comillas simples y barra invertida) tienen el mismo efecto. Dado que estamos hablando de expansión de barra invertida, usar ahora sería un buen momento para mencionar que para especificar un camino absoluto como ese no siempre es conveniente. Afortunadamenteliteral \, podemos usar el carácter ~ también puede incluirlo entre comillas simples o tipo \\ (tildese expandirá a \) para . Nota {{fancynote|Las comillas dobles funcionarán de forma similar a las comillas simples, pero todavía le permitirán a bash hacer alguna expansión limitada. Por lo mismotanto, las comillas simples son su mejor apuesta cuando realmente está interesado en pasar el texto literal a un comando. Para obtener más información sobre la expansión de comodines, escriba man 7 glob. Para más información sobre citar en bash, escriba man 8 glob y lea la sección titulada QUOTING. Si está planeando tomar los exámenes LPI, considere esto como una tarea :) }}
$ ./myprog ~/myfile.txtDirectorios de inicio de otros usuarios== Resumen y recursos ==
Bash expandirá un solo ~ para apuntar === Resumen === Felicitaciones; ¡Has llegado al final de nuestra revisión de los fundamentos de Linux! Espero que le haya ayudado a consolidar su directorio personalconocimiento básico de Linux. Los temas que has aprendido aquí, pero también puede usarlo para apuntar a incluyendo los directorios conceptos básicos de inicio bash, comandos básicos de otros usuarios. Por ejemploLinux, enlaces y comodines, han sentado las bases para nuestro próximo tutorial sobre administración básica, si queremos hacer referencia a un archivo llamado fredsfile.txt en el directorio personal que cubriremos temas como expresiones regulares, propiedad y permisos , Administración de Fred, podríamos escribir:cuentas de usuario y más.
$ Al continuar en esta serie de tutoriales, pronto estarás listo para obtener tu certificación LPIC Level 1 del Linux Professional Institute./myprog ~fred/fredsfileHablando de certificación LPIC, si esto es algo que le interesa, le recomendamos que estudie los recursos en el siguiente panel, que han sido cuidadosamente seleccionados para aumentar el material cubierto en este tutorial.txt
wiki-users
37
edits

Navigation menu