Wie verwende ich Pushd- und Popd-Befehle?

Was sind die praktischen Verwendungen von beiden pushdund popdwann gibt es einen Vorteil, wenn diese beiden Befehle gegenüber cdund verwendet werden cd -?

BEARBEITEN : Ich suche nach einigen praktischen Beispielen für die Verwendung dieser beiden Befehle oder nach Gründen, um den Stapel mit Verzeichnissen zu halten (wenn Sie die Tabulatoren vervollständigen cd -, Aliase zum Verkürzen cd ..usw.).

pushd, popdUnd dirssind Shell builtins , die Ihnen erlauben , die manipulieren Verzeichnis - Stack . Dies kann verwendet werden, um Verzeichnisse zu ändern, aber zu dem Verzeichnis zurückzukehren, von dem Sie gekommen sind.

Zum Beispiel

Starten Sie mit den folgenden Verzeichnissen:

$ ls
dir1  dir2  dir3

Pushd zu dir1

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

dirsBefehl bestätigt, dass wir jetzt 2 Verzeichnisse auf dem Stapel haben. dir1und die ursprünglich dir, somedir.

pushd to ../dir3 (weil wir jetzt drinnen sind dir1)

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

dirszeigt, dass wir jetzt 3 Verzeichnisse im Stapel haben. dir3, dir1Und somedir. Beachten Sie die Richtung. Jedes neue Verzeichnis wird links hinzugefügt. Wenn wir damit beginnen, Verzeichnisse auszublenden, kommen sie ebenfalls von links.

Ändern Sie die Verzeichnisse manuell in ../dir2

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

Beginnen Sie nun mit dem Poppen von Verzeichnissen

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

Beachten Sie, dass wir zurückgekehrt sind dir1.

Wieder Pop ...

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

Und wir sind wieder da, wo wir angefangen haben somedir.

Vielleicht ein wenig verwirrend, aber der Kopf des Stapels ist das Verzeichnis , das Sie sind momentan in Daher , wenn wir wieder zu bekommen. somedir, Obwohl dirszeigt dies:

$ dirs
~/somedir

Unser Stapel ist leer.

$ popd
bash: popd: directory stack empty

Es gibt einen sehr nützlichen Anwendungsfall für pushdund popdBefehle, um mit mehreren Ordnern gleichzeitig zu arbeiten.

Sie können den Stapel sehr einfach navigieren, da er nummeriert ist. Das heißt, Sie können während der Arbeit mehrere Arbeitsordner zur Verfügung haben.

Ein einfaches Beispiel finden Sie weiter unten.

Zuerst erstellen wir eine Beispielordnerstruktur.

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

Dann können Sie alle Ihre Ordner zum Stapel hinzufügen:

    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

Sie können es nachschlagen, indem Sie:

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

Um sicher zu navigieren, müssen Sie den letzten (Null-) Ordner zweimal hinzufügen, da er immer neu geschrieben wird:

    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

Jetzt können Sie durch diese Ordner springen und mit Stacks wie mit Aliases für die Ordner arbeiten. Ich denke, der folgende Teil ist selbsterklärend:

    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

Ein zusätzlicher Tipp ist, einen Alias ​​für zu erstellen dirs -v.

Zum Beispiel:

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

Ein einfacher Anwendungsfall für die Verwendung von dirs stack ist:

pushd .Fügt das aktuelle Verzeichnis XX zum dirsStapel hinzu. Danach können Sie sich mit bewegen cdund zu XX zurückkehren, popdunabhängig davon, wie "weit entfernt" Sie sich im Verzeichnisbaum befinden (Sie können über mehrere Ebenen, seitwärts usw. springen). Besonders nützlich in Bash-Skripten.

pushdund popderlauben Ihnen, die Verzeichnisse auf dem Stapel zu manipulieren.

Wenn Sie pushdein Verzeichnis erstellen, legen Sie das aktuelle Verzeichnis auf dem Stapel ab und ändern es in das als Parameter angegebene Verzeichnis.

popd Damit können Sie zum Verzeichnis auf dem Stapel zurückkehren.

Wenn Sie dies wiederholen, bleibt die Verzeichnisüberquerung erhalten, und Sie können in umgekehrter Reihenfolge zu den gespeicherten Verzeichnissen zurückkehren, in der Sie sie gespeichert haben.

für bash im grunde: anstatt cd zu verwenden kann man verzeichnisse pushdwechseln, mit der praktischen verwendung : der verlauf der besuchten verzeichnisse wird gespeichert (richtig: gestapelt) und man kann zwischen ihnen wechseln

pushd /home; pushd /var; pushd log

Um den Stack zu sehen, benutzen Sie dirsund zur einfacheren Navigation (um die Nummern der "Stack-Einträge" zu erhalten, benutzen Sie:

dirs -v

Ausgabe:

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

Verwenden Sie nun diese Zahlen mit cdund ~wie:

cd ~1

Aber diese Nummern sind jetzt neu angeordnet und Position "0" ändert sich, so dass nur pushddas Verzeichnis zweimal an die oberste Position (oder verwenden Sie einen Dummy auf Position 0) wie folgt :

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

Jetzt wird 1..3 dort Position halten

(um das aktuelle Verzeichnis vom Stack zu entfernen / aus dem Verlauf zu löschen popd)

Eine praktische Anwendung, die ich gefunden habe, ist das Wechseln zwischen Verzeichnissen mit pushd und popd.

Angenommen, wir haben zwei Verzeichnisse, dir1 und dir2, und ich muss aus irgendeinem xyz-Grund kontinuierlich zwischen ihnen wechseln.

Zur Zeit bin ich in einem Verzeichnis mit zwei Verzeichnissen dir1und dir2:

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

Jetzt wechsle ich zu dir1

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

Jetzt werde ich hinzufügen dir1, um zu stapeln und zu wechselndir2

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

Wie Sie sehen, habe ich jetzt dir2und dir1auf Stapel und ich bin derzeit in dir2.

Nun, um zurück zu wechseln dir1, werde ich rennen pushd || popd.

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

Voila, ich bin in dir1 und ich habe dir1 und dir2 auf dem Stapel. Um wieder zu dir2 zu wechseln, startepushd || popd

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

Dies ist eine einfache Möglichkeit, zwischen Verzeichnissen zu wechseln. Nun könnten Sie was wissen, warum ich zwischen Verzeichnissen wechseln muss? Nun, ein Anwendungsfall ist, wenn ich an einer Webanwendung arbeite, habe ich meine make-Datei in einem Verzeichnis und meine Protokolldateien in einem anderen Verzeichnis. Oft muss ich beim Debuggen der Anwendung zwischen dem Protokollverzeichnis und den neuesten Protokollen wechseln und dann zum make-Verzeichnis zurückkehren, um einige Änderungen vorzunehmen und die Anwendung zu erstellen.

Einfach ausgedrückt - wenn Sie zwischen mehr als 2 Verzeichnissen navigieren müssen, in der Regel mehrmals hin und her, da cd -nur 2 Ordner verwendet werden.

Anstatt also beispielsweise zu versuchen, frühere lange Pfade wiederherzustellen, indem Sie sich den Verlauf Ihres Puffers ansehen oder einen langen Pfad mit Tabulatoren abschließen, stapeln Sie einfach die wichtigen Pfade und wechseln bei Bedarf bequem allein nach ihrer Nummer zu ihnen. Das Drehen zwischen komplexen Verzeichnisstrukturen und langen Pfaden wird schnell und einfach.

Mit den integrierten Funktionen können Sie den Stapel auch neu anordnen oder die nicht mehr benötigten Verzeichnisse auslagern, um den Arbeitsablauf flexibel zu gestalten.

Das Stapeln von Verzeichnissen kann auf ähnliche Weise auch in Skripten für Vorgänge verwendet werden, die sich über mehrere Verzeichnisse erstrecken.

Ich fand die Verwendung von dirs / popd / pushd etwas unangenehm. Ich habe meine persönliche Lösung in tcsh gefunden, indem ich den folgenden Code zu .alias hinzugefügt habe

  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*'

auf diese Weise habe ich zum Beispiel "p." um das aktuelle Arbeitsverzeichnis in der Datei ~ / .mydir zu speichern. und "cd." um dieses Verzeichnis wieder herzustellen, wann und wo immer ich möchte. "del." entfernt die entsprechende Datei; "Zuhause." setzt das Verzeichnis auf das Ausgangsverzeichnis (entspricht cd; p.); "cdl" listet die gespeicherten Verzeichnisse auf. Beachten Sie, dass Sie mit ~ / Dropbox / .mydir $ b (oder einem anderen Cloud-Dienst wie z. B. ownCloud) anstelle von ~ / .mydir $ b auf intelligente Weise Ihre bevorzugten Verzeichnisse für verschiedene Konten und Computer verwenden können.

Ich benutze es so in meinem bash_profile und .bashrc so

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

Es hilft mir, zwischen den Verzeichnissen zu wechseln, die zuletzt auf meinem Terminal verwendet wurden. :-) Ich hoffe, es hilft dir, pushd zu verwenden, eher popd. Ich verwende cd ~ stackednumber

Mit cdund cd -können Sie nur zwischen den beiden zuletzt verwendeten Verzeichnissen wechseln. Ihre "Directory Working Set" -Größe ist zwei.

Mit pushdkönnen Sie beliebig viele Verzeichnisse in Ihrem Arbeitsset halten.

Ich benutze die pushdmeiste Zeit eher als cd. Sobald Sie einen Stapel von aktiven Verzeichnissen mit aufgebaut haben pushd directory_name, können Sie den ganzen Tag mit zwischen ihnen wechseln 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.

Ich verwende es popdnur selten, wenn ich ein Verzeichnis aus dem Stapel entfernen möchte, wenn ich weiß, dass ich mit diesem Verzeichnis fertig bin.

Gehen Sie in das Verzeichnis und entfernen Sie es vom Stapel:

popd ~2

Bleiben Sie im aktuellen Verzeichnis und entfernen Sie ein anderes Verzeichnis vom Stapel:

popd +2

Am Ende haben Sie einen ähnlichen Arbeitsstil wie beim Öffnen mehrerer Terminalfenster oder -registerkarten (eines für jedes Verzeichnis, in dem Sie aktiv arbeiten), jedoch alle in einem Terminal. Dies spart Platz auf dem Bildschirm und da die Verzeichnispfade alle in einer Shell verfügbar sind, können Sie Folgendes tun:

• Kopieren Sie Dateien zwischen Verzeichnissen, mit denen Sie gerade arbeiten
• Dateien in einem anderen Verzeichnis anzeigen oder bearbeiten, ohne dorthin zu wechseln

Beispiele:

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

In tcsh(aber nicht bash) können Sie Ihren Verzeichnisstapel sogar in einer Datei speichern und später wiederherstellen.

Sparen:

dirs -S ~/dirstack

Wiederherstellen:

dirs -L ~/dirstack

Ansonsten ersetzen Sie einfach ~in den bashBeispielen mit =zur Verwendung in tcsh.

pushd =2
popd =4
popd +1

Das pushd / popd ist ein so einfaches Konzept, dass ich eine Weile gebraucht habe, um es zu verstehen, da die Leute dazu neigen, es zu lehren, indem sie diese Befehle als Befehle definieren, die "den Verzeichnisstapel manipulieren", was meiner Meinung nach verwirrend ist.

Ich sehe das anders:

pushd [ordnername] - wechselt zu [ordnername] und dokumentiert das Ziel, das [ordnername] in einem Verzeichnisstapel ist, während das oberste Verzeichnis im Stapel immer das aktuelle Verzeichnis ist, in dem Sie sich befinden

popd - führt Sie zuerst in den Verzeichniseintrag, der sich dann oben auf dem Stapel befindet, und entfernt ihn aus dem Stapel

dirs - Gibt den dir-Stack aus (kann als dir-Db behandelt werden, wobei der am weitesten links stehende Eintrag das aktuelle Verzeichnis ist (oben im Stack)

Die 2 beliebtesten Anwendungsfälle sind also:

Anwendungsfall 1: Navigieren mit pushd und 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

Angenommen, ich habe die oben genannten Schritte ausgeführt, da ich zu den von mir dokumentierten Ordnern zurückkehren möchte!

Beachten Sie, dass ich bei einer manuellen CD den obersten Verzeichnis-Stapeleintrag (der immer das aktuelle Verzeichnis ist) beeinflusse.

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$ 

Lass uns jetzt rückwärts navigieren:

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

Ich kann wieder dokumentieren, was immer ich will, und dann manuell zu einem anderen Verzeichnis navigieren. Dann kann ich problemlos zu dem dokumentierten Verzeichnis zurückkehren, das ich in den Stapel eingefügt habe.

Anwendungsfall 2: Navigieren mit dem numerischen Stapelindex

Nehmen wir an, ich habe mit pushd dir4 dir3 dir2 dir1 gepusht, jetzt zeigt dir -v:

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

Jetzt können Sie jede Linux-Operation ausführen, bei der Verzeichnisse mithilfe des Stapelindexes verwendet werden:

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

Sie können sogar einen bestimmten Eintrag aus dem Verzeichnisstapel löschen:

root@mypc:/main$ popd ~4

Hoffe, dass die Verwendung der Wörter "documenting" oder die Verwendung des Verzeichnisstapels als eine Art Db das Konzept vereinfacht!