-o allexport enables all following variable definitions to be exported. +o allexport disables this feature.

set -o allexport source conf-file set +o allexport 

Problem with your approach is the export in the while loop is happening in a sub shell, and those variable will not be available in current shell (parent shell of while loop).

Add export command in the file itself:

export MINIENTREGA_FECHALIMITE="2011-03-31" export MINIENTREGA_FICHEROS="informe.txt programa.c" export MINIENTREGA_DESTINO="./destino/entrega-prac1" 

Then you need to source in the file in current shell using:

. ./conf/prac1 

OR

source ./conf/prac1 

set -a . ./env.txt set +a 

If env.txt is like:

VAR1=1 VAR2=2 VAR3=3 ... 

Explanations -a is equivalent to allexport. In other words, every variable assignment in the shell is exported into the environment (to be used by multiple child processes). More information can be found in the Set builtin documentation:

-a     Each variable or function that is created or modified is given the export attribute and marked for export to the environment of subsequent commands.

Using ‘+’ rather than ‘-’ causes these options to be turned off. The options can also be used upon invocation of the shell. The current set of options may be found in $-.

Tradeoffs. This recipe secures variable information in the script from being logged on the command line. This may be desired if the script contains sensitive information, however it could also be a hassle when debugging. With sensitive information like encryption keys, a plaintext file may not be an appropriate place for that especially if you're version controlling the file.

I found the most efficient way is:

export $(xargs < .env) 

Explanation

When we have a .env file like this:

key=val foo=bar 

run xargs < .env will get key=val foo=bar

so we will get an export key=val foo=bar and it's exactly what we need!

Limitation

1. It doesn't handle cases where the values have spaces in them. Commands such as env produce this format. – @Shardj

The allexport option is mentioned in a couple of other answers here, for which set -a is the shortcut. Sourcing the .env really is better than looping over lines and exporting because it allows for comments, blank lines, and even environment variables generated by commands. My .bashrc includes the following:

# .env loading in the shell dotenv () { set -a [ -f .env ] && . .env set +a } # Run dotenv on login dotenv # Run dotenv on every new directory cd () { builtin cd $@ dotenv } 

The problem with source is that it requires the file to have a proper bash syntax, and some special characters will ruin it: =, ", ', <, >, and others. So in some cases you can just

source development.env 

and it will work.

This version, however, withstands every special character in values:

set -a source <(cat development.env | \ sed -e '/^#/d;/^\s*$/d' -e "s/'/'\\\''/g" -e "s/=\(.*\)/='\1'/g") set +a 

Explanation:

• -a means that every bash variable would become an environment variable
• /^#/d removes comments (strings that start with #)
• /^\s*$/d removes empty strings, including whitespace
• "s/'/'\\\''/g" replaces every single quote with '\'', which is a trick sequence in bash to produce a quote :)
• "s/=\(.*\)/='\1'/g" converts every a=b into a='b'

As a result, you are able to use special characters :)

To debug this code, replace source with cat and you'll see what this command produces.

Note for direnv users: it has a helper function dotenv, use it instead in your .envrc file:

[ -f ".env" ] && dotenv ".env" 

eval $(cat .env | sed 's/^/export /') 

Here is another sed solution, which does not run eval or require ruby:

source <(sed -E -n 's/[^#]+/export &/ p' ~/.env) 

This adds export, keeping comments on lines starting with a comment.

.env contents

A=1 #B=2 

sample run

$ sed -E -n 's/[^#]+/export &/ p' ~/.env export A=1 #export B=2 

I found this especially useful when constructing such a file for loading in a systemd unit file, with EnvironmentFile.

Not exactly sure why, or what I missed, but after running trough most of the answers and failing. I realized that with this .env file:

MY_VAR="hello there!" MY_OTHER_VAR=123 

I could simply do this:

source .env echo $MY_VAR 

Outputs: Hello there!

Seems to work just fine in Ubuntu linux.

The shortest way I found:

Your .env file:

VARIABLE_NAME="A_VALUE" 

Then just

. ./.env && echo ${VARIABLE_NAME} 

Bonus: Because it's a short one-liner, it's very useful in package.json file

 "scripts": { "echo:variable": ". ./.env && echo ${VARIABLE_NAME}" } 

Note: This way does not export the variables to the child process, check other answers if this is your need.

I have upvoted user4040650's answer because it's both simple, and it allows comments in the file (i.e. lines starting with #), which is highly desirable for me, as comments explaining the variables can be added. Just rewriting in the context of the original question.

If the script is callled as indicated: minientrega.sh prac1, then minientrega.sh could have:

set -a # export all variables created next source $1 set +a # stop exporting # test that it works echo "Ficheros: $MINIENTREGA_FICHEROS" 

The following was extracted from the set documentation:

This builtin is so complicated that it deserves its own section. set allows you to change the values of shell options and set the positional parameters, or to display the names and values of shell variables.

set [--abefhkmnptuvxBCEHPT] [-o option-name] [argument …] set [+abefhkmnptuvxBCEHPT] [+o option-name] [argument …]

If no options or arguments are supplied, set displays the names and values of all shell variables and functions, sorted according to the current locale, in a format that may be reused as input for setting or resetting the currently-set variables. Read-only variables cannot be reset. In POSIX mode, only shell variables are listed.

When options are supplied, they set or unset shell attributes. Options, if specified, have the following meanings:

-a Each variable or function that is created or modified is given the export attribute and marked for export to the environment of subsequent commands.

And this as well:

Using ‘+’ rather than ‘-’ causes these options to be turned off. The options can also be used upon invocation of the shell. The current set of options may be found in $-.

Improving on Silas Paul's answer

exporting the variables on a subshell makes them local to the command.

(export $(cat .env | xargs) && rails c)

SAVE=$(set +o | grep allexport) && set -o allexport && . .env; eval "$SAVE"

This will save/restore your original options, whatever they may be.

Using set -o allexport has the advantage of properly skipping comments without a regex.

set +o by itself outputs all your current options in a format that bash can later execute. Also handy: set -o by itself, outputs all your current options in human-friendly format.

Sorry to add yet another answer but because it's simplistic and works in many (but obviously not all, see the comments) cases, try:

export $(< ~/my/.env) 

If env supports the -S option one may use newlines or escape characters like \n or \t (see env):

env -S "$(cat .env)" command 

.env file example:

KEY="value with space\nnewline\ttab\tand multiple lines" 

Test:

env -S "$(cat .env)" sh -c 'echo "$KEY"' 

Use shdotenv

dotenv support for shell and POSIX-compliant .env syntax specification
https://github.com/ko1nksm/shdotenv

eval "$(shdotenv)" 

Usage

Usage: shdotenv [OPTION]... [--] [COMMAND [ARG]...] -d, --dialect DIALECT Specify the .env dialect [default: posix] (posix, ruby, node, python, php, go, rust, docker) -s, --shell SHELL Output in the specified shell format [default: posix] (posix, fish) -e, --env ENV_PATH Location of the .env file [default: .env] Multiple -e options are allowed -o, --overload Overload predefined environment variables -n, --noexport Do not export keys without export prefix -g, --grep PATTERN Output only those that match the regexp pattern -k, --keyonly Output only variable names -q, --quiet Suppress all output -v, --version Show the version and exit -h, --help Show this message and exit 

Requirements

shdotenv is a single file shell script with embedded awk script.

• POSIX shell (dash, bash, ksh, zsh, etc)
• awk (gawk, nawk, mawk, busybox awk)

Here's my variant:

 with_env() { (set -a && . ./.env && "$@") } 

compared with the previous solutions:

• it does not leak variables outside scope (values from .env are not exposed to caller)
• does not clobber set options
• returns exit code of the executed command
• uses posix compatible set -a
• uses . instead of source to avoid bashism
• command is not invoked if .env loading fails

with_env rails console 

Some notes:

1. The ".env" file should have an "LF" end-of-line sequence.
2. Avoid using dynamic values in environment variables, such as variable1=$variable2@$variable3
3. Avoid using a quotation (") in environment variables vavlue, such as variable="value"

This is the best and shortest answer

source .env && export $(cut -d= -f1 < .env) 

Simpler:

1. grab the content of the file
2. remove any blank lines (just incase you separated some stuff)
3. remove any comments (just incase you added some...)
4. add export to all the lines
5. eval the whole thing

eval $(cat .env | sed -e /^$/d -e /^#/d -e 's/^/export /')

Another option (you don't have to run eval (thanks to @Jaydeep)):

export $(cat .env | sed -e /^$/d -e /^#/d | xargs) 

Lastly, if you want to make your life REALLY easy, add this to your ~/.bash_profile:

function source_envfile() { export $(cat $1 | sed -e /^$/d -e /^#/d | xargs); }

(MAKE SURE YOU RELOAD YOUR BASH SETTINGS!!! source ~/.bash_profile or.. just make a new tab/window and problem solved) you call it like this: source_envfile .env

t=$(mktemp) && export -p > "$t" && set -a && . ./.env && set +a && . "$t" && rm "$t" && unset t 

How it works

1. Create temp file.
2. Write all current environment variables values to the temp file.
3. Enable exporting of all declared variables in the sources script to the environment.
4. Read .env file. All variables will be exported into current environment.
5. Disable exporting of all declared variables in the sources script to the environment.
6. Read the contents of the temp file. Every line would have declare -x VAR="val" that would export each of the variables into environment.
7. Remove temp file.
8. Unset the variable holding temp file name.

Features

• Preserves values of the variables already set in the environment
• .env can have comments
• .env can have empty lines
• .env does not require special header or footer like in the other answers (set -a and set +a)
• .env does not require to have export for every value
• one-liner

You can use your original script to set the variables, but you need to call it the following way (with stand-alone dot):

. ./minientrega.sh 

Also there might be an issue with cat | while read approach. I would recommend to use the approach while read line; do .... done < $FILE.

Here is a working example:

> cat test.conf VARIABLE_TMP1=some_value > cat run_test.sh #/bin/bash while read line; do export "$line"; done < test.conf echo "done" > . ./run_test.sh done > echo $VARIABLE_TMP1 some_value 

I work with docker-compose and .env files on Mac, and wanted to import the .env into my bash shell (for testing), and the "best" answer here was tripping up on the following variable:

.env

NODE_ARGS=--expose-gc --max_old_space_size=2048 

Solution

So I ended up using eval, and wrapping my env var defs in single quotes.

eval $(grep -v -e '^#' .env | xargs -I {} echo export \'{}\') 

Bash Version

$ /bin/bash --version GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin18) Copyright (C) 2007 Free Software Foundation, Inc. 

My requirements were:

• simple .env file without export prefixes (for compatibility with dotenv)
• supporting values in quotes: TEXT="alpha bravo charlie"
• supporting comments prefixed with # and empty lines
• universal for both mac/BSD and linux/GNU

Full working version compiled from the answers above:

 set -o allexport eval $(grep -v '^#' .env | sed 's/^/export /') set +o allexport 

Building on other answers, here is a way to export only a subset of lines in a file, including values with spaces like PREFIX_ONE="a word":

set -a . <(grep '^[ ]*PREFIX_' conf-file) set +a 

I have issues with the earlier suggested solutions:

• @anubhava's solution makes writing bash friendly configuration files very annoying very fast, and also - you may not want to always export your configuration.
• @Silas Paul solution breaks when you have variables that have spaces or other characters that work well in quoted values, but $() makes a mess out of.

Here is my solution, which is still pretty terrible IMO - and doesn't solve the "export only to one child" problem addressed by Silas (though you can probably run it in a sub-shell to limit the scope):

source .conf-file export $(cut -d= -f1 < .conf-file) 

My .env:

#!/bin/bash set -a # export all variables #comments as usual, this is a bash script USER=foo PASS=bar set +a #stop exporting variables 

Invoking:

source .env; echo $USER; echo $PASS 

Reference https://unix.stackexchange.com/questions/79068/how-to-export-variables-that-are-set-all-at-once

My version :

I print the file, remove commented lines, emptylines, and I split key/value from "=" sign. Then I just apply the export command.

The advantage of this solution is the file can contain special chars in values, like pipes, html tags, etc., and the value doesn't have to be surrounded by quotes, like a real properties file.

# Single line version cat myenvfile.properties | grep -v '^#' | grep '=' | while read line; do IFS=\= read k v <<< $line; export $k="$v"; done # Mutliline version: cat myenvfile.properties | grep -v '^#' | grep '=' | while read line; do IFS=\= read k v <<< $line export $k="$v" done 

Here's my take on this. I had the following requirements:

• Ignore commented lines
• Allow spaces in the value
• Allow empty lines
• Ability to pass a custom env file while defaulting to .env
• Allow exporting as well as running commands inline
• Exit if env file doesn't exist

source_env() { env=${1:-.env} [ ! -f "${env}" ] && { echo "Env file ${env} doesn't exist"; return 1; } eval $(sed -e '/^\s*$/d' -e '/^\s*#/d' -e 's/=/="/' -e 's/$/"/' -e 's/^/export /' "${env}") } 

Usage after saving the function to your .bash_profile or equivalent:

source_env # load default .env file source_env .env.dev # load custom .env file (source_env && COMMAND) # run command without saving vars to environment 

Inspired by Javier and some of the other comments.

White spaces in the value

There are many great answers here, but I found them all lacking support for white space in the value:

DATABASE_CLIENT_HOST=host db-name db-user 0.0.0.0/0 md5 

I have found 2 solutions that work whith such values with support for empty lines and comments.

One based on sed and @javier-buzzi answer:

source <(sed -e /^$/d -e /^#/d -e 's/.*/declare -x "&"/g' .env) 

And one with read line in a loop based on @john1024 answer

while read -r line; do declare -x "$line"; done < <(egrep -v "(^#|^\s|^$)" .env) 

The key here is in using declare -x and putting line in double quotes. I don't know why but when you reformat the loop code to multiple lines it won't work — I'm no bash programmer, I just gobbled together these, it's still magic to me :)