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

En outre, cd ..cela nous amènera à un niveau du répertoire de travail actuel.

Mais, lorsque nous avons un /home/thina/teams/td/tech/app/release/apksrépertoire imbriqué avec un chemin plus long , il est fatiguant de simplement aller dans le dossier apkset il est également difficile de revenir à un autre nœud, par exemple ici /home/thina/teams.

Existe-t-il un moyen de sauter la saisie de cdet cd ..? J'utilise Ubuntu 16.04.

Il y a pushdet 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 pushdet help popdpour plus d'options. Il n'y a pas la manpage, parce que pushdet popdsont intégrés dans les commandes bash.

En plus des très bonnes réponses déjà fournies, voici quelques conseils pour une utilisation cdefficace.

• cd - vous ramènera au dernier répertoire dans lequel vous vous trouviez.
• cd ../../..vous fera monter de 3 niveaux à la fois, vous pouvez utiliser la ..notation enchaînée pour «remonter» autant de répertoires que vous le souhaitez.
• Si vous n'êtes pas sûr du nombre de fois que vous souhaitez remonter, utilisez cd .., puis utilisez l'historique bash en appuyant sur la touche fléchée pour réutiliser la commande.
• Utilisez ~pour remplacer le répertoire personnel des utilisateurs actuels, si vous êtes connecté en tant qu'utilisateur thina, cd ~/teamsvous amènera à/home/thina/teams
• Utilisez l'auto-complétion Bash pour les chemins, la touche de tabulation terminera une section d'un chemin dans la cdcommande, si vous tapez une partie d'un segment de chemin suivi par Tab, ce segment sera terminé s'il n'y a pas d'autre choix valide. Par exemple, si vous aviez tapé cd /home/thina/teams/td/tpuis appuyé Tab, le mot tech serait rempli pour vous, tant qu'il n'y aurait pas d'autres fichiers ou répertoires dans le répertoire td commençant par la lettre t.

Utiliser ces conseils ensemble peut rendre la traversée des répertoires cdbeaucoup moins pénible.

Pour remonter dans l'arborescence plusieurs niveaux à la fois, vous pouvez utiliser la fonction suivante (merci à 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 upsans argument est équivalent à en cd ..raison de ${1:-1}quels substituts $1lorsqu'ils sont définis et 1sinon
• la définition de OLDPWD après la dernière cd ..vise à conserver le cd -comportement habituel .

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 faire juste cd "$APKS"

Quant à monter x nombre de répertoires, j'ai cette fonction 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/teamsde apksvous faire

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 jamais autant utilisée est la bookmarkfonction.

Voici comment cela fonctionne: il enregistre votre dossier actuel dans un fichier, puis vous pouvez cd dans un répertoire spécifique en fonction du numéro de ligne dans 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
}

Mise à jour: Il y a un encore plus puissant outil que autojump: fasd, mais je ne suis pas familier avec elle.

Je suis surpris que personne n'ait autojumpencore mentionné qui

fonctionne en maintenant une base de données des répertoires que vous utilisez le plus à partir de la ligne de commande (les répertoires doivent être visités en premier 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 cd quelques fois dans un répertoire (même une seule fois suffit):

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

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

j apks

Notez que l'utilisation de n'importe quelle partie du chemin fonctionne, tant qu'il est le plus élevé de la liste: vous j appamènera également à .../apkssi vous y êtes allé plus de fois .../app.

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

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

Vous a déménagé à apksdans td, plutôt que d' une autre apkssous un arbre différent.

Alias

J'ai une liste des répertoires fréquemment utilisés directement disponibles via alias. Cela inclut également des raccourcis pour les répertoires de 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 de trois niveaux, je tape ....<Enter>et je suis là!

Activez l' autocdoption ( shopt -s autocd) pour ne pas avoir à 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 -, ce qui revient au répertoire de travail précédent. L' autocdoption ne fait pas- fonctionner 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 internes pushdet popd. Le builtin dirsrépertorie la pile de répertoires (je trouvedirs -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 CDPATHvariable. Mais sachez que je n'ai jamais trouvé de situation oùCDPATH vraiment pratique.

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

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

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

Il se souvient des répertoires dans lesquels vous cd, 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 cd'ed dans un répertoire au moins une fois, vous pouvez faire par exemple au lieu de:

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

Faites juste:

$ z sub

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

J'ai également défini une fonction comme celle-ci, qui essaie d'abord 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 se trouve dans le répertoire en cours ou si un chemin d'accès complet valide est donné, il y aura simplement un cd, mais sinon, il essaiera de trouver une correspondance dans la base de données et de y cd. Cela élimine la (petite) douleur d'avoir parfois à utiliser cd (pour former la base de données, aller dans un dossier auquel vous n'êtes jamais allé auparavant) et parfois de vous souvenir d'utiliser z, le cas échéant.

Trois autres options que je trouve bien fonctionner (bien que je puisse à l'avenir en utiliser pushddavantage, je viens juste de l'apprendre):

• Organisez vos chemins afin que vous n'ayez pas besoin d'accéder à cddes répertoires profondément imbriqués en premier lieu, ou plutôt: de sorte que les emplacements que vous devez souvent visiter soient à portée de main. Pour ce faire, utilisez les liens symboliques : conservez les répertoires explicites et bien hiérarchisés tels qu'ils sont, mais créez un lien d'accès rapide à votre convenance.

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

  Ensuite, au lieu de taper le long chemin vers cd, utilisez simplement cd ~/apks, et cd ../teams(ou, dans cet exemple préférable ~/teams), pour revenir.

• N'utilisez pas un seul shell et un CD dans les deux sens entre les chemins, mais gardez un shell en cours d'exécution pour chacun des chemins dans 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 ne faire que quelques commandes dans un certain répertoire: pour revenir, fermez simplement l'onglet du terminal!
  • (IMO pas vraiment sensé, mais pour être complet :) utilisez un terminal multiplexeur comme tmux.

  • Il suffit de lancer une action dans une commande à usage unique qui se trouve cddans le dossier, y fait une chose et redonne 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 ../../../../..

    faites simplement 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'

• Pas cd du tout , mais exécutez simplement la commande directement depuis votre répertoire personnel. Les extensions de corset 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}

Pushd et Popd

Les commandes pushdet popdsont mes favoris. La pushdcommande se souviendra des répertoires que vous avez visités, visibles avec la commande dirs, et lorsque vous êtes prêt à sauter en arrière, utilisezpopd pour revenir.

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

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 consultés consiste simplement à aliaser les commandes cdou pushd. 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 cd***et sd***alias à portée de main pour des choses comme Desktop, Documents, Music, Downloads, etc. et il est très pratique!

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 la base de données suivante:

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

  "z in"entrerait /home/user/mail/inboxcomme entrée pondérée la plus élevée. Cependant, vous pouvez passer 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, l'utilisation z -iaffichera 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. entrée 3 vers cd vers /home/data/software. Et si vous appuyez simplement sur ENTRÉE et n'entrez rien, il quittera et restera où vous étiez.

  z.luaprend également en charge la fzfsélection interactive ou la complétion d'arguments:

  achèvement avec fzf

• retour rapide au parent sans taper cd ../../..:

  Une 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) : cddans la racine du projet, la racine du projet le répertoire parent le plus proche avec .git/ .hg/ .svndedans.

  • (Un argument) : cddans le parent le plus proche commençant par mot-clé, sinon trouver, aller au parent contenant le mot-clé.

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

  ...

  Commençons par alias z -bpour 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 puisse répondre à vos besoins.

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

• Si vous tapez cd flèche droite, il répète le cd le plus récent.
• En utilisant cd flèche vers le haut flèche droite, il répète le deuxième CD le plus récent.
• 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 à ~ / f, donc je peux cd ~ / f / x pour accéder à ~ / foo / bar / baz / experimental-data.

J'ai longtemps utilisé des alias pour les répertoires fréquemment consultés.

J'ai également une fonction bash appelée ccb (abréviation de create cd bat file - cela provient de dos / windows où le script shell .bat ccb.bat créerait un autre fichier .bat pour sauter dans le répertoire en cours) qui crée / ajoute des alias (dans le fichier .bash_aliases) dans le répertoire courant.

par exemple: $ ccb myfav créera un alias dans le répertoire courant avec un alias myfav dans le fichier .bash_aliases et source le fichier .bashrc afin que l'alias soit immédiatement disponible.

Je viens de trouver une nouvelle solution. C'est une fonction bash

## USAGE : lj <your_dir>
### lj -- short for LongJump -- (kinda similar to a C function which would jump to an address outside of your current function)
function lj() {
        pushd `find . -type d -name $1 -print | head -n 1`
}

$ lj deeply_nested_dir_name

cela n'a pas besoin d'apprendre quoi que ce soit de l'utilisation précédente. Le problème que cela pourrait ne pas résoudre est le suivant: s'il y a plus de 1 répertoires nommés "deep_nested_dir_name" dans l'arborescence des sous-répertoires, alors il sautera au premier répertoire trouvé par find.

De plus, cette solution ne pourra pas accéder à une autre arborescence de répertoires.

entre les alias codés en dur et les alias générés et cette nouvelle fonction lj (), la plupart de mes besoins sont pris en charge.

Voici ma fonction bash ccb () pour tous ceux qui veulent l'utiliser

function ccb() {
        foo=$PWD
        echo "" >> ~/.bash_aliases
        echo "alias $1='pushd $foo > /dev/null'" >> ~/.bash_aliases
        source ~/.bashrc
}