expr`[`

arg1 operator arg2`... ]`

operator arg3

- +
Add

to*arg2*

.*arg1*- -
Subtract

from*arg2*

.*arg1*- *
Multiply the arguments.

- /
Divide

by*arg1*

.*arg2*- %
Take the remainder when

is divided by*arg1*

.*arg2*- =
Are the arguments equal?

- !=
Are the arguments different?

- >
Is

greater than*arg1*

?*arg2*- >=
Is

greater than or equal to*arg1*

?*arg2*- <
Is

less than*arg1*

?*arg2*- <=
Is

less than or equal to*arg1*

?*arg2*- |
Logical OR; if

has a non-zero (and non-null) value, the result is*arg1*

; otherwise, the result is*arg1*

.*arg2*- &
Logical AND; if both

and*arg1*

have a non-zero (and non-null) value, the result is*arg2*

; otherwise, the result is 0.*arg1*- :
Sort of like

**grep**;

is a pattern to search for in*arg2*

.*arg1*

must be a regular expression in this case. If the*arg2*

pattern is enclosed in \( \), the result is the portion of*arg2*

that matches; otherwise, the result is simply the number of characters that match. By default, a pattern match always applies to the beginning of the first argument (the search string implicitly begins with a ^). To match other parts of the string, start the search string with .* .*arg1*

Evaluate arguments as expressions and print the result.
Strings can be compared and searched.
Arguments and operators must be separated by spaces.
In most cases, an argument is an integer, typed literally or
represented by a shell variable.
There are three types of operators: arithmetic, relational, and logical.
Exit status for **expr** is 0 (expression is nonzero and nonnull),
1 (expression is 0 or null), or 2 (expression is invalid).

Use these to produce mathematical expressions whose results are printed.

Addition and subtraction are evaluated last, unless they are grouped inside
parentheses. The symbols *****, **(**, and **)** have meaning to the shell,
so they must be escaped (preceded by a backslash or enclosed in single
quotes).

Use these to compare two arguments. Arguments can also be words, in which
case comparisons assume **a < z** and **A < Z**.
If the comparison statement is true, the result is 1; if false,
the result is 0. Symbols **>** and **<** must be escaped.

Use these to compare two arguments. Depending on the values,
the result can be

(or some portion of it), *arg1*

, or 0.
Symbols *arg2***|** and **&** must be escaped.

Division happens first; result is 10:

expr 5 + 10 / 2

Addition happens first; result is 7 (truncated from 7.5):

expr \( 5 + 10 \) / 2

Add 1 to variable **i**; this is how variables are incremented in
shell scripts:

i=`expr $i + 1`

Print 1 (true) if variable **a** is the string "hello":

expr $a = hello

Print 1 (true) if **b** plus 5 equals 10 or more:

expr $b + 5 \>= 10

In the examples below, variable **p** is the string
"version.100". This command prints the number of characters in **p**:

expr $p : '.*'Result is 11

Match all characters and print them:

expr $p : '\(.*\)'Result is "version.100"

Print the number of lowercase letters at the beginning of **p**:

expr $p : '[a-z]*'Result is 7

Match the lowercase letters at the beginning of **p**:

expr $p : '\([a-z]*\)'Result is "version"

Truncate **$x** if it contains five or more characters;
if not, just print **$x**. (Logical OR uses the second argument when
the first one is 0 or null; i.e., when the match fails.)

expr $x : '\(.....\)' \| $x

In a shell script, rename files to their first five letters:

```

mv $x `expr $x : '\(.....\)' \| $x

(To avoid overwriting files with similar names, use **mv -i.)**