Como uso os comandos pushd e popd?

Quais são os usos práticos de ambos pushde popdquando há uma vantagem de usar esses dois comandos sobre cde cd -?

EDIT : Estou procurando alguns exemplos práticos de usos para esses dois comandos ou motivos para manter a pilha com diretórios (quando você tiver preenchimento de tabulação cd -, apelidos para encurtamento cd .., etc.).

pushd, popdE dirssão builtins shell que permitem manipular a pilha de diretórios . Isso pode ser usado para alterar diretórios, mas retorne ao diretório de onde você veio.

Por exemplo

inicie com os seguintes diretórios:

$ ls
dir1  dir2  dir3

pushd para dir1

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

dirsO comando confirma que temos 2 diretórios na pilha agora. dir1e o diretório original somedir,.

pressione push para ../dir3 (porque estamos dentro dir1agora)

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

dirsmostra que temos 3 diretórios na pilha agora. dir3,, dir1e somedir. Observe a direção. Cada novo diretório está sendo adicionado à esquerda. Quando começamos a exibir os diretórios, eles também vêm da esquerda.

altere manualmente os diretórios para ../dir2

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

Agora comece a aparecer diretórios

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

Observe que voltamos para dir1.

Pop novamente ...

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

E estamos de volta onde começamos somedir.

Pode ficar um pouco confuso, mas o cabeçalho da pilha é o diretório em que você está atualmente. Por isso, quando voltamos somedir, mesmo que dirsmostre isso:

$ dirs
~/somedir

Nossa pilha está vazia.

$ popd
bash: popd: directory stack empty

Existe um caso de uso pushde popdcomandos realmente úteis para trabalhar com várias pastas simultaneamente.

Você pode navegar na pilha com muita facilidade, pois ela é enumerada. Ou seja, você pode ter várias pastas de trabalho à sua disposição durante o trabalho.

Veja um exemplo simples abaixo.

Primeiro, vamos criar uma estrutura de pastas de exemplo.

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

Em seguida, você pode adicionar todas as suas pastas à pilha:

    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

Você pode procurar por:

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

Para navegar com segurança, é necessário adicionar a última pasta (zero) duas vezes, pois ela será sempre reescrita:

    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

Agora, você pode percorrer essas pastas e trabalhar com a pilha, como também com aliases para as pastas. Eu acho que a seguinte parte é auto-explicativa:

    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

Dica adicional é criar um alias para dirs -v.

Por exemplo:

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

Um caso de uso simples para usar a pilha de diretórios que você não pode fazer apenas com o cd é:

pushd .adiciona o diretório atual XX à dirspilha. Depois, você pode se movimentar usando cde, para retornar ao XX, basta fazê-lo, popdindependentemente de quão "distante" você está na árvore de diretórios (pode saltar sobre vários níveis, de lado, etc.). Especialmente útil em scripts bash.

pushde popdpermite que você manipule os diretórios na pilha.

Quando você é pushdum diretório, coloca o diretório atual na pilha e altera o diretório para o especificado como parâmetro.

popd permitirá que você volte para o diretório na pilha.

Se você repetir, o percurso do diretório será preservado e você poderá voltar para os diretórios salvos na ordem inversa do que os salvou.

para o bash , basicamente: em vez de usar o cd, é possível pushdalterar os diretórios, com o uso prático: o histórico dos diretórios visitados é salvo (corretamente: empilhado) e é possível alternar entre eles

pushd /home; pushd /var; pushd log

Para ver o uso da pilha dirse para facilitar a navegação (para obter os números das "entradas da pilha", use:

dirs -v

Resultado:

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

Agora utilize esses números com cde ~como:

cd ~1

Mas esses números são reorganizados agora e a posição "0" será alterada; portanto, apenas pushdo diretório para a posição superior duas vezes (ou use um manequim na posição 0) como:

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

agora 1..3 vai manter a posição

(para liberar o diretório atual da pilha / excluí-lo do uso do histórico popd)

Um uso prático que encontrei é alternar entre diretórios usando pushd e popd.

Suponha que tenhamos dois diretórios dir1 e dir2 e preciso alternar entre eles continuamente por algum motivo xyz.

Atualmente estou em somedir que tem dois diretórios dir1e dir2:

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

Agora eu mudo para dir1

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

Agora vou adicionar dir1à pilha e mudar paradir2

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

Como você pode ver, agora tenho dir2e dir1estou na pilha e atualmente estou no dir2.

Agora, para voltar dir1, eu correrei pushd || popd.

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

Voila, eu estou no dir1 e tenho dir1 e dir2 na pilha. Para voltar ao dir2 novamente, executepushd || popd

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

Essa é uma maneira simples de alternar entre diretórios. Agora, você pode saber o que saber, por que preciso alternar entre diretórios? Bem, um caso de uso é que, quando trabalho no aplicativo da web, tenho meu arquivo make em um diretório e meus arquivos de log em outro diretório. Freqüentemente, ao depurar o aplicativo, preciso alternar entre o diretório de log, verificar os logs mais recentes e voltar ao diretório make, fazer algumas alterações e criar o aplicativo.

Simplificando - quando você precisar navegar entre mais de 2 diretórios, geralmente várias vezes para frente e para trás, uma vez cd -que não o cortará com nada além de duas pastas.

Então, por exemplo, em vez de tentar voltar a percorrer os longos caminhos anteriores, olhando para o histórico do buffer ou preenchendo um caminho longo, basta empilhar os mais importantes e, se necessário, você os move convenientemente somente pelo número deles. A rotação entre estruturas complexas de diretórios e caminhos longos torna-se ágil e rápida.

Os recursos internos também permitem reordenar a pilha ou exibir os diretórios desnecessários, permitindo flexibilidade no seu fluxo de trabalho.

O empilhamento de diretórios também pode ser usado em scripts da mesma forma para operações que abrangem vários diretórios.

Achei o uso de dirs / popd / pushd um pouco desconfortável. Eu vim com minha solução pessoal no tcsh, adicionando o seguinte código em .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*'

dessa maneira, alias, por exemplo, "p". para salvar o diretório de trabalho atual no arquivo ~ / .mydir. e "cd". recuperar esse diretório quando e onde eu quiser. "del" remove o arquivo correspondente; "casa." define o diretório como o diretório inicial (equivalente a cd; p.); "cdl" lista quais são os diretórios salvos. Observe que se você usar ~ / Dropbox / .mydir $ b (ou qualquer outro serviço em nuvem como, por exemplo, ownCloud) em vez de ~ / .mydir $ b, terá uma maneira inteligente de usar seus diretórios preferidos em diferentes contas e máquinas.

Eu estou usando assim no meu bash_profile e .bashrc assim

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

isso me ajuda a pular entre os diretórios dos mais recentes usados ​​no meu terminal. :-) Espero que ajude você a usar pushd e popd eu uso cd ~ stackednumber

Usando cde cd -permite alternar entre apenas os dois diretórios usados ​​mais recentemente. O tamanho do seu "conjunto de trabalho de diretório" é dois.

Usando pushd, você pode manter um número arbitrariamente grande de diretórios em seu conjunto de trabalho.

Eu uso a pushdmaior parte do tempo e não cd. Depois de criar uma pilha de diretórios ativos pushd directory_name, você poderá alternar entre eles o dia inteiro 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.

Uso popdraramente, somente quando quero remover um diretório da pilha quando sei que terminei de usá-lo.

Vá para o diretório e remova-o da pilha:

popd ~2

Permaneça no diretório atual e remova outro diretório da pilha:

popd +2

Você acaba com um estilo de trabalho semelhante a ter várias janelas ou guias do terminal abertas (uma para cada diretório em que você está trabalhando ativamente), mas todas em um terminal. Isso economiza espaço na tela, além disso, como os caminhos de diretório estão todos disponíveis em um shell, você pode fazer coisas como:

• copiar arquivos entre diretórios com os quais você está trabalhando atualmente
• visualizar ou editar arquivos em outro diretório sem ir até lá

Exemplos:

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

Em tcsh(mas não bash), você pode salvar sua pilha de diretórios em um arquivo e restaurá-la mais tarde.

Salve :

dirs -S ~/dirstack

Restaurar:

dirs -L ~/dirstack

Caso contrário, basta substituir ~nos bashexemplos por =para uso em tcsh.

pushd =2
popd =4
popd +1

O pushd / popd é um conceito tão simples que demorei um pouco para compreender, pois as pessoas tendem a ensiná-lo definindo esses comandos como comandos que 'manipulam a pilha de diretórios' que, na minha opinião, é confusa.

Eu olho para isso de uma maneira diferente:

pushd [nome_da_pasta] - fará o cd para [nome_da_pasta] e documentará o destino que é [nome_da_pasta] em uma pilha de diretórios, enquanto o diretório superior da pilha será sempre o diretório atual em que você está

popd - primeiro coloca você no registro do diretório que está no topo da pilha e depois o remove da pilha

dirs - Imprime a pilha de diretórios (pode ser tratada como o dir Db, onde a entrada mais à esquerda é o diretório atual (parte superior da pilha)

Portanto, os 2 casos de uso mais populares são:

Caso de uso 1: Navegando usando pushd e 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 fiz o acima, pois gostaria de voltar para as pastas que documentei!

Observe que, se eu fizer um cd manualmente, afetarei a entrada da pilha de diretórios superior (que é sempre o diretório atual)

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 navegar para trás agora:

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

Mais uma vez, posso documentar qualquer diretório que eu quero e, em seguida, navegar manualmente para outro diretório, então poderei retornar facilmente ao diretório documentado que inseri na pilha.

Caso de uso 2: Navegando usando o índice de pilha numérica

Vamos dizer que eu enviei usando pushd dir4 dir3 dir2 dir1, agora executando 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

Agora você pode executar qualquer operação do Linux que envolva diretórios usando o índice da pilha:

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

Você pode até excluir uma entrada específica da pilha de diretórios:

root@mypc:/main$ popd ~4

Espero que o uso das palavras "documentando" ou pense na pilha de diretórios como algum tipo de Db simplifique o conceito!