¿Cómo uso los comandos pushd y popd?

¿Cuáles son los usos prácticos de ambos pushdy popdcuándo existe la ventaja de usar estos dos comandos sobre cdy cd -?

EDITAR : estoy buscando algunos ejemplos prácticos de usos para estos dos comandos o razones para mantener la pila de directorios (cuando tiene la finalización de la pestaña,cd - , alias para acortar cd .., etc.).

pushd, popdy dirsson componentes integrados de shell que le permiten manipular el pila de directorios . Esto se puede usar para cambiar los directorios pero volver al directorio del que vino.

Por ejemplo

Comience con los siguientes directorios:

$ ls
dir1  dir2  dir3

empujado a dir1

$ pushd dir1
~/somedir/dir1 ~/somedir
$ dirs
~/somedir/dir1 ~/somedir

dirsEl comando confirma que tenemos 2 directorios en la pila ahora. dir1y el directorio original, somedir.

empujado a ../dir3 (porque estamos dentro dir1ahora)

$ pushd ../dir3
~/somedir/dir3 ~/somedir/dir1 ~/somedir
$ dirs
~/somedir/dir3 ~/somedir/dir1 ~/somedir
$ pwd
/home/saml/somedir/dir3

dirsmuestra que tenemos 3 directorios en la pila ahora. dir3,dir1 Y somedir. Fíjate en la dirección. Cada nuevo directorio se agrega a la izquierda. Cuando comenzamos a abrir directorios, también vendrán desde la izquierda.

cambiar manualmente los directorios a ../dir2

$ cd ../dir2
$ pwd
/home/saml/somedir/dir2
$ dirs
~/somedir/dir2 ~/somedir/dir1 ~/somedir

Ahora comience a abrir directorios

$ popd
~/somedir/dir1 ~/somedir
$ pwd
/home/saml/somedir/dir1

Observe que volvimos a dir1 .

Pop de nuevo ...

$ popd
~/somedir    
$ pwd
/home/saml/somedir

Y estamos de vuelta donde empezamos, somedir .

Puede ser un poco confuso, pero el encabezado de la pila es el directorio en el que se encuentra actualmente. Por lo tanto, cuando volvamos a somedir, aunque dirsmuestra esto:

$ dirs
~/somedir

Nuestra pila está de hecho vacía.

$ popd
bash: popd: directory stack empty

Hay un caso de uso pushdy popdcomandos realmente útiles para trabajar con varias carpetas simultáneamente.

Puede navegar por la pila muy fácilmente, ya que se enumera. Es decir, puede tener varias carpetas de trabajo a su disposición durante el trabajo.

Vea un ejemplo simple a continuación.

Primero, creemos una estructura de carpetas de ejemplo.

    user@vb:~$ mkdir navigate
    user@vb:~/navigate$ mkdir dir1
    user@vb:~/navigate$ mkdir dir2
    user@vb:~/navigate$ mkdir dir3

Luego puede agregar todas sus carpetas a la pila:

    user@vb:~/navigate$ pushd dir1/
    ~/navigate/dir1 ~/navigate
    user@vb:~/navigate/dir1$ pushd ../dir2/
    ~/navigate/dir2 ~/navigate/dir1 ~/navigate
    user@vb:~/navigate/dir2$ pushd ../dir3/
    ~/navigate/dir3 ~/navigate/dir2 ~/navigate/dir1 ~/navigate

Puedes buscarlo por:

    user@vb:~/navigate/dir3$ dirs -v
     0  ~/navigate/dir3
     1  ~/navigate/dir2
     2  ~/navigate/dir1
     3  ~/navigate

Para navegar de forma segura, debe agregar la última carpeta (cero) dos veces, ya que siempre se reescribirá:

    user@vb:~/navigate/dir3$ pushd .
    user@vb:~/navigate/dir3$ dirs -v
     0  ~/navigate/dir3
     1  ~/navigate/dir3
     2  ~/navigate/dir2
     3  ~/navigate/dir1
     4  ~/navigate

Ahora, puede saltar a través de estas carpetas y trabajar con stack como con alias para las carpetas. Supongo que la siguiente parte se explica por sí misma:

    user@vb:~/navigate/dir3$ cd ~4
    user@vb:~/navigate$ dirs -v
     0  ~/navigate
     1  ~/navigate/dir3
     2  ~/navigate/dir2
     3  ~/navigate/dir1
     4  ~/navigate
    user@vb:~/navigate$ cd ~3
    user@vb:~/navigate/dir1$ dirs -v
     0  ~/navigate/dir1
     1  ~/navigate/dir3
     2  ~/navigate/dir2
     3  ~/navigate/dir1
     4  ~/navigate
    user@vb:~/navigate/dir1$ touch text.txt
    user@vb:~/navigate/dir1$ cp text.txt ~2
    user@vb:~/navigate/dir1$ ls ~2
    text.txt
    user@vb:~/navigate/dir1$ dirs -v
     0  ~/navigate/dir1
     1  ~/navigate/dir3
     2  ~/navigate/dir2
     3  ~/navigate/dir1
     4  ~/navigate

Un consejo adicional es crear algunos alias paradirs -v .

Por ejemplo:

# In ~/.bashrc
alias dirs="dirs -v"

Un caso de uso simple para usar la pila de directorios que no puede hacer con solo cd es:

pushd .agrega el directorio actual XX a la dirspila. Después, puedes moverte usando cd, y para volver a XX lo haces popdsin importar cuán "lejos" estés en el árbol de directorios (puedes saltar sobre múltiples niveles, de lado, etc.). Especialmente útil en scripts de bash.

pushdy le popdpermite manipular los directorios en la pila.

Cuando es pushdun directorio, coloca el directorio actual en la pila y cambia el directorio al especificado como parámetro.

popd le permitirá volver al directorio en la pila.

Si repite, el recorrido del directorio se conservará y podrá volver a los directorios guardados en orden inverso al que los guardó.

para bash , básicamente: en lugar de usar cd, uno puede usar pushdpara cambiar los directores, con el uso práctico: el historial de directorios visitados se guarda (correctamente: apilado) y uno puede cambiar entre ellos

pushd /home; pushd /var; pushd log

Para ver el uso de la pila dirsy para una navegación más fácil (para obtener los números de las "entradas de pila", use:

dirs -v

Salida:

me@myhost:/home$ dirs -v
 0  /home
 1  /var
 2  /tmp

Ahora utilice estos números con cdy ~como:

cd ~1

Pero estos números se reorganizan ahora y la posición "0" cambiará, por lo que solo pushdel directorio a la posición superior dos veces (o use un ficticio en la posición 0) como:

me@myhost:/home$ dirs -v
 0  /home
 1  /home
 2  /var
 3  /tmp

ahora 1..3 mantendrá su posición

(para liberar el directorio actual de la pila / eliminarlo del uso del historial popd)

Un uso práctico que he encontrado es alternar entre directorios usando pushd y popd.

Supongamos que tenemos dos directorios dir1 y dir2 y necesito alternar entre ellos continuamente por alguna razón xyz.

Actualmente estoy en somedir que tiene dos directorios dir1y dir2:

alcohol@alcohol-machine:~/somedir$ ls
dir1  dir2
alcohol@alcohol-machine:~/somedir$ 

Ahora cambio a dir1

alcohol@alcohol-machine:~/somedir$ cd dir1
alcohol@alcohol-machine:~/somedir/dir1$ pwd
/home/alcohol/somedir/dir1

Ahora agregaré dir1a la pila y cambiaré adir2

alcohol@alcohol-machine:~/somedir/dir1$ pushd /home/alcohol/somedir/dir2
~/somedir/dir2 ~/somedir/dir1
alcohol@alcohol-machine:~/somedir/dir2$

Como puede ver, ahora tengo dir2y dir1en la pila y actualmente estoy en dir2.

Ahora para volver a dir1, voy a correr pushd || popd.

alcohol@alcohol-machine:~/somedir/dir2$ pushd || popd
~/somedir/dir1 ~/somedir/dir2
alcohol@alcohol-machine:~/somedir/dir1$ 

Voila, estoy en dir1 y tengo dir1 y dir2 en la pila. Para volver a dir2, vuelva a ejecutarpushd || popd

alcohol@alcohol-machine:~/somedir/dir2$ pushd || popd
~/somedir/dir1 ~/somedir/dir2
alcohol@alcohol-machine:~/somedir/dir1$ 

Esta es una manera simple de alternar entre directorios. Ahora, puede saber qué, ¿por qué necesito alternar entre directorios? Bueno, un caso de uso es, cuando trabajo en una aplicación web, tengo mi archivo make en un directorio y mis archivos de registro en otro directorio. A menudo, al depurar la aplicación, necesito cambiar entre el directorio de registro, verificar los últimos registros y luego volver al directorio de creación, realizar algunos cambios y compilar la aplicación.

En pocas palabras, cuando necesita navegar entre más de 2 directorios, generalmente varias veces hacia adelante y hacia atrás, ya que cd -simplemente no lo cortará con nada más que 2 carpetas.

Entonces, por ejemplo, en lugar de intentar volver a encontrar caminos largos anteriores mirando el historial de su búfer o completando una ruta larga, simplemente apila los importantes y, si es necesario, se mueve convenientemente a ellos solo por su número. La rotación entre estructuras de directorios complejas y rutas largas se vuelve resbaladiza y rápida.

Los builtins también le permiten reordenar la pila o desplegar los directorios que ya no necesita, lo que permite flexibilidad en su flujo de trabajo.

El apilamiento de directorios también se puede usar en scripts de manera similar para operaciones que abarcan varios directorios.

El uso de dirs / popd / pushd me pareció un poco incómodo. Se me ocurrió mi solución personal en tcsh, agregando el siguiente código en .alias

  foreach b (. , - 0 1 2 3 4 5 6 7 8 9 )
    alias p$b       'set a=`pwd`; echo $a >! ~/.mydir'$b
    alias cd$b      'cd "`cat ~/.mydir'$b'`"'
    alias del$b     'rm -v ~/.mydir'$b
    alias home$b    'set a="~"; echo $a >! ~/.mydir'$b
  end
    alias cdl       'grep / ~/.mydir*'

de esta manera alias, por ejemplo, "p". para guardar el directorio de trabajo actual en el archivo ~ / .mydir. y "cd". para recuperar ese directorio cuando y donde quiera. "del". elimina el archivo correspondiente; "casa." establece el directorio en el directorio de inicio (equivalente a cd; p.); "cdl" enumera cuáles son los directorios guardados. Tenga en cuenta que si usa ~ / Dropbox / .mydir $ b (o cualquier otro servicio en la nube como, por ejemplo, ownCloud) en lugar de ~ / .mydir $ b, obtendrá una forma inteligente de usar sus directorios preferidos en diferentes cuentas y máquinas.

Lo estoy usando así en mi bash_profile y .bashrc así

vi .bash_profile
alias dirs="dirs -v"
source d.sh
:wq

vi .bashrc
alias dirs="dirs -v"
:wq

vi d.sh
pushd ~/Documents/GIT/seiso-data
pushd ~/Documents/GIT/ewe/EosRegistry
pushd ~/Documents/GIT_LODGING/site-cookbooks
pushd ~/Documents/CHEF_LODGING
pushd  .
:wq

me ayuda a saltar entre los directorios a los más recientes utilizados en mi terminal. :-) Espero que te ayude a usar pushd en lugar de popd, uso cd ~ número apilado

Usar cdy le cd -permite alternar solo entre los dos directorios utilizados más recientemente. El tamaño de su "conjunto de trabajo de directorio" es dos.

Utilizando pushd, puede mantener un número arbitrariamente grande de directorios en su conjunto de trabajo.

Yo uso la pushdmayor parte del tiempo en lugar de cd. Una vez que haya creado una pila de directorios activos con pushd directory_name, puede saltar entre ellos todo el día con pushd ~#.

pushd dir1
pushd ../dir2
pushd /full/path/to/dir3

# There are now three directories in the stack.

pushd ~3
pushd ~2

# The same three directories are still on the stack, 
# just in a different order.

popdRaramente lo uso , solo cuando quiero eliminar un directorio de la pila cuando sé que he terminado de usar ese directorio.

Vaya al directorio y quítelo de la pila:

popd ~2

Permanezca en el directorio actual y elimine otro directorio de la pila:

popd +2

Termina con un estilo de trabajo que es similar a tener múltiples ventanas de terminal o pestañas abiertas (una para cada directorio en el que está trabajando activamente), pero todo en una terminal. Esto ahorra espacio en la pantalla, además, debido a que todas las rutas de directorio están disponibles en un shell, puede hacer cosas como:

• copiar archivos entre directorios con los que está trabajando actualmente
• ver o editar archivos en otro directorio sin ir allí

Ejemplos:

cp ~2/myfile.txt ~4
less ~2/myfile.txt

En tcsh(pero no bash), incluso puede guardar su pila de directorios en un archivo y restaurarlo más tarde.

Salvar:

dirs -S ~/dirstack

Restaurar:

dirs -L ~/dirstack

De lo contrario, simplemente reemplace ~en los bashejemplos con =para usar en tcsh.

pushd =2
popd =4
popd +1

El pushd / popd es un concepto tan simple que me llevó un tiempo comprenderlo, ya que las personas tienden a enseñarlo definiendo estos comandos como comandos que 'manipulan la pila de directorios' que, en mi opinión, es confuso.

Lo veo de otra manera:

pushd [nombre_carpeta] : se cd a [nombre_carpeta] y documentará el destino que es [nombre_carpeta] en una pila de directorios, mientras que el directorio superior en la pila siempre será el directorio actual en el que se encuentra

popd : primero lo colocará en el registro del directorio que está en la parte superior de la pila y luego lo eliminará de la pila

dirs : imprimirá la pila de directorios (puede tratarse como el directorio Db donde la entrada más a la izquierda es el directorio actual (parte superior de la pila)

Entonces, los 2 casos de uso más populares son:

Caso de uso 1: Navegación usando pushd y popd

root@mypc:/main/$ ls
dir1  dir2  dir3  dir4

root@mypc:/main/$ dirs   # prints the current stack
/main

root@mypc:/main/$ pushd dir1    # Will cd to dir1 and document dir1 in dir stack, stack is now:
/main/dir1 /main 
root@mypc:/main/dir1$    # I am now in /main/dir1

root@mypc:/main/dir1$    # Now let's go wild and document whatever I want
root@mypc:/main/dir1$ pushd ../dir2 
root@mypc:/main/dir2$     # Woo I am in /main/dir2
root@mypc:/main/dir2$ pushd ../dir3 
root@mypc:/main/dir3$     # Woo I am in /main/dir3
root@mypc:/main/dir3$ pushd ../dir4 
root@mypc:/main/dir4$     # Woo I am in /main/dir4
root@mypc:/main/dir4$ dirs   # Now dir stack is:
/main/dir4 /main/dir3 /main/dir2 /main/dir1 /main

¡Digamos que hice lo anterior ya que me gustaría volver a las carpetas que documenté!

Tenga en cuenta que si hago un CD manualmente, afectaré la entrada de la pila del directorio superior (que siempre es el directorio actual)

root@mypc:/main/dir4$ cd ..   # Now dir stack is:
# (note that /main appear in the leftmost as well which is the top of the stack)
/main /main/dir3 /main/dir2 /main/dir1 /main
root@mypc:/main$ 

Vamos a navegar hacia atrás ahora:

root@mypc:/main$ popd
root@mypc:/main$     # Still in /main since it was at the top of the dir stack
root@mypc:/main$ dirs    # Stack is now:
/main/dir3 /main/dir2 /main/dir1 /main

root@mypc:/main$ popd
root@mypc:/main/dir3$ popd    # Woo in dir3 now, about to navigate to dir2
root@mypc:/main/dir2$ popd    # Woo in dir2, about to navigate to dir1
root@mypc:/main/dir1$ dirs    # Stack is now:
/main

Una vez más, puedo documentar el directorio que quiera y luego navegar manualmente a otro directorio, luego podré volver fácilmente al directorio documentado que inserté en la pila.

Caso de uso 2: Navegar usando el índice numérico de la pila

Digamos que presioné usando pushd dir4 dir3 dir2 dir2 dir1, ahora ejecutando dir -v mostrará:

root@mypc:/main$ dirs -v
 0  /main/dir1  (this is the current dir you are in always)
 1  /main/dir2
 2  /main/dir3
 3  /main/dir4

Ahora puede hacer cualquier operación de Linux que implique directorios utilizando el índice de pila:

root@mypc:/main$ cp ~2/temp.txt ~3/new_temp.txt    # this will run in the background, something like:
# cp /main/dir2/temp.txt  /main/dir3/new_temp.txt

Incluso puede eliminar una entrada específica de la pila de directorios:

root@mypc:/main$ popd ~4

¡Espero que usar las palabras "documentar" o pensar en la pila de directorios como una especie de Db simplifique el concepto!