Comment utiliser les commandes pushd et popd?

Quelles sont les utilisations pratiques des deux pushdet popdquand il y a un avantage à utiliser ces deux commandes sur cdet cd -?

EDIT : Je cherche des exemples pratiques d'utilisation de ces deux commandes ou des raisons de conserver la pile avec des répertoires (lorsque vous avez terminé la tabulation cd -, alias pour raccourcir cd .., etc.).

pushd, popdEt dirssont builtins shell qui vous permettent de manipuler la pile de répertoires . Cela peut être utilisé pour changer de répertoire mais pour revenir au répertoire d'où vous venez.

Par exemple

démarrer avec les répertoires suivants:

$ ls
dir1  dir2  dir3

pushd à dir1

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

dirsLa commande confirme que nous avons maintenant 2 répertoires sur la pile. dir1et le répertoire d' origine, somedir.

pushd to ../dir3 (parce que nous sommes à l'intérieur dir1maintenant)

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

dirsmontre que nous avons 3 répertoires dans la pile maintenant. dir3, dir1Et somedir. Remarquez la direction. Chaque nouveau répertoire est ajouté à gauche. Lorsque nous commencerons à supprimer les répertoires, ils viendront également de la gauche.

changer manuellement les répertoires en ../dir2

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

Maintenant, commencez à ouvrir des répertoires

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

Remarquez que nous sommes revenus à dir1.

Pop encore ...

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

Et nous sommes de retour là où nous avons commencé somedir.

Cela peut paraître un peu déroutant, mais la tête de la pile est le répertoire dans lequel vous vous trouvez actuellement. Par conséquent, lorsque nous revenons à somedir, même si dirscela montre ce qui suit:

$ dirs
~/somedir

Notre pile est en fait vide.

$ popd
bash: popd: directory stack empty

Il existe un cas d'utilisation pushdet des popdcommandes vraiment utiles pour travailler avec plusieurs dossiers simultanément.

Vous pouvez naviguer très facilement dans la pile, car elle est énumérée. Cela signifie que vous pouvez disposer de plusieurs dossiers de travail pendant le travail.

Voir un exemple simple ci-dessous.

Tout d'abord, créons un exemple de structure de dossiers.

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

Ensuite, vous pouvez ajouter tous vos dossiers à la pile:

    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

Vous pouvez le rechercher en:

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

Pour naviguer en toute sécurité, vous devez ajouter le dernier (zéro) dossier deux fois, car il sera toujours réécrit:

    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

Maintenant, vous pouvez naviguer dans ces dossiers et travailler avec stack comme avec des alias pour les dossiers. Je suppose que la partie suivante est explicite:

    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

Astuce supplémentaire est de créer un alias pour dirs -v.

Par exemple:

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

Un cas d'utilisation simple pour utiliser dirs empiler ce que vous ne pouvez pas faire simplement avec cd est:

pushd .ajoute le répertoire courant XX à dirsempiler. Ensuite, vous pouvez vous déplacer en utilisant cd, et pour revenir à XX, vous le ferez popdquelle que soit votre position dans l'arborescence de répertoires (vous pouvez sauter par-dessus plusieurs niveaux, de côté, etc.). Particulièrement utile dans les scripts bash.

pushdet popdvous permettent de manipuler les répertoires sur la pile.

Lorsque vous êtes pushdun répertoire, vous placez le répertoire actuel sur la pile et changez de répertoire pour celui spécifié en paramètre.

popd vous permettra de revenir au répertoire sur la pile.

Si vous répétez, la traversée de répertoires sera en quelque sorte préservée et vous pourrez revenir aux répertoires enregistrés dans l'ordre inverse de celui dans lequel vous les avez enregistrés.

pour bash , fondamentalement: au lieu d’utiliser cd, on peut utiliser pushdpour changer de répertoire, avec l’utilisation pratique: l’historique des répertoires visités est sauvegardé (correctement: empilé) et on peut basculer entre eux

pushd /home; pushd /var; pushd log

Pour voir la pile utilisée dirset pour faciliter la navigation (pour obtenir les numéros des "entrées de pile", utilisez:

dirs -v

Sortie:

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

Maintenant, utilisez ces chiffres avec cdet ~comme:

cd ~1

Mais ces chiffres sont maintenant réorganisés et la position "0" va changer, il suffit donc de placer pushdle répertoire à la position la plus haute deux fois (ou d'utiliser un mannequin à la position 0) comme:

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

maintenant 1..3 va y rester

(pour libérer le répertoire en cours de la pile / le supprimer de l'utilisation de l'historique popd)

Une utilisation pratique que j'ai trouvée consiste à basculer entre les répertoires à l'aide de pushd et popd.

Supposons que nous ayons deux répertoires dir1 et dir2 et que je dois basculer entre eux de façon continue pour une raison quelconque, xyz.

Actuellement, je suis dans somedir qui a deux répertoires dir1et dir2:

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

Maintenant je passe à dir1

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

Maintenant, je vais ajouter dir1à empiler et passer àdir2

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

Comme vous pouvez le voir, j'ai maintenant dir2et dir1sur la pile et je suis actuellement dans dir2.

Maintenant, pour revenir à dir1, je vais courir pushd || popd.

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

Voilà, je suis dans dir1 et j'ai dir1 et dir2 sur pile. Pour revenir à dir2 à nouveau, lancezpushd || popd

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

C'est un moyen simple de basculer entre les répertoires. Maintenant, vous pourriez savoir quoi, pourquoi je dois basculer entre les annuaires? Un exemple d'utilisation est que, lorsque je travaille sur une application Web, j'ai mon fichier make dans un répertoire et mes fichiers journaux dans un autre répertoire. Souvent, lors du débogage de l'application, je dois passer d'un répertoire à un autre, consulter les derniers journaux, puis revenir au répertoire de création, apporter des modifications et construire l'application.

En termes simples - lorsque vous devez naviguer entre plus de 2 répertoires, généralement plusieurs fois, cd -ne vous coupez pas avec plus de 2 dossiers.

Ainsi, par exemple, au lieu d'essayer de retrouver les longs chemins précédents en consultant l'historique de votre mémoire tampon ou en complétant un chemin long, vous empilez simplement les plus importants et, si nécessaire, vous y accédez facilement par leur seul numéro. La rotation entre les structures de répertoires complexes et les longs chemins devient simple et rapide.

Les fonctions intégrées vous permettent également de réorganiser la pile ou d’extraire les répertoires dont vous n’avez plus besoin, ce qui vous permet une plus grande souplesse dans votre flux de travail.

L'empilement de répertoires peut également être utilisé dans des scripts de la même manière pour des opérations couvrant plusieurs répertoires.

J'ai trouvé l'utilisation de dirs / popd / pushd un peu inconfortable. Je suis venu avec ma solution personnelle dans tcsh, en ajoutant le code suivant dans .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 cette façon, j'ai aliasé, par exemple, "p." enregistrer le répertoire de travail en cours dans le fichier ~ / .mydir. et "cd." pour récupérer ce dir quand et où je veux. "del." supprime le fichier correspondant; "domicile." définit le répertoire sur le répertoire d'origine (équivalent à cd; p.); "cdl" liste les répertoires sauvegardés. Notez que si vous utilisez ~ / Dropbox / .mydir $ b (ou tout autre service cloud tel que ownCloud) au lieu de ~ / .mydir $ b, vous disposez d’un moyen intelligent d’utiliser vos répertoires préférés sur différents comptes et machines.

Je l'utilise comme ça dans mes bash_profile et .bashrc comme ça

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

cela m'aide à naviguer entre les répertoires les plus récents utilisés sur mon terminal. :-) J'espère que ça vous aidera à utiliser pushd plutôt popd j'utilise cd ~ stackednumber

Utiliser cdet cd -vous permet de basculer uniquement entre vos deux répertoires les plus récemment utilisés. Votre taille de "répertoire de travail de répertoire" est deux.

En utilisant pushd, vous pouvez conserver un nombre arbitrairement grand de répertoires dans votre groupe de travail.

J'utilise la pushdplupart du temps plutôt que cd. Une fois que vous avez constitué une pile de répertoires actifs pushd directory_name, vous pouvez les parcourir toute la journée 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.

J'utilise popdrarement, uniquement lorsque je veux supprimer un répertoire de la pile lorsque je sais que j'en ai terminé avec ce répertoire.

Allez dans le répertoire et retirez-le de la pile:

popd ~2

Restez dans le répertoire en cours et supprimez un autre répertoire de la pile:

popd +2

Vous vous retrouvez avec un style de travail similaire à l'ouverture de plusieurs fenêtres ou onglets de terminal (un pour chaque répertoire dans lequel vous travaillez activement), mais dans un seul terminal. Cela permet d'économiser de l'argent sur l'écran. De plus, comme les chemins d'accès aux répertoires sont tous disponibles dans un seul shell, vous pouvez effectuer les opérations suivantes:

• copier des fichiers entre les répertoires avec lesquels vous travaillez actuellement
• voir ou éditer des fichiers dans un autre répertoire sans y aller

Exemples:

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

Dans tcsh(mais pas bash), vous pouvez même enregistrer votre pile de répertoires dans un fichier et le restaurer plus tard.

Sauver:

dirs -S ~/dirstack

Restaurer:

dirs -L ~/dirstack

Sinon, il suffit de remplacer ~dans les bashexemples par =pour utilisation dans tcsh.

pushd =2
popd =4
popd +1

Le pushd / popd est un concept si simple qui m'a pris un certain temps à comprendre, car les gens ont tendance à l'enseigner en définissant ces commandes comme des commandes qui «manipulent la pile de répertoires», ce qui, à mon avis, prête à confusion.

Je le regarde d'une manière différente:

pushd [nom_dossier] - cd sur [nom_dossier] et documentera la destination qui est [nom_fichier] dans une pile de répertoires, tandis que le répertoire principal de la pile sera toujours le répertoire actuel dans lequel vous vous trouvez.

popd - vous cdera d' abord dans le répertoire qui se trouve en haut de la pile, puis le retirera de la pile

dirs - va imprimer la pile de dir (peut être traité comme le dir Db où l'entrée la plus à gauche est le répertoire courant (en haut de la pile)

Donc, les 2 cas d'utilisation les plus populaires sont:

Cas d'utilisation 1: navigation à l'aide de pushd et 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

Disons que j'ai fait ce qui est mentionné ci-dessus puisque je voudrais revenir aux dossiers que j'ai documentés!

Notez que si je cd manuellement, j'affecterai la première entrée de la pile de dir (qui est toujours le dir actuel)

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$ 

Passons maintenant en arrière:

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

Encore une fois, je peux documenter le répertoire de mon choix puis naviguer manuellement vers un autre répertoire, ce qui me permettra de revenir facilement au répertoire documenté que j'ai inséré dans la pile.

Cas d'utilisation 2: navigation à l'aide d'un index de pile numérique

Disons que j'ai poussé en utilisant pushd dir4 dir3 dir2 dir1, maintenant lancer dir -v montrera:

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

Vous pouvez maintenant effectuer n’importe quelle opération Linux impliquant des répertoires utilisant l’index de pile:

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

Vous pouvez même supprimer une entrée spécifique de la pile de répertoires:

root@mypc:/main$ popd ~4

J'espère que l'utilisation des mots "documenter" ou penser à la pile de répertoires comme une sorte de Db simplifie le concept!