Estou tentando escrever um pequeno script para alterar o diretório atual para o diretório do meu projeto:

#!/bin/bash
cd /home/tree/projects/java

Salvei este arquivo como proj, adicionei permissão de execução chmode copiei-o para /usr/bin. Quando eu chamo por proj:, não faz nada. O que estou fazendo errado?

Os scripts de shell são executados dentro de um subshell, e cada subshell tem seu próprio conceito de qual é o diretório atual. O resultado cdé bem-sucedido, mas assim que o subshell sai, você volta ao shell interativo e nada muda lá.

Uma maneira de contornar isso é usar um alias:

alias proj="cd /home/tree/projects/java"

Você não está fazendo nada errado! Você alterou o diretório, mas apenas dentro do subshell que executa o script.

Você pode executar o script no seu processo atual com o comando "ponto":

. proj

Mas eu prefiro a sugestão de Greg de usar um pseudônimo neste caso simples.

O cdem seu script tecnicamente trabalhou como ele mudou o diretório do shell que executou o script, mas isso foi um processo separado bifurcada do seu shell interativo.

Uma maneira compatível com Posix para resolver esse problema é definir um procedimento de shell em vez de um script de comando invocado por shell .

jhome () {
  cd /home/tree/projects/java
}

Você pode digitar ou colocar em um dos vários arquivos de inicialização do shell.

Isso cdé feito dentro do shell do script. Quando o script termina, esse shell sai e você é deixado no diretório em que estava. "Origem" do script, não o execute. Ao invés de:

./myscript.sh

Faz

. ./myscript.sh

(Observe o ponto e o espaço antes do nome do script.)

Para criar um script bash que fará o cd para um diretório selecionado:

Crie o arquivo de script

#! / bin / sh
# file: / scripts / cdjava
#
cd / home / askgelal / projetos / java

Em seguida, crie um alias no seu arquivo de inicialização.

#! / bin / sh
# file /scripts/mastercode.sh
#
alias cdjava = '. / scripts / cdjava '

• Criei um arquivo de inicialização em que despejo todos os meus aliases e funções personalizadas.
• Depois, forneço esse arquivo no meu .bashrc para defini-lo em cada inicialização.

Por exemplo, crie um arquivo de aliases / funções mestre: /scripts/mastercode.sh
(coloque o alias neste arquivo.)

Em seguida, no final do seu arquivo .bashrc :

source /scripts/mastercode.sh

Agora é fácil fazer o cd no diretório java, basta digitar cdjava e você estará lá.

Você pode usar .para executar um script no ambiente atual do shell:

. script_name

ou, alternativamente, seu alias mais legível, mas específico do shell source:

source script_name

Isso evita o subshell e permite que quaisquer variáveis ​​ou componentes internos (inclusive cd) afetem o shell atual.

A idéia de Jeremy Ruten de usar um link simbólico desencadeou um pensamento que não passou por nenhuma outra resposta. Usar:

CDPATH=:$HOME/projects

O cólon principal é importante; significa que, se houver um diretório 'dir' no diretório atual, ' cd dir' será alterado para isso, em vez de sair para outro lugar. Com o valor definido como mostrado, você pode:

cd java

e, se não houver um subdiretório chamado java no diretório atual, ele o levará diretamente para $ HOME / projects / java - sem alias, sem scripts, sem executivos duvidosos ou comandos de ponto.

Meu $ HOME é / Users / jleffler; meu $ CDPATH é:

:/Users/jleffler:/Users/jleffler/mail:/Users/jleffler/src:/Users/jleffler/src/perl:/Users/jleffler/src/sqltools:/Users/jleffler/lib:/Users/jleffler/doc:/Users/jleffler/work

Use exec bashno final

Um script bash opera em seu ambiente atual ou em seus filhos, mas nunca em seu ambiente pai.

No entanto, essa pergunta geralmente é feita porque alguém deseja ser deixado em um (novo) prompt do bash em um determinado diretório após a execução de um script bash de outro diretório.

Se for esse o caso, basta executar uma instância do bash filho no final do script:

#!/usr/bin/env bash
cd /home/tree/projects/java
exec bash

Eu tenho meu código para trabalhar usando. <your file name>

./<your file name> Dose não funciona porque não altera seu diretório no terminal, apenas altera o diretório específico para esse script.

Aqui está o meu programa

#!/bin/bash 
echo "Taking you to eclipse's workspace."
cd /Developer/Java/workspace

Aqui está o meu terminal

nova:~ Kael$ 
nova:~ Kael$ . workspace.sh
Taking you to eclipe's workspace.
nova:workspace Kael$ 

basta executar:

cd /home/xxx/yyy && command_you_want

Quando você aciona um script de shell, ele executa uma nova instância desse shell ( /bin/bash). Assim, seu script apenas dispara um shell, altera o diretório e sai. Em cdoutras palavras , (e outros comandos desse tipo) em um script de shell não afetam nem têm acesso ao shell a partir do qual foram iniciados.

No meu caso particular, eu precisei muitas vezes para alterar para o mesmo diretório. Então, no meu .bashrc (eu uso o ubuntu), adicionei o

1 -

$ nano ~ / bashrc

 function switchp
 {
    cd /home/tree/projects/$1
 }

2-

$ fonte ~ / .bashrc

3 -

$ switchp java

Diretamente ele fará: cd / home / tree / projects / java

Espero que ajude!

Você pode fazer o seguinte:

#!/bin/bash
cd /your/project/directory
# start another shell and replacing the current
exec /bin/bash

EDIT: Isso também pode ser 'pontilhado', para impedir a criação de shells subsequentes.

Exemplo:

. ./previous_script  (with or without the first line)

Ele altera apenas o diretório do próprio script, enquanto o diretório atual permanece o mesmo.

Você pode usar um link simbólico . Ele permite que você faça um "atalho" para um arquivo ou diretório, então você só precisa digitar algo parecido cd my-project.

Você pode combinar o alias de Adam & Greg e as abordagens de pontos para criar algo que possa ser mais dinâmico.

alias project=". project"

Agora, a execução do alias do projeto executará o script do projeto no shell atual, em oposição ao subshell.

Você pode combinar um alias e um script,

alias proj="cd \`/usr/bin/proj !*\`"

desde que o script faça eco no caminho de destino. Observe que esses são backticks que cercam o nome do script. 

Por exemplo, seu script pode ser

#!/bin/bash
echo /home/askgelal/projects/java/$1

A vantagem dessa técnica é que o script pode pegar qualquer número de parâmetros de linha de comando e emitir destinos diferentes calculados por uma lógica possivelmente complexa.

para navegar pelos diretórios rapidamente, existem $ CDPATH, cdargs e maneiras de gerar aliases automaticamente

http://jackndempsey.blogspot.com/2008/07/cdargs.html

http://muness.blogspot.com/2008/06/lazy-bash-cd-aliaes.html

https://web.archive.org/web/1/http://articles.techrepublic%2ecom%2ecom/5100-10878_11-5827311.html

No seu arquivo ~ / .bash_profile. adicione a próxima função

move_me() {
    cd ~/path/to/dest
}

Reinicie o terminal e você pode digitar

move_me 

e você será movido para a pasta de destino.

Você pode usar o operador &&:

cd myDirectory && ls

Embora a fonte do script que você deseja executar seja uma solução, você deve estar ciente de que esse script pode modificar diretamente o ambiente do seu shell atual. Também não é mais possível passar argumentos.

Outra maneira de fazer isso é implementar seu script como uma função no bash.

function cdbm() {
  cd whereever_you_want_to_go
  echo "Arguments to the functions were $1, $2, ..."
}

Essa técnica é usada pelo autojump: http://github.com/joelthelion/autojump/wiki para fornecer a você os indicadores de diretório de shell de aprendizado.

Você pode criar uma função como abaixo na sua .bash_profilee ela funcionará sem problemas.

A função a seguir aceita um parâmetro opcional que é um projeto. Por exemplo, você pode simplesmente executar

cdproj

ou

cdproj project_name

Aqui está a definição da função.

cdproj(){
    dir=/Users/yourname/projects
    if [ "$1" ]; then
      cd "${dir}/${1}"
    else
      cd "${dir}"
    fi
}

Não se esqueça de adquirir seu .bash_profile

Isso deve fazer o que você quiser. Vá para o diretório de interesse (de dentro do script) e crie um novo shell bash.

#!/bin/bash

# saved as mov_dir.sh
cd ~/mt/v3/rt_linux-rt-tools/
bash

Se você executar isso, ele o levará ao diretório de interesse e, quando você o sair, o levará de volta ao local original.

root@intel-corei7-64:~# ./mov_dir.sh

root@intel-corei7-64:~/mt/v3/rt_linux-rt-tools# exit
root@intel-corei7-64:~#

Isso levará você a voltar ao diretório original quando sair ( CTRL+ d)

LOOOOOng depois, mas fiz o seguinte:

crie um arquivo chamado case

cole o seguinte no arquivo:

#!/bin/sh

cd /home/"$1"

salve-o e depois:

chmod +x case

Eu também criei um alias no meu .bashrc:

alias disk='cd /home/; . case'

agora quando digito:

case 12345

essencialmente eu estou digitando:

cd /home/12345

Você pode digitar qualquer pasta após 'case':

case 12

case 15

case 17

que é como digitar:

cd /home/12

cd /home/15

cd /home/17

respectivamente

No meu caso, o caminho é muito mais longo - esses caras resumiram o ~ info anteriormente.

Você não precisa de script, apenas defina a opção correta e crie uma variável de ambiente.

shopt -s cdable_vars

no seu ~/.bashrcpermite ao cdconteúdo de variáveis ​​de ambiente.

Crie uma variável de ambiente:

export myjava="/home/tree/projects/java"

e você pode usar:

cd myjava

Outras alternativas .

Se você estiver usando peixe como casca, a melhor solução é criar uma função. Como exemplo, dada a pergunta original, você pode copiar as 4 linhas abaixo e colá-las na linha de comando do peixe:

function proj
   cd /home/tree/projects/java
end
funcsave proj

Isso criará a função e a salvará para uso posterior. Se o seu projeto mudar, basta repetir o processo usando o novo caminho.

Se preferir, você pode adicionar manualmente o arquivo de função, fazendo o seguinte:

nano ~/.config/fish/functions/proj.fish

e digite o texto:

function proj
   cd /home/tree/projects/java
end

e, finalmente, pressione ctrl + x para sair ey seguido de return para salvar suas alterações.

( NOTA: o primeiro método de usar o funcsave cria o arquivo proj.fish para você ).

Eu tenho um script bash simples chamado p para gerenciar a alteração de diretório no
github.com/godzilla/bash-stuff,
basta colocar o script no diretório bin local (/ usr / local / bin)
e colocar

alias p='. p'

no seu .bashrc

Observe a discussão Como faço para definir o diretório de trabalho do processo pai?

Ele contém algumas respostas hackish, por exemplo, https://stackoverflow.com/a/2375174/755804 (alterando o diretório do processo pai via gdb, não faça isso) e https://stackoverflow.com/a/51985735/755804 ( o comando tailcdque injeta cd dirname no fluxo de entrada do processo pai; bem, idealmente, ele deve fazer parte do bash e não um hack)

É uma pergunta antiga, mas estou realmente surpreso por não ver esse truque aqui

Em vez de usar cd, você pode usar

export PWD=the/path/you/want

Não há necessidade de criar subshells ou usar aliases.

Observe que é sua responsabilidade garantir que o / path / you / want exista.

Conforme explicado nas outras respostas, você alterou o diretório, mas apenas dentro do sub-shell que executa o script . isso não afeta o shell pai.

Uma solução é usar funções bash em vez de um script bash ( sh); colocando seu código de script bash em uma função. Isso torna a função disponível como um comando e, em seguida, isso é executado sem um processo filho e, portanto, qualquer cdcomando afeta o shell do chamador.

Funções do Bash:

Um recurso do perfil bash é armazenar funções personalizadas que podem ser executadas no terminal ou em scripts bash da mesma maneira que você executa aplicativos / comandos. Isso também pode ser usado como um atalho para comandos longos.

Para tornar seu sistema eficiente de funções amplamente, você precisará copiar sua função no final de vários arquivos

/home/user/.bashrc
/home/user/.bash_profile
/root/.bashrc
/root/.bash_profile

Você pode sudo kwrite /home/user/.bashrc /home/user/.bash_profile /root/.bashrc /root/.bash_profileeditar / criar esses arquivos rapidamente

Como :

Copie o código do seu script bash dentro de uma nova função no final do arquivo de perfil do bash e reinicie o terminal. Depois, você pode executar cddou qualquer que seja a função que você escreveu.

Exemplo de script

Fazendo atalho para cd ..comcdd

cdd() {
  cd ..
}

ls atalho

ll() {
  ls -l -h
}

ls atalho

lll() {
  ls -l -h -a
}

Você pode executar algumas linhas no mesmo subshell se terminar as linhas com barra invertida.

cd somedir; \
pwd