How to Delete Exported Environment Variables in Linux
Environment variables sometimes need to be removed from your shell session, whether you're cleaning up after testing, removing sensitive data, or fixing configuration issues. Linux provides several methods to delete environment variables, each serving different scenarios and persistence requirements.
Prerequisites
You'll need access to a Linux terminal with basic command-line knowledge. The examples work with bash, zsh, and most POSIX-compliant shells.
Using the unset Command
The unset
command is the standard way to remove environment variables from your current shell session. If you've exported a variable like this:
export API_KEY="abc123xyz"
You can remove it completely with:
unset API_KEY
After running unset, the variable no longer exists in your environment. You can verify this by trying to echo the variable, which will return nothing:
echo $API_KEY
# No output - variable is gone
Removing Multiple Variables at Once
The unset command accepts multiple variable names, allowing you to clean up several variables in one command:
unset API_KEY DATABASE_URL SECRET_TOKEN
This approach is efficient when you need to remove related variables, such as cleaning up after a development session or removing a set of configuration variables.
Checking Variable Existence Before Unsetting
Sometimes you want to verify a variable exists before attempting to remove it. This script checks for the variable first:
if [ -n "$API_KEY" ]; then
unset API_KEY
echo "API_KEY has been removed"
else
echo "API_KEY was not set"
fi
The -n
test checks if the variable is not empty. This approach prevents errors and provides feedback about the operation's success.
Understanding Scope and Inheritance
Environment variables exist at different scopes. When you unset a variable in your current shell, it only affects that session and any child processes started afterward:
export TEST_VAR="example"
bash # Start a new shell session
echo $TEST_VAR # Shows "example" (inherited)
unset TEST_VAR
echo $TEST_VAR # Shows nothing in this shell
exit # Return to parent shell
echo $TEST_VAR # Still shows "example" in parent
This behavior means unsetting variables in scripts or subshells doesn't affect the parent environment.
Removing Variables from Shell Configuration Files
If you've added variables to shell configuration files like .bashrc
, .zshrc
, or .profile
, you need to edit these files directly to prevent the variables from being recreated in new sessions:
# Edit your shell configuration file
nano ~/.bashrc
# Remove or comment out lines like:
# export API_KEY="abc123xyz"
# Reload the configuration
source ~/.bashrc
Simply unsetting the variable in your current session won't prevent it from being exported again when you start a new terminal.
Using env Command to Run Without Variables
The env
command can run programs with a modified environment. You can use it to start a shell without specific variables:
env -u API_KEY bash
This starts a new bash session with the API_KEY variable removed from the environment. The original shell session remains unchanged when you exit this new session.
Clearing All Environment Variables
In rare cases, you might want to start with a completely clean environment. The env command can do this:
env -i bash
This starts a bash session with only minimal environment variables. Use this approach carefully, as it removes PATH and other essential variables that many programs depend on.
Handling Variables with Special Characters
If your variable names contain special characters or spaces, you need to handle them carefully:
export "MY-API-KEY"="value"
unset "MY-API-KEY"
The quotes ensure the shell treats the entire string as the variable name, even with hyphens or other special characters.
Creating a Variable Cleanup Function
For development workflows that frequently create and remove variables, consider creating a cleanup function:
cleanup_dev_vars() {
unset API_KEY
unset DATABASE_URL
unset DEBUG_MODE
unset SECRET_TOKEN
echo "Development variables cleared"
}
# Usage
cleanup_dev_vars
Add this function to your shell configuration file to make it available in all sessions. This approach standardizes your cleanup process and prevents accidentally leaving sensitive variables in your environment.
Verifying Variable Removal
You can list all environment variables to confirm removal using the env
command:
env | grep API_KEY
If the variable was successfully removed, this command returns no output. For a more comprehensive check, you can compare the environment before and after:
env > before.txt
unset API_KEY
env > after.txt
diff before.txt after.txt
This shows exactly what changed in your environment, which is useful when debugging complex variable issues.
Temporary Variable Isolation
When you need to temporarily remove variables for testing, consider using a subshell:
(unset API_KEY; ./run-tests.sh)
The parentheses create a subshell where the variable is removed only for the duration of the test script. Your original shell session keeps the variable intact.
Next Steps
You now understand how to manage environment variable lifecycles in Linux. Consider learning about variable scoping in different shells, exploring tools like direnv
for project-specific environment management, or investigating how containerization affects environment variable inheritance.
Good luck managing your environment!
Found an issue?