如何在 shell 脚本中声明和使用布尔变量？

Question

我尝试使用以下语法在 shell 脚本中声明一个布尔变量：

variable=$false

variable=$true

这个对吗？ 另外，如果我想更新该变量，我会使用相同的语法吗？ 最后，以下使用布尔变量作为表达式的语法是否正确？

if [ $variable ]

if [ !$variable ]

Answer 1

修订后的答案（2014 年 2 月 12 日）

the_world_is_flat=true
# ...do something interesting...
if [ "$the_world_is_flat" = true ] ; then
    echo 'Be careful not to fall off!'
fi

---

原始答案

注意事项： https ://stackoverflow.com/a/21210966/89391

the_world_is_flat=true
# ...do something interesting...
if $the_world_is_flat ; then
    echo 'Be careful not to fall off!'
fi

来自： 在 Bash 中使用布尔变量

之所以将原始答案包含在此处，是因为 2014 年 2 月 12 日修订之前的评论仅与原始答案有关，并且与修订后的答案相关联的许多评论是错误的。 例如，Dennis Williamson 在 2010 年 6 月 2 日关于 bash builtin true的评论仅适用于原始答案，而不适用于修订后的答案。

Answer 2

TL;博士

my_bool=true

if [ "$my_bool" = true ]

---

Miku（原始）答案的问题

我不推荐接受的答案¹ 。 它的语法很漂亮，但有一些缺陷。

假设我们有以下条件。

if $var; then
  echo 'Muahahaha!'
fi

在以下情况²中，此条件将评估为true并执行嵌套命令。

# Variable var not defined beforehand. Case 1
var=''  # Equivalent to var="".      # Case 2
var=                                 # Case 3
unset var                            # Case 4
var='<some valid command>'           # Case 5

通常，当您的“布尔”变量（在本例中为var ）显式设置为 true 时，您只希望您的条件评估为 true。 所有其他情况都具有危险的误导性！

最后一种情况（#5）特别顽皮，因为它将执行包含在变量中的命令（这就是为什么对于有效命令^{3, 4}的条件评估为 true 的原因）。

这是一个无害的例子：

var='echo this text will be displayed when the condition is evaluated'
if $var; then
  echo 'Muahahaha!'
fi

# Outputs:
# this text will be displayed when the condition is evaluated
# Muahahaha!

引用变量更安全，例如if "$var"; then if "$var"; then 。 在上述情况下，您应该会收到未找到该命令的警告。 但我们仍然可以做得更好（见底部我的建议）。

^{另请参阅 Mike Holt 对 Miku 原始答案的解释。}

Hbar回答的问题

这种方法也有意想不到的行为。

var=false
if [ $var ]; then
  echo "This won't print, var is false!"
fi

# Outputs:
# This won't print, var is false!

您会期望上述条件评估为假，因此永远不会执行嵌套语句。 惊喜！

引用值（ "false" ），引用变量（ "$var" ），或使用test或[[而不是[ ，都没有区别。

我推荐的：

以下是我建议您检查“布尔值”的方法。 他们按预期工作。

my_bool=true

if [ "$my_bool" = true ]; then
if [ "$my_bool" = "true" ]; then

if [[ "$my_bool" = true ]]; then
if [[ "$my_bool" = "true" ]]; then
if [[ "$my_bool" == true ]]; then
if [[ "$my_bool" == "true" ]]; then

if test "$my_bool" = true; then
if test "$my_bool" = "true"; then

它们都差不多。 与其他答案⁵中的方法相比，您必须键入更多的击键，但您的代码将更具防御性。

---

脚注

1. Miku 的答案已被编辑，不再包含（已知）缺陷。
2. 不是一份详尽的清单。
3. 此上下文中的有效命令意味着存在的命令。 正确或错误地使用命令都没有关系。 例如，即使不存在这样的手册页， man woman仍将被视为有效命令。
4. 对于无效（不存在）的命令，Bash 只会抱怨找不到该命令。
5. 如果你关心长度，第一个建议是最短的。

Answer 3

这里似乎对 Bash 内置的true存在一些误解，更具体地说，关于 Bash 如何扩展和解释括号内的表达式。

miku 的答案中的代码与 Bash 内置true 、 /bin/true或任何其他类型的true命令完全无关。 在这种情况下， true只不过是一个简单的字符串，并且不会调用true命令/内置命令，既不是通过变量赋值，也不是通过对条件表达式的评估。

以下代码在功能上与 miku 答案中的代码相同：

the_world_is_flat=yeah
if [ "$the_world_is_flat" = yeah ]; then
    echo 'Be careful not to fall off!'
fi

这里唯一的区别是被比较的四个字符是'y'、'e'、'a'和'h'而不是't'、'r'、'u'和'e'。 而已。 当 Bash 解析令牌true时，没有尝试调用名为yeah的命令或内置命令，也没有（在 miku 的示例中）进行任何类型的特殊处理。 它只是一个字符串，而且是一个完全任意的字符串。

更新（2014-02-19）：按照 miku 的答案中的链接后，现在我看到了一些混乱的来源。 Miku 的答案使用单括号，但他链接到的代码片段不使用括号。 只是：

the_world_is_flat=true
if $the_world_is_flat; then
  echo 'Be careful not to fall off!'
fi

两个代码片段的行为方式相同，但括号完全改变了幕后发生的事情。

以下是 Bash 在每种情况下所做的事情：

无括号：

1. 将变量$the_world_is_flat展开为字符串"true" 。
2. 尝试将字符串"true"解析为命令。
3. 查找并运行true命令（内置命令或/bin/true ，具体取决于 Bash 版本）。
4. 比较true命令的退出代码（始终为 0）和 0。回想一下，在大多数 shell 中，退出代码 0 表示成功，其他任何值都表示失败。
5. 由于退出代码为 0（成功），执行if语句的then子句

括号：

1. 将变量$the_world_is_flat展开为字符串"true" 。
2. 解析现在完全扩展的条件表达式，其形式为string1 = string2 。 =运算符是 bash 的字符串比较运算符。 所以...
3. 对"true"和"true"进行字符串比较。
4. 是的，这两个字符串是相同的，所以条件的值为真。
5. 执行if语句的then子句。

无括号代码有效，因为true命令返回退出代码 0，表示成功。 括号中的代码有效，因为$the_world_is_flat的值与=右侧的字符串文字true相同。

只是为了说明这一点，请考虑以下两个代码片段：

此代码（如果以 root 权限运行）将重新启动您的计算机：

var=reboot
if $var; then
  echo 'Muahahaha! You are going down!'
fi

这段代码只打印“Nice try”。 不调用reboot 命令。

var=reboot
if [ $var ]; then
  echo 'Nice try.'
fi

更新 (2014-04-14)要回答评论中关于=和==之间区别的问题：AFAIK，没有区别。 ==运算符是=的 Bash 特定同义词，据我所知，它们在所有上下文中的工作方式完全相同。

但是请注意，我专门讨论在[ ]或[[ ]]测试中使用的=和==字符串比较运算符。 我并不是说=和==在 bash 中的任何地方都可以互换。

例如，您显然不能使用==进行变量赋值，例如var=="foo" （从技术上讲，您可以这样做，但var的值将是"=foo" ，因为 Bash 没有看到==运算符在这里，它看到一个= （赋值）运算符，然后是文字值="foo" ，它变成了"=foo" ）。

此外，尽管=和==可以互换，但您应该记住，这些测试的工作方式取决于您是在[ ]还是[[ ]]中使用它，以及是否引用了操作数。 您可以在Advanced Bash 脚本指南：7.3 其他比较运算符中阅读更多相关信息（向下滚动到=和==的讨论）。

Answer 4

使用算术表达式。

#!/bin/bash

false=0
true=1

((false)) && echo false
((true)) && echo true
((!false)) && echo not false
((!true)) && echo not true

输出：

真的
不假

Answer 5

长话短说：

Bash 中没有布尔值

true false

Bash 在比较和条件方面确实有布尔表达式。 也就是说，您可以在 Bash 中声明和比较的是字符串和数字。 而已。

无论你在 Bash 中看到true还是false ，它要么是一个字符串，要么是一个仅用于其退出代码的命令/内置命令。

这种语法...

if true; then ...

本质上是...

if COMMAND; then ...

命令为true地方。 只要命令返回退出代码 0，条件就为真。 true和false是 Bash 内置程序，有时也是独立程序，它们只返回相应的退出代码。

---

if..then..fi中的条件

当使用方括号或test命令时，您依赖于该构造的退出代码。 请记住， [ ]和[[ ]]也只是命令/内置命令，就像任何其他命令一样。 所以 ...

if [[ 1 == 1 ]]; then echo yes; fi

对应于

if COMMAND; then echo yes; fi

这里的COMMAND是[[参数为1 == 1 ]]

if..then..fi结构只是语法糖。 您始终可以只运行以双 & 号分隔的命令以获得相同的效果：

[[ 1 == 1 ]] && echo yes

在这些测试结构中使用true和false时，您实际上只是将字符串"true"或"false"传递给测试命令。 这是一个例子：

信不信由你，但这些条件都产生了相同的结果：

if [[ false ]]; then ...
if [[ "false" ]]; then ...
if [[ true ]]; then ...
if [[ "true" ]]; then ...

TL;博士; 始终与字符串或数字进行比较

为了让未来的读者清楚这一点，我建议始终在true和false周围使用引号：

做

if [[ "${var}" == "true" ]]; then ...
if [[ "${var}" == "false" ]]; then ...
if [[ "${var}" == "yes" ]]; then ...
if [[ "${var}" == "USE_FEATURE_X" ]]; then ...
if [[ -n "${var:-}" ]]; then echo "var is not empty" ...

别

# Always use double square brackets in bash!
if [ ... ]; then ...
# This is not as clear or searchable as -n
if [[ "${var}" ]]; then ...
# Creates impression of Booleans
if [[ "${var}" != true ]]; then ...
# `-eq` is for numbers and doesn't read as easy as `==`
if [[ "${var}" -eq "true" ]]; then ...

也许

# Creates impression of Booleans.
# It can be used for strict checking of dangerous operations.
# This condition is false for anything but the literal string "true".
if [[ "${var}" != "true" ]]; then ... 

Answer 6

很久以前，当我们只有sh时，布尔值通过依赖test程序的约定来处理，如果在没有任何参数的情况下运行， test返回错误的退出状态。

这允许人们将未设置为假的变量和设置为任何值的变量视为真。 今天， test是 Bash 的内置插件，通常以其单字符别名[ （或在缺少它的 shell 中使用的可执行文件，如 dolmen 所述）而闻名：

FLAG="up or <set>"

if [ "$FLAG" ] ; then
    echo 'Is true'
else
    echo 'Is false'
fi

# Unset FLAG
#    also works
FLAG=

if [ "$FLAG" ] ; then
    echo 'Continues true'
else
    echo 'Turned false'
fi

由于引用约定，脚本编写者更喜欢使用复合命令[[模仿test ，但语法更好：带空格的变量不需要引用； 可以使用&&和|| 作为具有奇怪优先级的逻辑运算符，并且对术语的数量没有 POSIX 限制。

例如，要确定是否设置了 FLAG 并且 COUNT 是大于 1 的数字：

FLAG="u p"
COUNT=3

if [[ $FLAG  && $COUNT -gt '1' ]] ; then
    echo 'Flag up, count bigger than 1'
else
    echo 'Nope'
fi

当所有需要空格、零长度字符串和空变量时，以及当您的脚本需要与多个 shell 一起工作时， 这些东西可能会让人感到困惑。

Answer 7

如何在 shell 脚本中声明和使用布尔变量？

与许多其他编程语言不同，Bash 不按“类型”来隔离其变量。 [1]

所以答案很明确。 Bash 中没有任何布尔变量。

然而：

使用声明语句，我们可以限制对变量的赋值。 [2]

#!/bin/bash
declare -ir BOOL=(0 1) # Remember BOOL can't be unset till this shell terminates
readonly false=${BOOL[0]}
readonly true=${BOOL[1]}

# Same as declare -ir false=0 true=1
((true)) && echo "True"
((false)) && echo "False"
((!true)) && echo "Not True"
((!false)) && echo "Not false"

declare和readonly中的r选项用于明确声明变量是只读的。 我希望目的很明确。

Answer 8

与其伪造布尔值并为未来的读者留下陷阱，为什么不使用比真假更好的值呢？

例如：

build_state=success
if something-horrible; then
  build_state=failed
fi

if [[ "$build_state" == success ]]; then
  echo go home; you are done
else
  echo your head is on fire; run around in circles
fi

Answer 9

我的发现和建议与其他帖子略有不同。 我发现我基本上可以像使用任何“常规”语言一样使用“布尔值”，而没有建议的“箍跳”......

不需要[]或显式字符串比较...我尝试了多个 Linux 发行版。 我测试了 Bash、Dash 和BusyBox 。 结果总是一样的。 我不确定最初投票最多的帖子在说什么。 也许时代变了，仅此而已？

如果将变量设置为true ，它随后会在条件中评估为“肯定”。 将其设置为false ，它的评估结果为“否定”。 很直接！ 唯一需要注意的是，未定义的变量也会像true一样评估！ 如果它做相反的事情会很好（就像在大多数语言中那样），但这就是诀窍 -你只需要明确地将你的布尔值初始化为 true 或 false 。

为什么它会这样工作？ 这个答案是双重的。 A）shell中的真/假实际上意味着“无错误”与“错误”（即0与其他任何东西）。 B）真/假不是值-而是shell脚本中的语句！ 关于第二点，单独在一行上执行true或false会将您所在块的返回值设置为该值，即false是“遇到错误”的声明，其中 true 会“清除”该值。 将其与对变量的赋值一起使用会将其“返回”到变量中。 未定义的变量在条件中的计算结果类似于true ，因为它同样表示 0 或“未遇到错误”。

请参阅下面的示例 Bash 行和结果。 如果您想确认，请自行测试...

#!/bin/sh

# Not yet defined...
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=true
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=false
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

产量

when set to
it evaluates to true
when set to true
it evaluates to true
when set to false
it evaluates to false

Answer 10

POSIX （便携式操作系统接口）

我在这里错过了关键点，即便携性。 这就是为什么我的标题本身具有POSIX的原因。

本质上，所有投票的答案都是正确的，除了它们是Bash特定的太多。

基本上，我只想添加更多关于可移植性的信息。

---

1. [ [ "$var" = true ]中的[和]括号不是必需的，您可以省略它们并直接使用test命令：

    test "$var" = true && yourCodeIfTrue || yourCodeIfFalse

   重要提示：我不再推荐这个，因为它正在慢慢被弃用，并且更难以组合多个语句。

2. 想象一下true和false这些词对 shell 意味着什么，自己测试一下：

    echo $(( true ))

    0

    echo $(( false ))

    1

   但使用引号：

    echo $(( "true" ))

    bash: "true": syntax error: operand expected (error token is ""true"") sh (dash): sh: 1: arithmetic expression: expecting primary: ""true""

   这同样适用于：

    echo $(( "false" ))

   除了字符串之外，shell 无法解释它。 我希望您了解使用不带引号的正确关键字有多好。

   但是在之前的答案中没有人这么说。

3. 这是什么意思？ 嗯，有几件事。

   • 您应该习惯布尔关键字实际上被视为数字，即true = 0和false = 1 ，记住所有非零值都被视为false 。

   • 由于它们被视为数字，因此您也应该这样对待它们，即如果您定义变量说：

      var_bool=true echo "$var_bool"

      true

     您可以使用以下方法创建相反的值：

      var_bool=$(( 1 - $var_bool )) # same as $(( ! $var_bool )) echo "$var_bool"

      1

   正如您自己所看到的，shell 在您第一次使用它时会打印true字符串，但从那时起，它都通过数字0表示true或1表示false分别工作。

---

最后，您应该如何处理所有这些信息

• 首先，一个好习惯是分配0而不是true ； 1而不是false 。

• 第二个好习惯是测试变量是否 / 不等于零：

   if [ "$var_bool" -eq 0 ]; then yourCodeIfTrue else yourCodeIfFalse fi

Answer 11

在许多编程语言中，布尔类型是或实现为整数的子类型，其中true行为类似于1而false的行为类似于0 ：

• C 中的布尔值

• Python中的布尔值

• Java中的布尔值

在数学上，布尔代数类似于整数算术模 2。因此，如果一种语言不提供原生布尔类型，最自然和最有效的解决方案是使用整数。 这几乎适用于任何语言。 例如，在 Bash 中，您可以执行以下操作：

# val=1; ((val)) && echo "true" || echo "false"
true
# val=0; ((val)) && echo "true" || echo "false"
false

男子重击：

（（表达））

表达式根据下面算术评估中描述的规则进行评估。 如果表达式的值为非零，则返回状态为0； 否则返回状态为 1。这完全等同于 let "表达式"。

Answer 12

关于语法，这是我使用（通过示例）一致和理智地管理布尔逻辑的一种简单方法：

# Tests
var=
var=''
var=""
var=0
var=1
var="abc"
var=abc

if [[ -n "${var}" ]] ; then
    echo 'true'
fi
if [[ -z "${var}" ]] ; then
    echo 'false'
fi

# Results
# var=        # false
# var=''      # false
# var=""      # false
# var=0       # true
# var=1       # true
# var="abc"   # true
# var=abc     # true

如果从未声明变量，则答案是： # false

因此，将变量设置为 true（使用此语法方法）的简单方法是var=1 ； 相反， var='' 。

参考：

-n = True 如果 var 字符串的长度不为零。

-z = 如果 var 字符串的长度为零，则为真。

Answer 13

比尔·帕克（Bill Parker）被否决了，因为他的定义与正常的代码约定相反。 通常，true 定义为 0，false 定义为非零。 1 适用于 false，9999 和 -1 也适用。 与函数返回值相同 - 0 表示成功，任何非零值表示失败。 对不起，我还没有街头信誉可以投票或直接回复他。

Bash 建议现在使用双括号而不是单括号作为习惯，Mike Holt 给出的链接解释了它们工作方式的差异。 7.3. 其他比较运算符

一方面， -eq是一个数字运算符，所以有代码

#**** NOTE *** This gives error message *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

将发出一个错误语句，期望一个整数表达式。 这适用于任一参数，因为两者都不是整数值。 然而，如果我们在它周围加上双括号，它不会发出错误声明，但会产生错误的值（嗯，在 50% 的可能排列中）。 它将评估为 [[0 -eq true]] = 成功，但也将评估为 [[0 -eq false]] = 成功，这是错误的（嗯......那个内置是一个数值呢？）。

#**** NOTE *** This gives wrong output *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then

条件的其他排列也会给出错误的输出。 基本上，任何（除了上面列出的错误条件）将变量设置为数值并将其与真/假内置函数进行比较，或将变量设置为真/假内置函数并将其与数值进行比较。 此外，任何将变量设置为真/假内置并使用-eq进行比较的东西。 因此，避免使用-eq进行布尔比较，并避免使用数值进行布尔比较。 以下是会给出无效结果的排列的摘要：

# With variable set as an integer and evaluating to true/false
# *** This will issue error warning and not run: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

# With variable set as an integer and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then
#
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" == true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then


# With variable set as an true/false builtin and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = 0 ]; then
#
if [[ "${The_world_is_flat}" = 0 ]]; then
#
if [ "${The_world_is_flat}" == 0 ]; then
#
if [[ "${The_world_is_flat}" == 0 ]]; then

所以，现在什么有效。 使用 true/false 内置函数进行比较和评估（正如 Mike Hunt 指出的那样，不要将它们括在引号中）。 然后使用单等号或双等号（= 或 ==）以及单括号或双括号（[ ] 或 [[ ]]）。 就个人而言，我喜欢双等号，因为它让我想起了其他编程语言中的逻辑比较，而双引号只是因为我喜欢打字。 所以这些工作：

# With variable set as an integer and evaluating to true/false
# *** These statements will work properly: *****
#
The_world_is_flat=true/false;
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then

你有它。

Answer 14

我对（我自己的）白痴的收据：

# setting ----------------
commonMode=false
if [[ $something == 'COMMON' ]]; then
    commonMode=true
fi

# using ----------------
if $commonMode; then
    echo 'YES, Common Mode'
else
    echo 'NO, no Common Mode'
fi

$commonMode && echo 'commonMode is ON  ++++++'
$commonMode || echo 'commonMode is OFF xxxxxx'

Answer 15

使用布尔值的另一种方法是测试值的空性。 这样做的好处是可以进行更短的测试：

first=1  # A true value
second=   # A false value

[ -n "$first" ]  && echo 'First var is true'
[ -z "$first" ]  && echo 'First var is false'
[ -n "$second" ] && echo 'Second var is true'
[ -z "$second" ] && echo 'Second var is false'

输出：

First var is true
Second var is false

这是使用 bash 的另一种测试语法： [[ -n $one ]]

Answer 16

我发现现有的答案令人困惑。

就个人而言，我只想拥有一些看起来和工作起来像 C 的东西。

这个片段在生产中每天工作多次：

snapshotEvents=true

if ($snapshotEvents)
then
    # Do stuff if true
fi

为了让每个人都开心，我测试了：

snapshotEvents=false

if !($snapshotEvents)
then
    # Do stuff if false
fi

这也很好用。

$snapshotEvents评估变量值的内容。 所以你需要$ 。

你真的不需要括号，我只是觉得它们很有帮助。

• 测试于：GNU Bash，版本 4.1.11(2)-release

• Bash 初学者指南，Machtelt Garrels，v1.11，2008

Answer 17

这是对 miku原始答案的改进，解决了Dennis Williamson对未设置变量的情况的担忧：

the_world_is_flat=true

if ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

并测试变量是否为false ：

if ! ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

关于变量中包含令人讨厌的内容的其他情况，这是馈送到程序的任何外部输入的问题。

在信任任何外部输入之前，必须对其进行验证。 但是，当收到该输入时，该验证只需进行一次。

它不必像丹尼斯威廉姆森建议的那样，通过在每次使用变量时都这样做来影响程序的性能。

Answer 18

这是一个对我有用的简单示例：

temp1=true
temp2=false

if [ "$temp1" = true ] || [ "$temp2" = true ]
then
    echo "Do something." 
else
    echo "Do something else."
fi

Answer 19

这是一个短手if true的实现。

# Function to test if a variable is set to "true"
_if () {
    [ "${1}" == "true" ] && return 0
    [ "${1}" == "True" ] && return 0
    [ "${1}" == "Yes" ] && return 0
    return 1
}

示例 1

my_boolean=true

_if ${my_boolean} && {
    echo "True Is True"
} || {
    echo "False Is False"
}

示例 2

my_boolean=false
! _if ${my_boolean} && echo "Not True is True"

Answer 20

您可以使用shFlags 。

它使您可以选择定义： DEFINE_bool

例子：

DEFINE_bool(big_menu, true, "Include 'advanced' options in the menu listing");

从命令行您可以定义：

sh script.sh --bigmenu
sh script.sh --nobigmenu # False

Answer 21

这是关于在 Bash 中测试“布尔”值的不同方法的速度测试：

#!/bin/bash
rounds=100000

b=true # For true; b=false for false
type -a true
time for i in $(seq $rounds); do command $b; done
time for i in $(seq $rounds); do $b; done
time for i in $(seq $rounds); do [ "$b" == true ]; done
time for i in $(seq $rounds); do test "$b" == true; done
time for i in $(seq $rounds); do [[ $b == true ]]; done

b=x; # Or any non-null string for true; b='' for false
time for i in $(seq $rounds); do [ "$b" ]; done
time for i in $(seq $rounds); do [[ $b ]]; done

b=1 # Or any non-zero integer for true; b=0 for false
time for i in $(seq $rounds); do ((b)); done

它会打印类似的东西

true is a shell builtin
true is /bin/true

real    0m0,815s
user    0m0,767s
sys     0m0,029s

real    0m0,562s
user    0m0,509s
sys     0m0,022s

real    0m0,829s
user    0m0,782s
sys     0m0,008s

real    0m0,782s
user    0m0,730s
sys     0m0,015s

real    0m0,402s
user    0m0,391s
sys     0m0,006s

real    0m0,668s
user    0m0,633s
sys     0m0,008s

real    0m0,344s
user    0m0,311s
sys     0m0,016s

real    0m0,367s
user    0m0,347s
sys     0m0,017s

Answer 22

[[ "$x" == 'true' || "$x" -ne 0 ]] && ...

足够简单并且没有依赖关系。

Answer 23

Bash 确实将问题与[ 、 [[ 、 (( 、 $((等) 之类的问题混淆了。

所有人都在践踏彼此的代码空间。 我想这主要是历史性的，Bash 不得不偶尔假装是sh 。

大多数时候，我可以选择一种方法并坚持下去。 在这种情况下，我倾向于声明（最好在一个公共库文件中，我可以在我的实际脚本中包含. ）。

TRUE=1; FALSE=0

然后我可以使用(( ... ))算术运算符进行测试。

testvar=$FALSE

if [[ -d ${does_directory_exist} ]]
then
    testvar=$TRUE;
fi

if (( testvar == TRUE )); then
    # Do stuff because the directory does exist
fi

1. 你必须遵守纪律。 您的testvar必须始终设置为$TRUE或$FALSE 。

2. 在(( ... ))比较器中，您不需要前面的$ ，这使其更具可读性。

3. 我可以使用(( ... ))因为$TRUE=1和$FALSE=0 ，即数值。

4. 缺点是必须偶尔使用$ ：

    testvar=$TRUE

   这不是那么漂亮。

这不是一个完美的解决方案，但它涵盖了我需要进行此类测试的所有情况。

Answer 24

替代方案 - 使用函数

is_ok(){ :;}
is_ok(){ return 1;}
is_ok && echo "It's OK" || echo "Something's wrong"

定义函数不太直观，但检查它的返回值非常容易。