为什么使用&&比if ... fi快75倍，以及如何使代码更清晰

我有以下工作代码：

largest_prime=1
for number_under_test in {1..100}
do
  is_prime=true
  factors=''
  for ((divider = 2; divider < number_under_test-1; divider++));
  do
    remainder=$(($number_under_test % $divider))
    [ $remainder == 0 ] && [ is_prime ] && is_prime=false && factors+=$divider' '
  done
  [ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test
done
printf "\nLargest Prime= $largest_prime\n"

这段代码迅速运行了0.194秒。但是，我发现它&& is_prime= false有点难以阅读，并且（未经训练的人）看起来好像是在测试它，而不是在设置它。所以我试图改变&&成if...then在14.48秒但慢75倍-而这个作品。在较高的数字上最明显。

largest_prime=1
for number_under_test in {1..100}
do
  is_prime=true
  factors=''
  for ((divider = 2; divider < number_under_test-1; divider++));
  do  
    remainder=$(($number_under_test % $divider))
    if ([ $remainder == 0 ] && [ $is_prime == true ]); then
      is_prime=false
      factors+=$divider' '
    fi  
  done
  [ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test
done  
printf "\nLargest Prime= $largest_prime\n"

有没有让块变得清晰而又没有缓慢的东西？

更新（2015年1月4日美国东部时间上午10:40）

很好的反馈！我现在正在使用以下内容。还有其他反馈意见吗 ？

largest_prime=1
separator=' '
for number_under_test in {1..100}; {
  is_prime=true
  factors=''
  for ((divider = 2; divider < (number_under_test/2)+1; divider++)) {
    remainder=$(($number_under_test % $divider))
    if [ $remainder == 0 ]; then
      is_prime=false
      factors+=$divider' '
    fi
  } 
  if $is_prime; then
    printf "\n${number_under_test} IS prime\n\n"
    largest_prime=$number_under_test
  else
    printf "${number_under_test} is NOT prime, factors are: "
    printf "$factors\n"
  fi
}
printf "\nLargest Prime= $largest_prime\n"

这是因为您每次都会生成一个子外壳：

if ([ $remainder == 0 ] && [ $is_prime == true ]); then

只需删除括号

if [ $remainder == 0 ] && [ $is_prime == true ]; then

如果要对命令进行分组，请在当前的 shell中使用以下语法：

if { [ $remainder == 0 ] && [ $is_prime == true ]; }; then

（需要结尾的分号，请参见手册）

请注意，[ is_prime ]这与[ $is_prime == true ]：可以一样简单地编写$is_prime（不带括号），这将调用bash内置true或false命令。
[ is_prime ]是一个带有一个参数（字符串“ is_prime”）的测试-当[给定单个参数时，如果参数为非空且该文字字符串始终为非空，则结果为成功，因此始终为“ true”。

为了提高可读性，我将更改很长的一行

[ $is_prime == true ] && echo "${number_under_test} is prime!" || echo "${number_under_test} is NOT prime (factors= $factors)"  [ $is_prime == true ] && largest_prime=$number_under_test

至

if [ $is_prime == true ]; then
  echo "${number_under_test} is prime!"
else 
  echo "${number_under_test} is NOT prime (factors= $factors)"
  # removed extraneous [ $is_prime == true ] test that you probably
  # didn't notice off the edge of the screen
  largest_prime=$number_under_test
fi

不要低估空格以提高清晰度。

我认为您正在为自己的功能而努力。考虑：

unset num div lprime; set -- "$((lprime=(num=(div=1))))"
while [     "$((     num += ! ( div *= ( div <= num   ) ) ))" -eq \
            "$((     num *=   ( div += 1 )   <= 101   ))" ]    && {
      set   "$(( ! ( num %      div )         * div   ))"     "$@"
      shift "$(( !    $1 +    ( $1 ==  1 )    *  $#   ))"
}; do [ "$div" -gt "$num" ] && echo "$*"      
done

Shell算法非常有能力自行评估整数条件。它很少需要太多的测试和/或外部分配。这个while循环非常好地复制了嵌套循环：

当然，它的打印量不是很多，但是，例如，将上限设置为16，而不是上面写的101，那么...

2
3
4 2
5
6 3 2
7
8 4 2
9 3
10 5 2
11
12 6 4 3 2
13
14 7 2
15 5 3

肯定是在做工作。它几乎不需要其他任何东西就能近似您的输出：

...
do [ "$div" -eq "$num" ] && shift &&
   printf "$num ${1+!}= prime.${1+\t%s\t%s}\n" \
          "factors= $*"                        \
          "lprime=$(( lprime = $# ? lprime : num ))"
done

只是这样做而不是echo和...

1 = prime.
2 = prime.
3 = prime.
4 != prime.     factors= 2      lprime=3
5 = prime.
6 != prime.     factors= 3 2    lprime=5
7 = prime.
8 != prime.     factors= 4 2    lprime=7
9 != prime.     factors= 3      lprime=7
10 != prime.    factors= 5 2    lprime=7
11 = prime.
12 != prime.    factors= 6 4 3 2        lprime=11
13 = prime.
14 != prime.    factors= 7 2    lprime=13
15 != prime.    factors= 5 3    lprime=13

这适用于busybox。它非常便携，快速且易于使用。

您的subshel​​l问题将在大多数shell中发生，但到目前为止，在bashshell中最为严重。我交替做

( [ "$div" -gt "$num" ] ) && ...

...以及我在上面几个外壳中将其编写为101的上限的方式，dash并在.017秒内完成了不带子壳的工作，而在1.8秒内完成了不带子壳的工作。busybox.149和2，zsh .149和4，bash.35和6，以及ksh93.149和.160。ksh93不会像其他外壳程序那样为子外壳程序分叉。因此，也许问题不仅仅在于子外壳，还在于它是外壳。