Navigazione rapida delle directory nella shell bash

Vorrei passare frequentemente tra directory che si trovano in percorsi totalmente non correlati, ad esempio /Project/Warnest/docs/e ~/Dropbox/Projects/ds/test/.

Ma non voglio scrivere cd /[full-path]/tutto il tempo. Esistono comandi di scelta rapida per passare a directory precedentemente funzionate?

Una soluzione che mi viene in mente è quella di aggiungere variabili di ambiente alle mie bash .profileper le directory usate di frequente e cdad esse usando quelle variabili.

Ma c'è qualche altra soluzione a questo?

Se stai semplicemente passando da una directory cd -all'altra , puoi usare per andare avanti e indietro.

Esiste una variabile shell CDPATHin bashe kshe cdpathin zsh:

CDPATH    The search path for the cd command. This is a colon-separated
          list of directories in which the shell looks for destination
          directories specified by the cd command.

Quindi puoi impostare nel tuo ~ / .bashrc:

export CDPATH=/Project/Warnest:~/Dropbox/Projects/ds

Poi cd docse cd testvi porterà alla prima di queste directory trovata. (Voglio dire, anche se una directory con lo stesso nome esisterà nella directory corrente, CDPATHsarà comunque consultata. Se CDPATHconterrà più directory con sottodirectory con il nome dato, verrà usata la prima.)

Qualcos'altro che potresti provare è uno strumento chiamato autojump . Mantiene un database di chiamate al suo alias ( jper impostazione predefinita) e tenta di prendere decisioni intelligenti su dove vuoi andare. Ad esempio se digiti frequentemente:

j ~/Pictures

È possibile utilizzare quanto segue per arrivarci in un pizzico:

j Pic

È disponibile su Debian e Ubuntu ed è incluso per utente in ~/.bashrco ~/.zshrcper impostazione predefinita.

Se è un numero limitato di directory, è possibile utilizzare pushdper ruotare tra di loro:

# starting point
$ pwd
/Project/Warnest/docs
# add second dir and change to it
$ pushd ~/Dropbox/Projects/ds/test
~/Dropbox/Projects/ds/test /Project/Warnest/docs
# prove we're in the right place
$ pwd
~/Dropbox/Projects/ds/test
# swap directories
$ pushd
/Project/Warnest/docs ~/Dropbox/Projects/ds/test

diversamente cd -, puoi usarlo con più di due directory

Seguendo il suggerimento di Noach, ora sto usando questo:

function pd()
{
    if [[ $# -ge 1 ]];
    then
        choice="$1"
    else
        dirs -v
        echo -n "? "
        read choice
    fi
    if [[ -n $choice ]];
    then
        declare -i cnum="$choice"
        if [[ $cnum != $choice ]];
        then #choice is not numeric
            choice=$(dirs -v | grep $choice | tail -1 | awk '{print $1}')
            cnum="$choice"
            if [[ -z $choice || $cnum != $choice ]];
            then
                echo "$choice not found"
                return
            fi
        fi
        choice="+$choice"
    fi
    pushd $choice
}

esempio di utilizzo:

# same as pushd +1
$ pd 1

# show a prompt, choose by number
$ pd
 0 ~/Dropbox/Projects/ds/test
 1 /Project/Warnest/docs
 2 /tmp
? 2
/tmp ~/Dropbox/Projects/ds/test /Project/Warnest/docs

# or choose by substring match
$ pd
 0 /tmp
 1 ~/Dropbox/Projects/ds/test
 2 /Project/Warnest/docs
? doc
/Project/Warnest/docs /tmp ~/Dropbox/Projects/ds/test

# substring without prompt
$ pd test
~/Dropbox/Projects/ds/test /Project/Warnest/docs /tmp

ecc. Ovviamente questo è solo per ruotare attraverso lo stack e non gestisce l'aggiunta di nuovi percorsi - forse dovrei rinominarlo.

Uso aliasbashrc per fare quei cd.
ad esempio:

alias wdoc='cd ~/Project/Warnest/docs'
alias dstest='cd ~/Dropbox/Projects/ds/test'

Ho trovato uno script (in genere chiamato acd_funch.sh) che ha risolto questo problema per me. Con questo puoi digitare cd --per vedere le ultime 10 directory che hai usato. Sarà simile a questo:

0  ~/Documents/onedir
1  ~/Music/anotherdir
2  ~/Music/thirddir
3  ~/etc/etc

Per andare a ~/Music/thirddirdigitarecd -2

Riferimenti

• scripts / acd_func.sh
• SkyRocknRoll / acd_func.sh

NOTA: questo script è stato originariamente pubblicato in un articolo della gazzetta di Linux che è disponibile qui: acd_func.sh - estende il CD di bash per conservare, visualizzare e accedere alla cronologia dei nomi delle directory visitate .

Prova l' cdable_varsopzione shell in bash. Lo accendi con shopt -s cdable_vars.

Quindi è necessario impostare le variabili export dir1=/some/path. e infine cd dir1, ecc. Quindi puoi metterlo nel tuo ~/.bashrcper farlo aderire.

Usa "pushd -n " (supponendo che tu usi bash).

Aggiungi al tuo ~ / .bashrc:

pushd -n /Project/Warnest/docs/
pushd -n ~/Dropbox/Projects/ds/test/

poi,

cd ~ è la tua casa,

cd ~1 è ~/Dropbox/Projects/ds/test/

cd ~2 è /Project/Warnest/docs/

Puoi usare ~1, ~2ecc. Esattamente nello stesso modo di ~.

Ci sono molti buoni suggerimenti qui. Quale da utilizzare dipende dal fatto che tu abbia un piccolo elenco fisso di directory tra cui passare o se stai cercando una soluzione più generica.

Se si tratta di un piccolo elenco fisso, impostare alias semplici (come suggeriva Felix Yan) sarebbe più facile da usare.

Se stai cercando una soluzione più generalizzata (cioè molte directory diverse, che cambiano nel tempo), userei pushd e popd (come suggerito da Inutile). Personalmente trovo difficile usare il pushd / popd predefinito, specialmente quando inizi a passare da una cartella all'altra; tuttavia ho scritto alcune modifiche che mi rendono molto più semplice. Aggiungi quanto segue al tuo bashrc:

alias dirs='dirs -v'
pd () 
{ 
    if [ "$1" ]; then
        pushd "${1/#[0-9]*/+$1}";
    else
        pushd;
    fi > /dev/null
}

• Usa pd(come una forma più breve di pushd) per passare a una nuova cartella, ricordando dove ti trovavi.
• Utilizzare dirsper visualizzare l'elenco delle directory salvate.
• Utilizzare pd 3per passare alla directory numero 3.

Esempio di utilizzo:

$ PS1='\w\$ '   ## just for demo purposes
~$ pd ~/Documents/data
~/Documents/data$ pd ../spec
~/Documents/spec$ pd ~/Dropbox/Public/
~/Dropbox/Public$ pd /tmp
/tmp$ pd /etc/defaults/
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 2
~/Dropbox/Public$ dirs
 0  ~/Dropbox/Public
 1  ~/Documents/spec
 2  ~/Documents/data
 3  ~
 4  /etc/defaults
 5  /tmp
~/Dropbox/Public$ pd 4
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 3
~/Documents/spec$ popd
~/Documents/data ~ /etc/defaults /tmp ~/Dropbox/Public
~/Documents/data$ 

Il seguente sembra funzionare sull'unico caso in cui l'ho testato e puoi semplicemente rilasciare i nomi delle tue directory come collegamenti simbolici in ~ / Bookmarks:

mkdir "$HOME/Bookmarks"
ln -s /tmp "$HOME/Bookmarks/testdir"

function ccd() { cd $(readlink "$HOME/Bookmarks/$1") ; }

ccd testdir && echo $PWD
# gives /tmp

Potresti fare di peggio che provare j2 .

Dal README:

Trascorrere molto tempo facendo il cd-ing attorno a un albero di directory complesso?

j tiene traccia di dove sei stato e di quanto tempo passi lì, e fornisce un modo conveniente per passare alle directory che usi effettivamente.

Lo uso ampiamente e lo consiglio.

Consiglierei di usare zsh , quella shell come ottimo completamento TAB per directory, file e persino opzioni per la maggior parte dei programmi di cli.

Uso quella shell da anni ormai e mi mancherebbe la funzionalità se non ci fosse più. Lo scripting di zsh è anche molto divertente, con un gran numero di battute singole che possono aiutarti ogni giorno.

Nella mia esperienza, il massimo della velocità di navigazione in una shell è utilizzare la sua funzionalità di ricerca della cronologia. In Bash puoi cercare all'indietro nella cronologia dei comandi premendo Ctrl+ Re digita un modello. Tale modello viene quindi confrontato con le voci precedenti nella cronologia, ad esempio cdcomandi o altre operazioni, e durante la digitazione vengono forniti suggerimenti. Basta premere invio per eseguire nuovamente il comando suggerito. Questo si chiama reverse-search-historyBash e lo adoro. Mi fa risparmiare un sacco di tasti e risparmia la mia memoria interna.

È una buona cosa perché devi solo ricordare una parte più piccola di un comando, come Dropo Wadistinguere tra le due voci della cronologia cd ~/Dropbox/Projects/ds/test/e cd /Project/Warnest/docs/.

Uso anche questi alias (aggiungili a ~ / .bashrc):

alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'

È molto più veloce andare nella directory superiore con loro (eppure risolve solo metà della navigazione).

se stai usando zsh:

• non è necessario digitare cd, basta digitare il percorso della directory ( /foo/bar/baz<Enter>uguale a cd /foo/bar/baz<Enter>)

  richiede auto_cdun'opzione da impostare

• puoi espandere i percorsi abbreviati con la Tabchiave (si /u/sh/pi<Tab>espande in /usr/share/pixmaps; funziona anche per i nomi di file)

C'è uno strumento piuttosto carino per rapidi cambi di directory:

xd - eXtra fast Cambio directory http://xd-home.sourceforge.net/xdman.html

un po 'imbarazzante è che è necessario mapparlo nel profilo bash o simile poiché emette solo la directory

# function to do `cd` using `xd`
# -g turns generalized directory search command processing on
# which improves the whole thing a bit
f() 
{
        cd `/usr/bin/xd -g $*`
}

puoi fare cose come:

# change to /var/log/a* (gives you a list to choose from)    
f vla
# to skip the list and go directly to /var/log/apache2
f vlapach

Non dovresti mai digitare comunque il percorso completo nella shell. Puoi sempre usare:

soffice /P*/W*/*/mydoc*

invece di

soffice /Project/Warnest/docs/mydoc.odt

C'è anche OLDPWDuna variabile d'ambiente che, secondo IEEE 1003.1 (POSIX), dovrebbe essere aggiornata con la precedente directory di lavoro ogni volta che cdcambia la directory di lavoro (per i curiosi, riga 80244 di pagina 2506 di IEEE 1003.1-2008).

Esiste anche un'app "wcd" creata appositamente per questo (anch'essa trasferita su cygwin, dato che ci sono io). È possibile creare collegamenti, segnalibri di directory con esso. Supporta anche jolly. Leggere la pagina man e i documenti in / usr / share / wcd dovrebbe aiutare molto.

http://manpages.ubuntu.com/manpages/hardy/man7/wcd.7.html

cdargs è lo strumento più efficiente per aggiungere una directory ai segnalibri: http://www.youtube.com/watch?v=uWB2FIQlzZg

Prova fastcd ( https://github.com/frazenshtein/fastcd ) Imposta l'hook che registra le directory visitate da bash. E imposta lo script come alias "j", che mostra le ultime directory visitate, con la possibilità di eseguire rapidamente il cd (iniziare a digitare per filtrare le directory). La modifica di .bashrc è necessaria per creare l'alias "j".

Ottenere strumento

cd ~; mkdir Soft; cd Soft
git clone https://github.com/frazenshtein/fastcd

Installa i moduli richiesti

pip install --user urwid

Sorgente il file set.sh nel tuo bashrc

echo -e "\nsource /home/$USER/Soft/fastcd/set.sh\n" >> ~/.bashrc

E aggiorna bashrc

source ~/.bashrc

Quindi digita "j" nella console

Ho avuto la stessa domanda e ho trovato prima questa risposta . Ho installato l'utility z ( https://github.com/rupa/z ).

Questo è esattamente ciò che cercate, perché z impara dai tuoi comandi cd, e tiene traccia delle directory in base al frecency principio (frequente e recente). Quindi dopo aver eseguito entrambi i comandi cd una volta, puoi fare qualcosa come:

z docs
z ds

saltare a /Project/Warnest/docs/e ~/Dropbox/Projects/ds/test/rispettivamente. Gli argomenti di z sono regex, quindi non è nemmeno necessario digitare un nome di cartella completo.

Aggiornamento (2016): ora uso FASD per questo, che consente la ricerca fuzzy basata sulle ultime directory.

Ho creato uno strumento per questo, in Ruby. Ti consente di utilizzare i file YAML per dichiarare i tuoi progetti.

Ho scritto un piccolo articolo a riguardo qui: http://jrnv.nl/switching-projects-terminal-quickly/

Ho anche pubblicato la fonte su GitHub: https://github.com/jeroenvisser101/project-switcher

Sto usando il mio cdhist di utilità per gestirlo da molti anni. Alias ​​il comando cd e mantiene automaticamente uno stack di directory.

È possibile utilizzare exportper assegnare i percorsi della directory alle variabili e quindi fare riferimento a loro.

export dir1=/Project/Warnest/docs/
export dir2= ~/Dropbox/Projects/ds/test/
cd $dir1
cd $dir2

Alcuni suggerimenti qui:

Idea più diretta, aggiungerò alias nel file .profile

vi ~/.profile
alias dir1='cd /myhome/onedir'
alias dir2='cd /jimmy/anotherdir'

Quindi utilizzare $ dir1 o dir2, può cd

Se si passa sempre solo a due dir. usando cd -cambierà tra di loro.

La soluzione che uso per questa situazione è screen. Avviare la schermata e creare una finestra per ogni directory con C-a ce navigare lì. Cambia tra windows / directory con C-a no C-a p. Dai un nome alle finestre con C-a A. Quindi è possibile visualizzare un elenco di finestre con C-a "e navigare utilizzando il numero o il nome della finestra. Dal momento che è possibile screen, è possibile staccare dalla sessione salvando lo spazio di lavoro e ricollegarsi successivamente con la stessa configurazione.

Sembra che ciò di cui hai bisogno sia sostanzialmente un file di progetto per il tuo flusso di lavoro. Con le directory che appartengono alla tua attività, come in un IDE di programmazione. Prova Zsh Navigation Tools e lo strumento n-cdlì. Ti permetterà di navigare tra le ultime cartelle visitate e anche di definire un Hotlistcon le directory di tua scelta:

n-cd può essere associato a una combinazione di tasti con:

zle -N znt-cd-widget

bindkey "^ T" znt-cd-widget

TL; DR

1. Utilizzare un Fishper shell interattiva che si potenziare immediatamente ( fish> zsh> bash).
2. Usare POSIX/ Bashper lo scripting che è la sintassi più ampiamente supportato ( POSIX> Bash> Zsh> Fish).

conchiglie

Dopo aver testato diverse shell qui è il mio feedback (in ordine di test / adozione):

• Bash:
  • completamento automatico: di base;
  • espansione del percorso: no;
  • sceneggiatura: eccellente.
• Zsh+ oh-my-zsh:
  • completamento automatico: buono (scorrendo ciclicamente);
  • espansione del percorso: sì ( cd /e/x1→ cd /etc/X11/);
  • scripting: buono.
• Fish+ oh-my-fish(corrente) è il migliore fuori dalla scatola:
  • completamento automatico: opzioni native e supportate;
  • espansione del percorso: sì;
  • scripting: troppa differenza rispetto a POSIX compatibile.

Usa alias significativi

Ogni shell può essere espansa usando functione alias, ecco quelle che uso relative al tuo problema (compatibile con POSIX):

back () {  # go to previous visited directory
        cd - || exit
}

up () {  # go to parent directory
        cd ..|| exit
}

Ci sono semplici, ma davvero significativi, così facili da ricordare e da completare automaticamente.

Conosci la tua conchiglia

Configura CDPATHper aggiungere le directory più utilizzate (ad es ~/projects/. /etc/init.d/) In modo da poterle saltare rapidamente.

Vedi la risposta del manatwork per maggiori dettagli suCDPATH .

Hangout e leggi

• le mie personalizzazioni sono su github: posix (bash / zsh) , fish (PR accettata);
• varie utility che potrebbero essere interessanti: tree , k (Elenchi di directory per zsh)
• entry-points per trovare plugin per la tua shell :
  • bucaran / pesce fantastico ,
  • unixorn / awesome-zsh-plugins ,
  • alebcay / impressionante-shell
• bashFAQ ;
• Documentazione del pesce ;
• per differenze tra le shell , raccomando l'eccellente confronto hyperpolyglot.org/unix-shells .
• sul loro IRC: #bash, #zsh, #ohmyzsh, #fish, ecc. ci sono molte persone simpatiche (dovrai essere paziente giovane padawan).

ancè uno strumento di linea cmd (abbreviazione di anchor), che mantiene i segnalibri delle directory. (finora testato solo con bash)

Nel tuo caso:

anc a /Project/Warnest/docs/ ~/Dropbox/Projects/ds/test/

questo aggiunge entrambe le directory all'elenco di ancoraggio (pensa ai segnalibri)

ora se vuoi saltare /Project/Warnest/docs/da qualsiasi parte del tuo tipo di sistema:

anc Warn

e se vuoi saltare per ~/Dropbox/Projects/ds/test/digitare:

anc ds test

Oltre alla corrispondenza del testo con i percorsi dei segnalibri, anc ha molti altri modi convenienti per saltare tra le directory.

anc i

avvia la modalità interattiva, che elenca tutti i segnalibri per numero, quindi è sufficiente digitare il numero

Se digiti:

anc Pro[TAB]

viene visualizzato un elenco corrispondente a tutti i segnalibri (nel tuo caso entrambi i segnalibri) e puoi selezionarlo usando i tasti freccia, questo è un modo molto rapido e intuitivo.

Ottieni anc alla pagina github del progetto: https://github.com/tobimensch/anc

C'è anche un file README con esempio di utilizzo.

Divulgazione completa: sono l'autore di questo script. Spero che alcune persone lo trovino utile.