Multiplication Assignment

The *= operator is an arithmetic compound assignment operator in Bash that performs in-place multiplication. It evaluates the arithmetic expression on its right-hand side, multiplies the result by the current integer value of the variable on its left-hand side, and assigns the computed product back to that variable.

Syntax

Because Bash variables are treated as strings by default, the *= operator must be executed within an arithmetic evaluation context. This is typically achieved using double parentheses (( )) or the let builtin.

(( variable *= expression ))

let "variable *= expression"

Mechanics and Evaluation Rules

1. Single Evaluation of the Left-Hand Side While (( x *= y )) is functionally similar to (( x = x * y )), the *= operator evaluates the left-hand side exactly once. This distinction is critical when the left-hand side contains an expression with side effects, such as a post-increment operator.

i=0
a=(2 2 2)
(( a[i++] *= 5 )) 

# 'i++' is evaluated only once. a[0] becomes 10, and i becomes 1.

# If written as (( a[i++] = a[i++] * 5 )), 'i++' would evaluate twice.

2. Right-Hand Side Precedence The right-hand side expression is fully evaluated before the multiplication occurs. The operator implicitly wraps the right-hand side in parentheses, ensuring its operations complete before the product is calculated.

x=10
(( x *= 2 + 3 )) 

# Evaluates as: x = 10 * (2 + 3)

# Result: x equals 50 (not 23)

3. Unset or Null Variables If the target variable on the left-hand side is unset or contains a null string, Bash evaluates its initial value as 0 within the arithmetic context. Consequently, multiplying an unset variable will always initialize it to 0.

unset y
(( y *= 5 ))

# Result: y equals 0

4. Integer Restriction Bash arithmetic strictly supports integers. Attempting to use floating-point numbers on either side of the *= operator will result in a syntax error (syntax error: invalid arithmetic operator).

5. Recursive String Evaluation In Bash arithmetic contexts, strings are not simply coerced to 0. Instead, they are evaluated recursively as variable names or arithmetic expressions. If the left-hand variable contains a string, Bash attempts to resolve that string as a variable name. If the resolved name is unset, it evaluates to 0. If the string contains invalid arithmetic syntax, Bash throws a syntax error.

text=10
z="text"
(( z *= 5 ))

# 'z' resolves to 'text', which evaluates to 10. 10 * 5 = 50.

# Result: z equals 50

w="foo bar"
(( w *= 5 ))

# Result: syntax error in expression (error token is "bar")

Invalid Usage

Using *= outside of an arithmetic context is syntactically invalid for variable assignment. Bash assignment syntax strictly requires a valid identifier (consisting only of alphanumeric characters and underscores, and not starting with a number) immediately preceding the equals sign.

Because an asterisk (*) is an invalid identifier character, Bash does not parse a sequence like x*=3 as an assignment. Instead, it parses the entire token as a command, which results in a command not found error.

# INCORRECT: Outside arithmetic context
x=5
x*=3  # Bash attempts to execute a command literally named 'x*=3'

Master Bash with Deep Grasping Methodology!

Learn More