Navegación rápida de directorios en el shell bash

Me gustaría cambiar frecuentemente entre directorios que están en rutas totalmente no relacionadas, por ejemplo /Project/Warnest/docs/y ~/Dropbox/Projects/ds/test/.

Pero no quiero escribir cd /[full-path]/todo el tiempo. ¿Hay algún comando de acceso directo para cambiar a directorios previamente trabajados?

Una solución que se me ocurre es agregar variables de entorno a mi bash .profilepara los directorios de uso frecuente y cdpara que usen esas variables.

¿Pero hay alguna otra solución para esto?

Si solo está cambiando entre dos directorios, puede usar cd -para ir y venir.

Hay una variable de shell CDPATHen bashy kshy cdpathen zsh:

CDPATH    The search path for the cd command. This is a colon-separated
          list of directories in which the shell looks for destination
          directories specified by the cd command.

Entonces puede configurar en su ~ / .bashrc:

export CDPATH=/Project/Warnest:~/Dropbox/Projects/ds

Luego cd docsy cd testlo llevará al primer directorio que se encuentre. (Quiero decir, incluso si un directorio con el mismo nombre existirá en el directorio actual, CDPATHaún será consultado. Si CDPATHcontendrá más directorios con subdirectorios con el nombre dado, se usará el primero).

Algo más que podrías probar es una herramienta llamada autojump . Mantiene una base de datos de llamadas a su alias ( jpor defecto) e intenta tomar decisiones inteligentes sobre dónde desea ir. Por ejemplo, si escribe con frecuencia:

j ~/Pictures

Puede usar lo siguiente para llegar en un apuro:

j Pic

Está disponible para Debian y Ubuntu, y se incluye por usuario en ~/.bashrco ~/.zshrcpor defecto.

Si se trata de una pequeña cantidad de directorios, puede usar pushdpara rotar entre ellos:

# starting point
$ pwd
/Project/Warnest/docs
# add second dir and change to it
$ pushd ~/Dropbox/Projects/ds/test
~/Dropbox/Projects/ds/test /Project/Warnest/docs
# prove we're in the right place
$ pwd
~/Dropbox/Projects/ds/test
# swap directories
$ pushd
/Project/Warnest/docs ~/Dropbox/Projects/ds/test

a diferencia cd -, puede usar esto con más de dos directorios

Siguiendo la sugerencia de Noach, ahora estoy usando esto:

function pd()
{
    if [[ $# -ge 1 ]];
    then
        choice="$1"
    else
        dirs -v
        echo -n "? "
        read choice
    fi
    if [[ -n $choice ]];
    then
        declare -i cnum="$choice"
        if [[ $cnum != $choice ]];
        then #choice is not numeric
            choice=$(dirs -v | grep $choice | tail -1 | awk '{print $1}')
            cnum="$choice"
            if [[ -z $choice || $cnum != $choice ]];
            then
                echo "$choice not found"
                return
            fi
        fi
        choice="+$choice"
    fi
    pushd $choice
}

ejemplo de uso:

# same as pushd +1
$ pd 1

# show a prompt, choose by number
$ pd
 0 ~/Dropbox/Projects/ds/test
 1 /Project/Warnest/docs
 2 /tmp
? 2
/tmp ~/Dropbox/Projects/ds/test /Project/Warnest/docs

# or choose by substring match
$ pd
 0 /tmp
 1 ~/Dropbox/Projects/ds/test
 2 /Project/Warnest/docs
? doc
/Project/Warnest/docs /tmp ~/Dropbox/Projects/ds/test

# substring without prompt
$ pd test
~/Dropbox/Projects/ds/test /Project/Warnest/docs /tmp

Obviamente, esto es solo para rotar a través de la pila y no maneja agregar nuevas rutas; tal vez debería cambiarle el nombre.

Yo uso aliasen bashrc para hacer esos cds.
como:

alias wdoc='cd ~/Project/Warnest/docs'
alias dstest='cd ~/Dropbox/Projects/ds/test'

Encontré un script (típicamente llamado acd_funch.sh) que resolvió este problema por mí. Con esto, puede escribir cd --para ver los últimos 10 directorios que ha utilizado. Se verá más o menos así:

0  ~/Documents/onedir
1  ~/Music/anotherdir
2  ~/Music/thirddir
3  ~/etc/etc

Para ir a ~/Music/thirddirescribircd -2

Referencias

• scripts / acd_func.sh
• SkyRocknRoll / acd_func.sh

NOTA: Este script se publicó originalmente en un artículo de la gaceta de Linux que está disponible aquí: acd_func.sh: extiende el CD de bash para mantener, mostrar y acceder al historial de los nombres de directorios visitados .

Prueba la cdable_varsopción de shell en bash. Lo enciendes con shopt -s cdable_vars.

Entonces necesitas establecer tus variables export dir1=/some/path. y finalmente cd dir1, etc. Luego puedes ponerlo en tu ~/.bashrcpara que se pegue.

Use "pushd -n " (suponiendo que use bash).

Agregue a su ~ / .bashrc:

pushd -n /Project/Warnest/docs/
pushd -n ~/Dropbox/Projects/ds/test/

entonces,

cd ~ es tu hogar

cd ~1 es ~/Dropbox/Projects/ds/test/

cd ~2 es /Project/Warnest/docs/

Puede usar ~1, ~2etc. exactamente de la misma manera que ~.

Hay muchas buenas sugerencias aquí. El uso dependerá de si tiene una pequeña lista fija de directorios entre los que cambia, o si está buscando una solución más genérica.

Si se trata de una pequeña lista fija, configurar alias simples (como sugirió Felix Yan) sería más fácil de usar.

Si está buscando una solución más generalizada (es decir, muchos directorios diferentes, que cambian con el tiempo), usaría pushd y popd (como sugirió Useless). Personalmente, considero que el pushd / popd predeterminado es difícil de usar, especialmente cuando comienzas a cambiar entre muchas carpetas; Sin embargo, escribí algunos ajustes que me lo hacen mucho más fácil. Agregue lo siguiente a su bashrc:

alias dirs='dirs -v'
pd () 
{ 
    if [ "$1" ]; then
        pushd "${1/#[0-9]*/+$1}";
    else
        pushd;
    fi > /dev/null
}

• Use pd(como una forma más corta de pushd) para saltar a una nueva carpeta, recordando dónde estaba.
• Use dirspara ver la lista de directorios guardados.
• Use pd 3para saltar al directorio número 3.

Ejemplo de uso:

$ PS1='\w\$ '   ## just for demo purposes
~$ pd ~/Documents/data
~/Documents/data$ pd ../spec
~/Documents/spec$ pd ~/Dropbox/Public/
~/Dropbox/Public$ pd /tmp
/tmp$ pd /etc/defaults/
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 2
~/Dropbox/Public$ dirs
 0  ~/Dropbox/Public
 1  ~/Documents/spec
 2  ~/Documents/data
 3  ~
 4  /etc/defaults
 5  /tmp
~/Dropbox/Public$ pd 4
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 3
~/Documents/spec$ popd
~/Documents/data ~ /etc/defaults /tmp ~/Dropbox/Public
~/Documents/data$ 

Lo siguiente pareció funcionar en el caso en el que lo probé, y puede dejar caer los nombres de sus directorios como enlaces simbólicos en ~ / Marcadores:

mkdir "$HOME/Bookmarks"
ln -s /tmp "$HOME/Bookmarks/testdir"

function ccd() { cd $(readlink "$HOME/Bookmarks/$1") ; }

ccd testdir && echo $PWD
# gives /tmp

Podrías hacer algo peor que probar j2 .

Desde el archivo Léame:

¿Pasa mucho tiempo haciendo discos alrededor de un árbol de directorios complejo?

j realiza un seguimiento de dónde has estado y cuánto tiempo pasas allí, y proporciona una manera conveniente de saltar a los directorios que realmente utilizas.

Lo uso ampliamente y lo recomiendo.

Aconsejaría usar zsh , ese shell como muy buena terminación de TAB para directorios, archivos e incluso opciones para la mayoría de los programas cli.

He estado usando ese shell durante años y extrañaría la funcionalidad si hubiera desaparecido. Crear secuencias de comandos de zsh también es muy divertido, con una gran cantidad de frases ingeniosas que pueden ayudarlo todos los días.

En mi experiencia, la mayor aceleración en la navegación en un shell es usar su funcionalidad de búsqueda de historial. En Bash puede buscar hacia atrás en su historial de comandos presionando Ctrl+ Ry escribir algún patrón. Ese patrón se compara con las entradas anteriores en su historial, ya sean cdcomandos u otras operaciones, y se hacen sugerencias a medida que escribe. Simplemente presione enter para ejecutar el comando sugerido nuevamente. Esto se llama reverse-search-historyen Bash y me encanta. Me ahorra muchas pulsaciones de teclas y me ahorra memoria interna.

Es bueno porque solo tiene que recordar una parte más pequeña de un comando, como Dropo Wapara distinguir entre las dos entradas del historial cd ~/Dropbox/Projects/ds/test/y cd /Project/Warnest/docs/.

También uso estos alias (agregarlos a ~ / .bashrc):

alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'

Es mucho más rápido ir al directorio superior con ellos (sin embargo, solo resuelve la mitad de la navegación).

si estás usando zsh:

• no tiene que escribir cd, solo escriba la ruta del directorio ( /foo/bar/baz<Enter>igual a cd /foo/bar/baz<Enter>)

  requiere auto_cdque se establezca la opción

• puede expandir las rutas abreviadas con la Tabtecla (se /u/sh/pi<Tab>expande a /usr/share/pixmaps; funciona también para los nombres de archivo)

Hay una herramienta bastante agradable para cambios rápidos de directorio:

xd - Cambiador de directorios rápido eXtra http://xd-home.sourceforge.net/xdman.html

un poco incómodo es que necesita mapearlo en bash profile o similar, ya que solo genera el directorio

# function to do `cd` using `xd`
# -g turns generalized directory search command processing on
# which improves the whole thing a bit
f() 
{
        cd `/usr/bin/xd -g $*`
}

puedes hacer cosas como:

# change to /var/log/a* (gives you a list to choose from)    
f vla
# to skip the list and go directly to /var/log/apache2
f vlapach

Nunca debe escribir la ruta completa en shell de todos modos. Siempre puedes usar:

soffice /P*/W*/*/mydoc*

en lugar de

soffice /Project/Warnest/docs/mydoc.odt

También hay OLDPWDuna variable de entorno que, según IEEE 1003.1 (POSIX), debe actualizarse con el directorio de trabajo anterior cada vez que cdcambia el directorio de trabajo (para los curiosos, línea 80244 de la página 2506 de IEEE 1003.1-2008).

También hay una aplicación "wcd" creada específicamente para esto (también portada a cygwin, ya que estoy en eso). Puede crear accesos directos, marcadores de directorios con él. También es compatible con comodines. Leer la página del manual y los documentos en / usr / share / wcd debería ayudar mucho.

http://manpages.ubuntu.com/manpages/hardy/man7/wcd.7.html

cdargs es la herramienta más eficiente para marcar un directorio: http://www.youtube.com/watch?v=uWB2FIQlzZg

Pruebe fastcd ( https://github.com/frazenshtein/fastcd ) Establece el enlace que registra los directorios visitados desde bash. Y establece el script como alias "j", que le muestra los últimos directorios visitados, con la capacidad de crear cd rápidamente (comience a escribir para filtrar directorios). Se requiere la modificación de .bashrc para hacer el alias "j".

Obteniendo herramienta

cd ~; mkdir Soft; cd Soft
git clone https://github.com/frazenshtein/fastcd

Instalar módulos requeridos

pip install --user urwid

Fuente del archivo set.sh en su bashrc

echo -e "\nsource /home/$USER/Soft/fastcd/set.sh\n" >> ~/.bashrc

Y actualizar bashrc

source ~/.bashrc

Luego simplemente escriba "j" en la consola

Tenía la misma pregunta, y primero encontré esta respuesta . Instalé la utilidad z ( https://github.com/rupa/z ).

Esto es exactamente lo que usted busca, porque z aprende de sus comandos cd, y realiza un seguimiento de los directorios de acuerdo con el frecency principio (frecuente y reciente). Entonces, después de hacer ambos comandos de CD una vez, puede hacer algo como:

z docs
z ds

saltar a /Project/Warnest/docs/y ~/Dropbox/Projects/ds/test/respectivamente. Los argumentos para z son expresiones regulares, por lo que ni siquiera necesita escribir un nombre de carpeta completo.

Actualización (2016): ahora uso FASD para esto, que permite la búsqueda difusa basada en sus últimos directorios.

He creado una herramienta para esto, en Ruby. Le permite usar archivos YAML para declarar sus proyectos.

He escrito un pequeño artículo al respecto aquí: http://jrnv.nl/switching-projects-terminal-quickly/

También publiqué la fuente en GitHub: https://github.com/jeroenvisser101/project-switcher

He estado usando mi propia utilidad cdhist para administrar esto durante muchos años. Alias ​​su comando de CD y mantiene automáticamente una pila de directorios.

Puede usar exportpara asignar sus rutas de directorio a variables y luego hacer referencia a ellas.

export dir1=/Project/Warnest/docs/
export dir2= ~/Dropbox/Projects/ds/test/
cd $dir1
cd $dir2

Algunas sugerencias aquí:

La idea más directa, agregaré un alias en el archivo .profile

vi ~/.profile
alias dir1='cd /myhome/onedir'
alias dir2='cd /jimmy/anotherdir'

Luego use $ dir1 o dir2, puede cd

Si siempre está cambiando solo en dos directorios. usando cd -cambiará entre ellos.

La solución que uso para esta situación es screen. Pantalla de inicio y cree una ventana para cada directorio con C-a cy navegue hasta allí. Cambiar entre ventanas / directorios con C-a no C-a p. Nombra las ventanas con C-a A. Luego puede abrir una lista de sus ventanas C-a "y navegar usando el número o nombre de la ventana. Como es así screen, puede desconectarse de la sesión guardando su espacio de trabajo y volver a adjuntarlo más tarde con la misma configuración.

Parece que lo que necesita es básicamente un archivo de proyecto para su flujo de trabajo. Con directorios que pertenecen a su actividad, como en un IDE de programación. Prueba Zsh Navigation Tools y la herramienta n-cdallí. Le permitirá navegar por las últimas carpetas visitadas y también definir un Hotlistdirectorio con su elección:

n-cd se puede vincular a una combinación de teclas con:

zle -N znt-cd-widget

bindkey "^ T" znt-cd-widget

TL; DR

1. Utilice una Fishde shell interactivo que la autonomía de inmediato ( fish> zsh> bash).
2. Uso POSIX/ Bashsecuencias de comandos que es la sintaxis más amplio apoyo ( POSIX> Bash> Zsh> Fish).

Conchas

Haber probado diferentes shells aquí es mi opinión (en orden de prueba / adopción):

• Bash:
  • autocompletado: básico;
  • expansión del camino: no;
  • scripting: excelente
• Zsh+ oh-my-zsh:
  • autocompletado: bueno (ciclismo);
  • expansión de ruta: sí ( cd /e/x1→ cd /etc/X11/);
  • scripting: bueno
• Fish+ oh-my-fish(actual) es el mejor fuera de la caja:
  • autocompletado: opciones nativas y compatibles;
  • expansión del camino: sí;
  • secuencias de comandos: demasiada diferencia con respecto a POSIX-compatible.

Usa alias significativos

Cada shell se puede expandir usando functiony alias, aquí están los que uso relacionados con su problema (compatible con POSIX):

back () {  # go to previous visited directory
        cd - || exit
}

up () {  # go to parent directory
        cd ..|| exit
}

Hay básicos, pero realmente significativos, fáciles de recordar y autocompletar.

Conoce tu caparazón

Configure CDPATHpara agregar sus directorios más usados ​​(por ejemplo ~/projects/, /etc/init.d/) para que pueda saltar rápidamente a ellos.

Vea la respuesta de manatwork para obtener más detallesCDPATH .

Hangout y leer

• mi personalización está en github: posix (bash / zsh) , fish (PR aceptado);
• Varias utilidades que pueden ser interesantes: árbol , k (listados de directorio para zsh)
• puntos de entrada para encontrar complementos para su shell :
  • bucaran / pescado impresionante ,
  • unixorn / awesome-zsh-plugins ,
  • alebcay / awesome-shell
• bashFAQ ;
• Documentación de pescado ;
• Para las diferencias entre los shells , recomiendo la excelente comparación de hyperpolyglot.org/unix-shells .
• en su IRC: #bash, #zsh, #ohmyzsh, #fish, etc. hay mucha gente agradable (tendrás que ser paciente, joven padawan).

ances una herramienta de línea cmd (abreviatura de ancla), que mantiene marcadores de directorios. (hasta ahora solo probado con bash)

En tu caso:

anc a /Project/Warnest/docs/ ~/Dropbox/Projects/ds/test/

esto agrega ambos directorios a la lista de anclaje (piense en marcadores)

ahora si quiere saltar /Project/Warnest/docs/desde cualquier lugar de su sistema, escriba:

anc Warn

y si quieres saltar para ~/Dropbox/Projects/ds/test/escribir:

anc ds test

Además de hacer coincidir el texto con las rutas marcadas, anc tiene muchas otras formas convenientes para saltar por los directorios.

anc i

inicia el modo interactivo, que enumera todos los marcadores por número, por lo que todo lo que tiene que escribir es el número

Si escribe:

anc Pro[TAB]

se muestra una lista que coincide con todos los marcadores (en su caso, ambos marcadores) y puede seleccionarla usando las teclas de flecha, esta es una forma muy rápida e intuitiva.

Obtenga anc en la página de github del proyecto: https://github.com/tobimensch/anc

También hay un archivo README con ejemplos de uso.

Divulgación completa: soy el autor de este script. Espero que algunas personas lo encuentren útil.