Join Log in
Score:5
Saad Abdul Majid avatar Ubuntu

Increment operator does not work on a variable if variable is set to 0

br flag
Saad Abdul Majid

Incrementing a variable var works in bash when enclosed in double parentheses like (( var++ )). But I have found that it fails if variable is set to 0 beforehand like var=0.

$ a=0
$ ((a++)) && echo "command succeeded" || echo "command failed"
command failed

$ a=1
$ ((a++)) && echo "command succeeded" || echo "command failed"
command succeeded

Can someone explain this behavior?

Environment:

I am using gnome-terminal on Ubuntu Desktop 18.04.5 LTS.

765
0 + 0
pLumo avatar
in flag
pLumo
I think you should not really on the exit status of `((` to know if the command was working.. *>> "If the result of the expression is 0, the exit status code returned will be 1 or “false”, while the exit status code returned by a non-zero value expression will be 0 or “true”."* ([via](https://developpaper.com/functions-of-in-linux-shell-2))
4
Reply
wjandrea avatar
cn flag
wjandrea
Sidenote: there's more than one way to [increment a variable in Bash](/q/385528/301745). Probably the most idiomatic is to explicitly make it an integer first: `declare -i a=0` then `a+=1`.
1
Reply
ilkkachu avatar
co flag
ilkkachu
@pLumo, it's not the exit status that's wrong, but the users' assumptions (yours, too). It works exactly like post-increment is defined, and exactly like it does in e.g. C. Though you're right in that you can't use the exit status of `(( .. ))` to see if it _worked_, since a syntax error also makes it exit with status 1. (and not e.g. 2, like `[` and `[[` do)
0
Reply
Saad Abdul Majid avatar
br flag
Saad Abdul Majid
@pLumo, exit status code is of concern to me because script is using `trap ... ERR` and this line provokes it. I have avoided this scenario, for now, by using pre-increment as my base value is 0 for `var`. But this solution is specific to my use case. Maybe I should search for a way to bypass `trap` for such/selected statements.
0
Reply
Score:10
vanadium avatar Ubuntu
cn flag
vanadium

With credit from here: https://unix.stackexchange.com/questions/146773/why-bash-increment-n-0n-return-error

The return value of (( expression )) does not indicate an error status, but, from the bash manpage:

((expression)) The expression is evaluated according to the rules described below under ARITHMETIC EVALUATION. If the value of the expression is non-zero, the return status is 0; otherwise the return status is 1. This is exactly equivalent to let "expression".

In ((a++))you are doing a post increment. The value of a is 0 so 1 is returned, after that, it is incremented.

Compare

$ unset a
$ ((a++)) ; echo Exitcode: $? a: $a
Exitcode: 1 a: 1

versus

$ unset a
$ ((++a)) ; echo Exitcode: $? a: $a
Exitcode: 0 a: 1

A pre-increment, so a has become 1 and 0 is returned.

0 + 0
wizzwizz4 avatar
de flag
wizzwizz4
Technically, the increment occurs before the return; however, the returned value is the value taken before the increment.
0
Reply
Score:5
sudodus avatar Ubuntu
jp flag
sudodus

This works for me (in bash in Ubuntu),

$ a=0
$ echo $((a++))
0
$ echo $((a++))
1
$ echo $((a++))
2
$ echo $((a++))
3
$ echo $a
4

Notice the difference with

$ a=0
$ echo $((++a))
1
$ echo $((++a))
2
$ echo $((++a))
3
$ echo $a
3
0 + 0
pLumo avatar
in flag
pLumo
check `echo $?`.
2
Reply
sudodus avatar
jp flag
sudodus
@pLumo, echo $((a++)) prints before update, echo $((++a)) prints after update.
2
Reply
bac0n avatar
cn flag
bac0n
Arithmetic expansion does not emit an exit status does not see the connection?
0
Reply
ธงชาติไทย
Elon Musk
I sit in a Tesla and translated this thread with Ai:

mangohost

Post an answer

Most people don’t grasp that asking a lot of questions unlocks learning and improves interpersonal bonding. In Alison’s studies, for example, though people could accurately recall how many questions had been asked in their conversations, they didn’t intuit the link between questions and liking. Across four studies, in which participants were engaged in conversations themselves or read transcripts of others’ conversations, people tended not to realize that question asking would influence—or had influenced—the level of amity between the conversationalists.