Sto cercando di scrivere un piccolo script per cambiare la directory corrente nella directory del mio progetto:

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

Ho salvato questo file come proj, ho aggiunto il permesso di esecuzione chmode l'ho copiato /usr/bin. Quando lo chiamo per: projnon fa nulla. Che cosa sto facendo di sbagliato?

Gli script della shell vengono eseguiti all'interno di una subshell e ogni subshell ha il proprio concetto di quale sia la directory corrente. Il cdriesce, ma non appena le uscite subshell, sei tornata nella shell interattiva e nulla mai ci cambiato.

Un modo per aggirare questo è invece usare un alias:

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

Non stai facendo niente di male! Hai modificato la directory, ma solo all'interno della subshell che esegue lo script.

È possibile eseguire lo script nel processo corrente con il comando "punto":

. proj

Ma preferirei il suggerimento di Greg di usare un alias in questo semplice caso.

Il cdnello script tecnicamente lavorato in quanto cambiava la directory della shell che eseguiva lo script, ma quello era un processo separato biforcuto dalla tua shell interattiva.

Un modo compatibile con Posix per risolvere questo problema consiste nel definire una procedura shell anziché uno script di comandi invocato dalla shell .

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

Puoi semplicemente digitare questo o inserirlo in uno dei vari file di avvio della shell.

Il cdavviene entro guscio della sceneggiatura. Quando lo script termina, quella shell si chiude e quindi si rimane nella directory in cui ci si trovava. "Fonte" lo script, non eseguirlo. Invece di:

./myscript.sh

fare

. ./myscript.sh

(Nota il punto e lo spazio prima del nome dello script.)

Per creare uno script bash che verrà inserito in una directory selezionata:

Crea il file di script

#! / Bin / sh
# file: / scripts / cdjava
#
cd / home / askgelal / progetti / java

Quindi creare un alias nel file di avvio.

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

• Ho creato un file di avvio in cui ho scaricato tutti i miei alias e funzioni personalizzate.
• Quindi sorgente questo file nel mio .bashrc per averlo impostato su ogni avvio.

Ad esempio, creare un file alias / funzioni master: /scripts/mastercode.sh
(inserire l'alias in questo file.)

Quindi alla fine del tuo .bashrc file :

fonte /scripts/mastercode.sh

Ora è facile da cd nella tua directory java, basta digitare cdjava e sei lì.

È possibile utilizzare .per eseguire uno script nell'ambiente shell corrente:

. script_name

o in alternativa, il suo alias più leggibile ma specifico per shell source:

source script_name

Ciò evita la subshell e consente invece a qualsiasi variabile o builtin (incluso cd) di influire sulla shell corrente.

L'idea di Jeremy Ruten di usare un collegamento simbolico ha scatenato un pensiero che non ha incrociato altre risposte. Uso:

CDPATH=:$HOME/projects

Il colon principale è importante; significa che se c'è una directory 'dir' nella directory corrente, allora ' cd dir' cambierà in quella, piuttosto che saltare da qualche altra parte. Con il valore impostato come mostrato, puoi fare:

cd java

e, se non vi è alcuna sottodirectory chiamata java nella directory corrente, allora vi porterà direttamente a $ HOME / progetti / java - nessun alias, nessuno script, nessun exec o comandi punto dubbi.

My $ HOME è / Users / jleffler; il mio $ 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

Utilizzare exec bashalla fine

Uno script bash opera nel suo ambiente attuale o in quello dei suoi figli, ma mai nel suo ambiente genitore.

Tuttavia, questa domanda viene spesso posta perché si desidera essere lasciati al prompt (nuovo) bash in una determinata directory dopo l'esecuzione di uno script bash da un'altra directory.

In tal caso, eseguire semplicemente un'istanza bash figlio alla fine dello script:

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

Ho ottenuto il mio codice per funzionare utilizzando. <your file name>

./<your file name> la dose non funziona perché non cambia la directory nel terminale ma cambia solo la directory specifica per quello script.

Ecco il mio programma

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

Ecco il mio terminale

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

corri semplicemente:

cd /home/xxx/yyy && command_you_want

Quando si attiva uno script di shell, viene eseguita una nuova istanza di quella shell ( /bin/bash). Pertanto, il tuo script attiva solo una shell, cambia la directory ed esce. In altri termini cd(e altri comandi simili) all'interno di uno script di shell non influiscono né hanno accesso alla shell da cui sono stati lanciati.

Nel mio caso particolare avevo bisogno di troppe volte per cambiare per la stessa directory. Quindi sul mio .bashrc (io uso Ubuntu) ho aggiunto il

1 -

$ nano ~. / bashrc

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

2-

$ source ~ / .bashrc

3 -

$ switchp java

Direttamente farà: cd / home / tree / projects / java

Spero che aiuti!

Puoi fare quanto segue:

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

EDIT: anche questo potrebbe essere 'punteggiato', per impedire la creazione di shell successive.

Esempio:

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

Cambia solo la directory per lo script stesso, mentre la directory corrente rimane la stessa.

È possibile che si desideri utilizzare un collegamento simbolico . Ti consente di creare un "collegamento" a un file o una directory, quindi dovresti solo digitare qualcosa del genere cd my-project.

Puoi combinare l'alias di Adam e Greg e gli approcci a punti per creare qualcosa che può essere più dinamico:

alias project=". project"

A questo punto, l'esecuzione dell'alias del progetto eseguirà lo script del progetto nella shell corrente anziché nella subshell.

Puoi combinare un alias e uno script,

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

a condizione che lo script riprenda il percorso di destinazione. Si noti che si tratta di backtick che circondano il nome dello script. 

Ad esempio, la tua sceneggiatura potrebbe essere

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

Il vantaggio di questa tecnica è che lo script potrebbe accettare qualsiasi numero di parametri della riga di comando ed emettere destinazioni diverse calcolate da una logica forse complessa.

per navigare rapidamente nelle directory, ci sono $ CDPATH, cdarg e modi per generare automaticamente gli alias

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

Nel tuo file ~ / .bash_profile. aggiungi la prossima funzione

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

Riavvia il terminale e puoi digitare

move_me 

e verrai spostato nella cartella di destinazione.

Puoi usare l'operatore &&:

cd myDirectory && ls

Mentre l'approvvigionamento dello script che si desidera eseguire è una soluzione, è necessario tenere presente che questo script può quindi modificare direttamente l'ambiente della shell corrente. Inoltre non è più possibile passare argomenti.

Un altro modo di fare è implementare il tuo script come funzione in bash.

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

Questa tecnica viene utilizzata da autojump: http://github.com/joelthelion/autojump/wiki per fornire i segnalibri della directory di shell di apprendimento.

Puoi creare una funzione come di seguito nel tuo .bash_profile e funzionerà senza problemi.

La seguente funzione accetta un parametro opzionale che è un progetto. Ad esempio, puoi semplicemente correre

cdproj

o

cdproj project_name

Ecco la definizione della funzione.

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

Non dimenticare di procurarti il ​​tuo .bash_profile

Questo dovrebbe fare quello che vuoi. Passare alla directory di interesse (dall'interno dello script), quindi generare una nuova shell bash.

#!/bin/bash

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

Se lo esegui, ti porterà alla directory di interesse e quando lo esci ti riporterà nella posizione originale.

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

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

Questo ti riporterà anche alla directory originale quando esci ( CTRL+ d)

LOOOOOng tempo dopo, ma ho fatto quanto segue:

crea un file chiamato case

incolla quanto segue nel file:

#!/bin/sh

cd /home/"$1"

salvalo e poi:

chmod +x case

Ho anche creato un alias nel mio .bashrc:

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

ora quando scrivo:

case 12345

essenzialmente sto scrivendo:

cd /home/12345

Puoi digitare qualsiasi cartella dopo 'case':

case 12

case 15

case 17

che è come scrivere:

cd /home/12

cd /home/15

cd /home/17

rispettivamente

Nel mio caso il percorso è molto più lungo - questi ragazzi lo hanno riassunto con le ~ informazioni in precedenza.

Non hai bisogno di script, imposta solo l'opzione corretta e crea una variabile d'ambiente.

shopt -s cdable_vars

nel tuo ~/.bashrcconsente di cdal contenuto delle variabili di ambiente.

Crea una tale variabile d'ambiente:

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

e puoi usare:

cd myjava

Altre alternative .

Se stai usando il pesce come guscio, la soluzione migliore è creare una funzione. Ad esempio, data la domanda originale, è possibile copiare le 4 righe sottostanti e incollarle nella riga di comando del pesce:

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

Questo creerà la funzione e la salverà per usarla in seguito. Se il tuo progetto cambia, ripeti il ​​processo usando il nuovo percorso.

Se preferisci, puoi aggiungere manualmente il file di funzione procedendo come segue:

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

e inserisci il testo:

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

e infine premi ctrl + x per uscire e y seguito da invio per salvare le modifiche.

( NOTA: il primo metodo di utilizzo di funcsave crea il file proj.fish per te ).

Ho un semplice script bash chiamato p per gestire il cambio di directory su
github.com/godzilla/bash-stuff,
basta inserire lo script nella directory bin locale (/ usr / local / bin)
e mettere

alias p='. p'

nel tuo .bashrc

Nota la discussione Come posso impostare la directory di lavoro del processo genitore?

Contiene alcune risposte hacker, ad esempio https://stackoverflow.com/a/2375174/755804 (modifica della directory del processo principale tramite gdb, non farlo) e https://stackoverflow.com/a/51985735/755804 ( il comando tailcdche inietta cd dirname nel flusso di input del processo genitore; beh, idealmente dovrebbe essere una parte di bash piuttosto che un hack)

È una vecchia domanda, ma sono davvero sorpreso di non vedere questo trucco qui

Invece di usare cd puoi usare

export PWD=the/path/you/want

Non è necessario creare sottotitoli o utilizzare alias.

Nota che è tua responsabilità assicurarti che il / percorso / tu / desideri esista.

Come spiegato nelle altre risposte, hai modificato la directory, ma solo all'interno della sotto-shell che esegue lo script . questo non ha alcun impatto sulla shell padre.

Una soluzione è usare le funzioni bash invece di uno script bash ( sh); inserendo il codice dello script bash in una funzione. Ciò rende disponibile la funzione come comando e quindi verrà eseguita senza un processo figlio e quindi qualsiasi cdcomando avrà un impatto sulla shell del chiamante.

Funzioni Bash:

Una caratteristica del profilo bash è l'archiviazione di funzioni personalizzate che possono essere eseguite nel terminale o negli script bash nello stesso modo in cui si eseguono applicazioni / comandi, questo potrebbe anche essere usato come scorciatoia per comandi lunghi.

Per rendere ampiamente efficiente il tuo sistema di funzioni dovrai copiare la tua funzione alla fine di diversi file

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

È possibile sudo kwrite /home/user/.bashrc /home/user/.bash_profile /root/.bashrc /root/.bash_profilemodificare / creare rapidamente quei file

Come :

Copia il codice dello script bash all'interno di una nuova funzione alla fine del file del profilo di bash e riavvia il terminale, quindi puoi eseguire cddo qualunque sia la funzione che hai scritto.

Esempio di script

Scorciatoia cd ..concdd

cdd() {
  cd ..
}

È una scorciatoia

ll() {
  ls -l -h
}

È una scorciatoia

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

È possibile eseguire alcune righe nella stessa subshell se si terminano le linee con barra rovesciata.

cd somedir; \
pwd