web-dev-qa-db-fra.com

Comment passer rapidement dans des répertoires profondément imbriqués via CLI?

Nous savons que l'utilisation de cd <directory> ouvrira le répertoire, s'il existe!

De plus, cd .. nous fera remonter d’un niveau dans le répertoire de travail actuel.

Mais, lorsque nous avons un répertoire imbriqué avec un chemin plus long tel que /home/thina/teams/td/tech/app/release/apks, il est fatiguant d’aller simplement dans le dossier apks et il est également difficile de revenir à un autre nœud, disons ici /home/thina/teams.

Existe-t-il un moyen d'éviter la saisie de cd et cd ..? J'utilise Ubuntu 16.04.

command-linebashdirectory
16
gsthina

Il y a pushd et popd:

pushd /home/thina/teams/td/tech/app/release/apks
# current directory now /home/thina/teams/td/tech/app/release/apks
popd
# current directory now what it was before pushd command

Essayez help pushd et help popd pour plus d'options. Il n'y a pas de page man, car pushd et popd sont des commandes intégrées bash.

29
Jos

En plus des très bonnes réponses déjà fournies, voici quelques conseils pour bien utiliser cd.

  • cd - vous ramènera au dernier répertoire dans lequel vous vous trouviez.
  • cd ../../.. vous mènera sur 3 niveaux à la fois, vous pouvez utiliser la notation .. enchaînée pour "remonter" autant de répertoires que vous le souhaitez.
  • Si vous ne savez pas combien de fois vous souhaitez monter, utilisez cd .., puis utilisez bash history en appuyant sur la touche fléchée pour utiliser la commande à nouveau.
  • Utilisez ~ pour remplacer le répertoire de base des utilisateurs actuels. Si vous êtes connecté en tant qu'utilisateur thina, cd ~/teams, vous mènera à /home/thina/teams.
  • Utilisez l'auto-complétion Bash pour les chemins, la touche de tabulation complétera une section d'un chemin dans la commande cd, si vous tapez une partie d'un segment de chemin suivi de Tab, ce segment sera complété s’il n’ya pas d’autre choix valable. Par exemple, si vous avez tapé cd /home/thina/teams/td/t puis appuyé sur Tab, la technologie Word serait remplie pour vous, tant qu’il n’y avait pas d’autres fichiers ou répertoires dans le répertoire td commençant par la lettre t.

L'utilisation conjointe de ces astuces peut rendre la traversée de répertoires avec cd beaucoup moins pénible.

15
Arronical

Pour monter dans l’arbre plusieurs niveaux à la fois, vous pouvez utiliser la fonction suivante (grâce à muru pour la version améliorée):

up ()
{
    local old="$PWD"
    for i in $(seq "${1:-1}"); do
        cd ..
    done
    OLDPWD="$old"
}

Ensuite, vous pouvez faire:

$ pwd
/home/thina/teams/td/tech/app/release/apks
$ up 5
cd'ing into /home/thina/teams

Aditionellement:

  • appeler up sans argument équivaut à cd .. en raison de ${1:-1} qui remplace $1 lorsqu'il est défini et 1 sinon
  • définir OLDPWD après le dernier cd .. a pour but de préserver le comportement habituel cd -.
8
parras

Pour les noms de répertoire longs, utilisez des variables avec un chemin complet. Par exemple,

APKS="/home/thina/teams/td/tech/app/release/apks"

Ensuite, vous pouvez juste faire cd "$APKS"

Pour monter x nombre de répertoires, cette fonction est définie dans mon .bashrc

goup() # go up x number of dirs
{
  num=$1
  while [ $num -ne 0  ];do
    cd ..
    num=$( expr $num - 1   )
  done
}

Pour revenir à /home/thina/teams à partir de apks vous feriez

goup  6

Voici un exemple d'utilisation:

$> pwd
/sys/class/backlight/intel_backlight
$> goup 3
$> pwd
/sys
$>

Une autre petite fonction que j’ai imaginée, mais que je n’ai jamais utilisée autant, est la fonction bookmark.

Voici comment cela fonctionne: il enregistre votre dossier actuel dans un fichier, puis vous pouvez accéder à un répertoire spécifique en fonction du numéro de ligne de ce fichier. Exemple:

$> cd /etc/lightdm
$> bookmark
$> cat ~/.dirsbookmarks                                                                                                  
/home/xieerqi
/sys/class/backlight
/etc/lightdm
$> cd $( awk 'NR==2' ~/.dirsbookmarks  )                                                                                 
$> pwd
/sys/class/backlight

Et voici la fonction elle-même:

bookmark()
{ # bookmarks current dir
  pwd >> $HOME/.dirsbookmarks
}
6
Sergiy Kolodyazhnyy

UPDATE: Il existe un outil encore plus puissant que autojump: fasd , mais je ne le connais pas bien.

Je suis surpris que personne n’a mentionné autojump encore

fonctionne en maintenant une base de données des répertoires que vous utilisez le plus souvent à partir de la ligne de commande (les répertoires doivent d'abord être visités avant de pouvoir y accéder).

C'est essentiellement ce que @graipher a construit, avec quelques options supplémentaires.

Comme je l'ai mentionné sur une autre question:

Après avoir accédé plusieurs fois à un répertoire (même une fois suffit):

cd /home/thina/teams/td/tech/app/release/apks

vous pouvez utiliser le raccourci j pour vous y rendre rapidement, quel que soit le répertoire dans lequel vous vous trouvez:

j apks

Notez que l’utilisation de n’importe quelle partie du chemin fonctionne tant que c’est le plus haut de la liste: j app vous mènera également à .../apks si vous y êtes allé plus de fois que .../app.

Je le recommanderais plutôt que d'avoir votre propre script car il est bien entretenu, distribué pour Ubuntu et possède d'autres fonctionnalités intéressantes, telles que et saute à l'enfant :

.../td/tech $ jc apk
.../release/apks $

Vous a déplacé vers apks dans td, plutôt que vers un autre apks sous un autre arbre.

4
Ciprian Tomoiagă

Activez l'option autocd (shopt -s autocd), de sorte que vous n'ayez pas à taper cd. Par exemple, vous avez juste besoin de la commande à deux caractères .. pour accéder au répertoire parent.

Si vous naviguez entre deux répertoires, vous pouvez basculer entre eux avec cd -, qui passe au répertoire de travail précédent. L'option autocd ne permet pas à - d'exécuter cd - mais vous pouvez définir un alias ou une fonction pour cela.

Vous pouvez mémoriser des répertoires sur une pile avec les commandes intégrées pushd et popd . La fonction intégrée dirs répertorie la pile de répertoires (je trouve dirs -v plus lisible).

Si vous passez fréquemment aux sous-répertoires d'un répertoire particulier et que ces sous-répertoires ont un nom plutôt unique, ajoutez-les à la variable CDPATH . Cependant, sachez que je n’ai jamais trouvé de situation où CDPATH était réellement pratique.

Vous pouvez définir une variable sur un nom de répertoire, puis la modifier avec $foo.

ZshInstall zsh a quelques fonctionnalités intéressantes que bash n’a pas. Certains peuvent être imités en écrivant des fonctions qui font le même travail. En particulier, la forme à deux arguments de cd vous permet de passer facilement à un autre répertoire portant un nom similaire, par exemple. à partir de /home/thina/teams/td/tech/app/release/apks/com.acme/v1, l'exécution de cd release beta passe à /home/thina/teams/td/tech/app/beta/apks/com.acme/v1.

4
Gilles

Alias

J'ai une liste de répertoires fréquemment utilisés directement disponibles via un alias. Cela inclut également des raccourcis pour les répertoires dans la hiérarchie.

alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'
alias cdwork=/home/knub/Repositories/work
alias cduni=/home/knub/University

Maintenant, quand je veux monter trois niveaux, je tape simplement ....<Enter> et me voilà!

3
knub

Comme j'ai déjà répondu à une question liée sur UnixSE, j'utilise un script appelé z [github] pour cela.

Il mémorise les répertoires auxquels vous avez accédé, les classe en fonction de la fréquence (fréquence + récence) et vous permet de passer à l’un des chemins mémorisés en utilisant une partie de son nom.

Après avoir accédé à un répertoire au moins une fois, vous pouvez faire par exemple au lieu de:

$ cd ~user/very/long/path/with/many/subfolders/

Il suffit de faire:

$ z sub

ce qui fonctionnera, en utilisant une correspondance de nom partielle (en supposant que vous n’ayez pas d’autre répertoire contenant dans son chemin le terme sub et qui a une fréquence plus élevée).

J'ai aussi défini une fonction comme celle-ci, qui commence par essayer un cd normal et, si cela échoue, utilise z:

function cd() {
    builtin cd "$1" 2> /dev/null || z "$1" || (echo "cd: File or Directory not found: $1" >&2 && exit 1)
}

Cela vous donne le meilleur des deux. Si le dossier est dans le répertoire en cours ou si un chemin complet est donné, il sera simplement cd, mais sinon, il tentera de trouver une correspondance dans la base de données et y sera cd. Cela supprime la (petite) douleur de devoir parfois utiliser cd (pour former la base de données, accéder à un dossier dans lequel vous n’avez jamais été auparavant) et de penser parfois à utiliser z, le cas échéant.

2
Graipher

Pushd et Popd

Les commandes pushdet popdsont mes favoris. La commande pushdretiendra les répertoires visités, visualisables à l'aide de la commande dirset, lorsque vous êtes prêt à revenir en arrière, utilisez popdpour revenir.

Voici un exemple d'utilisation de fonctions bash et d'alias:

sd ()
{
    pushd "$1" > /dev/null
}

po ()
{
    popd
}

alias d='dirs'

J'utilise constamment un mélange de ces commandes de différentes manières.

Alias

Une autre option pour les répertoires fréquemment utilisés consiste à simplement aliaser les commandes cdou pushdname__. Donc, en utilisant les exemples de votre message:

alias cdapks='cd /home/thina/teams/td/tech/app/release/apks'
alias cdteams='cd /home/thina/teams'

Combinaison

Combinez les deux idées et vous pouvez même avoir ceci:

alias sdapks='sd /home/thina/teams/td/tech/app/release/apks'
alias sdteams='sd /home/thina/teams'

Ce qui vous donne alors beaucoup de flexibilité pour parcourir les répertoires. Je garde les alias cd*** et sd*** pour des choses comme Desktopname__, Documentsname__, Musicname__, Downloadsname__, etc., et c'est très pratique!

1
tniles

Trois autres options que je trouve qui fonctionnent bien (bien que je puisse utiliser à l'avenir pushd plus, je viens juste d'apprendre à ce sujet):

  • Arrangez vos chemins afin que vous n'ayez pas besoin de cd dans des répertoires profondément imbriqués en premier lieu, ou plutôt: les emplacements que vous devez souvent visiter se trouvent donc tout à fait à portée de main. Pour y parvenir, utilisez des liens symboliques : conservez les répertoires explicites, bien hiérarchisés, mais créez un lien d'accès rapide pour votre convenance. .

    ln -s ~/teams/td/tech/app/release/apks ~/apks

    Ensuite, au lieu de saisir le long chemin d'accès à cd, utilisez simplement cd ~/apks et cd ../teams (ou, dans cet exemple, préférable, ~/teams) pour revenir en arrière.

  • N'utilisez pas un seul shell ou un seul CD-ROM entre les chemins, mais maintenez-le en marche pour chacun des chemins sur lesquels vous devez travailler. Il existe plusieurs niveaux pour réaliser ce multitâche:

    • Utilisez plusieurs fenêtres de terminal. Fonctionne mieux si les fenêtres vivent sur différents espaces de travail .
    • Utilisez plusieurs onglets dans une seule fenêtre. Ceci est particulièrement bien adapté pour n’exécuter que quelques commandes dans certains répertoires: pour revenir en arrière, fermez simplement l’onglet du terminal!
    • (Pas vraiment raisonnable IMO, mais pour être complet :) utilisez un multiplexeur de terminaux comme tmux.

    • Lancez simplement une action dans une commande à usage unique qui cds se trouve dans le dossier, fait une chose et restitue immédiatement le contrôle sur le dossier d'origine: au lieu de

      $ cd /home/thina/teams/td/tech/app/release/apks
$ some_command this_file_here
$ cd ../../../../..

      il suffit de faire le one-liner

      $ (cd ~/teams/td/tech/app/release/apks; some_command this_file_here)

      ou équivalent

      $ sh -c 'cd ~/teams/td/tech/app/release/apks
> some_command this_file_here'

  • Ne pas cd du tout , mais simplement exécuter la commande directement à partir de votre répertoire personnel. Les développements d'expansion peuvent aider beaucoup ici: Au lieu de

    $ cd /home/thina/teams/td/tech/app/release/apks
$ some_command this_file_here other_file_also_apks
$ cd ../../../../..

    tu peux faire

    $ some_command ~/teams/td/tech/app/release/apks/{this_file_here,other_file_also_apks}
1
leftaroundabout

le poisson a plusieurs installations de Nice pour se déplacer rapidement.

  • Si vous tapez c d flèche droite entrée, le cd le plus récent est répété.
  • En utilisant c d flèche haut flèche droite, entrez, le deuxième disque le plus récent est répété.
  • Etc.
  • Il a prevd et nextd, qui sont souvent plus faciles à utiliser que pushd et popd.

De plus, je garde mes répertoires préférés liés par un lien symbolique à ~/f, afin de pouvoir cd ~/f/x pour accéder à ~/foo/bar/baz/experimental-data.

0
Theodore Norvell

Essayez z.lua - Une nouvelle commande cd qui vous aide à naviguer plus rapidement en apprenant vos habitudes.

  • cd dans un répertoire contient foo:

    z foo

  • cd dans un répertoire se termine par foo:

    z foo$

  • utiliser plusieurs arguments:

    En supposant que la base de données suivante:

    10   /home/user/work/inbox
30   /home/user/mail/inbox

    "z in" serait inséré dans /home/user/mail/inbox en tant qu'entrée pondérée la plus élevée. Cependant, vous pouvez transmettre plusieurs arguments à z.lua pour préférer une entrée différente. Dans l'exemple ci-dessus, "z w in" changerait alors de répertoire en /home/user/work/inbox.

  • cd avec sélection interactive:

    Lorsque plusieurs correspondances sont trouvées, utiliser z -i affichera une liste:

    $ z -i soft
3:  0.25        /home/data/software
2:  3.75        /home/skywind/tmp/comma/software
1:  21          /home/skywind/software
> {CURSOR}

    Ensuite, vous pouvez entrer le numéro et choisir où aller avant le cd réel. par exemple. saisissez 3 sur cd dans /home/data/software. Et si vous appuyez simplement sur ENTRÉE sans rien entrer, cela arrêtera simplement et restera où vous étiez.

    z.lua supporte également fzf pour la sélection interactive ou la complétion d'arguments:

    complétion avec fzf

  • revenir rapidement au parent sans taper cd ../../..:

    La nouvelle option "-b" peut rapidement revenir à un répertoire parent spécifique dans bash au lieu de taper "cd ../../ .." de manière redondante:

    • (aucun argument) : cd dans la racine du projet, le projet racine le répertoire parent le plus proche dans lequel se trouve .git/.hg/.svn.

    • (Un argument) : cd dans le parent le plus proche commençant par mot-clé. Si vous ne trouvez pas, accédez au parent contenant le mot-clé.

    • (Deux arguments) : remplace la première valeur par la seconde (dans le chemin actuel).

    ...

    Commençons par aliaser z -b en zb:

    # go all the way up to the project root (in this case, the one that has .git in it)
~/github/lorem/src/public$ zb
  => cd ~/github/lorem

# cd into to the first parent directory named g*
~/github/vimium/src/public$ zb g
  => cd ~/github

# substitute jekyll with ghost
~/github/jekyll/test$ zb jekyll ghost
  => cd ~/github/ghost/test

Je souhaite que cela corresponde à vos besoins.

0
skywind3000