In bash, what does declaring a variable with `declare -i` change about later assignments to it, and how does that compare with a plain assignment using `$(( ))`?

## The integer attribute `declare -i name` (or `typeset -i`, its ksh-compatible alias) sets the *integer attribute* on a variable. The attribute does not change how the variable is read; it changes how it is **written**. Once set, the right-hand side of every assignment is passed through the arithmetic evaluator rather than stored verbatim. ```bash declare -i n n=3+4 # stores 7 n="2 * 5" # stores 10 -- quoting keeps it one word, arithmetic does the rest n+=1 # 11 -- += is addition, not string concatenation n=n*2 # 22 -- bare names are resolved, as in any arithmetic context ``` Contrast with a plain variable, where the same assignments store text: ```bash m=3+4 # stores the four-character string "3+4" m+=1 # stores "3+41" ``` ## The failure mode that makes people avoid it Arithmetic context treats an unset or null name as 0. Combined with the integer attribute, that turns bad input into a believable number: ```bash declare -i retries retries="$user_supplied" # "three" -> 0, "" -> 0, "5abc" -> arithmetic error ``` A value of `abc` is parsed as a variable name, found unset, and becomes 0. There is no warning. Downstream, `if (( retries > 0 ))` quietly takes the wrong branch. The attribute is also *invisible at the point of confusion*: someone reading `retries="$input"` two hundred lines below the `declare` has no local signal that an evaluation is happening. The declaration is action at a distance. A second sharp edge is that the attribute is a property of the variable, not of the value, and it persists — including for exported variables within the same shell, and for anything the same name is reused for later in a long script. ## `let`, `(( ))` and `declare -i` are three doors to one evaluator ```bash let 'total = price * qty' (( total = price * qty )) total=$(( price * qty )) ``` All three compute the same thing. The differences are ergonomic and in what they return: - **`let`** takes each argument as a separate expression and returns 1 if the *last* one evaluates to zero — the same inverted status rule as `(( ))`, and the same trap for `let count++` at zero. Its real problem is quoting: `let x = 1 + 1` fails because the shell word-splits it, and `let x=a*2` can be mangled by pathname expansion when a matching file exists, so nearly every use needs quotes. `let` predates `(( ))` and survives mainly in older scripts. - **`(( ))`** needs no quoting because no word splitting or globbing happens inside it, which makes it the readable modern form for both conditions and assignments. - **`$(( ))`** is the expansion, so its status is that of the surrounding command — the reason it is the safest form of an increment in a `set -e` script. ## Where `declare -i` still earns its place It is genuinely useful for a small, tightly scoped accumulator whose whole life is visible on one screen — a loop counter inside a short function, for example, where `total+=size` reads better than repeating `total=$(( total + size ))`. It also documents intent: the declaration states that this variable is a number. As a general habit, though, most style guides prefer explicit `$(( ))` at each site. It is local, greppable, and it does not turn a bad string into a silent zero. If you do use the attribute on anything touching external input, validate the value first — a `[[ $input =~ ^[0-9]+$ ]]` guard, or a `case` on the shape — rather than relying on arithmetic to reject it, because arithmetic will not. ## Related `declare` options worth naming `declare -r` makes a variable readonly, and `declare -A` creates an associative array (bash 4 and later). Both are attributes set the same way and can be combined, as in `declare -ir MAX=10` for a readonly integer. Attribute flags are cleared with a leading `+`, so `declare +i n` removes the integer attribute and restores ordinary string assignment.