Come si usano i comandi pushd e popd?

pushd , popd e dirs sono incorporati nella shell consentono di manipolare lo stack di directory . Questo può essere utilizzato per cambiare directory ma tornare alla directory da cui provieni.

Ad esempio

avvia con le seguenti directory:

$ pwd /home/saml/somedir $ ls dir1 dir2 dir3 

pushd to dir1

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

dirs conferma che ora abbiamo 2 directory nello stack. dir1 e la directory originale, somedir. NOTA: Il nostro ” corrente ” directory è ~/somedir/dir1.

pushd to ../dir3 (perché “siamo dentro dir1 ora)

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

dirs mostra che ora abbiamo 3 directory nello stack. dir3, dir1 e somedir. Nota la direzione. Ogni nuova directory viene aggiunta a sinistra. Quando iniziamo a visualizzare le directory off, verranno anche da sinistra.

cambia manualmente le directory in ../dir2

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

Ora inizia a visualizzare le directory

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

Si noti che siamo tornati a dir1.

Pop di nuovo …

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

E siamo “tornati da dove siamo partiti, somedir.

Potrebbe creare un po di confusione, ma il capo dello stac k è la directory in cui ti trovi attualmente. Quindi, quando torniamo a somedir, anche se dirs mostra questo:

$ dirs ~/somedir 

Il nostro stack è infatti vuoto.

$ popd bash: popd: directory stack empty 

Commenti

• Grazie, capisco perfettamente il concetto di stack e come funzionano questi comandi. Tuttavia, ‘ sto cercando alcuni motivi pratici per mantenere lo stack con le directory (quando hai il completamento con tabulazione, cd -, alias per abbreviare cd .. e così via).
• Uso spesso pushd & popd negli script b / c mi evitano di dover ricordare da dove venivo, posso sempre popd tornare da dove sono venuto. Di solito faccio popd >/dev/null 2>&1 per renderlo silenzioso. Uso cd tutti i giorni nella mia shell. Ci sono anche altri suggerimenti per risparmiare tempo in questo articolo: thegeekstuff.com/2008/10/… .
• @Garrett – nessuno che io possa concepire.
• @Garrett @slm poiché cd - tiene traccia solo dellultima directory, immagino lo farebbe Potrebbero verificarsi problemi se chiamate una funzione che cambia anche directory internamente. in tal caso, la funzione finirebbe per reimpostare – nella directory corrente, non nella directory in cui si desidera tornare. pushd / popd è il metodo più sicuro. Nota. Non ho ‘ testato la mia teoria.
• Perché non tornare a ~/somedir/dir3 dopo il primo popd?

Cè un caso duso davvero utile per i comandi pushd e popd per lavorare con più cartelle contemporaneamente.

Puoi navigare nello stack molto facilmente, poiché è enumerato. Ciò significa che puoi avere diverse cartelle di lavoro a tua disposizione durante il lavoro.

Guarda un semplice esempio di seguito.

Per prima cosa, creiamo una struttura di cartelle di esempio.

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

Quindi puoi aggiungere tutte le tue cartelle allo stack :

 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 

Puoi cercarlo in:

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

Per navigare in sicurezza, devi aggiungere lultima cartella (zero) due volte, poiché verrà sempre riscritta:

 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 

Ora puoi saltare tra queste cartelle e lavorare con impilare come con gli alias per le cartelle.Immagino che la parte seguente sia autoesplicativa:

 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 

Suggerimento aggiuntivo serve a creare un alias per dirs -v.

Ad esempio:

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

Commenti

• E puoi cancellare lo stack con dirs -c
• +1 per dando effettivamente alcuni esempi pratici. ‘ è facile vedere cosa fa pushd / popd dalla pagina man, ma dirs e cd ~ # non sono ovvi allinizio.
• potresti anche usare una soluzione come fasd per questo tipo di flusso di lavoro invece, sebbene
• @Jun, ci ‘ s ” mkdir dir {1,2,3} ” per creare 3 directory in un colpo solo.
• @JunMurakami questo ha segnato il mio anno! Buon 2020!

Un semplice caso duso per usare lo stack delle directory ciò che non puoi fare solo con cd è :

pushd . aggiunge la directory corrente XX allo stack dirs. Successivamente, puoi spostarti utilizzando cd e per tornare a XX devi semplicemente popd indipendentemente da quanto “lontano” ti trovi lalbero delle directory (può saltare più livelli, lateralmente, ecc.). Particolarmente utile negli script bash.

Commenti

• Penso che questa sia la caratteristica di cui traggo vantaggio più spesso. Poiché pushd / popd funzionano indipendentemente da cd, puoi utilizzarli come un segnalibro di cd -.
• per me questo non è vero. Ogni volta che uso cd il mio stack cambia.
• oh, era perché usavo zsh, quando passo a bash, funziona bene
• Questa è lunica risposta sostanziale per quanto riguarda un confronto con cd -, IMO. Quanto al fatto che pushd foo; < cambio di directory casuale >; popd è più utile di a = foo; cd $ a; < cambio di directory casuale >; cd $ a … Per gli script posso vedere una piccola comodità sintattica nel primo (pushd), ma un enorme miglioramento della chiarezza nel secondo (variabili [esplicite]!). Per una sessione interattiva, penso che suppongo che la mia gerarchia di directory sia organizzata correttamente in primo luogo, e se mi perdessi semplicemente cd ~ / back / to / ovvio / path.
• @HarendraSingh tu don ‘ non è stato impostato AUTO_PUSHD? cd si comporterà come pushd, lo annullerà e tu ‘ tornerai a ” comportamento normale “.

pushd e popd ti consentono di manipolare le directory nello stack.

Quando pushd una directory, metti la directory corrente nello stack e cambi la directory in quella specificata come parametro.

popd ti permetterà di tornare alla directory sullo stack.

Se ripeti, lattraversamento della directory verrà in qualche modo preservato e potrai tornare alle directory salvate in ordine inverso rispetto a quello in cui le hai salvate.

Per bash , in pratica: invece di usare cd si può utilizza pushd per cambiare directory. Con un utilizzo pratico: la cronologia delle directory visitate viene salvata (correttamente: impilata) e si può passare da una allaltra:

pushd /home; pushd /var; pushd log 

Per vedere lo stack utilizzare dirs e per una navigazione più semplice (per ottenere i numeri delle ” voci dello stack ” utilizzare:

dirs -v 

Risultato:

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

Ora utilizza questi numeri con cd e ~ come:

cd ~1 

Ma questi numeri sono stati riorganizzati ora e posizionati ” 0 ” cambierà, quindi pushd la directory nella prima posizione due volte (o usa un manichino sulla posizione 0) come:

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

Ora 1..3 manterrà la loro posizione

(Per rilasciare la directory corrente da lo stack / eliminandolo dalla cronologia, utilizza popd)

In poche parole, quando è necessario navigare tra più di 2 directory, di solito più volte indietro & avanti, poiché cd - non lo taglierà con qualsiasi cosa oltre a 2 cartelle.

Quindi, ad esempio, invece di provare a rievocare percorsi lunghi precedenti guardando la cronologia del buffer o completando con tabulazione un percorso lungo, semplicemente impilate quelli importanti e, se necessario, vi spostate comodamente in base al loro numero. La rotazione tra strutture di directory complesse e percorsi lunghi diventa fluida e rapida.

I builtin ti consentono anche di riordinare lo stack o di estrarre le directory che non ti servono più, consentendo flessibilità nel tuo flusso di lavoro.

Limpilamento delle directory può essere utilizzato anche negli script in modo simile per operazioni che si estendono su più directory.

I ho trovato luso di dirs / popd / pushd un po scomodo. Ho trovato la mia soluzione personale in tcsh, aggiungendo il seguente codice in .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*" 

in questo modo ho creato un alias, ad esempio, “p.” per salvare la directory di lavoro corrente nel file ~ / .mydir. e “cd.” per recuperare quella directory quando e dove preferisco. “del.” rimuove il file corrispondente; “home.” imposta la directory sulla directory home (equivalente a cd; p.); “cdl” elenca quali sono le directory salvate. Nota che se usi ~ / Dropbox / .mydir $ b (o qualsiasi altro servizio cloud come eg ownCloud) invece di ~ / .mydir $ b ottieni un modo intelligente per utilizzare le directory preferite su diversi account e computer.

Utilizzando cd e cd - ti consente di alternare solo tra le due directory utilizzate più di recente. La dimensione della tua “directory working set” è due.

Usando pushd, puoi mantenere un numero arbitrariamente grande di directory nel tuo working set.

Uso pushd la maggior parte delle volte invece di cd. Dopo aver creato uno stack di directory attive con pushd directory_name, puoi passare da una directory allaltra tutto il giorno 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. 

Uso popd raramente, solo quando voglio rimuovere una directory dallo stack quando so che “ho finito” utilizzando quella directory.

Vai alla directory e rimuovila dallo stack:

popd ~2 

Rimani nella directory corrente e rimuovi unaltra directory dal stack:

popd +2 

Ti ritroverai con uno stile di lavoro simile allavere più finestre o schede di terminale aperte (una per ogni directory in cui sei attivamente funzionante), ma tutto in un unico terminale.Ciò consente di risparmiare spazio sullo schermo, inoltre, poiché i percorsi delle directory sono tutti disponibili in una shell, puoi fare cose come:

• copiare i file tra le directory con cui stai attualmente lavorando
• visualizzare o modificare i file in unaltra directory senza accedervi

Esempi:

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

In tcsh (ma non bash), puoi persino salvare lo stack di directory in un file e ripristinarlo in un secondo momento.

Salva:

dirs -S ~/dirstack 

Ripristina:

dirs -L ~/dirstack 

Altrimenti, sostituisci semplicemente ~ negli bash esempi con = da utilizzare in tcsh.

pushd =2 popd =4 popd +1 

Lo sto usando in questo modo nel mio bash_profile e .bashrc in questo modo

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 

aiuta Passo da una directory allaltra alla più recente usata sul mio terminale. 🙂 Spero che ti aiuti a usare pushd piuttosto che popd io uso cd ~ stackednumber