aliasing cd to pushd - è una buona idea?

È una buona idea usare il seguente alias:

cd() {
    pushd $1;
}

a bash?

Penso che questo sarebbe molto utile, dal momento che posso quindi utilizzare una serie di popds anziché solo una cd -volta.

C'è qualche caso in cui questo potrebbe essere un problema?

Personalmente, li ho nel mio bashrc e li uso sempre:

pushd()
{
  if [ $# -eq 0 ]; then
    DIR="${HOME}"
  else
    DIR="$1"
  fi

  builtin pushd "${DIR}" > /dev/null
  echo -n "DIRSTACK: "
  dirs
}

pushd_builtin()
{
  builtin pushd > /dev/null
  echo -n "DIRSTACK: "
  dirs
}

popd()
{
  builtin popd > /dev/null
  echo -n "DIRSTACK: "
  dirs
}

alias cd='pushd'
alias back='popd'
alias flip='pushd_builtin'

Puoi quindi navigare sulla riga di comando un po 'come un browser. cdcambia la directory. backpassa alla directory precedente da cui è stato cdeditato. E flipsi sposterà tra le directory attuali e precedenti senza estrarle dallo stack di directory. Nel complesso, funziona benissimo.

L'unico vero problema di cui sono a conoscenza è il fatto che è quindi un insieme di comandi a cui sono completamente abituato ma che non esiste sulla macchina di nessun altro. Quindi, se devo usare la macchina di qualcun altro, può essere un po 'frustrante. Se sei abituato a usare pushde popddirettamente, non hai questo problema. E mentre se alias semplicemente cdnon lo popdfai, non avrai il problema di backnon esistere, avrai comunque il problema che cdnon fa esattamente quello che ti aspetti su altre macchine.

Vorrei notare, tuttavia, che la tua particolare implementazione di cdnon funziona come cdse il normale cdda solo andasse alla tua home directory, ma la tua no. La versione che ho qui non ha questo problema. Il mio si aggiunge anche DIRSTACKalla parte anteriore della dirsstampa, ma è più una questione di gusti personali più che altro.

Quindi, come ho detto, uso sempre questi alias e non ho alcun problema con essi. È solo che può essere un po 'frustrante dover usare un'altra macchina e poi non trovarle lì (il che non dovrebbe sorprendere, ma sono una di quelle cose che usi così spesso che non ci pensi , quindi farli non funzionare come sei abituato può essere ancora sorprendente).

Questa non è una risposta diretta alla domanda, ma mi sono innamorata della finestra della cronologia delle directory in 4DOS. Tanto che ho scritto la mia versione per Linux (e Cygwin). Non sono mai riuscito a renderlo un'utilità facile da installare, ma se sai come aggirare un prompt di Bash, non dovrebbe essere così difficile iniziare. La tua domanda mi ha ispirato a inserirlo in un repository Git e caricarlo su GitHub: dirhistory .

Fondamentalmente, è un demone che raccoglie le modifiche alla directory da tutte le tue shell e un programma Cdk che mostra la cronologia e ti consente di scegliere qualsiasi directory su cui passare (quindi non sei limitato a uno stack). Lo trovo davvero utile e lo associo a Ctrl-PageUp, proprio come ha fatto 4DOS. (Ho anche patchato PuTTY in modo da inviare Ctrl-PageUp a Bash.)

Per me pushd / popd / dirs è quasi utile, ma manca. Così ho creato un 'wrapper' attorno a questi chiamati 'navd', implementato essenzialmente come un insieme di 20 alias. (Uno di questi è una funzione, davvero.) Il codice è sotto, ma ecco prima una breve spiegazione. (Una cosa bella di "navd" e di lavorare su macchine di altre persone: esiste una forma "non installabile" per eseguirla: come opzione di installazione puoi semplicemente incollare i comandi che implementano "navd" al prompt di bash e per tutta la durata di quella sessione bash per quella macchina navd funzionerà. Ciò dà zero footprint nel file system, ma è un'installazione temporanea. Metti quei comandi in .bashrc per un'installazione "reale", di corso.)

Caratteristiche:

navd <path>;   -- will make that path the current dir AND will add it to the stack
                         AS A BONUS: If a relative path is used, this command is added to history
                         with an absolute path instead. This improves navigation even when only
                         using history ... because very often relative-path commands in history
                         are useless if the command changes the current directory. (After all, you
                         would have to be in the directory the command was originally issued
                         from in order for such a command to work correctly.)
navd           -- shows the stack, with index numbers for convenience
navd0          -- makes the first entry on the stack (read left-to-right) **the current dir**
navd1          -- makes the second entry on the stack (read left-to-right) **the current dir**
.
.
.
navd9          -- makes the tenth entry on the stack (read left-to-right) **the current dir**
navd-1         -- makes the first entry on the stack WHEN READ RIGHT-to-LEFT(!) **the current dir**
.                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^
.
.
navd-9         -- makes the 9th entry on the stack WHEN READ RIGHT-to-LEFT(!) **the current dir**

Qualsiasi delle diciannove navd <N> comandi ruota la pila in modo che la directory che diventa directory corrente anche ora visualizzato nella parte anteriore della risma. I valori <N> positivi trovano un conteggio da sinistra, con l'indicizzazione che inizia da zero. I valori <N> negativi trovano un conteggio a partire da DESTRA, con l'indicizzazione che inizia da -1. (Ciò segue la convenzione di come gli indici di array possono essere usati in Java e in altre lingue.)

Nota: qualsiasi comando "navd" visualizza lo stesso stack utilizzato da "pushd" e "dirs", ma lo visualizza SENZA la voce più a sinistra che verrà visualizzato "dirs" (poiché quella voce non è realmente nello stack - è la directory corrente e con "dirs" la voce più a sinistra cambia se viene inserito un comando cd). (Il comando "cd <percorso>" non influenza alcun comportamento di navd sebbene certamente influisca sul comportamento di pushd / dirs / popd. Inoltre ... Adoro usare "cd -" per "tornare" una volta a un directory da cui mi sono appena allontanato e "cd -" non ha alcun effetto sul comportamento di navd.)

Bonus: possono esserci altri 19 alias che NON ruotano la pila, ma cambiano semplicemente dir nella posizione indicata sulla pila.

 nav0 ... nav9   and   nav-1  ... nav-9

Secondo bonus: "navh" mostra i comandi navd <path> della storia, per caricare facilmente la pila con cut-n-paste. (Ognuno è elencato una sola volta anche se è nella cronologia più volte e l'elenco è ordinato. Inoltre, le voci possono essere inserite in un file $ HOME / .navhignore per impedire che quelle voci esatte compaiano nell'elenco navh.)

 navh

Tre comportamenti chiave:

1. Se si cancella lo stack e si ripete un comando specifico "navd <percorso>", quel percorso verrà inserito nello stack. Questo è quello che voglio e mi aspetto ... ma pushd non lo fa - mette in pila la directory corrente da cui stai navigando LONTANO - quindi l'effetto sullo stack è variabile (sembra imprevedibile) quando ripeti il ​​comando .

2. "navd <percorso>" non inserirà due volte lo stesso percorso nello stack.

3. "navd <percorso>" si inserisce nella cronologia dei comandi con il percorso assoluto anche se il percorso relativo è stato digitato per il comando.

Per me, gli ultimi tre comportamenti descritti rendono l'utilizzo di un comando "navd <percorso>" della cronologia molto più utile rispetto all'utilizzo di un "pushd <percorso>" della cronologia. Davvero posso riutilizzare storia per andare posti. E quando lo faccio, non "rovino" il mio stack.

Se puoi e vuoi avvolgerci il cervello, puoi alternare usando navd e pushd / dirs / popd. Entrambi usano lo stesso stack; solo con uno stile diverso. Ad esempio, usa "popd" per rimuovere elementi dallo stack "navd" o usa "dirs -c" per cancellare lo stack navd.

Pensa a pushd / dirs / popd come "come posso ripercorrere i miei passi?".
Pensa a navd come "come posso aggrapparmi a una serie di directory preferite e passare facilmente da una all'altra?".

Incolla quanto segue in una finestra di terminale e puoi immediatamente iniziare a usare navd per la durata di quella sessione di terminale. Questo è tutto il codice che c'è in questa funzione.

# Add 1 function and many related aliases for something like "pushd", called "navd". http://unix.stackexchange.com/a/229161
# Think of pushd/dirs/popd as "how do I retrace my steps?".
# Think of navd as "how do I hold on to a set of favorite directories, and easily switch between them?".
# Pseudo-code to explain each part of the "navd" bash function just below:
#              If no arguments to the 'navd' command:
#                  If stack has entries, then print the stack one-line-per-dir with each line numbered.
#                  Else, if stack is empty, automatically run the equivalent of the navh command.
#              Else (there **are** arguments to the 'navd' command):
#                  If arg is '--help' or '/?' then show help.
#                  Else    (arg is assumed to be a path to a directory)
#                      Remember the directory we are starting at
#                      Change to dir given as argument (the "arg-dir"), and do a few chores:
#                      Do not use arg-dir literally ... instead, magically put the **absolute** path we arrived at into history.
#                      Set a flag if the arg-dir is already in the stack.
#                      If the flag is set then just show the stack (on one line), else ADD to stack, ROTATE to end-of-stack, and show the stack.
#                      Change to dir we started at and then back to the arg-dir. This allows "cd -" to go back to dir we started at.
#                  End-If
#              End-If
navd () {
    if [[ $1 == '' ]]; then                             #--no arguments to the 'navd' command
        if dirs +1 >/dev/null 2>&1; then                #------stack has entries
            dirs -p | perl -ne 'print (-1+$cn++); print "$_"' | grep -v "^-1";
        else                                            #------stack is empty
            echo "The navd stack is empty. Now running 'navh' in case that's helpful. navd --help works."
            if [[ ! -f $HOME/.navhignore ]]; then echo -n ''>>$HOME/.navhignore;fi;diff --new-line-format="" --unchanged-line-format="" <(history | perl -ne "if (m/^\s*\d+\s+navd [\"~.\/]/) {s/^\s*\d+\s+/  /;s/\/$//;print}" | sort -u) <(cat $HOME/.navhignore | sort -u);echo "cat $HOME/.navhignore # (Has "`grep -c . <(sort -u $HOME/.navhignore)`" unique lines.)"
        fi
    else                                                #--(there **are** arguments to the 'navd' command)
        if [[ $1 == '--help' || $1 == '/?' ]]; then     #------arg is '--help' or '/?'
            echo "The 'navd' functionality is nothing but one bash function and a set of aliases."
            echo "It offers a different style of handy directory navigation than pushd/popd."
            echo "It uses the same 'stack' as pushd. Look in the .bashrc file for details."
            echo "    (Think of pushd/dirs/popd as 'how do I retrace my steps?'."
            echo "     Think of navd as 'how do I remember a set of favorite directories,"
            echo "     and easily switch between them?'.)"
            echo "As of 10/2015, this link has more info: http://unix.stackexchange.com/a/229161"
            echo "Here is the set of navd-related aliases. None need any parameter:"
            alias | grep 'alias nav' | cut -d= -f1 | grep -v '-' | grep -v 'navh'
            alias | grep 'alias nav' | cut -d= -f1 | grep '-'
            echo "alias navh  # The 'navh' alias has nothing to display until a 'navd <path>' is run. Short for nav-history."
            echo "---- To get started, simpy type navd followed by your favorite path. ----"
            echo "---- navd with no param shows stack. nav0 navigates to first on stack. ----"
        else                                            #------(arg is assumed to be a path to a directory)
            mypwd="$PWD"
            cd "$1" >/dev/null;
            history -s `echo "$PWD" | perl -pe 's/$ENV{'HOME'}/~/;s/ /\\\\ /g;s/^/navd /'`
            myflag=`dirs -p | perl -pe 's/\n/:/' | perl -ne '@a=split(":");$pwd=shift(@a);$flag=0;foreach (@a) {if ($_ eq $pwd) {$flag=1}};print $flag'`
            if [[ $myflag == 1 ]]; then dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"; else pushd .>/dev/null; pushd +1>/dev/null; dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"; fi
            cd "$mypwd"; cd "`dirs -l -0`"
        fi
    fi
};
# Aliases for navigating and rotating the "pushd" stack in the style of "navd":
alias navd0='cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"' # "-l" is dash-L, and expands "~" to denote the home dir. Needed inside back-ticks.
alias navd1='cd "`dirs -l +1`";pushd -n +1;cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd2='myd=$PWD;cd "`dirs -l +1`";for i in {1..2};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd3='myd=$PWD;cd "`dirs -l +1`";for i in {1..3};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd4='myd=$PWD;cd "`dirs -l +1`";for i in {1..4};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd5='myd=$PWD;cd "`dirs -l +1`";for i in {1..5};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd6='myd=$PWD;cd "`dirs -l +1`";for i in {1..6};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd7='myd=$PWD;cd "`dirs -l +1`";for i in {1..7};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd8='myd=$PWD;cd "`dirs -l +1`";for i in {1..8};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd9='myd=$PWD;cd "`dirs -l +1`";for i in {1..9};do pushd -n +1>/dev/null;cd "`dirs -l +1`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-1='cd "`dirs -l -0`";pushd -n -0>/dev/null; dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-2='myd=$PWD;cd "`dirs -l -0`";pushd -n -0>/dev/null;cd "`dirs -l -0`";pushd -n -0>/dev/null;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-3='myd=$PWD;cd "`dirs -l -0`";for i in {1..3};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-4='myd=$PWD;cd "`dirs -l -0`";for i in {1..4};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-5='myd=$PWD;cd "`dirs -l -0`";for i in {1..5};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-6='myd=$PWD;cd "`dirs -l -0`";for i in {1..6};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-7='myd=$PWD;cd "`dirs -l -0`";for i in {1..7};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-8='myd=$PWD;cd "`dirs -l -0`";for i in {1..8};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias navd-9='myd=$PWD;cd "`dirs -l -0`";for i in {1..9};do pushd -n -0>/dev/null;cd "`dirs -l -0`";done;cd "$myd";cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
# BONUS commands (beyond the 20). Aliases for navigating but NOT rotating the "navd" stack:
#      Help in remembering: "navd<#>" does more since it both changes the PWD and rotates the stack, whereas "nav<#>" does less
#            (and has one letter less) since "nav<#>" only changes the PWD. Also "navd<#>" acts like the pushd-related command: dirs
#      There is no "nav" command (with no number) so that there will be no conflict if any program called "nav" is used.
alias nav0='cd "`dirs -l +1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav1='cd "`dirs -l +2`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav2='cd "`dirs -l +3`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav3='cd "`dirs -l +4`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav4='cd "`dirs -l +5`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav5='cd "`dirs -l +6`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav6='cd "`dirs -l +7`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav7='cd "`dirs -l +8`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav8='cd "`dirs -l +9`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav9='cd "`dirs -l +10`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-1='cd "`dirs -l -0`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-2='cd "`dirs -l -1`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-3='cd "`dirs -l -2`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-4='cd "`dirs -l -3`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-5='cd "`dirs -l -4`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-6='cd "`dirs -l -5`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-7='cd "`dirs -l -6`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-8='cd "`dirs -l -7`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
alias nav-9='cd "`dirs -l -8`";dirs -p | perl -ne "chomp;s/$/ /;print unless ++\$cn==1"'
# BONUS command (beyond the 20). Alias for showing 'history' of all navd commands that add to the stack.
#                Can be used in a new terminal session to quickly add recently used dirs to the navd stack.
alias navh='if [[ ! -f $HOME/.navhignore ]]; then echo -n ''>>$HOME/.navhignore;fi;diff --new-line-format="" --unchanged-line-format="" <(history | perl -ne "if (m/^\s*\d+\s+navd [\"~.\/]/) {s/^\s*\d+\s+/  /;s/\/$//;print}" | sort -u) <(cat $HOME/.navhignore | sort -u);echo "cat $HOME/.navhignore # (Has "`grep -c . <(sort -u $HOME/.navhignore)`" unique lines.)"'
# Note: When 'navd <relative-path>' is used, then by bash-magic the navd command puts 'navd <absolute-path>' into history,
#       instead. This allows the output of "navh" to be useful regardless of the directory that is current when it is run.
#
# BONUS commands (beyond the 20). An even shorter alias for navd. An even shorter alias for navh.
alias nd='navd'
alias nh='if [[ ! -f $HOME/.navhignore ]]; then echo -n "">>$HOME/.navhignore;fi;diff --new-line-format="" --unchanged-line-format="" <(history | perl -ne "if (m/^\s*\d+\s+navd [\"~.\/]/) {s/^\s*\d+\s+/  /;s/\/$//;print}" | sort -u) <(cat $HOME/.navhignore | sort -u);echo "cat $HOME/.navhignore # (Has "`grep -c . <(sort -u $HOME/.navhignore)`" unique lines.)"'

Questi alias si basano su comandi "bash". Si presta particolare attenzione a preservare il normale comportamento di "cd -". (Molte volte uso "cd -" invece di preoccuparmi di pushd o navd - perché "cd -" è molto utile per tornare all'ultimo "posto" che eri, o passare da solo 2 posti, e funziona ovunque senza installazione.)

Naturalmente questi comandi possono essere inseriti nel file .bashrc per una loro installazione permanente.

Ecco l'ennesima soluzione che ti potrebbe piacere. L'ho scritto dopo aver giocato con la soluzione di @cjm. Utilizza il comando dialog per creare un menu di tipo ncurses dall'output di dirs. La selezione di un elemento porterà quella directory in cima allo stack e cd in esso. Questo ha il vantaggio rispetto alla diristoria di dare a ciascun emulatore di terminale il proprio buffer di cronologia delle directory e di essere un po 'più facile da installare.

Per installare: Dopo aver modificato il cd da pushd, installa la finestra di dialogo, quindi inserisci questa funzione nel tuo bashrc:

dirmenu(){
    dirIter=$(dialog --backtitle 'dirmenu' --clear --cancel-label "Exit" --menu "Please select:" 0 0 0 $(dirs) 3>&2 2>&1 1>&3)
    cmd="builtin cd ~$dirIter"
    eval $cmd
}

Mi piace un po 'meglio che eseguire dirs -v, quindi eseguire un altro comando per pop o cd nella directory che desidero. I menu di dialogo possono anche essere altamente personalizzati attraverso il suo dialogrc.

Quindi, per rispondere alla tua domanda, sì, penso che l'aliasing pushd su cd sia un'ottima idea. È improbabile che si verifichino problemi di overflow del buffer se si riavvia il computer regolarmente almeno per gli aggiornamenti. Anche se starei attento a usare cd durante lo scripting; cd in un ciclo while potrebbe potenzialmente causare problemi di overflow del buffer. Non sono sicuro di cosa controlla la dimensione del buffer dirs / pushd.