Sabemos que usar cd <directory>abrirá o diretório, se existir!

Além disso, cd ..nos elevará um nível do diretório de trabalho atual.

Mas, quando temos um diretório aninhado com caminho mais longo /home/thina/teams/td/tech/app/release/apks, é cansativo apenas ir para a pasta apkse também é difícil voltar para outro nó, digamos aqui /home/thina/teams.

Existe alguma maneira de pular a digitação de cde cd ..? Estou usando o Ubuntu 16.04.

Existe pushde 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

Tente help pushde help popdpara mais opções. Não há manpágina, porque pushde popdsão comandos internos do bash.

Além das respostas muito boas já fornecidas, aqui estão algumas dicas sobre o uso cdeficaz.

• cd - o levará de volta ao último diretório em que você estava.
• cd ../../..o levará a três níveis de uma só vez, você pode usar a ..notação encadeada para 'subir' os diretórios que desejar.
• Se você não tiver certeza de quantas vezes deseja subir, use cd ..e use o histórico do bash pressionando a tecla de seta para usar o comando novamente.
• Use ~para substituir o diretório inicial dos usuários atuais, se você estiver conectado como o usuário thina, cd ~/teamslevará você para/home/thina/teams
• Use o preenchimento automático do Bash para caminhos, a tecla Tab irá concluir uma seção de um caminho no cdcomando, se você digitar parte de um segmento de caminho seguido por Tab, esse segmento será concluído se não houver outra opção válida. Por exemplo, se você tivesse digitado cd /home/thina/teams/td/te pressionado Tab, a palavra tecnologia seria preenchida para você, desde que não houvesse outros arquivos ou diretórios no diretório td que iniciassem com a letra t.

O uso dessas dicas em conjunto pode dificultar a travessia de diretórios cd.

Para subir na árvore vários níveis por vez, você pode usar a seguinte função (graças a muru pela versão aprimorada):

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

Então você pode fazer:

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

Além disso:

• chamar upsem um argumento é equivalente ao cd ..devido a ${1:-1}quais substitutos $1quando definidos e 1caso contrário
• A definição de OLDPWD após o último cd ..visa preservar o cd -comportamento usual .

Para nomes de diretório longos, use variáveis ​​com caminho completo. Por exemplo,

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

Então você pode fazer apenas cd "$APKS"

Quanto a subir x número de diretórios, tenho essa função definida no meu .bashrc

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

Para retornar /home/thina/teamsde apksvocê faria

goup  6

Aqui está um exemplo de uso:

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

Outra função pequena que eu criei, mas nunca usei tanto, é bookmarkfunção.

Eis como funciona: ele salva sua pasta atual em algum arquivo e, em seguida, você pode fazer o cd em um diretório específico com base no número da linha nesse arquivo. Exemplo:

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

E aqui está a própria função:

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

UPDATE: Há uma ferramenta ainda mais poderosa do que autojump: fasd, mas eu não estou familiarizado com ele.

Estou surpreso que ninguém tenha mencionado autojumpainda que

funciona mantendo um banco de dados dos diretórios que você mais usa na linha de comando (os diretórios devem ser visitados primeiro antes que possam ser acessados.)

É basicamente o que o @graipher criou, com algumas opções extras.

Como mencionei em outra pergunta:

Depois de fazer o cd algumas vezes em um diretório (mesmo uma vez basta):

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

você pode usar o atalho jpara ir para lá rapidamente, independentemente do diretório em que está atualmente:

j apks

Observe que o uso de qualquer parte do caminho funciona, desde que seja o mais alto da lista: j apptambém o levará .../apksse você for lá mais vezes do que para .../app.

Eu o recomendaria, em vez de ter seu próprio script, pois é bem conservado, distribuído para o Ubuntu e possui outros recursos interessantes, como pular para o filho :

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

Você mudou para apksdentro td, em vez de outro apkssob uma árvore diferente.

Apelido

Eu tenho uma lista de diretórios usados ​​com freqüência diretamente disponíveis via alias. Isso também inclui atalhos para os diretórios na hierarquia.

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

Agora, quando quero subir três níveis, apenas digito ....<Enter>e aqui estou!

Ative a autocdopção ( shopt -s autocd) para não precisar digitar cd. Por exemplo, você só precisa do comando de dois caracteres ..para ir para o diretório pai.

Se você estiver navegando entre dois diretórios, poderá alternar entre eles com cd -, que vai para o diretório de trabalho anterior. A autocdopção não -executa a execução, cd -mas você pode definir um alias ou função para isso.

Você pode memorizar diretórios em uma pilha com os componentes internos pushde popd. O builtin dirslista a pilha de diretórios (acho dirs -vmais legível).

Se você mudar frequentemente para subdiretórios de um diretório específico, e esses subdiretórios tiverem nomes bastante exclusivos, adicione-os à CDPATHvariável No entanto, esteja avisado de que nunca encontrei uma situação em que CDPATHfosse realmente útil.

Você pode definir uma variável como um nome de diretório e depois alterá-la com $foo.

O Zsh possui alguns recursos interessantes que o bash não possui. Alguns deles podem ser emulados escrevendo funções que executam o mesmo trabalho. Em particular, a forma de dois argumentos cdpermite que você mude convenientemente para outro diretório com um nome semelhante, por exemplo /home/thina/teams/td/tech/app/release/apks/com.acme/v1, from , running cd release betavai para /home/thina/teams/td/tech/app/beta/apks/com.acme/v1.

Como já respondi a uma pergunta relacionada ao UnixSE, uso um script chamado z [github] para isso.

Ele lembra os diretórios nos quais você toca o CD, classifica-os de acordo com a frequência (frequência + recente) e permite que você mude para um dos caminhos lembrados usando alguma parte do nome.

Depois de ter cdado em um diretório pelo menos uma vez, você pode fazer, por exemplo, em vez de:

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

Apenas faça:

$ z sub

que funcionará, usando correspondência parcial de nome (supondo que você não tenha outro diretório que contenha em seu caminho o termo sub e que tenha uma frequência mais alta).

Também defini uma função como esta, que primeiro tenta um CD normal e, se isso falhar, usa z:

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

Isso oferece o melhor de ambos. Se a pasta estiver no diretório atual ou se for fornecido um caminho completo válido, ele apenas cdará lá, mas, caso contrário, tentará encontrar uma correspondência no banco de dados e o cd lá. Isso elimina a (pequena) dor de algumas vezes ter que usar cd (para treinar o banco de dados, ir para uma pasta que você nunca esteve antes) e às vezes lembrar de usar z, quando aplicável.

Acho que mais três opções funcionam bem (embora eu possa usar pushdmais no futuro , só aprendi sobre isso):

• Organize seus caminhos para que você não precise cdentrar em diretórios profundamente aninhados, ou melhor: para que os locais que você precisa visitar frequentemente estejam ao seu alcance. A maneira de conseguir isso é com links simbólicos : mantenha os diretórios explícitos e bem hierarquizados como estão, mas faça um link de acesso rápido para sua própria conveniência.

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

  Então, em vez de digitar o caminho longo para cd, basta usar cd ~/apkse cd ../teams(ou, nesse exemplo, preferível ~/teams) para voltar.

• Não use um único shell e CD entre os caminhos, mas mantenha um shell em execução para cada um dos caminhos em que você precisa trabalhar. Existem vários níveis nos quais você pode conseguir essa multitarefa:

  • Use várias janelas de terminal. Funciona melhor se as janelas estiverem em diferentes áreas de trabalho .
  • Use várias guias em uma única janela. Isso é particularmente adequado para executar apenas alguns comandos em algum diretório: para voltar, basta fechar a guia do terminal!
  • (IMO não muito sensato, mas para ser completo :) use um multiplexador de terminal como tmux.

  • Basta iniciar uma ação em um comando de uso único que cdesteja na pasta, faça uma coisa lá e devolva imediatamente o controle à pasta original: em vez de

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

    basta fazer o one-liner

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

    ou equivalente

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

• Não faça cd nada , mas simplesmente execute o comando diretamente no seu diretório pessoal. As expansões de cinta podem ajudar muito aqui: em vez de

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

  você pode fazer

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

Pushd e Popd

Os comandos pushde popdsão meus favoritos. O pushdcomando lembrará os diretórios que você visitou, visíveis com o comando dirse, quando estiver pronto para pular para trás, use popdpara retornar.

Aqui está um exemplo usando funções e aliases do bash:

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

po ()
{
    popd
}

alias d='dirs'

Eu constantemente uso uma mistura desses comandos de várias maneiras.

Apelido

Outra opção para diretórios acessados ​​com frequência é simplesmente usar o apelido de cdou pushdcomandos. Então, usando os exemplos do seu post:

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

Combinação

Combine as duas idéias e você pode até ter isso:

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

O que lhe dá muita flexibilidade ao percorrer diretórios. Eu mantenho os cd***e sd***aliases na mão para coisas como Desktop, Documents, Music, Downloads, etc. e é muito útil!

Experimente o z.lua - um novo comando cd que ajuda você a navegar mais rapidamente aprendendo seus hábitos.

• cd para um diretório contém foo:

  z foo

• cd para um diretório termina com foo:

  z foo$

• use vários argumentos:

  Supondo o seguinte banco de dados:

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

  "z in"entraria /home/user/mail/inboxcomo a entrada com maior peso. No entanto, você pode passar vários argumentos para o z.lua para preferir uma entrada diferente. No exemplo acima, "z w in"o diretório seria alterado para /home/user/work/inbox.

• CD com seleção interativa:

  Quando houver várias correspondências encontradas, usar z -iexibirá uma lista:

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

  Depois, você pode inserir o número e escolher para onde ir antes do CD real. por exemplo. introduza 3 no cd para /home/data/software. E se você simplesmente pressionar ENTER e não inserir nada, ele simplesmente sairá e permanecerá onde estava.

  z.luatambém suporta fzfseleção seletiva ou conclusão de argumento:

  conclusão com fzf

• rápido, volte para o pai sem digitar cd ../../..:

  A nova opção "-b"pode voltar rapidamente para um diretório pai específico no bash, em vez de digitar "cd ../../ .." de forma redundante:

  • (Sem argumento) : cdna raiz do projeto, o projeto enraíza o diretório-pai mais próximo com .git/ .hg/ .svn.

  • (Um argumento) : cdno pai mais próximo, começando com a palavra-chave, se não encontrar, vá para o pai que contém a palavra-chave.

  • (Dois argumentos) : substitua o primeiro valor pelo segundo (no caminho atual).

  ...

  Vamos começar aliasing z -bpara 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

Gostaria que pudesse se adequar à sua necessidade.

O peixe tem várias instalações agradáveis ​​para se mover rapidamente.

• Se você digitar cd, clique com a seta para a direita e repete o CD mais recente.
• Usando cd seta para cima seta para a direita entrar, ele repete o segundo CD mais recente.
• Etc.
• Tem prevd e nextd, que geralmente são mais fáceis de usar do que pushd e popd.

Além disso, mantenho meus diretórios favoritos vinculados a ~ / f, para que eu possa cd ~ / f / x para obter ~ / foo / bar / baz / experimental-data.

Há muito tempo que uso aliases para diretórios acessados ​​com frequência.

Eu também tenho uma função bash chamada ccb (abreviação de create cd bat file - originada no DOS / Windows, onde o script .bat shell ccb.bat criaria outro arquivo .bat para ir para o diretório atual) que cria / acrescenta aliases (no arquivo .bash_aliases) para o diretório atual.

por exemplo: $ ccb myfav criará um alias para o diretório atual com um alias myfav no arquivo .bash_aliases e criará o arquivo .bashrc para que o alias fique imediatamente disponível.

Acabei de encontrar uma nova solução. É uma função 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

isso não precisa aprender nada com o uso anterior. O problema que isso pode não resolver é: se houver mais de 1 diretórios chamados "deep_nested_dir_name" na árvore de subdiretórios, ele passará para o primeiro diretório encontrado pela localização.

Além disso, esta solução não poderá ir para outra árvore de diretórios.

entre aliases codificados e aliases gerados e essa nova função lj (), a maioria das minhas necessidades é atendida.

Aqui está minha função bash ccb () para quem quiser usá-la

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