Shell - HowTo's

while read link; do
	target=$(readlink "$link")
	[ -d "$target" ] && continue			it's not possible to target a directory with a hard link
#	echo "$link --> $target"
	ls -l "$link"
	echo '==============================='
	mv "$link" "$link"_DISABLED
	ln "$target" "$link"
done < <(find -type l)

5
1
6
1

3	a++ : "return" the value, then increment
5	++a : increment the value, then return it
5

4
5

0 1 2 0 1 2 0 1 2 0 

What about the $[] operator ?

Example 1 : display the angstrom symbol : Å

Example 2 : and now a doggy 🐕

What's the difference between \u and \U ? (source)

Detailed answer

Example

sleepDuration='0.1';
echo -en '\033[1;31mO\033[0;33m o===B\033[0m'; sleep 0.8
echo -en '\b\b\b\b\b\b\b\033[1;31mO\033[0;33mo===B\033[0m '; sleep 0.8
while true; do
echo -en '\b\b\b\b\b\b\b\b\033[1;31mO\033[0;33m===B\033[0m  '; sleep $(echo $sleepDuration*2 | bc)
echo -en '\b\b\b\b\b\b\b\033[1;31mO\033[0;33m==B\033[0m   '; sleep $sleepDuration
echo -en '\b\b\b\b\b\033[0;33mB\033[0m    '; sleep $sleepDuration
echo -en '\b\b\b\b\b\b\033[0;33mB\033[0m     '; sleep $sleepDuration
echo -en '\b\b\b\b\b\b\b\033[1;31mO\033[0;33m=B\033[0m    '; sleep $sleepDuration
done

Details and warning about this construct :

Remember : command1 && command2 || command3 ...

Compare 2 sets of files having the same names (such as 2 backups : ./directory1/* ./directory2/*) :

export TMOUT=0

-bash: TMOUT: readonly variable

unset TMOUT

-bash: unset: TMOUT: cannot unset: readonly variable

Method 1 : gdb (sources : 1, 2)

# Disable the stupid auto-logout
unset TMOUT >/dev/null 2>&1
if [ $? -ne 0 ]; then
	gdb <<EOF >/dev/null 2>&1
	attach $$
	call unbind_variable("TMOUT")
	detach
	quit
EOF
fi

Method 2 : exec (source)

A symlink (aka symbolic or soft link)

is just a special file (with its own inode) containing the path to another file. This is why it's able to refer to files on any filesystem.

A hard link

is not so special, actually. On *Nix filesystems (where Everything is a file., remember ?), directories are "files listing files" (including sub-directories). They do so by matching an inode number (i.e. where the data is found on the filesystem) to a label (the file name). And since this is just a list of matching inode / label, nothing forbids several labels to share the same inode. Which is exactly what hard links do. (sources : 1, 2)

A "regular" file (or a directory)

is just a hard link with a "1 to 1" inode / label relation, whereas hard links have a "1 to many" inode / label relation.

If you know the target :

135340 -rw-r--r-- 2 kevin users 9042 Sep 19 15:05 suspectFile
135340 -rw-r--r-- 2 kevin users 9042 Sep 19 15:05 target

If you don't know the target :

/path/to/suspectFile
/different/path/to/someFile

  File: suspectFile
  Size: 9042            Blocks: 24         IO Block: 4096   regular file
Device: fe04h/65028d    Inode: 135340      Links: 2		more than 1 link : this is a hard link
Access: (0644/-rw-r--r--)  Uid: ( 1000/   kevin)   Gid: ( 1000/   users)
Access: 2018-09-19 15:05:26.103989305 +0200
Modify: 2018-09-19 15:05:26.103989305 +0200
Change: 2018-09-20 14:11:38.766124455 +0200
 Birth: -

1. If the key is a "special" one (function, CTRL-ed or ALT-ed), get its code with CTRL-V key. For example, CTRL-V F9 will output ^[[20~, but we mustn't forget that the ^[ here is an escape sequence and stands for \e. So the final code for F9 is \e[20~.
2. Then : bind '"keyCode":"someCommand"' :
   • bind '"\e[20~":"echo \"Hello World\""' : this just displays the echo "Hello World" string after pressing F9without actually executing the echo command.
   • bind '"\e[20~":"echo \"Hello World\"\n"' : thanks to the final \n (interpreted as), the command is executed upon pressing F9. There seem to be no way of preventing the bound command to be displayed
   • Also works with compound commands : bind '"\e[20~":"for i in $(seq 10 -1 1); do echo $i; sleep 0.1; done; echo 'BOOOM\!'\n"'
   • Or : bind '"\e[20~":"nbPressed=$((nbPressed+1)); echo \"You pressed F9 $nbPressed times.\"\n"'
3. To unbind the function : bind '"\e[20~":""'

Define key bindings in ~/.inputrc to make them permanent

# CTRL-F11 : display "/etc/apache2/sites-enabled/"
"\e[23;5~":"/etc/apache2/sites-enabled/"

# CTRL-F12 : display "/var/www/"
"\e[24;5~":"/var/www/"

# F11 : display "/etc/apache2/sites-enabled/"
"\e[23~":"/etc/apache2/sites-enabled/"

# F12 : display "/var/www/"
"\e[24~":"/var/www/"

Standard file descriptors :

Redirections (source) :

ls --nonExistentOption > myFile 2>&1
	(nothing)
cat myFile
	ls: unrecognized option '--nonExistentOption'	the error message has been written to myFile
	Try 'ls --help' for more information.

ls --nonExistentOption 2>&1 > myFile
	ls: unrecognized option '--nonExistentOption'	the error message has been written to stdout
	Try 'ls --help' for more information.
cat myFile
	(nothing)

Redirect the outputs :

Discard the output :

(listOfCommands)

a=42
	a=42		$a is "passed" inside of the ()
	b=12
	a=0		$a can be overwritten inside of the ()
	b=12
a=42			the changed value of $a doesn't exist outside of the ()
b=			$b doesn't exist outside of ()

{ listOfCommands; }

a=42
	a=42		this is the same "$a" since it's the same shell context
	b=12
	a=0		we can do whatever we like
	b=12
a=0			being in the same shell context means variables stay altered outside of the {}
b=12			$b now exists outside of {}

prefix the file name with its path :

rm ./-foo

explicitly declare the end of command options with -- (sources : 1, 2) :

rm -- -foo

with a hack involving find and an inode number

not sure this actually works because there's some character substitution occurring (Bash normal behavior), and you'd have to circumvent this with "--" :

testDir='/tmp'; touch "$testDir/-foo"; inodeNumber=$(ls -i "$testDir/"*foo | cut -d' ' -f1); find "$testDir" -inum "$inodeNumber"

This lists much more than only /tmp/-foo .

• 20161115_workOnSomeStuff
• 20161121-25_support
• 20161122_otherProject

Solution at the end of this article

1. You type : cd 2 + TAB
2. the shell completes :

   cd 201611

   but to go further you have to hit TAB + TAB again to see the available options
3. the shell returns :

   20161115_workOnSomeStuff/	20161121-25_support/	20161122_otherProject/

   so now you have to figure out which character to type next : 2 + TAB + TAB again for available options
4. still 2 options :

   20161121-25_support/	20161122_otherProject/

   Type the next character : 1 + TAB
5. the shell completes :

   cd 20161121-25_support/

6. then you just have to hit : you're in !

All the magic here is in the shell expansion of the wildcard * + rt to match any directory which name ends in rt.

Make backup copies :

Change file extensions :

Rename *JPG files into *jpg :

Change all the spaces in the name of .mpg files into _ :

Remove a substring from several file names such as xx - artist - title.mp3 (actually : replace it with an empty string) :

drwxr-xr-x 5 bob users	4096 jun.	25 21:19 normalDirectory_1
drwxr-xr-x 6 bob users	4096 nov.	18 07:46 normalDirectory_2
drwxr-xr-x 4 bob users	4096 dec.	 1 18:48 normalDirectory_3
drwxr-xr-x 3 bob users	4096 nov.	28 10:00 ?weirdDirectory		what's wrong with this one ?

This ?weirdDirectory contains a non-printable character in its name represented by a ? by ls. BTW, ls can do more for us and report the octal code of this special character with its -b flag (but this is of no help here).
This is even worse when the special character is the 1^st one, because we can't even be saved by Bash completion.

All of this is inspired by a true story, while trying to browse directories on a remote server (where locales were possibly quite f***ed up) via PuTTY + screen (possibly poorly configured also). That server had directories — wherever they came from — with letters such as éèà... and since I couldn't type them in my terminal (even copy-pasting), I could not enter those directories.

<spoiler_alert>We'll have to create such a directory for the demonstration, which lets the cat out of the bag on the solution</spoiler_alert>

Let's create a directory named €uro, then enter it (as said earlier, this is piece of cake when sitting in front of a properly configured host, and everything below is meaningless) :

1. let's start by finding the octal code of the € symbol here : 240
2. echo -e "\0240uro"

   �uro

3. create the directory : mkdir $(echo -e "\0240uro")
4. display it : ls -l will return

   drwxr-xr-x 2 bob users 4,0K déc.	3 17:17 ?uro/

5. enter it : cd $(ls -d *uro)

Actually, cd $(ls -d ?uro) would have done the job perfectly but might be confusing : ls -l "displays" the directory name with a ? because the terminal itself is not able to display it, whereas the ? in the cd $(ls ) command is a wildcard representing a single character.

command1; command2; command3

Run command1, then command2, then command3. The exit status is that of command3.

command1 & command2 & command3

All commands are executed at once and return results as they arrive.
Try it : { sleep 2; echo "2s"; } & { sleep 1; echo "1s"; } &

command1 && command2

command2 is executed only if command1 exits on success.
Try it : true && echo 'I said TRUE.'; false && echo 'I said FALSE.'

command1||command2

command2 is executed only if command1 exits on failure.
Try it : true || echo 'I said TRUE.'; false || echo 'I said FALSE.'

command1 && commandIfSuccess || commandIfFailure

Based on success / failure of command1, execute either commandIfSuccess or commandIfFailure

Albeit extremely convenient, this construct comes with serious warnings.

Compound &&'s :

true && true && echo 'Hello world'

Hello world

true && false && echo 'Hello world'

(nothing)

true && echo 'Hello' && echo 'world'

Hello
world

true && { false; echo 'hello'; }

hello

This is the typical case where the success of a single command triggers n extra commands. More on {} and ()

Many articles answer this question suggesting to parse the output of ifconfig (ip a should be preferred, actually) with the usual grep, cut, awk et al.

• hostname --all-ip-addresses
  This outputs a space-separated list of IP addresses, hence, with a single IP : 12.34.56.78[SPACE]
• hostname -i
  • This works only if the hostname can be resolved by DNS.
  • Using this option is discouraged by the man page (but it's still handy compared to --all-ip-addresses because it has no trailing space)

A (CPU + HDD)-hungry find :

for item in list of items; do
	find haystack [find options] & pidFind=$!
	echo Nicing
	ionice -c 3 -p $pidFind
	renice 19 -p $pidFind
	echo Finding...
	wait $pidFind
done

When starting a single process :

Other methods :