$ time for i in {1..1000}; do echo a >-; done
real 0m0.701s
user 0m0.043s
sys 0m0.258s

$ time for i in {1..1000}; do echo a >/dev/null; done
real 0m0.063s
user 0m0.038s
sys 0m0.020s

> it’s more important than I would’ve thought, too, not to overuse quotes

That is very interesting… I am guessing BASH checks each token to see if its quoted, if so it must remove the quotes which is the extra time were are seeing. I am not exactly sure why there would be a difference in single versus double quotes? Likely I guess because double quotes can have enclosed expressions whereas single quotes are taken literally.

> Not only is the former far more efficient, it also isn’t safe for entries that contain spaces:

Good point, I did not quote the variable in my example.

Regarding:

$ a=(); time for i in {0..1000}; do a=(${a[@]} $i);done; echo ${#a[@]}
real    0m3.545s
user    0m3.544s
sys     0m0.000s
1001

$ a=(); time for i in {0..1000}; do a[${#a[@]}]=$i;done; echo ${#a[@]}
real    0m0.043s
user    0m0.040s
sys     0m0.003s
1001

Not only is the former far less efficient, it also isn’t safe for entries that contain spaces:

$ A[0]='a b'
$ A[1]=c
$ for ((i=0; i< ${#A[@]}; i++)); do echo ${A[$i]}; done
a b
c

$ B=('a b')
$ B=(${B[@]} c)
$ for ((i=0; i<${#B[@]}; i++)); do echo ${B[$i]}; done
a
b
c

$ C=('a b')
# now with quotes!
$ C=("${C[@]}" c)
$ for ((i=0; i<${#C[@]}; i++)); do echo ${C[$i]}; done
a b
c

-- Elias ]]> http://bashcurescancer.com/six-ways-to-speed-up-your-shell-scripts.html/comment-page-1#comment-5148 Elias Pipping Tue, 25 Mar 2008 12:46:52 +0000 http://bashcurescancer.com/six-ways-to-speed-up-your-shell-scripts.html#comment-5148 Hi, it's more important than I would've thought, too, not to overuse quotes - especially with double quotes when they're not needed: <pre> bash-3.2$ time for (( i = 0; i < 100000; ++i )); do echo 1 2 3 4 5 6 >/ dev/null;done real 0m8.544s user 0m5.845s sys 0m2.698s bash-3.2$ time for (( i = 0; i < 100000; ++i)); do echo '1' '2' '3' '4' '5' '6' >/dev/null;done real 0m9.003s user 0m6.291s sys 0m2.711s bash-3.2$ time for (( i = 0; i < 100000; ++i )); do echo "1" "2" "3" "4" "5" "6" >/dev/null;done real 0m9.523s user 0m6.787s sys 0m2.730s</pre> Hi,

it’s more important than I would’ve thought, too, not to overuse quotes – especially with double quotes when they’re not needed:

bash-3.2$ time for (( i = 0; i < 100000; ++i )); do echo 1 2 3 4 5 6 >/
dev/null;done
real    0m8.544s
user    0m5.845s
sys     0m2.698s

bash-3.2$ time for (( i = 0; i < 100000; ++i)); do echo '1' '2' '3'
'4' '5' '6' >/dev/null;done
real    0m9.003s
user    0m6.291s
sys     0m2.711s

bash-3.2$ time for (( i = 0; i < 100000; ++i )); do echo "1" "2" "3"
"4" "5" "6" >/dev/null;done
real    0m9.523s
user    0m6.787s
sys     0m2.730s

Thanks for the BSD tip….I have been meaning to start up a OpenBSD and FreeBSD vmware instance.

Brock

You make an excellent point. The comparisons are not the same. Not sure why I did not use “let i++”. With that said, ((i++)) still seems to be faster than let i++ but not by the same margin.

Brock

$ i=0; time while :; do let i++; [[ $i -gt 100000 ]] && break;done

real    0m5.167s
user    0m4.773s
sys     0m0.392s
$ i=0; time while :; do ((i++)); [[ $i -gt 100000 ]] && break;done

real    0m4.147s
user    0m3.815s
sys     0m0.331s

On BSD systems, jot(1) is faster than List expansion.

bash-3.2$ time for i in `jot 1000001 0`; do :; done
real 0m8.765s
user 0m8.799s
sys 0m0.187s

bash-3.2$ time for i in {0..1000000}; do :; done
real 0m9.411s
user 0m9.346s
sys 0m0.053s

PS: naturally, using jot(1) doesn’t exactly make a script portable since it won’t work on, say, linux, but then again using seq(1) would break the script on BSD…

in “Arithmetic Evaluation is faster than let” you’re comparing

$ i=0; time while :; do let “i = i + 1″; [[ $i -gt 100000 ]] && break;done

and

$ i=0; time while :; do ((i++)); [[ $i -gt 100000 ]] && break;done

That’s not really “Arithmetic Evaluation vs. let”, though, because the former can be written as

$ i=0; time while :; do let i++; [[ $i -gt 100000 ]] && break;done

resulting in mostly the same speed. So what’s slow here is really

((i++)) vs. ((i=i+1)) or `let i++` vs. `let i=i+1`