Esiste una cronologia delle directory per bash?

C'è qualcosa come la storia della ricerca inversa di bash (Ctrl-r), ma solo per le directory?

Ho alcune gerarchie di cartelle profonde a cui voglio saltare, quindi mi piacerebbe usare qualcosa come la cronologia di ricerca inversa, ma cerca solo i nomi delle cartelle e mi dà percorsi assoluti.

In sostanza, darebbe risultati simili all'utilizzo !?ma abbinando solo i comandi con cd in primo piano, è possibile scorrere i risultati e percorsi completi.

Finora, la migliore soluzione che ho trovato è bashmarks .

Dai un'occhiata a autojump :

Uno dei comandi di shell più utilizzati è "cd". Un rapido sondaggio tra i miei amici ha rivelato che tra il 10 e il 20% di tutti i comandi che digitano sono in realtà comandi cd! Sfortunatamente, saltare da una parte del sistema a un'altra con cd richiede di inserire quasi l'intero percorso, il che non è molto pratico e richiede molte sequenze di tasti.

autojump è un modo più veloce per navigare nel tuo filesystem. Funziona mantenendo un database delle directory che usi di più dalla riga di comando. Il comando jumpstat mostra il contenuto corrente del database. È necessario lavorare un po 'prima che il database diventi utilizzabile. Una volta che il tuo database è ragionevolmente completo, puoi "saltare" in una directory ed "cd" comunemente digitando:
j dirspec

C'è

cd -

questo è il comando "cd [spazio] [trattino]", che passa alla directory che eri prima, essenzialmente una "storia della profondità 1". Il "cd -" ripetuto passa avanti e indietro tra due directory.

Citando la pagina man:

Sono supportati i seguenti operandi: [...]

Quando un [trattino] viene utilizzato come operando, questo deve essere equivalente al comando:

      cd "$OLDPWD" && pwd

Sfortunatamente, non conosco una vera cronologia di directory integrata.

bash ha pushd / popd / dirs. Ho questo nel mio .bashrc per spingere automaticamente le directory nello stack di bash.

#let cd also pushd directories into stack. Use popd to reverse stack
function cd ()
{
  if [ -e $1 ]; then 
    pushd $1 &> /dev/null   #dont display current stack 
  fi
}

Pop questi usando popde visualizzare lo stack utilizzandodirs

Ho avuto una buona esperienza con z-jump Permette il completamento, anche se solo per la destinazione finale, non attraversare un percorso. Tuttavia, mostra il percorso completo al completamento della scheda.

Solo per entrare in contatto con la mia esperienza, ho scritto un semplice script per rispondere a questa esigenza qualche tempo fa, sovrascrive il comando cd incorporato con una semplice funzione che aggiunge la nuova posizione della directory a un file di cronologia, quindi uno script Python viene utilizzato per fornire un'interfaccia bash che aggiorna dinamicamente un elenco ordinato di directory quando si inseriscono i termini di ricerca, un po 'come la ricerca del comando inverso di bash.

È disponibile su git-hub per coloro che sono curiosi.

Vorrei raccomandare il mio ltcdper una rapida navigazione nella cronologia delle directory:

https://github.com/dczhu/ltcd

Fornisce le seguenti funzionalità per semplificare la vita:

• Elenco globale delle directory, che mostra le directory visitate di recente da tutte le schede / finestre del terminale.
• Elenco di directory locale, che è locale alla sessione di shell corrente.
• Entrambi gli elenchi supportano la navigazione rapida utilizzando j / k (vai giù / su), i numeri e la ricerca di parole.
• Salto libero globale (ad es. "Cd dir" o "cd ar" per accedere a / path / to / foo / bar / directory /).

Ho realizzato uno script con funzionalità simili al comando di oh-my-zshdirs -v che funziona su bash. Se hai mai usato oh-my-zsh , potresti aver notato che la cronologia delle directory fornita dal comando dirs -vverrà ripristinata ogni volta che esci dal terminale. Tuttavia, non accadrà se si utilizza questo script .

La funzionalità:

• Mostra l'elenco delle 10 directory usate più recenti con d.

• Passa a qualsiasi directory nell'elenco digitando il numero della directory nell'elenco. Devi usare 0 invece di 10 per saltare alla decima directory.

• Un percorso di directory verrà messo in cima all'elenco ogni volta che si utilizza v( vim ) per modificare i file o o( xdg-open ) per aprire un file da quella directory. O se ti piace, ogni volta che visiti una directory.

Puoi vederlo in azione qui .

Bene, potresti aggiungere questo snippet di codice al tuo ~/.bashrc, che

1. fornisce un comando cd personalizzato

       function cd ()
       {
           exists=false
           for dir in "${CDHIST[@]}"; do
               [ "$dir" == "$1" ] && {
                   exists == true
                   break
               }
           done
   
           $exists || {
               len=${#CDHIST[@]}
               ${CDHIST[$len]} = "$1"
           }
   
           builtin cd "$1"
       }

2. e fornisce un comando di ricerca cronologia cd.

   function cdhist ()
   {
       #TODO: Make this magical.
   
       for dir in "${CDHIST[@]}"; do
           echo "$dir"
       done
   }

Naturalmente, il comando cdhist che ho fornito è molto semplice, e non quello che volevi; ma è concepibile utilizzare le istruzioni case o l'espansione dei parametri per ottenere qualcosa di simile a ciò che si desidera.

È anche possibile aggiungere alcune funzioni di "Completamento programmabile", che potrebbero essere utilizzate per aggiungere il cd /path/to/mydircomando completo basato su una sottostringa univoca di /path/to/unique/mydir, sebbene tale metodo richiederebbe comunque di digitare cd unique/mydir<tab>.

È possibile costruire il proprio cdcomando con pushd, popd, dirs comandi incorporati.

uso

• cd -- (elenca la cronologia attuale)

• cd -num (vai alla directory num)

• cd - (vai alla directory precedente)

function cd()
{
    local hnum=16  # number of entries
    local new_dir index dir cnt
    if ! [ $# -eq 0 ]; then
        if [[ $# -eq 2 && $1 = "--" ]]; then
            shift
        else 
            if ! { [ $# -eq 1 ] && [[ $1 =~ ^(-[0-9]{,2}|-|--|[^-].*)$ ]] ;}
            then
                builtin cd "$@"
                return
            fi
        fi
    fi
    [ "$1" = "--" ] && { dirs -v;  return ;}
    new_dir=${1:-$HOME}
    if [[ "$new_dir" =~ ^(-[0-9]{,2}|-)$ ]]; then
        index=${new_dir:1}
        [ -z "$index" ] && index=1
        new_dir=$(dirs -l +$index) || return
    fi
    pushd -- "$new_dir" > /dev/null || return
    popd -n +$hnum &> /dev/null
    new_dir=$PWD cnt=1
    while dir=$(dirs -l +$cnt 2> /dev/null); do
        if [ "$dir" = "$new_dir" ]; then
            popd -n +$cnt > /dev/null
            continue
        fi
        let cnt++
    done
}

export -f cd

Ho messo insieme questo strumento, che combina le precedenti soluzioni per l'archiviazione di una cronologia globale della CLI globale con uno strumento di grepping interattivo chiamato percol (mappato su C ^ R). Lo uso per recuperare i comandi da dove sono stati eseguiti o per trovare una directory da un comando. È ancora perfetto sulla prima macchina che ho iniziato a usarlo, ora con una cronologia della CLI di 2 anni.

Lo strumento grep funziona sia su percorso che su comando, ma potrebbe essere comunque utile per te. Vedi anche 'dirs -v' in zsh

https://github.com/gawells/ariadne