Come uso i comandi pushd e popd?

332

Quali sono gli usi pratici di entrambi pushde popdquando vi è il vantaggio di usare questi due comandi oltre cde cd -?

EDIT : sto cercando alcuni esempi pratici di usi per entrambi questi comandi o motivi per mantenere lo stack con le directory (quando hai il completamento con la tabulazione cd -, alias per abbreviare cd .., ecc.).

shell cd-command pushd

— sintagma
fonte

304

pushd, popde dirssono incorporati della shell che consentono di manipolare lo stack di directory . Questo può essere usato per cambiare directory ma tornare alla directory da cui sei venuto.

Per esempio

avviare con le seguenti directory:

$ ls
dir1  dir2  dir3

inviato a dir1

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

dirsIl comando conferma che ora abbiamo 2 directory nello stack. dir1e il dir originale, somedir.

pushd to ../dir3 (perché siamo dentro `dir1`adesso)

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

dirsmostra che ora abbiamo 3 directory nello stack. dir3, dir1e somedir. Notare la direzione. Ogni nuova directory viene aggiunta a sinistra. Quando inizieremo a rimuovere le directory, 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 di nuovo al punto di partenza, somedir.

Potrebbe diventare un po 'confuso, ma il capo dello stack è la directory in cui ti trovi attualmente. Quindi quando torniamo a somedir, anche se dirsmostra questo:

$ dirs
~/somedir

Il nostro stack è infatti vuoto.

$ popd
bash: popd: directory stack empty

— slm
fonte

19

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 si ha il completamento delle schede cd -, alias per l'accorciamento cd .., ecc.).

— syntagma,

21

Uso spesso pushde popdnegli script b / c che mi salvano dal dover ricordare da dove venivo, posso sempre solo popdtornare da dove sono venuto. Di solito lo faccio popd >/dev/null 2>&1per farlo tacere. Uso cd ogni giorno nella mia shell. Ci sono anche altri suggerimenti per risparmiare tempo in questo articolo: thegeekstuff.com/2008/10/… .

— slm

2

@Garrett - nessuno che io possa concepire.

— slm

4

@Garrett @slm poiché cd -tiene traccia solo dell'ultima directory, immagino che sarebbe possibile avere problemi se si chiama una funzione che cambia anche la directory internamente. in tal caso, la funzione finirebbe per reimpostarsi - nella directory corrente, non nella directory in cui si desidera tornare indietro. pushd / popd è il metodo più sicuro. Nota: non ho testato la mia teoria.

— File binario,

5

Perché non tornare a ~/somedir/dir3dopo il primo popd?

— ziyuang,

198

C'è un caso d'uso davvero utile per pushde popdcomandi per lavorare con più cartelle contemporaneamente.

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

Vedi un semplice esempio di seguito.

Innanzitutto, 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 da:

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

Per navigare in sicurezza, devi aggiungere l'ultima (zero) cartella due volte, poiché sarà 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 lo stack 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

Un altro suggerimento è creare un alias per dirs -v.

Per esempio:

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

— Jun Murakami
fonte

28

E puoi cancellare lo stack didirs -c

— Jun Murakami il

19

+1 per aver effettivamente fornito alcuni esempi pratici. È facile vedere cosa fanno pushd / popd dalla pagina man, ma all'inizio dir e cd ~ # non sono ovvi.

— Scribblemacher,

potresti anche usare una soluzione come Fasd per questo tipo di flusso di lavoro, però

— WuTheFWasThat

quindi è meglio per un caso d'uso più transitorio che impostare un CDPATH?

— rfabbri,

2

@Jun, c'è "mkdir dir {1,2,3}" per creare 3 directory in un colpo solo.

— Bulat M.

39

Un semplice caso d'uso per usare dirs stack che non puoi fare solo con cd è:

pushd .aggiunge la directory corrente XX allo dirsstack. Successivamente, puoi spostarti utilizzando cde, per tornare a XX, fai semplicemente popdindipendentemente da quanto "sei lontano" nella struttura della directory (puoi saltare su più livelli, lateralmente, ecc.). Particolarmente utile negli script bash.

— Peter M.
fonte

2

Penso che questa sia la caratteristica di cui approfitto più spesso. Poiché pushd/ popdfunzionano indipendentemente da cd, è possibile utilizzarli come un segnalibro più stabile di cd -.

— Gordon Bean,

per me questo non è vero. Ogni volta che uso cd il mio stack cambia.

— Harendra Singh,

oh, questo è stato il motivo per cui ho usato zsh, quando cambio a bash, funziona benissimo

— Harendra Singh

4

Questa è l'unica risposta sostanziale per quanto riguarda un confronto con cd -, IMO. Per quanto riguarda se 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 convenienza sintattica nella prima (pushd), ma un enorme miglioramento della chiarezza nella seconda (variabili [esplicite]!). Per una sessione interattiva, penso che dovrei solo supporre che la mia gerarchia di directory sia organizzata correttamente in primo luogo, e se mi perdessi semplicemente cd ~ / back / to /verse / path.

— Jan Kyu Peblik,

9

pushde popdti permettono di manipolare le directory in pila.

Quando si è pushduna directory, si mette la directory corrente nello stack e si cambia la directory con quella specificata come parametro.

popd ti permetterà di tornare alla directory nello stack.

Se ripeti, l'attraversamento della directory sarà in qualche modo conservato e puoi tornare alle directory salvate in ordine inverso rispetto a quello in cui le hai salvate.

— unxnut
fonte

6

per bash , in sostanza: invece di usare cd si può usare pushdper cambiare directory, con l'uso pratico: la storia delle directory visitate viene salvata (correttamente: impilata) e si può passare da una all'altra

pushd /home; pushd /var; pushd log

Per vedere lo stack utilizzare dirse per una navigazione più semplice (per ottenere i numeri delle "voci dello stack" utilizzare:

dirs -v

Produzione:

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

Ora utilizza questi numeri con cde ~simili:

cd ~1

Ma questi numeri ora sono riorganizzati e la posizione "0" cambierà, quindi solo pushdla directory nella posizione più alta due volte (o usa un manichino nella posizione 0) come:

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

ora 1..3 manterrà la sua posizione

(per rilasciare la directory corrente dallo stack / eliminarla dall'uso della cronologia popd)

— eli
fonte

5

Un uso pratico che ho trovato è quello di alternare tra le directory usando pushd e popd.

Supponiamo di avere due directory dir1 e dir2 e che devo passare da una all'altra continuamente per qualche ragione xyz.

Attualmente sono a Somedir che ha due directory dir1e dir2:

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

Ora passo a dir1

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

Ora aggiungerò dir1per impilare e passare adir2

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

Come puoi vedere, ora ho dir2e dir1in pila e al momento mi occupo di dir2.

Ora per tornare a dir1, corro pushd || popd.

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

Voila, sono in dir1 e ho dir1 e dir2 in pila. Per tornare di nuovo a dir2 eseguire nuovamentepushd || popd

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

Questo è un modo semplice per passare da una directory all'altra. Ora, potresti sapere cosa, perché devo passare da una directory all'altra? Bene, un caso d'uso è, quando lavoro su un'applicazione web, ho il mio file make in una directory e i miei file di registro in un'altra directory. Spesso durante il debug dell'applicazione, è necessario passare dalla directory dei registri, controllare gli ultimi registri e quindi tornare alla directory make, apportare alcune modifiche e creare l'applicazione.

— Varun Risbud
fonte

11

(1) La domanda si pone: "Quali sono i vantaggi di pushde popdoltre cd -?" Chiaramente non hai risposto a questa domanda, poiché stai descrivendo esattamente cosa cd -fa. (2) Qual è il punto di dire pushd || popd? Sì, lo so che cmdA || cmdBsignifica correre cmdAe, se fallisce, quindi correre cmdB. Sto chiedendo a cosa serve in questo contesto. pushdsenza argomenti significa "scambiare i primi due elementi nello stack di directory"; non riesce se la directory corrente è l'unico elemento nello stack di directory. In tal caso, popdfallirà anche.

— G-Man,

3

Non posso credere che nessuno ti abbia votato! Salvavita! Che trucco meraviglioso. Grazie. L'attivazione, a mio avviso, del caso d'uso di pushde popd.

— Sonny,

3

Esistono due modi distinti che richiedono una digitazione molto minore rispetto pushd || popda quella per passare da una directory all'altra: pushdsenza argomenti fa proprio questo. cd -esiste esplicitamente unicamente per tornare all'ultima directory. Inoltre, la domanda ha chiesto il vantaggio di pushdover cd -, mentre questa risposta chiaramente non fornisce nient'altro che uno svantaggio: una maggiore digitazione.

— Benjamin Riggs,

In bash, senza argomenti, pushd scambia le prime due directory e restituisce 0. Perché è necessario || popdattivare / disattivare? Spiega per favore. (Non è solo abbastanza spinta?)

— Johnny Wong,

@Sonny Basta usare cd -per alternare tra due directory. Inoltre, cdsenza argomenti, ritorna alla tua home directory.

— Steve

2

In poche parole, quando è necessario spostarsi tra più di 2 directory, di solito più volte avanti e indietro, in quanto cd -non lo taglieranno con nulla oltre 2 cartelle.

Quindi, ad esempio, invece di provare a rielaborare percorsi lunghi precedenti osservando la cronologia del buffer o completando un percorso lungo un tab, impilate semplicemente quelli importanti e, se necessario, vi spostate comodamente su di essi solo per il loro numero. La rotazione tra strutture di directory complesse e percorsi lunghi diventa liscia 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.

Lo stacking delle directory può anche essere usato negli script in modo simile per le operazioni che si estendono su più directory.

— ELIG
fonte

1

Ho trovato un po 'scomodo l'uso di dirs / popd / pushd. 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 aliasato, ad esempio, "p". per salvare la directory di lavoro corrente nel file ~ / .mydir. e "cd". per recuperare quella directory quando e dove mi piace. "Del". rimuove il file corrispondente; "casa." imposta la directory sulla home directory (equivalente a cd; p.); "cdl" elenca quali sono le directory salvate. Nota che se usi ~ / Dropbox / .mydir $ b (o qualsiasi altro servizio cloud come ad esempio ownCloud) invece di ~ / .mydir $ b otterrai un modo intelligente di usare le tue directory preferite su account e macchine diversi.

— Vitelot
fonte

0

Lo sto usando così 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

mi aiuta a passare da una directory all'ultima utilizzata sul mio terminale. :-) Spero che ti aiuti a usare pushd piuttosto popd io uso cd ~ stackednumber

— Ankur Jain
fonte

0

L'uso cde cd -consente di alternare solo tra le due directory utilizzate più di recente. La dimensione del "set di directory di lavoro" è due.

Utilizzando pushd, è possibile mantenere un numero arbitrariamente elevato di directory nel proprio set di lavoro.

Uso la pushdmaggior parte delle volte anziché cd. Una volta che hai creato una pila di directory attive con pushd directory_name, puoi quindi saltare tra di loro 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 popdraramente, solo quando voglio rimuovere una directory dallo stack quando so che ho finito di usare quella directory.

Vai alla directory e rimuovilo dallo stack:

popd ~2

Rimani nella directory corrente e rimuovi un'altra directory dallo stack:

popd +2

Si finisce con uno stile di lavoro simile a quello di avere più finestre o schede aperte (una per ogni directory in cui si sta lavorando attivamente), ma tutte in un unico terminale. Ciò consente di risparmiare spazio sullo schermo, inoltre, poiché i percorsi delle directory sono tutti disponibili in una shell, è possibile eseguire operazioni come:

copia i file tra le directory con cui stai attualmente lavorando
visualizzare o modificare i file in un'altra directory senza andare lì

Esempi:

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

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

Salva:

dirs -S ~/dirstack

Ristabilire:

dirs -L ~/dirstack

Altrimenti, basta sostituire ~negli bashesempi con =per l'uso in tcsh.

pushd =2
popd =4
popd +1

— jskroch
fonte

0

Il pushd / popd è un concetto così semplice che mi ci è voluto un po 'di comprensione poiché le persone tendono a insegnarlo definendo questi comandi come comandi che "manipolano lo stack di directory" che secondo me è confuso.

Lo guardo in un modo diverso:

pushd [nome_cartella] - eseguirà il cd su [nome_cartella] e documenterà la destinazione che è [nome_cartella] in uno stack dir mentre la directory principale nello stack sarà sempre la directory corrente in cui ci si trova

popd : ti inserirà prima nel record della directory che si trova in cima allo stack, quindi lo rimuoverà dallo stack

dirs : stamperà lo stack dir (può essere trattato come Db dir dove la voce più a sinistra è la directory corrente (parte superiore dello stack)

Quindi i 2 casi d'uso più popolari sono:

Caso d'uso 1: Navigazione tramite 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

Diciamo che ho fatto quanto sopra poiché vorrei tornare alle cartelle che ho documentato!

Nota che se cd manualmente, influenzerò la voce dello stack dir superiore (che è sempre la dir corrente)

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$

Andiamo indietro ora:

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

Ancora una volta posso documentare qualunque dir desidero e poi navigare manualmente verso un'altra dir, quindi potrò facilmente tornare alla dir documentata che ho inserito nello stack.

Caso d'uso 2: navigazione mediante l'indice dello stack numerico

Diciamo che ho spinto usando pushd dir4 dir3 dir2 dir1, ora in esecuzione dir -v mostrerà:

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

Ora puoi eseguire qualsiasi operazione Linux che coinvolga directory usando l'indice dello stack:

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

Puoi persino eliminare una voce specifica dallo stack dir:

root@mypc:/main$ popd ~4

Spero che usare le parole "documentare" o pensare allo stack dir come una sorta di Db semplifichi il concetto!

— Mercurio
fonte