When dereferencing a variable in bash, you have to use $ sign. Nevertheless, it seems that the following is working just fine:

x=5

[[ x -gt 2 ]]

Can anybody explain this?

Edit: (more info)

What I mean is how and why the [[ ]] command is dereferencing my variable x without the $ sign. And yes, if x=1, the statement is evaluated to false (return status 1)

The reason is that the -eq forces an arithmetic evaluation of the arguments.

An arithmetic operator: -eq, -gt, -lt, -ge, -le and -ne inside a [[ ]] (in ksh,zsh and bash) means to automatically expand variable names as in the c language, not need for a leading $.

• 
  

  For confirmation we must look into bash source code. The manual offers no direct confirmation.

  
  
  

  Inside test.c the processing of arithmetic operators fall into this function:

  
  
  

  arithcomp (s, t, op, flags)
  
  

  
  
  

  Where s and t are both operands. The operands are handed to this function:

  
  
  

  l = evalexp (s, &expok);
  
  r = evalexp (t, &expok);
  
  

  
  
  

  The function evalexp is defined inside expr.c, which has this header:

  
  
  

  /* expr.c -- arithmetic expression evaluation. */
  
  

  
  
  

  So, yes, both sides of an arithmetic operator fall (directly) into arithmetic expression evaluation. Directly, no buts, no ifs.

  
  

In practice, with:

 $ x=3

Both of this fail:

 $ [[ x = 4 ]] && echo yes || echo no

 no



 $ [[ x = 3 ]] && echo yes || echo no

 no

Which is correct, x is not being expanded and x is not equal to a number.

However:

 $ [[ x -eq 3 ]] && echo yes || echo no

 yes



 $ [[ x -eq 4 ]] && echo yes || echo no

 no

The variable named x gets expanded (even without a $).

This doesn't happen for a […] in zsh or bash (it does in ksh).

That is the same as what happens inside a $((…)):

 $ echo $(( x + 7 ))

 10

And, please understand that this is (very) recursive (except in dash and yash):

 $ a=b b=c c=d d=e e=f f=3

 $ echo "$(( a + 7 ))" 

 10

😮

And quite risky:

 $ x=$(date)

 $ [[ x -eq 3 ]] && echo yes || echo no

 bash: [[: Mon Dec  3 23:18:19 UTC 2018: syntax error in expression (error token is "Dec  3 23:18:19 UTC 2018")

 no

The syntax error could be easily avoided:

 $ x=$(date >/dev/null; echo 3)



 $ [[ x -eq 3 ]] && echo yes || echo no

 yes

😮

Both the (older) external /usr/bin/test (not the builtin test) and the still older and also external expr do not expand expressions only integers (and apparently, only decimal integers):

 $ /usr/bin/test "x" -eq 3

 /usr/bin/test: invalid integer ‘x’



 $ expr x + 3

 expr: non-integer argument

The operands of the numerical comparisons -eq, -gt, -lt, -ge, -le and -ne are taken as arithmetic expressions. With some limitation, they still need to be single shell words.

The behaviour of variable names in arithmetic expression is described in Shell Arithmetic:

Shell variables are allowed as operands; parameter expansion is performed before the expression is evaluated. Within an expression, shell variables may also be referenced by name without using the parameter expansion syntax. A shell variable that is null or unset evaluates to 0 when referenced by name without using the parameter expansion syntax.

and also:

The value of a variable is evaluated as an arithmetic expression when it is referenced

But I can't actually find the part of the documentation where it's said that the numeric comparisons take arithmetic expressions. It's not described in Conditional Constructs under [[, nor is it described in Bash Conditional Expressions.

But, by experiment, it seems to work as said above.

So, stuff like this works:

a=6

[[ a -eq 6 ]] && echo y 

[[ 1+2+3 -eq 6 ]] && echo y

[[ "1 + 2 + 3" -eq 6 ]] && echo y

this too (the value of the variable is evaluated):

b='1 + 2 + 3'

[[ b -eq 6 ]] && echo y

But this doesn't; it's not a single shell word when the [[ .. ]] is parsed, so there's a syntax error in the conditional:

[[ 1 + 2 + 3 -eq 6 ]] && echo y

In other arithmetic contexts, there's no need for the expression to be without whitespace. This prints 999, as the brackets unambiguously delimit the arithmetic expression in the index:

a[6]=999; echo ${a[1 + 2 + 3]}

On the other hand, the = comparison is a pattern match, and doesn't involve arithmetic, nor the automatic variable expansion done in an arithmetic context (Conditional Constructs):

When the == and != operators are used, the string to the right of the operator is considered a pattern and matched according to the rules described below in Pattern Matching, as if the extglob shell option were enabled. The = operator is identical to ==.

So this is false since the strings are obviously different:

[[ "1 + 2 + 3" = 6 ]] 

as is this, even though the numerical values are the same:

[[ 6 = 06 ]] 

and here, too, the strings (x and 6) are compared, they're different:

x=6

[[ x = 6 ]]

This would expand the variable, though, so this is true:

x=6

[[ $x = 6 ]]

Yes, your observation is correct, variable expansion is performed on expressions under double brackets [[ ]], so you don't need to put $ in front of a variable name.

This is explicitly stated in the bash manual:

[[ expression ]]

(...) Word splitting and pathname expansion are not performed on the words between the [[ and ]]; tilde expansion, parameter and variable expansion, arithmetic expansion, command substitution, process substitution, and quote removal are performed.

Notice that this is not the case of single-bracket version [ ], as [ is not a shell keyword (syntax), but rather a command (in bash it is builtin, other shells could use external, lined to test).