aliasing cd to pushd - est-ce une bonne idée?

Est-ce une bonne idée d'utiliser l'alias suivant:

cd() {
    pushd $1;
}

en bash?

Je pense que cela serait très utile, car je peux alors utiliser une série de popds au lieu d’une cd -seule fois.

Y a-t-il des cas où cela pourrait être un problème?

Personnellement, je les ai dans mon panier et les utilise tout le temps:

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'

Vous pouvez ensuite naviguer sur la ligne de commande un peu comme un navigateur. cdchange le répertoire. backva au répertoire précédent que vous avez cdédité. Et flipse déplacera entre les répertoires actuel et précédent sans les extraire de la pile de répertoires. Globalement, cela fonctionne très bien.

Le seul problème que je connaisse est le fait qu’il s’agit alors d’un ensemble de commandes auxquelles je suis complètement habitué, mais qui n’existent pas sur la machine de quelqu'un d’autre. Donc, si je dois utiliser la machine de quelqu'un d'autre, cela peut être un peu frustrant. Si vous avez l'habitude d'utiliser pushdet popddirectement, vous n'avez pas ce problème. Et bien que si vous dites simplement que cdnon popd, vous n'aurez pas le problème de backne pas exister, vous aurez toujours le problème qui cdne fait pas tout à fait ce que vous attendiez sur d'autres machines.

Je tiens toutefois à souligner que votre implémentation particulière de cdne fonctionne pas vraiment cddans le sens où la normale cdira elle-même vers votre répertoire personnel, mais pas le vôtre. La version que j'ai ici n'a pas ce problème. Mine s’ajoute également DIRSTACKau recto de l’ dirsimpression, mais c’est plus une question de goût personnel que d’autre chose.

Donc, comme je l'ai dit, j'utilise ces alias tout le temps et je n'ai aucun problème avec eux. C'est juste que ça peut être un peu frustrant de devoir utiliser une autre machine et ensuite de la trouver pas là (ce qui ne devrait pas être surprenant, mais c'est une de ces choses que vous utilisez si souvent que vous n'y pensez pas de sorte qu’ils ne fonctionnent pas comme vous en avez l'habitude peut encore être surprenant).

Ce n'est pas une réponse directe à la question, mais je suis tombé amoureux de la fenêtre d'historique des répertoires dans 4DOS. À tel point que j'ai écrit ma propre version pour Linux (et Cygwin). Je n'ai jamais eu l'idée d'en faire un utilitaire facile à installer, mais si vous connaissez bien une invite Bash, son exécution ne devrait pas être si difficile. Votre question m'a inspiré de le mettre dans un dépôt Git et de le télécharger sur GitHub: dirhistory .

En gros, il s’agit d’un démon qui collecte les modifications de répertoires de tous vos shells et d’un programme Cdk qui affiche l’historique et vous permet de choisir n’importe quel répertoire dans lequel basculer (pour que vous ne soyez pas limité à une pile). Je le trouve vraiment utile et le lie à Ctrl-PageUp, tout comme 4DOS. (J'ai même corrigé PuTTY pour qu'il envoie Ctrl-PageUp à Bash.)

Pour moi, pushd / popd / dirs est utile, mais manque. J'ai donc créé un «wrapper» autour de ceux-ci appelé «navd», implémenté comme un ensemble de 20 alias. (L'une d'entre elles est une fonction, en réalité.) Le code est ci-dessous, mais voici d'abord une brève explication. (Une bonne chose à propos de "navd" et du travail sur les machines d'autres personnes: il existe une forme "sans installation" pour l'exécuter: en tant qu'option d'installation, vous pouvez simplement coller les commandes qui implémentent "navd" à l'invite bash et pendant la durée de cette session bash pour cette machine, navd fonctionnera. Cela donne une empreinte de pied nulle dans le système de fichiers, mais il s’agit d’une installation temporaire. Mettez ces commandes dans .bashrc pour une "vraie" installation, de cours.)

Fonctionnalités:

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**

N'importe laquelle des dix-neuf commandes navd <N> fait pivoter la pile de sorte que le répertoire qui devient le répertoire en cours s'affiche également à l'avant de la pile. Les valeurs <N> positives trouvent un répertoire comptant à partir de la gauche, l’indexation commençant à zéro. Les valeurs <N> négatives trouvent un répertoire à partir de la droite, avec une indexation commençant à -1. (Ceci suit la convention sur la manière dont les tableaux-index peuvent être utilisés en Java et dans d'autres langages.)

Remarque: Toute commande "navd" affiche la même pile que "pushd" et "dirs" - mais l'affiche SANS l' entrée la plus à gauche que "dirs" afficherait (cette entrée n'étant pas vraiment sur la pile - elle le répertoire en cours et avec "dirs" que l' entrée la plus à gauche change si une commande cd est entrée). (La commande "cd <chemin>" n'affecte pas le comportement de navd bien qu'elle affecte certainement le comportement de pushd / dirs / popd. Aussi ... J'aime utiliser "cd -" pour "revenir" une fois à une répertoire que je viens de naviguer, et "cd -" n’affecte pas non plus le comportement de navd.)

Bonus: Il peut y avoir 19 autres alias ne faisant PAS pivoter la pile, mais se contentant de changer dir à l'endroit indiqué sur la pile.

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

2e bonus: "navh" affiche les commandes navd <chemin> de l'historique, pour charger facilement la pile avec cut-n-paste. (Chaque élément est répertorié une seule fois, même s'il figure plusieurs fois dans l'historique, et la liste est triée. De plus, les entrées peuvent être placées dans un fichier $ HOME / .navhignore pour empêcher ces entrées exactes d'apparaître dans la liste navh.)

 navh

Trois comportements clés:

1. Si vous effacez la pile et répétez une commande spécifique "navd <chemin>", ce chemin ira sur la pile. C'est ce que je veux et ce à quoi je m'attends ... mais pushd ne le fait pas - il met le répertoire actuel sur lequel vous naviguez, AWAY FROM, sur la pile - de sorte que l'effet sur la pile est variable (semble imprévisible) lorsque vous répétez la commande .

2. "navd <chemin>" ne mettra pas deux fois le même chemin sur la pile.

3. "navd <chemin>" se met dans l'historique des commandes avec le chemin absolu même si le chemin relatif a été saisi pour la commande.

Pour moi, les trois derniers comportements décrits rendent l'utilisation d'une commande "navd <chemin>" de l'historique beaucoup plus utile que l'utilisation d'un "pushd <chemin>" de l'historique. Je peux vraiment réutiliser l'histoire pour me déplacer . Et quand je le fais, je ne "gâte" pas mon stack.

Si vous le pouvez et que vous souhaitez envelopper votre cerveau, vous pouvez utiliser navd ou pushd / dirs / popd. Les deux utilisent la même pile; juste avec un style différent. Par exemple, utilisez "popd" pour supprimer des éléments de la pile "navd" ou utilisez "dirs -c" pour vider la pile de navd.

Pensez à pushd / dirs / popd comme "comment revenir sur mes pas?".
Pensez à navd comme "comment puis-je conserver un ensemble de répertoires favoris et basculer facilement entre eux?".

Collez le texte suivant dans une fenêtre de terminal et vous pouvez immédiatement commencer à utiliser navd pendant la durée de cette session. C'est tout le code qui existe pour cette fonctionnalité.

# 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.)"'

Ces alias sont basés sur des commandes "bash". Un soin particulier est pris pour préserver le comportement normal de "cd -". (Souvent, j'utilise "cd -" au lieu de m'embêter avec pushd ou navd - parce que "cd -" est très pratique pour revenir à la dernière "place" où vous étiez, ou pour basculer entre seulement 2 places et cela fonctionne partout sans installation.)

Bien entendu, ces commandes peuvent être placées dans le fichier .bashrc pour une installation plus permanente de celles-ci.

Voici encore une autre solution qui pourrait vous plaire. J'ai écrit ceci après avoir joué avec la solution de @cjm. Il utilise la commande dialog pour créer un menu de type ncurses à partir de la sortie de dirs. La sélection d'un élément amènera ce répertoire en haut de la pile et y sera inséré. Cela a l'avantage sur dirhistory de donner à chaque émulateur de terminal son propre tampon d'historique de répertoires, et d'être un peu plus facile à installer.

Pour installer: Une fois que vous avez assigné alias cd à pushd, installez la boîte de dialogue, puis mettez cette fonction dans votre base:

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
}

J'aime cela un peu mieux que d'exécuter dirs -v, puis d'exécuter une autre commande pour faire apparaître ou cd dans le répertoire que je veux. Les menus de dialogue peuvent également être hautement personnalisés via sa boîte de dialogue.

Donc, pour répondre à votre question, oui, je pense que l'aliasing pushd to cd est une excellente idée. Il est peu probable que vous rencontriez des problèmes de débordement de mémoire tampon si vous redémarrez votre ordinateur régulièrement, du moins pour les mises à jour. Bien que je sois prudent en utilisant le cd lors de la rédaction du script; Un cd dans une boucle while pourrait potentiellement causer des problèmes de débordement de mémoire tampon. Je ne sais pas ce qui contrôle la taille du tampon dirs / pushd.