How can I test if a variable is not a positive integer?

Question

To test whether a variable is e.g. a number greater than 0, you would write:

((i > 0))

But how would I test if the variable is not a number greater than 0?

EDIT

Sorry for the typo, meant not a number greater than 0.

EDIT 2

Sry for the poor question. The value of the variable is passed as a commandline argument, so it may be a number or not. This also needs to be checked.

I think this question can be answered with just a bit of googling... — nhahtdh, Jun 05 '12 at 14:38
Who ever used `-gt`: That does not work in a general case to test if variable is number or not. It does not work because in aritmetic expressions, if a variable is not a number, it evaluates to 0 — Op De Cirkel, Jun 05 '12 at 14:59
I don't understand why this question is down-voted. It is a valid question. — Op De Cirkel, Jun 05 '12 at 15:01
@DennisWilliamson Fair enough. The OP has updated his question to make the validation an explicit requirement, and I've updated my answer accordingly. — Todd A. Jacobs, Jun 05 '12 at 17:05
possible duplicate of [BASH: Test whether string is valid as an integer?](http://stackoverflow.com/questions/2210349/bash-test-whether-string-is-valid-as-an-integer) — tripleee, Sep 04 '13 at 17:37

score 13 · Answer 1 · answered Jun 05 '12 at 14:36

13

i=15
if [[ ! $i -gt 10 ]]; then
        echo "lalala"
fi

answered Jun 05 '12 at 14:36

Daniel Kamil Kozar

18,476
5
50
64

1

@Achshar I disagree. Bash `[[` does not give an error. The script will return the result `lalala`. – Apostle Apr 29 '14 at 09:47

score 11 · Accepted Answer · edited Aug 12 '17 at 07:30

11

For checking on not being number, you have to test with regex. I have used -5 instead 0 just to demonstrate more general case (My assumption is that you use integers):

#!/bin/bash

A=$1

if [[ $A =~ ^[\-0-9]+$ ]] && (( A > -5)); then
  echo "A is number and is greater then -5"
else
  echo "A is not a number or is <= -5"
fi

If you want to test for non-integers, you have to clarify in your question what is considered number.

edited Aug 12 '17 at 07:30

penguin359

1,289
13
26

answered Jun 05 '12 at 14:56

Op De Cirkel

28,647
6
40
53

3

-1: using a regex is absolutely wrong. `test` is designed specifically for this type of comparison, and using it will be less fragile, more readable, and faster. – William Pursell Jun 06 '12 at 13:35
4

The number literals in any programming language are defined in terms of "regular expressions". I dont see how that can be wrong. – Op De Cirkel Jun 06 '12 at 13:44
It is wrong because explicitly testing if the number is greater than 0 is far more understandable than a regex string comparison, more efficient, and less prone to programming error. Using `[[` instead of `test` forces you to make this string comparison, so the problem here is two-fold: `test` should be used instead of `[[` because using `[[` forces the regex comparison, which has no place here. – William Pursell Jun 06 '12 at 13:56

score 5 · Answer 3 · edited May 23 '17 at 12:23

Comparisons

This is clearly covered in the Bash manual sections on Shell Arithmetic and Bash Conditional Expressions.

# Shell arithmetic
$ (( -1 <= 0 )); echo $?
0

# Conditional expression
$ [[ -1 -le 0 ]]; echo $?
0

# Negated conditional. Confusing, but possible.
[[ ! -1 -gt 0 ]]; echo $?
0

Simple, right?

Validation

However, if you are trying to test whether or not the number is actually an integer before performing the comparsion, then you can use a compound expression like this to validate and compare a variable named int:

[[ "$int" =~ ^[-+]?([1-9][[:digit:]]*|0)$ && "$int" -le 0 ]]

Note that the comparison determines whether the validated integer is "less than or equal to zero," rather than negating the assertion that it is a positive integer. The entire expression will thus return true (e.g. an exit status of zero) only if the regular expression validates as a (possibly signed) integer and if the integer is a signed negative integer.

There are certainly other ways to construct this expression, but this is a fairly readable (if rather Bash-specific) solution.

Related Links

`[^-]?` means an optional non-hyphen. You may have meant `^-?` which means an optional hyphen at the beginning of the string. While your `-gt` test indicates that your looking for a positive integer, your regex lacks generality since it excludes zero (while including positive and negative integers). — Dennis Williamson, Jun 05 '12 at 17:16
@DennisWilliamson I appreciate the feedback. The entire expression actually had some inverted logic (now fixed), but the point is that the first half of the expression isn't intended to do anything other than validate "integerness." Admittedly, one could construct a regex that would replace both of the current validation and comparison steps (e.g. `^-[[:digit:]]+|^0$`), but I think that making the steps separate conveys the intent more clearly. YMMV. — Todd A. Jacobs, Jun 05 '12 at 17:39

score 4 · Answer 4 · answered Jun 05 '12 at 14:41

4

Yes, I realize this question is tagged bash, but there is no reason not to do this is a portable manner:

if ! test "$i" -gt 0 2> /dev/null ; then
   echo $i is not a positive integer
fi

answered Jun 05 '12 at 14:41

William Pursell

204,365
48
270
300

1

+1. I still prefer using Bash constructs when Bash is explicitly mentioned, though. ;) – Daniel Kamil Kozar Jun 05 '12 at 14:42

Dennis Williamson · Answer 5 · 2012-06-05T17:53:04.563

Simple regexes can allow non-numbers such as "11--22--99" (although they do evaluate mathematically inside the (())).

The following regex only allows 0 or negative integers without leading zeros and rejects negative zero.

for a in 0 -0 00 -1 -01 1 1-1 --1
do
    if [[ $a =~ ^(-[1-9][0-9]*|0)$ ]]
    then
        echo "[+] $a passes"
    else
        echo "[X] $a doesn't"
    fi
done

Output:

[+] 0 passes
[X] -0 doesn't
[X] 00 doesn't
[+] -1 passes
[X] -01 doesn't
[X] 1 doesn't
[X] 1-1 doesn't
[X] --1 doesn't

At this point, you don't really need to add a test for ((a <= 0)) although you could test whether it was less than or equal to some smaller number.

Edit:

You could put the integer validation test in a function and do the comparison separately for readability like this:

isint () {
    [[ $1 =~ ^(-?[1-9][0-9]*|0)$ ]] # use [+-]? instead of -? to allow "+"
}

if isint "$var" && ((var <= 0))
then
    echo "validated and compared: $var"
else
    echo "non-integer or out of range: $var"
fi

I like the idea of extracting the regular expression test to a function. It certainly does make the conditional friendlier on the eyes. Thanks for posting a great alternate construction. — Todd A. Jacobs, Jun 05 '12 at 18:09

How can I test if a variable is *not* a positive integer?

5 Answers5

Comparisons

Validation

Related Links

How can I test if a variable is not a positive integer?