More tips

<ol>
<li>Abuse the ternary operator, <code>((test)) && cmd1 || cmd2</code> or <code>[ test ] && cmd1 || cmd2</code>, as much as possible.<br>
<br>
Examples (length counts always exclude the top line):<br>
<br><pre>
t="$something"
if [ $t == "hi" ];then
cmd1
cmd2
elif [ $t == "bye" ];then
cmd3
cmd4
else
cmd5
if [ $t == "sup" ];then
cmd6
fi
fi
</pre>
<br>
By using ternary operators only, this can easily be shortened to:<br>
<br>
<pre>
t="$something"
[ $t == "hi" ]&&{
cmd1;cmd2
}||[ $t == "bye" ]&&{
cmd3;cmd4
}||{
cmd5
[ $t == "sup" ]&&cmd6
}
</pre>
<p>As nyuszika7h pointed out in the comments, this specific example could be shortened even further using <code>case</code>:</p>
<pre>
t="$something"
case $t in "hi")cmd1;cmd2;;"bye")cmd3;cmd4;;*)cmd5;[ $t == "sup" ]&&cmd6;esac
</pre>
<br>&nbsp;
</li>
<li>Also, prefer parentheses to braces as much as possible. Since parentheses are a metacharacter, and not a word, they never require spaces in any context. This also means run as many commands in a subshell as possible, because curly braces (i.e. <code>{</code> and <code>}</code>) are reserved words, not meta-characters, and thus have to have whitespace on both sides to parse correctly, but meta-characters don't. I assume that you know by now that subshells don't affect the parent environment, so assuming that all the example commands can safely be run in a subshell (which isn't typical in any case), you can shorten the above code to this:<br>
<br>
<pre>
t=$something
[ $t == "hi" ]&&(cmd1;cmd2)||[ $t == "bye" ]&&(cmd3;cmd4)||(cmd5;[ $t == "sup" ]&&cmd6)
</pre>
<br>
Also, if you can't, using parentheses can still minify it some. One thing to keep in mind is that it only works for integers, which renders it useless for the purposes of this example (but it is much better than using `-eq` for integers).
<br>&nbsp;
</li>
<li>
One more thing, avoid quotes where possible. Using that above advice, you can further minify it. Example:<br>
<br>
<pre>
t=$something
[ $t == hi ]&&(cmd1;cmd2)||[ $t == bye ]&&(cmd3;cmd4)||(cmd5;[ $t == sup ]&&cmd6)
</pre>
<br>&nbsp;
</li>
<li>
In testing conditions, prefer single brackets to double brackets as much as possible with a few exceptions. It drops two characters for free, but it isn't as robust in some cases (see below for an example). Also, use the single equals argument rather than the double. It is a free character to drop.
<pre>
[[ $f == b ]]&&: # ... &lt;-- Bad
[ $f == b ]&&: # ... &lt;-- Better
[ $f = b ]&&: # ... &lt;-- Best

# Note this caveat, especially in checking for null output or an undefined variable:
[[ "$f" ]]&&:
[ "$f" = '' ]&&: &lt;-- This is significantly longer
</pre>
<p>In all technicality, this specific example would be best with <code>case ... in</code>:</p>
<pre>
t=$something
case $t in hi)cmd1;cmd2;;bye)cmd3;cmd4;;*)cmd5;[ $t == sup ]&&cmd6;esac
</code>
</li>
</ol>
So, the moral of this post is this:
<ol>
<li>Abuse the ternary operator as much as possible, and <strong>always</strong> use it instead of if/if-else/etc. constructs always.</li>
<li>Use parentheses as much as possible and run as many segments as possible in subshells because parentheses are meta-characters and not reserved words.</li>
<li>Avoid quotes as much as physically possible.</li>
</ol>

<p>P.S.: Here's a list of meta-characters recognized in Bash regardless of context (and can separate words):</p>
<pre>
&lt; &gt; ( ) ; & | &lt;space&gt; &lt;tab&gt;
</pre>
<br>
<strong>EDIT:</strong> As manatwork pointed out, the double parenthesis test only works for integers. Also, indirectly, I found that you need to have whitespace surrounding the `==` operator. Corrected my post above.<br>
<br>
I also was too lazy to recalculate the length of each segment, so I simply removed them. It should be easy enough to find a string length calculator online if necessary.