Bagaimana cara menggunakan perintah pushd dan popd?

Apa manfaat praktis dari kedua pushddan popdketika ada keuntungan dari menggunakan kedua perintah di atas cddan cd -?

EDIT : Saya sedang mencari beberapa contoh praktis penggunaan untuk kedua perintah ini atau alasan untuk menjaga tumpukan dengan direktori (ketika Anda memiliki penyelesaian tab cd -,, alias untuk memperpendek cd .., dll.).

pushd,, popddan dirsshell bawaan yang memungkinkan Anda memanipulasi tumpukan direktori . Ini dapat digunakan untuk mengubah direktori tetapi kembali ke direktori tempat Anda berasal.

Sebagai contoh

mulai dengan direktori berikut:

$ ls
dir1  dir2  dir3

pushd ke dir1

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

dirsperintah mengkonfirmasi bahwa kita memiliki 2 direktori pada stack sekarang. dir1dan dir yang asli somedir,.

pushd to ../dir3 (karena kita di dalam dir1sekarang)

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

dirsmenunjukkan kita memiliki 3 direktori di stack sekarang. dir3,, dir1dan somedir. Perhatikan arahnya. Setiap direktori baru ditambahkan ke kiri. Ketika kita mulai menghapus direktori, mereka akan datang dari kiri juga.

ubah direktori secara manual menjadi ../dir2

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

Sekarang mulailah membuka direktori

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

Perhatikan kami muncul kembali ke dir1.

Pop lagi ...

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

Dan kita kembali ke tempat kita mulai somedir,.

Mungkin sedikit membingungkan, tetapi kepala tumpukan adalah direktori tempat Anda berada saat ini. Karenanya ketika kami kembali somedir, meskipun dirsmenunjukkan ini:

$ dirs
~/somedir

Tumpukan kami benar-benar kosong.

$ popd
bash: popd: directory stack empty

Ada use case yang sangat berguna untuk pushddan popdperintah untuk bekerja dengan beberapa folder secara bersamaan.

Anda dapat menavigasi tumpukan dengan sangat mudah, karena ini disebutkan. Artinya, Anda dapat memiliki beberapa folder kerja yang dapat Anda gunakan selama bekerja.

Lihat contoh sederhana di bawah ini.

Pertama, mari kita buat contoh struktur folder.

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

Kemudian Anda dapat menambahkan semua folder Anda ke tumpukan:

    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

Anda dapat mencarinya dengan:

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

Untuk menavigasi dengan aman, Anda perlu menambahkan folder terakhir (nol) dua kali, karena akan selalu ditulis ulang:

    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

Sekarang, Anda dapat melompat-lompat melalui folder ini dan bekerja dengan tumpukan seperti alias untuk folder. Saya kira bagian berikut ini cukup jelas:

    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

Kiat tambahan adalah membuat beberapa alias untuk dirs -v.

Sebagai contoh:

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

Satu kasus penggunaan sederhana untuk menggunakan dirs stack yang tidak dapat Anda lakukan hanya dengan cd adalah:

pushd .menambahkan direktori XX saat ini ke dirsstack. Setelah itu, Anda dapat berpindah menggunakan cd, dan untuk kembali ke XX Anda hanya melakukan popdterlepas dari seberapa "jauh" Anda di pohon direktori (dapat melompati beberapa level, ke samping dll). Sangat berguna dalam skrip bash.

pushddan popdmemungkinkan Anda untuk memanipulasi direktori pada stack.

Saat Anda pushddirektori, Anda meletakkan direktori saat ini di tumpukan dan mengubah direktori ke yang ditentukan sebagai parameter.

popd akan memungkinkan Anda untuk kembali ke direktori di tumpukan.

Jika Anda mengulangi, traversal direktori akan dipertahankan dan Anda dapat kembali ke direktori yang disimpan dalam urutan terbalik dari tempat Anda menyimpannya.

untuk bash , pada dasarnya: alih-alih menggunakan cd, dapat digunakan pushduntuk mengubah direktori, dengan penggunaan praktis: riwayat direktori yang dikunjungi disimpan (dengan benar: ditumpuk) dan satu dapat beralih di antaranya

pushd /home; pushd /var; pushd log

Untuk melihat penggunaan tumpukan dirsdan untuk navigasi yang lebih mudah (untuk mendapatkan nomor "entri-tumpukan" gunakan:

dirs -v

Keluaran:

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

Sekarang gunakan angka-angka ini dengan cddan ~suka:

cd ~1

Tetapi angka-angka ini disusun ulang sekarang dan posisi "0" akan berubah, jadi hanya pushddirektori ke posisi teratas dua kali (atau gunakan dummy di posisi 0) seperti:

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

sekarang 1..3 akan mempertahankan posisinya

(untuk melepaskan direktori saat ini dari tumpukan / menghapusnya dari penggunaan sejarah popd)

Satu kegunaan praktis yang saya temukan adalah untuk beralih antara direktori menggunakan pushd dan popd.

Misalkan kita memiliki dua direktori dir1 dan dir2 dan saya perlu beralih di antara mereka secara terus-menerus untuk beberapa alasan xyz.

Saat ini saya di somedir yang memiliki dua direktori dir1dan dir2:

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

Sekarang saya beralih ke dir1

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

Sekarang saya akan menambah dir1tumpukan dan beralih kedir2

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

Seperti yang Anda lihat, saya sekarang memiliki dir2dan dir1di stack dan saya saat ini masuk ke dir2.

Sekarang untuk kembali dir1, saya akan lari pushd || popd.

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

Voila, saya ke dir1 dan saya punya dir1 dan dir2 di stack. Untuk beralih kembali ke dir2 jalankan lagipushd || popd

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

Ini cara mudah untuk beralih di antara direktori. Sekarang, Anda mungkin tahu apa, mengapa saya perlu beralih di antara direktori? Nah satu use case adalah, ketika saya bekerja pada aplikasi web, saya punya file make saya di satu direktori dan file log saya di direktori lain. Seringkali ketika men-debug aplikasi, saya perlu beralih di antara direktori log, untuk memeriksa log terbaru dan kemudian beralih kembali ke direktori make, untuk membuat beberapa perubahan dan membangun aplikasi.

Sederhananya - ketika Anda perlu menavigasi antara lebih dari 2 direktori, biasanya beberapa kali bolak-balik, karena cd -tidak akan memotongnya dengan apa pun di luar 2 folder.

Jadi, misalnya, alih-alih mencoba kembali dengan jalur panjang sebelumnya dengan melihat riwayat buffer Anda atau menyelesaikan tab jalur panjang Anda cukup menumpuk yang penting dan jika perlu Anda dengan mudah pindah ke mereka dengan nomor mereka sendiri. Berputar di antara struktur direktori kompleks dan jalur panjang menjadi licin dan cepat.

Builtin juga memungkinkan Anda untuk memesan ulang tumpukan atau mengeluarkan direktori yang tidak Anda butuhkan lagi sehingga memungkinkan fleksibilitas dalam alur kerja Anda.

Penumpukan direktori juga dapat digunakan dalam skrip yang sama untuk operasi yang menjangkau beberapa direktori.

Saya menemukan penggunaan dirs / popd / pushd sedikit tidak nyaman. Saya datang dengan solusi pribadi saya di tcsh, dengan menambahkan kode berikut ke dalam .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*'

dengan cara ini saya alias, misalnya, "p." untuk menyimpan direktori kerja saat ini ke dalam file ~ / .mydir. dan "cd." untuk memulihkan dir itu kapan saja dan di mana saja saya suka. "del." menghapus file yang sesuai; "rumah." set dir ke dir home (setara dengan cd; p.); "cdl" mencantumkan apa saja dir yang disimpan. Perhatikan bahwa jika Anda menggunakan ~ / Dropbox / .mydir $ b (atau layanan cloud lainnya seperti mis. OwnCloud) alih-alih.

Saya menggunakannya seperti ini di bash_profile dan .bashrc saya seperti ini

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

ini membantu saya melompat di antara direktori ke direktori yang paling baru digunakan di terminal saya. :-) Semoga ini bisa membantu Anda menggunakan pushd, bukan popd, saya menggunakan cd ~ stackednumber

Menggunakan cddan cd -memungkinkan Anda untuk beralih di antara hanya dua direktori Anda yang terakhir digunakan. Ukuran "direktori yang berfungsi" adalah dua.

Dengan menggunakan pushd, Anda dapat menyimpan sejumlah besar direktori sewenang-wenang di set kerja Anda.

Saya menggunakan pushdsebagian besar waktu daripada cd. Setelah Anda membangun setumpuk direktori aktif pushd directory_name, Anda dapat melompat di antara mereka sepanjang hari 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.

Saya popdjarang menggunakan , hanya ketika saya ingin menghapus direktori dari tumpukan ketika saya tahu saya selesai menggunakan direktori itu.

Pergi ke direktori dan hapus dari tumpukan:

popd ~2

Tetap di direktori saat ini dan hapus direktori lain dari stack:

popd +2

Anda berakhir dengan gaya kerja yang mirip dengan membuka banyak jendela atau tab terminal (satu untuk setiap direktori tempat Anda bekerja aktif), tetapi semuanya dalam satu terminal. Ini menyimpan real estat layar, plus, karena jalur direktori semua tersedia dalam satu shell, Anda dapat melakukan hal-hal seperti:

• salin file di antara direktori yang sedang Anda kerjakan
• melihat atau mengedit file di direktori lain tanpa pergi ke sana

Contoh:

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

Dalam tcsh(tetapi tidak bash), Anda bahkan dapat menyimpan tumpukan direktori Anda ke file dan mengembalikannya nanti.

Menyimpan:

dirs -S ~/dirstack

Mengembalikan:

dirs -L ~/dirstack

Jika tidak, ganti saja ~dalam bashcontoh dengan =untuk digunakan dalam tcsh.

pushd =2
popd =4
popd +1

Pushd / popd adalah konsep sederhana yang membuat saya perlu memahaminya karena orang cenderung mengajarkannya dengan mendefinisikan perintah-perintah ini sebagai perintah yang 'memanipulasi tumpukan direktori' yang menurut saya membingungkan.

Saya melihatnya dengan cara yang berbeda:

pushd [folder_name] - akan cd ke [folder_name] dan akan mendokumentasikan tujuan yang [folder_name] dalam direktori stack sementara direktori teratas di stack akan selalu menjadi direktori saat ini Anda berada di

popd - pertama-tama akan cd Anda ke dalam catatan direktori yang ada di atas tumpukan kemudian dan menghapusnya dari tumpukan

dirs - Akan mencetak dir stack (dapat dianggap sebagai dir Db di mana entri paling kiri adalah direktori saat ini (atas tumpukan)

Jadi 2 kasus penggunaan paling populer adalah:

Use case 1: Navigasi menggunakan pushd dan 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

Katakanlah saya melakukan hal di atas karena saya ingin menavigasi kembali ke folder yang saya dokumentasikan!

Perhatikan bahwa jika saya melakukan cd secara manual, saya akan memengaruhi entri tumpukan direktori teratas (yang selalu merupakan direktori saat ini)

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$ 

Mari bernavigasi mundur sekarang:

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

Sekali lagi saya dapat mendokumentasikan dir apa pun yang saya inginkan dan kemudian menavigasi secara manual ke dir lain maka saya akan dapat dengan mudah kembali ke dir yang terdokumentasi yang saya masukkan ke stack.

Use case 2: Menavigasi menggunakan indeks tumpukan numerik

Katakanlah saya mendorong menggunakan dird dir4 dir3 dir2 dir1, sekarang menjalankan dir -v akan menunjukkan:

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

Sekarang Anda dapat melakukan operasi Linux apa pun yang melibatkan direktori menggunakan indeks tumpukan:

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

Anda bahkan dapat menghapus entri tertentu dari tumpukan direktori:

root@mypc:/main$ popd ~4

Berharap bahwa menggunakan kata-kata "mendokumentasikan" atau berpikir tentang tumpukan stack karena beberapa jenis Db menyederhanakan konsep!