BASH, the Bourne-Again shell - (on my way to) mastering the command line

What is a subshell ?

unset -v a; a=1
(echo "in the subshell, a is $a.")
sh -c 'echo "in the child shell, a is $a."'

in the subshell, a is 1.
in the child shell, a is .

https://tldp.org/LDP/abs/html/subshells.html

https://www.gnu.org/software/bash/manual/bash.html#Command-Execution-Environment


https://unix.stackexchange.com/questions/264169/on-fork-children-processes-and-subshells/264199#264199
- you're in a console (i.e. shell) and type : [command][ENTER]
- 'fork' makes a new process, with a new PID, that starts running in parallel from exactly where this one left off
- 'exec' replaces the currently-executing code with a new program loaded from somewhere, running from the beginning
	==> if this "new program" is the same binary (e.g. /bin/bash), there is nothing to 'exec'

so, when you spawn a new program :
- you first 'fork' yourself
- then 'exec' that program in the child
That is the fundamental theory of processes that applies everywhere, inside and outside of shells.

Subshells are forks, and every non-builtin command you run leads to both a 'fork' and an 'exec'.


https://unix.stackexchange.com/questions/264169/on-fork-children-processes-and-subshells/264192#264192
'fork', assuming all goes well, returns twice :
- one return is in the parent process (which has the original process ID)
- and the other in the new child process (a different process ID but otherwise sharing much in common with the parent process).

At this point, the child could 'exec' something, which would cause some "new" binary to be loaded into that process, though the child need not do that, and could run other code already loaded via the parent process (zsh functions, for example).
Hence, a fork may or may not result in a "completely new" process, if "completely new" is taken to mean something loaded via an 'exec' system call.

details on fork + exec
https://en.wikipedia.org/wiki/Fork%E2%80%93exec

Why does this matter ?

#!/usr/bin/env bash
a=3

displayA() {
	local message=$1
	echo -e "a = $a\t$message"
	}

main() {
	displayA 'in main, just started'

	let "a+=1"
	displayA 'in main, after increment'

	{
	let "a+=1"
	displayA 'in curly braces, after increment within braces'
	}

	displayA 'back in main'

	(
	let "a+=1"
	displayA 'in parentheses, after increment within parentheses'
	)

	displayA 'back in main'

	{
	let "a+=1"
	displayA 'increment + display as a background process'
	} &
	wait
	displayA 'back in main'

	}

main

a = 3   in main, just started
a = 4   in main, after increment
a = 5   in curly braces, after increment within braces
a = 5   back in main
a = 6   in parentheses, after increment within parentheses
a = 5   back in main
a = 6   increment + display as a background process
a = 5   back in main

• allows a process's input or output to be referred to using a filename :
  • some commands are like : myCommand myFile
  • process substitution allows a process to appear as a file for myCommand : myCommand aProcessDisguisedAsAFile
• can be either :
  • command1 <(command2) : the output of command2 serves as input to command1
  • or command1 >(command2) : the output of command1 serves as input to command2
• examples :
  • in whileread loops

How it works

• options :
  • affect the actions of command :
    • ls : (no option) list files
    • ls -l : list files using the long display format
  • can be specified with :
    • a single character with a leading hyphen : ls -a
    • a word with 2 leading hyphens : ls --all
  • may require a value (sometimes referred to as argument, which is rather confusing) :
    • for single-character options : with a [space] between the option and its value : tail -n 5 someFile
    • for "word" options : with a = between the option and its value : tail --lines=5 someFile
  • can have their short versions combined when they have no argument : ls -lh
  •  --  (i.e. [space]+--+[space]) marks the end of options, everything after this is an argument (even though it looks like a valid option)
• arguments :
  • are what command works on :
    • for cp : the source and destination values
    • for cd : the directory to enter
    • for emacs : the file to edit
    • for vlc : the file to play

More definitions (sources : 1, 2) :

!!

previous command (source : man -P 'less -p "\\!\\!"' history)

Technically, this is not a variable but a command. It's listed here because this article is where I'll start searching when facing such cryptic things .

!$

last argument of the preceding command. Said to be equivalent to $_ (see also)

$!

PID of last job run in background. Try it : pwd & echo $!

$#

number of parameters passed to the current script or function

Check it :

#!/usr/bin/env bash

tmpScript=$(mktemp tmpScript.XXXXXXXX)

cat << 'EOF' > "$tmpScript"
#!/usr/bin/env bash
main() { echo $# : $@; }
main "$@"
EOF

chmod +x "$tmpScript"
./"$tmpScript"
./"$tmpScript" foo
./"$tmpScript" foo bar
./"$tmpScript" 'foo bar'
rm "$tmpScript"

0 :
1 : foo
2 : foo bar
1 : foo bar

$$

PID of current process

• It _may_ sound like a good idea to use this as part of a temporary file name so that concurrent executions of a script won't collide, but mktemp will do that better.
• It's very convenient to detect which flavor of shell is being used : ps $$

  PID	TTY	STAT	TIME	COMMAND
  18060	pts/1	Ss	0:01	/bin/bash

$*

all the parameters passed to the current script, as a space-separated string (source) :

• $* and $@ hold a b c d (4 distinct elements)
• "$*" holds a b c d (a single string having spaces). This is not iterable because of the explicit double-quotes.
• "$@" holds a b c d (the 3 script parameters). The double quotes protect spaces when they are part of the parameter itself.

Check it :

#!/usr/bin/env bash
# run :	./script.sh a b 'c d'

echo -e '\nwith $* :'
for i in $*; do echo $i; done

echo -e '\nwith $@ :'
for i in  $@; do echo $i; done

echo -e '\nwith "$*" :'
for i in  "$*"; do echo $i; done

echo -e '\nwith "$@" :'
for i in  "$@"; do echo $i; done

with $* :
a
b
c
d

with $@ :
a
b
c
d

with "$*" :
a b c d

with "$@" :
a
b
c d

$-

current options set for the shell, the doc says it is not completely reliable

This variable is often used to check whether the current script is run interactively or not (details).

$0

name of the shell or current shell script (see also ${BASH_SOURCE[0]})

$?

decimal exit code of previous process (aka "most recent pipeline").

This handles the value returned by return.

$@

all the parameters passed to the current script or function, as separate words. This is an "iterable list of strings" (source, see $* for details)

You should practically always use double quotes around "$@".

$_

final argument of previous command executed :

testFile='./test'; echo $_; echo hello >"$testFile"; echo $_; rm "$testFile"; echo $_

hello	this is the last argument of echo, even if there are some extra directives on the command line
./test	this refers to "$testFile" coming after rm : the value has been substituted

BASH_SOURCE[0]

this is almost a synonymous of $0 but has slight differences (source) :

${BASH_SOURCE[0]}	$0
holds the current script name, when executed or sourced is read-only is Bash-specific can be shortened to $BASH_SOURCE (Bash allows referring to the element 0 of an array with the array name itself)	holds the current script name only when executed (something else when sourced) can be overwritten is POSIX-compliant

Check it with this script :

#!/usr/bin/env bash
echo -e "
\$0:$0
\$BASH_SOURCE:$BASH_SOURCE
\${BASH_SOURCE[0]}:${BASH_SOURCE[O]}
" | column -s ':' -t

• ./test.sh

  $0			./test.sh
  $BASH_SOURCE		./test.sh
  ${BASH_SOURCE[0]}	./test.sh

• source test.sh

  $0			/bin/bash
  $BASH_SOURCE		test.sh
  ${BASH_SOURCE[0]}	test.sh

DISPLAY

• indicates where the X server is. Format :
  host:displayNumber.screenNumber
  Numbers start at 0 !
• To temporarily connect to a specific X server, just type :
  command_line -display (or --display ?) host:displayNumber.screenNumber
• If you're connecting to the remote host via SSH, consider using the X11 forwarding option.

EDITOR

define which editor to use with :

• crontabs
• Git commit messages, rebases, patches, ...
• files viewed with less
• ansible-vault

http_proxy

Set it with :

export http_proxy=http://host:port

Same goes on for https_proxy and ftp_proxy.

HISTFILE

Upon Bash process termination, all typed commands are written into an history file — ~/.bash_history — which absolute path is stored in HISTFILE.

You may disable recording the history of commands.

HOME

current user's home directory, and default for the cd builtin command

About unquoted tilde expressions : ~whatever (source) :

• if whatever is a valid user name — like ~bob— the tilde expression is expanded into Bob's home directory
• if whatever is an empty string, ~ is expanded into $HOME
• otherwise, whatever is left unchanged

HOSTNAME

The name of the current host

IFS

• input field separator : used to split string into substrings, defaults to "[space][tab][newline]"
• How to loop on items with SPACEs ?

LANG (1, 2, 3)

• sets the default locale, i.e. the locale used when no more specific setting (LC_COLLATE, LC_NUMERIC, LC_TIME, ) is provided; it doesn't override any setting, it provides the base value.
• prefixing a shell command with LANG=C is a common hack to ensure the output message will be displayed in the default language (i.e. english), which is important on commands that select/filter text
• list the available locales

LANGUAGE

• not listed in the Bash reserved variables names (???)
• usage :

  LANGUAGE=en find charlie
  	find: 'charlie': No such file or directory
  LANGUAGE=fr find charlie
  	find: 'charlie': Aucun fichier ou dossier de ce type

LC_NUMERIC

defines whether numbers should be displayed with a point or a comma as a decimal separator

LOGNAME

Depending on the Unix / Linux flavor :

• either the name of the user that initially logged in, even though this user executed su afterwards (source : 1, 2)
• or a synonymous for USER

OLDPWD

The previous working directory as set by the cd builtin (see PWD)

PATH

Path to binaries. Since this is a colon (:)-separated list, to append a new value :

• DON'T :
  PATH=path/to/some/directory
  this would overwrite the whole content of the variable
• DO :
  PATH=$PATH:path/to/some/directory

PIPESTATUS

Array holding exit statuses of last executed foreground pipe. Indexes start at 0.

true | true | false | true | false | false | true; echo ${PIPESTATUS[*]}

0 0 1 0 1 1 0

true | true | false | true | false | false | true; echo "${PIPESTATUS[0]} ${PIPESTATUS[1]} ${PIPESTATUS[2]} ${PIPESTATUS[3]} ${PIPESTATUS[4]} ${PIPESTATUS[5]} ${PIPESTATUS[6]}"

0 0 1 0 1 1 0

PPID

The shell's parent process identifier (or parent's pid if you like)

PROMPT_COMMAND

The contents of this variable are executed as a regular Bash command just before Bash displays a prompt.

This can be used to display the current Git branch in the prompt (inspired by).

PS1

is the shell prompt (details)

PWD

The current working directory as set by cd (see OLDPWD). Using currentDir=$(pwd) is double work since PWD is already available.

RANDOM

• returns a pseudorandom integer in the range 0 - 32767
• to roll a dice :
  echo $(($RANDOM % 6))
  • this is a 0-based dice, with numbers 0, 1, 2, 3, 4, 5 and no 6
  • you may find articles mentioning the $[] construct : this is an old syntax that has been obsoleted by $(())
• see also shuf

SHELL

• full pathname to the shell
• if not set when the shell starts, Bash assigns to it the full pathname of the current user's login shell

SHLVL

number of nested subshells (starts at 1). Try it : echo -n $SHLVL; bash -c 'echo -n $SHLVL; bash -c "echo -n \$SHLVL"; echo -n $SHLVL; exit; '; echo -n $SHLVL will output :

12321

TMPDIR

directory in which Bash creates temporary files for its own use

UID

The numeric real user id of the current user, readonly.

USER

the current user name, replaces an overkill $(whoami) in scripts

This variable is often set as an environment variable by Bash login startup files, but it is not actually a Bash builtin (source).

• WARNING: terminal is not fully functional
• Error opening terminal: screen.xterm-256color.

1. this has to do with the shell history
2. history entries are named events
3. the shell interprets inputs like !something as commands to recall an event (details)

So, if you just want to use an exclamation mark (not followed by a space) in a string, just simple-quote it :

echo Hello world !

Hello world !

echo Hello world ! Hello everybody !

Hello world ! Hello everybody !

echo ah!ah!ah!

bash: !ah!ah!: event not found

echo "ah!ah!ah!"

bash: !ah!ah!: event not found

echo 'ah!ah!ah!'

ah!ah!ah!

echo Hello everybody !!

Surprise... but remember !! can express more than just extreme happiness

• set -o vi
• set -o emacs

I have :

testString='I like bananas.\nbananas are great.\nbananas are what I prefer.\nMy favorite fruit is bananas.'; echo -e "$testString"

I like bananas.
bananas are great.
bananas are what I prefer.
My favorite fruit is bananas.

I want :

I like bananas.
bananas are great.
oranges are what I prefer.
My favorite fruit is bananas.

With awk (source) :

oranges are what I prefer.

With sed :

I like bananas.
bananas are great.
oranges are what I prefer.
My favorite fruit is bananas.

BEFORE :
I like bananas.
bananas are great.
bananas are what I prefer.
My favorite fruit is bananas.

AFTER :
I like bananas.
bananas are great.
oranges are what I prefer.
My favorite fruit is bananas.

At first sight, sed looked simpler to me than Awk, but Awk is also able to work on a specific field of every line, or on a specific field of a specific line.

1. read input
2. ignore the comment sign # and the rest of the line —if any
3. break it up into words and operators, obeying the quoting rules (escape characters, simple and double quotes) :
   • backslash \ : preserve the literal value of the following character (except newline)
   • single quotes '' : preserve the literal value of each character enclosed within the quotes. A single quote may not occur between single quotes, even when preceded by a \.
   • double quotes "" : preserve the literal value of all characters enclosed within the quotes, except for $, `` and \.
   No * within quotes.
4. perform alias expansion
5. substitute the tokens into simple and compound commands (e.g. if, for, while, [[, case, constructs. More)
6. perform shell expansions (details at gnu.org, tldp.org) :
   1. brace expansion : {}
   2. tilde expansion : ~
   3. variables expansion : $myVariable is substituted with its value
   4. commands substitution :
      • $(command) (or `command`) is substituted with its output
      • command is executed in a subshell
      • details at : gnu.org, tldp.org
   5. arithmetic expansion : $((arithmeticExpression)) is substituted with its result
   6. process substitution
   7. word split : split the result of previous expansions by SPACE (actually, each character of $IFS is a delimiter).
   8. file name expansion : if any word contains *, ? or[, it is considered as a pattern and replaced with an alphabetically sorted list of file names matching the pattern (if any. Otherwise, leave the special character as-is)
7. redirections —if any
8. execute the command
9. wait for the command to complete and collect its exit status

Examples :

• Regex operators
• Substrings and regular expressions in a Awk / Bash / Perl / sed context
• Wildcards in Bash

On UTF-8-capable systems (and generally speaking : extended charsets), characters lists such as a-z include special characters like à, é or î. Thus, characters lists (a-z) can not be used in regular expressions to discriminate ASCII/non-ASCII characters. To do so, the solution is to build a complete list of all characters to match against with a regular expression : abcdefghijklmnopqrstuvwxyz (source).

-bash: [: -eq: unary operator expected
this is the "ELSE" part

ksh: [: argument expected
this is the "ELSE" part

-bash: [: -ne: unary operator expected
this is the "ELSE" part

ksh: [: argument expected
this is the "ELSE" part

We note that :

• The error messages differ depending on the shell being used
• Whatever a -eq or a -ne test is made, the else part is executed.

Send several commands via SSH :

ssh bob@sshServer << EOC
command1
command2
EOC

Send several lines of text to a command via a | :

cat << EOL | grep base
Roses are #ff0000
Violets are #0000ff
All my base are belong to you
EOL

Create a new file :

cat << EOF > newFile.txt
some text, line 1
some text, line 2
some text, line n
EOF

cat << EOF > newFile.txt
line 1, not indented
    line 2, space-indented
	line 3, TAB-indented
EOF
cat newFile.txt; rm newFile.txt

Stop token hacks

cat << EOF
indent : none
  indent : SPACE * 2
	indent : TAB * 1

EOF

cat <<-EOF
indent : none
  indent : SPACE * 2
	indent : TAB * 1

EOF

indent : none
  indent : SPACE * 2
	indent : TAB * 1

indent : none
  indent : SPACE * 2
indent : TAB * 1

What if I want to output some special characters without disabling variable expansion ?

value=42; exampleFile='/tmp/myExampleFile.txt'; cat << EOF > "$exampleFile"
if (\$something > $value)
    blah

if (\$anything < ($value/2))
    pooh
else
    nomnom

if (true || false || whatever)
    who_cares
EOF
cat "$exampleFile"; rm "$exampleFile"

if ($something > 42)
    blah

if ($anything < (42/2))
    pooh
else
    nomnom

if (true || false || whatever)
    who_cares

How to pipe a multiline heredoc into a command ?

cat << EOSQL | sqlplus -s / as sysdba | grep -Ev '^$'
SELECT DISTINCT(TRUNC(last_refresh)) FROM dba_snapshot_refresh_times;
query1;
query2;
EOSQL

echo -e "query1;\nquery2;" | sqlplus -s / as sysdba | grep -Ev '^$'

sqlplus -s / as sysdba << EOSQL | grep -Ev '^$'
query1;
query2;
EOSQL

HEADER
data line 1
data line 2
data line 3

... with grep :

echo -e "HEADER\ndata line 1\ndata line 2\ndata line 3" | grep -v 'HEADER'

Requires to know how to match the header line, i.e. knowing HEADER.

... with sed :

• echo -e "HEADER\ndata line 1\ndata line 2\ndata line 3" | sed -n '2,$ p'
• or even simpler : echo -e "HEADER\ndata line 1\ndata line 2\ndata line 3" | sed 1d

... with tail :

echo -e "HEADER\ndata line 1\ndata line 2\ndata line 3" | tail -n +2

• bash --version
• echo $BASH_VERSION

Leading characters :

for i in {1..1000}; do echo $RANDOM >> data.txt; done

sed -r 's/(^.{3}).*$/\1/g' data.txt

cut -c -3 data.txt

Trailing characters :

echo hello | sed -r 's/.*(.{3})$/\1/g'

user@host $ emacs & vlc &
[1] 10367
[2] 10368

List the current jobs :

Suspend a running job :

Resume a suspended job :

Output a list of values (details) :

Output a sequence of characters or numbers (details):

Other brace expansions :

foo1bar foo2bar foo3bar

test_1a_ test_1b_ test_2a_ test_2b_

a h o v

myFunction() {
	local myVariable=$1
	local myOtherVariable=${2:-42}
	
	}

value
nothing

value
42

value
nothing

key exists
(empty line)

42
bash: value: this variable is unset.

7

☹☺	2

def
bcdef
bbccc

txt

ccc

log

aaabbbccc
aaabb

aaa

abcdef

abCD abcd

abCD abCD

Hello, world
HELLO, WORLD
hELLO, WORLD
hello, world

Exit codes over 255

With !! :

With ^wrong^right^ :

HISTCONTROL=ignoredups

Log only once repeated commands

HISTCONTROL=ignorespace

Don't log commands prefixed with a space

This disables recalling the last argument of a previous command with ALT-..

HISTCONTROL=ignoreboth

Equivalent to HISTCONTROL=ignoredups:ignorespace

HISTCONTROL value is a colon (:) -separated list.

Foreword :

A basic colorless prompt : stuart@myWorkstation:~[0]$ :

export PS1='\u@\h:\w[\j]\$ '

Add colors + a green / red square indicating the status of the previous command (more about colors) : █ stuart@myWorkstation [0] ~$ :

NOCOLOR="\[\e[0m\]"
RED="\[\e[1;31m\]"
GREEN="\[\e[0;32m\]"
YELLOW="\[\e[1;33m\]"
BLUE="\[\e[1;34m\]"
SQUARE="\342\226\210"

export PS1="\`if [ \$? = 0 ]; then echo '${GREEN}'; else echo '${RED}'; fi\`$SQUARE $RED\u$NOCOLOR@$BLUE\h $NOCOLOR[$YELLOW\j$NOCOLOR] \w\$ "

Improvement : also display the current Git branch (if any) : █ stuart@myWorkstation [0][master] ~$ :

NOCOLOR="\[\e[0m\]"
RED="\[\e[1;31m\]"
GREEN="\[\e[0;32m\]"
YELLOW="\[\e[1;33m\]"
BLUE="\[\e[1;34m\]"
SQUARE="\342\226\210"

export PS1="\`if [ \$? = 0 ]; then echo '${GREEN}'; else echo '${RED}'; fi\`$SQUARE $RED\u$NOCOLOR@$BLUE\h $NOCOLOR[$YELLOW\j$NOCOLOR]\`git branch &>/dev/null; if [ \$? ]; then git branch 2>/dev/null | awk '/^\*/ {print \"[$BLUE\"\$2\"$NOCOLOR]\"}'; fi\` \w\$ "

Improvement of this improvement (still gives █ stuart@myWorkstation [0][master] ~$ ) :

NOCOLOR="\[\e[0m\]"
RED="\[\e[1;31m\]"
GREEN="\[\e[0;32m\]"
YELLOW="\[\e[1;33m\]"
BLUE="\[\e[1;34m\]"
SQUARE="\342\226\210"

PROMPT_COMMAND='[ $? = 0 ] && squareColor="$GREEN" || squareColor="$RED"; \
currentGitBranch=$(git branch 2>/dev/null | awk '"'"'/^\*/ {print $2}'"'"'); \
[ -n "$currentGitBranch" ] && displayBranch="[$BLUE$currentGitBranch$NOCOLOR]" || displayBranch=''; \
PS1="$squareColor$SQUARE $RED\u$NOCOLOR@$BLUE\h $NOCOLOR[$YELLOW\j$NOCOLOR]$displayBranch \w\$ "'

Fix of the improvement of this improvement : (virtualenv) █ stuart@myWorkstation [0][master] ~$ :

NOCOLOR="\[\e[0m\]"
RED="\[\e[1;31m\]"
GREEN="\[\e[0;32m\]"
brightGreen="\[\e[1;32m\]"
YELLOW="\[\e[1;33m\]"
BLUE="\[\e[1;34m\]"
lightPurple="\[\e[1;35m\]"
SQUARE="\342\226\210"

PROMPT_COMMAND='[ $? = 0 ] && squareColor="$GREEN" || squareColor="$RED"; \
[ -z "$VIRTUAL_ENV" ] && displayVirtualEnv='' || displayVirtualEnv="($brightGreen$(basename "$VIRTUAL_ENV")$NOCOLOR) "
currentGitBranch=$(git branch 2>/dev/null | awk '"'"'/^\*/ {print $2}'"'"'); \
[ -n "$currentGitBranch" ] && displayBranch="[$lightPurple$currentGitBranch$NOCOLOR]" || displayBranch=''; \
PS1="$displayVirtualEnv$squareColor$SQUARE $RED\u$NOCOLOR@$BLUE\h $NOCOLOR[$YELLOW\j$NOCOLOR]$displayBranch \w\$ "'

List of color codes (full list with details and examples) :

Black       0;30		White         1;37
Dark Gray   1;30		Light Gray    0;37
Red         0;31		Light Red     1;31
Green       0;32		Light Green   1;32
Brown       0;33		Yellow        1;33
Blue        0;34		Light Blue    1;34
Purple      0;35		Light Purple  1;35
Cyan        0;36		Light Cyan    1;36

Demo : display all available colors :

Bash has a built-in pattern matching parser (which must not be mistaken with actual regular expressions). Wildcards can be used with any command that accepts file names as arguments (i.e. almost anything ).

1. Bash searches for wildcards substitutions to perform on file names : are there any existing files matching the wildcards ?
   • yes : perform substitutions
   • no : leave the command as-is
2. execute the command obtained from the step above

Wildcards / patterns :

/home/bob ~ ~

touch /tmp/myFile_{foo,bar,baz}

ls /tmp/myFile* | grep -E 'ba[rz]'; ls /tmp/myFile*[rz]
ls /tmp/myFile* | grep -E 'o+'; ls /tmp/myFile*+(o)

ls /tmp/myFile* | grep -E '[^o]$'; ls /tmp/myFile*!(o)		<-- ko :-(
ls /tmp/myFile* | grep -E '[^o].$'; ls -1 /tmp/myFile??!(o)?

rm /tmp/myFile_{foo,bar,baz}

Different flavors of shell :

Shell type	Technical definition	Description	Use case
login	shell whose first character of argument zero is - or one started with --login	This is a shell that is opened after authenticating, either locally (e.g. at boot time) or via SSH : the prompt is displayed after a successful login (going through /bin/login). The login shell is the first process that executes under your user ID when you log in for an interactive session.	virtual terminal (Ctrl-Alt-Fn) SSH
non-login		The prompt is displayed without re-authenticating.	shell emulator within a GUI : gnome-terminal xfce4-terminal
interactive	a shell started : without non-option arguments (unless -s is specified) and without the -c option whose standard input and error are both connected to terminals or one started with -i PS1 is set and $- includes i if bash is interactive, allowing a shell script or a startup file to test this state.	The shell : waits for keyboard input to execute commands. can be either a login or non-login shell.	virtual terminal (Ctrl-Alt-Fn) SSH emulator such as gnome-terminal, xfce4-terminal or xterm
non-interactive		A non-interactive shell is usually present when a shell script is running. It is non-interactive because it is processing a script and not waiting for user input between commands. For these shell invocations, only the environment inherited from the parent shell is used.	scripts daemons / "rc scripts"

And because an image is worth 1000 words (full-size version) :

Files read :

How to set environment variables for a specific daemon ?

export http_proxy="http://kevin:password@proxyHost:port/"
export https_proxy="http://kevin:password@proxyHost:port/"

Other version / doesn't agree (!)

1. If ~/.bash_profile exists, it's executed, then "STOP". If it doesn't exist, go on to the next step.
2. if ~/.profile exists, it's executed, then "STOP". If it doesn't exist, go on to the next step.
3. if ~/.bashrc exists, it's executed, then "STOP".

~/.bash_profile or ~/.profile must end on :

. ~/.bashrc

for i in *tmp; do command $i; done

• find location criteria -delete
• find location criteria | xargs rm
• If you're just trying to delete numerous files, consider this rsync hack.