Unix‎ > ‎Solaris‎ > ‎Solaris man pages‎ > ‎1‎ > ‎


     expr - evaluate arguments as an expression

     /usr/bin/expr argument...

     /usr/xpg4/bin/expr argument...

     /usr/xpg6/bin/expr argument...

  /usr/bin/expr, /usr/xpg4/bin/expr
     The expr utility evaluates the  expression  and  writes  the
     result  to  standard  output.  The character 0 is written to
     indicate a zero value and nothing is written to  indicate  a
     null string.

     The expr utility evaluates the  expression  and  writes  the
     result to standard output followed by a NEWLINE. If there is
     no result from expr processing,  a  NEWLINE  is  written  to
     standard output.

     The argument operand is evaluated as an expression. Terms of
     the  expression must be separated by blanks. Characters spe-
     cial to the shell must be escaped (see sh(1)). Strings  con-
     taining blanks or other special characters should be quoted.
     The length of the expression is limited  to  LINE_MAX  (2048

     The operators and keywords are listed below. The list is  in
     order of increasing precedence, with equal precedence opera-
     tors grouped within {} symbols. All  of  the  operators  are

     expr \| expr

         Returns the evaluation of the first expr if it  is  nei-
         ther  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 string comparison using the locale-specific  coalition
         sequence. The result of each comparison will be 1 if the
         specified relationship is TRUE, 0 if the relationship is

     expr { +, - } expr

         Addition or subtraction of integer-valued arguments.

     expr { \*, /, %} expr

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

     expr : expr

         The matching operator : (colon) compares the first argu-
         ment with the second argument, which must be an interna-
         tionalized basic regular expression (BRE),  except  that
         all  patterns  are  anchored  to  the  beginning  of the
         string. That is, only sequences starting  at  the  first
         character of a string are matched by the regular expres-
         sion.   See   regex(5)   and   NOTES.   Normally,    the
         /usr/bin/expr  matching  operator  returns the number of
         bytes matched and the /usr/xpg4/bin/expr matching opera-
         tor  returns  the  number  of  characters  matched (0 on
         failure). If the second argument contains at  least  one
         BRE  sub-expression  [\(...\)],  the  matching  operator
         returns the string corresponding to \1.


         An argument consisting only of an (optional) unary minus
         followed by digits.


         A string  argument  that  cannot  be  identified  as  an
         integer  argument  or  as one of the expression operator

  Compatibility Operators (x86 only)
     The following operators are included for compatibility  with
     INTERACTIVE UNIX System only and are not intended to be used
     by non- INTERACTIVE UNIX System scripts:

     index string character-list

         Report the first position in which any one of the  bytes
         in character-list matches a byte in string.

     length string

         Return the length (that is,  the  number  of  bytes)  of

     substr string integer-1 integer-2

         Extract the substring of  string  starting  at  position
         integer-1  and  of length integer-2 bytes.  If integer-1
         has a value greater than the number of bytes in  string,
         expr  returns a null string.  If you try to extract more
         bytes than there are in string,  expr  returns  all  the
         remaining  bytes from string. Results are unspecified if
         either integer-1 or integer-2 is a negative value.

     Example 1: Adding an integer to a shell variable

     Add 1 to the shell variable a:

     example$ a=`expr $a + 1`

     Example 2: Returning a path name segment

     The following example emulates  basename(1),  returning  the
     last  segment  of  the  path name $a. For $a equal to either
     /usr/abc/file or just file, the example returns file. (Watch
     out  for  / alone as an argument: expr takes it as the divi-
     sion operator.  See NOTES below.)

     example$ expr $a : '.*/\(.*\)' \| $a

     Example 3: Using // characters to simplify the expression

     Here is a better version of the previous example. The  addi-
     tion of the // characters eliminates any ambiguity about the
     division operator and simplifies the whole expression.

     example$ expr //$a : '.*/\(.*\)'

     Example 4: Returning the number of bytes in a variable

     example$ expr "$VAR" : '.*'

     Example 5: Returning the number of characters in a variable

     example$ expr "$VAR" : '.*'

     See environ(5) for descriptions of the following environment
     variables  that  affect the execution of expr: LANG, LC_ALL,

     As a side effect of expression evaluation, expr returns  the
     following exit values:

     0        If the expression is neither NULL nor 0.

     1        If the expression is either NULL or 0.

     2        For invalid expressions.

     >2       An error occurred.

     See attributes(5) for descriptions of the  following  attri-

    |       ATTRIBUTE TYPE        |       ATTRIBUTE VALUE       |
    | Availability                | SUNWcsu                     |
    | CSI                         | enabled                     |
    | Interface Stability         | Standard                    |

     basename(1),   ed(1),   sh(1),   Intro(3),    attributes(5),
     environ(5), regex(5), standards(5)

     syntax error            Operator and operand errors.

     non-numeric argument    Arithmetic is attempted  on  such  a

     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:

     example$ expr $a = '='

     looks like:

     example$ expr = = =

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

     example$ expr X$a = X=

  Regular Expressions
     Unlike some previous versions, expr  uses  Internationalized
     Basic  Regular  Expressions for all system-provided locales.
     Internationalized Regular Expressions are explained  on  the
     regex(5) manual page.

Man pages from Solaris 10 Update 8. See docs.sun.com and www.oracle.com for further documentation and Solaris information.