Reputation: 9381
Is it possible to change current directory from a script?
I want to create a utility for directory navigation in Bash. I have created a test script that looks like the following:
#!/bin/bash
cd /home/artemb
When I execute the script from the Bash shell the current directory doesn't change. Is it possible at all to change the current shell directory from a script?
Upvotes: 250
Views: 387146
Reputation: 1611
This is a simplified compilation of above answer.
Create a shell file shellfile.sh
In the script change your directory inside a function
#!/bin/bash
cd folder1/folder2/
Now run the script with .
before it.
.
uses the current thread/session to execute the script.
. shellfile.sh
Upvotes: 3
Reputation: 621
This is my current way of doing it for bash (tested on Debian). Maybe there's a better way:
Don't do it with exec bash, for example like this:
#!/bin/bash
cd $1
exec bash
because while it appears to work, after you run it and your script finishes, yes you'll be in the correct directory, but you'll be in it in a subshell, which you can confirm by pressing Ctrl+D afterwards, and you'll see it exits the subshell, putting you back in your original directory.
This is usually not a state you want a script user to be left in after the script they run returns, because it's non-obvious that they're in a subshell and now they basically have two shells open when they thought they only had one. They might continue using this subshell and not realize it, and it could have unintended consequences.
If you really want the script to exit and leave open a subshell in the new directory, it's better if you change the PS1 variable so the script user has a visual indicator that they still have a subshell open.
Here's an example I came up with. It is two files, an outer.sh which you call directly, and an inner.sh which is sourced inside the outer.sh script. The outer script sets two variables, then sources the inner script, and afterwards it echoes the two variables (the second one has just been modified by the inner script). Afterwards it makes a temp copy of the current user's ~/.bashrc file, adds an override for the PS1 variable in it, as well as a cleanup routine, and finally it runs exec bash --rcfile pointing at the .bashrc.tmp file to initialize bash with a modified environment, including the modified prompt and the cleanup routine.
After outer.sh exits, you'll be left inside a subshell in the desired directory (in this case testdir/ which was entered into by the inner.sh script) with a visual indicator making it clear to you, and if you exit out of the subshell, the .bashrc.tmp file will be deleted by the cleanup routine, and you'll be back in the directory you started in.
Maybe there's a smarter way to do it, but that's the best way I could figure out in about 40 minutes of experimenting:
#!/bin/bash
var1="hello"
var2="world"
source inner.sh
echo $var1
echo $var2
cp ~/.bashrc .bashrc.tmp
echo 'export PS1="(subshell) $PS1"' >> .bashrc.tmp
cat <<EOS >> .bashrc.tmp
cleanup() {
echo "cleaning up..."
rm .bashrc.tmp
}
trap 'cleanup' 0
EOS
exec bash --rcfile .bashrc.tmp
cd testdir
var2="bird"
then run:
$ mkdir testdir
$ chmod 755 outer.sh
$ ./outer.sh
it should output:
hello
bird
and then drop you into your subshell using exec bash, but with a modified prompt which makes that obvious, something like:
(subshell) user@computername:~/testdir$
and if you Ctrl-D out of the subshell, it should clean up by deleting a temporary .bashrc.tmp file in the testdir/ directory
I wonder if there's a better way than having to copy the .bashrc file like that though to change the PS1 var properly in the subshell...
Upvotes: 2
Reputation: 1
I like to do the same thing for different projects without firing up a new shell.
In your case:
cd /home/artemb
Save the_script as:
echo cd /home/artemb
Then fire it up with:
\`./the_script\`
Then you get to the directory using the same shell.
Upvotes: -1
Reputation: 9167
I've also created a utility called goat that you can use for easier navigation.
You can view the source code on GitHub.
As of v2.3.1 the usage overview looks like this:
# Create a link (h4xdir) to a directory:
goat h4xdir ~/Documents/dev
# Follow a link to change a directory:
cd h4xdir
# Follow a link (and don't stop there!):
cd h4xdir/awesome-project
# Go up the filesystem tree with '...' (same as `cd ../../`):
cd ...
# List all your links:
goat list
# Delete a link (or more):
goat delete h4xdir lojban
# Delete all the links which point to directories with the given prefix:
goat deleteprefix $HOME/Documents
# Delete all saved links:
goat nuke
# Delete broken links:
goat fix
Upvotes: 0
Reputation: 1589
This approach is easier for me.
Suppose on a personal iMac where you are an admin, under the default directory when a command window is opened, /Users/jdoe, this will be the directory to go to: /Users/jdoe/Desktop/Mongo/db.3.2.1/bin.
These are the steps that can have the job done:
cd /Users/jdoe/Desktop/Mongo/db.3.2.1/bin
as the first line.chmod 755 mongobin
source mongobin
pwd
Voila!
Upvotes: 0
Reputation: 1684
Simply go to
yourusername/.bashrc (or yourusername/.bash_profile on MAC) by an editor
and add this code next to the last line:
alias yourcommand="cd /the_path_you_wish"
Then quit editor.
Then type:
source ~/.bashrc or source ~/.bash_profile on MAC.
now you can use: yourcommand in terminal
Upvotes: 6
Reputation: 10851
When you start your script, a new process is created that only inherits your environment. When it ends, it ends. Your current environment stays as it is.
Instead, you can start your script like this:
. myscript.sh
The .
will evaluate the script in the current environment, so it might be altered
Upvotes: 284
Reputation: 1151
Basically we use cd..
to come back from every directory. I thought to make it more easy by giving the number of directories with which you need to come back at a time. You can implement this using a separate script file using the alias command . For example:
code.sh
#!/bin/sh
_backfunc(){
if [ "$1" -eq 1 ]; then
cd ..
elif [ "$1" -eq 2 ]; then
cd ../..
elif [ "$1" -eq 3 ]; then
cd ../../..
elif [ "$1" -eq 4 ]; then
cd ../../../..
elif ["$1" -eq 10]; then
cd /home/arun/Documents/work
fi
}
alias back='_backfunc'
After using source code.sh
in the current shell you can use :
$back 2
to come two steps back from the current directory. Explained in detail over here. It is also explained over there how to put the code in ~/.bashrc so that every new shell opened will automatically have this new alias command. You can add new command to go to specific directories by modifying the code by adding more if conditions
and different arguments. You can also pull the code from git over here.
Upvotes: 3
Reputation: 111
I've made a script to change directory. take a look: https://github.com/ygpark/dj
Upvotes: 3
Reputation:
In light of the unreadability and overcomplication of answers, i believe this is what the requestor should do
PATH
. scriptname
The .
(dot) will make sure the script is not run in a child shell.
Upvotes: 63
Reputation: 3286
If you run a bash script then it will operates on its current environment or on those of its children, never on the parent.
If goal is to run your command : goto.sh /home/test Then work interactively in /home/test one way is to run a bash interactive subshell within your script :
#!/bin/bash
cd $1
exec bash
This way you will be in /home/test until you exit ( exit or Ctrl+C ) of this shell.
Upvotes: 24
Reputation: 565
Putting the above together, you can make an alias
alias your_cmd=". your_cmd"
if you don't want to write the leading "." each time you want to source your script to the shell environment, or if you simply don't want to remember that must be done for the script to work correctly.
Upvotes: 54
Reputation: 1516
If you are using bash you can try alias:
into the .bashrc file add this line:
alias p='cd /home/serdar/my_new_folder/path/'
when you write "p" on the command line, it will change the directory.
Upvotes: 38
Reputation: 2625
You need to convert your script to a shell function:
#!/bin/bash
#
# this script should not be run directly,
# instead you need to source it from your .bashrc,
# by adding this line:
# . ~/bin/myprog.sh
#
function myprog() {
A=$1
B=$2
echo "aaa ${A} bbb ${B} ccc"
cd /proc
}
The reason is that each process has its own current directory, and when you execute a program from the shell it is run in a new process. The standard "cd", "pushd" and "popd" are builtin to the shell interpreter so that they affect the shell process.
By making your program a shell function, you are adding your own in-process command and then any directory change gets reflected in the shell process.
Upvotes: 209
Reputation: 1608
With pushd the current directory is pushed on the directory stack and it is changed to the given directory, popd get the directory on top of the stack and changes then to it.
pushd ../new/dir > /dev/null
# do something in ../new/dir
popd > /dev/null
Upvotes: 20