Updated: 6 Jun 2000

Index Return to Main Contents

The **expr** utility evaluates expressions as specified by its arguments. After evaluation, the result is written on the standard output. Each token of the expression is a separate argument,
so terms of the expression must be separated by blanks. Characters special to the shell must be escaped. Note: **0** is returned to indicate a zero value, rather than the null string. Strings containing blanks or other special characters should be quoted. Integer-valued arguments may be
preceded by a unary minus sign. Internally, integers are treated as 32-bit, two's-complement numbers.

The operators and keywords are listed below. Characters that need to be escaped are preceded by `**\**'. The list is in order of increasing precedence, with equal precedence operators grouped within **{}** symbols.

*expr*** \| ***expr*

Returns the evaluation of the first *expr* if it is neither *NULL* nor **0**; otherwise, returns the evaluation of the second *expr* if it is not *NULL*; otherwise, **0**.

*expr*** \& ***expr*

Returns the first *expr* if neither *expr* is *NULL* or **0**, otherwise
returns **0**.

*expr* { **=,** \**,** \ , **\<**,** \<=**,** != **} *expr*

Returns the result of an integer comparison if both arguments are integers, otherwise returns the result of a lexical comparison.

*expr* { **+**,** - **} *expr*

Addition or subtraction of integer-valued arguments.

*expr* { **\**,** /**,** % **} **expr**

Multiplication, division, or remainder of the integer-valued arguments.

*string*** : ***regular-expression*

**match*** string regular-expression*

The two forms of the matching operator above are synonymous. The matching
operators **:** and **match** compare the first argument with the second argument which must be a regular expression. Regular expression syntax is the same as that of **regexp**(5), except that all patterns are "anchored" (treated as if they begin with **^**) and therefore **^** is not a special character, in that context. Normally, the matching operator returns the number of characters matched
(**0** on failure). Alternatively, the **\...\** pattern symbols can be used to return a portion of the first argument.

**substr** *string integer-1 integer-2*

Extracts the substring of *string* starting at position *integer-1* and of length *integer-2* characters.
If *integer-1* has a value greater than the length of *string*, **expr** returns a null string. If you try to extract more characters than there are in *string*, **expr** returns all the remaining
characters from *string*. Beware of using negative values for either *integer-1* or *integer-2* as **expr** tends to run forever in these cases.

**index** *string character-list*

Reports the first position in *string* at which any one of the characters in *character-list* matches a character in *string*.

**length** *string*

Returns the length (that is, the number of characters) of *string*.

**( expr )**

Parentheses may be used for grouping.

**Example 1: Adding an integer to a shell variable**

Add 1 to the shell variable **a**.

a='expr $a + 1'

**Example 2: Returning a path name segment**

Return the last segment of a path name (that is, the filename part). Watch out for **/** alone as an argument: **expr** will take it as the division operator (see **BUGS** below).

# 'For $a equal to either "/usr/abc/file" or just "file"' expr $a : '.*/\ \ $a

**Example 3: Using // characters to simplify the expression**

The addition of the **//** characters eliminates any ambiguity about the division operator and simplifies the whole expression.

# A better representation of example 2. expr //$a : '.*/\

**Example 4: Returning the value of a variable**

Returns the number of characters in **$VAR**.

expr $VAR : '.*'

**expr** returns the following exit codes:

**0**
If the expression is neither *NULL* nor **0**.

**1**
If the expression *is* *NULL* or **0**.

**2**
For invalid expressions.

See **attributes**(5) for descriptions of the following attributes:

ATTRIBUTE TYPE | ATTRIBUTE VALUE |

Availability | SUNWscpu |

**sh**(1), **test**(1), **attributes**(5), **regexp**(5)

**syntax** **error**
for operator/operand errors

**non-numeric argument**
if arithmetic is attempted on such a string

**division by zero**
if an attempt to divide by zero is made

After argument processing by the shell, **expr** cannot tell the difference between an operator and an operand except by the value. If **$a** is an **=**, the command:

expr $a = '='

looks like:

expr = = =

as the arguments are passed to **expr** (and they will all be taken as the **=** operator). The following works:

expr X$a = X=

Note: the **match**, **substr**, **length**, and **index** operators cannot themselves be used as ordinary strings. That is, the expression:

example%expr index expurgatorious lengthsyntax errorexample%

generates the `**syntax error**' message as shown instead of the value **1** as you might expect.

- NAME
- SYNOPSIS
- DESCRIPTION
- EXAMPLES
- EXIT STATUS
- ATTRIBUTES
- SEE ALSO
- DIAGNOSTICS
- BUGS

This document was created by man2html, using the manual pages.

Time: 02:39:15 GMT, October 02, 2010