Index for Section 1

Alphabetical listing for E

Bottom of page

expr(1)
NAME
  expr - Evaluates arguments as expressions

SYNOPSIS
  expr expression

STANDARDS
  Interfaces documented on this reference page conform to industry standards
  as follows:

  expr:	 XCU5.0

  Refer to the standards(5) reference page for more information about
  industry standards and associated tags.

OPTIONS
  None

OPERANDS
  The single expression evaluated by expr will be formed from the operands,
  as described in the DESCRIPTION section.  Each of the expression operator
  symbols: (   )   |   &   = > >=   <	<=   !=	  +   -	  *   /	  %   : and
  the symbols integer and string in the DESCRIPTION section must be provided
  as separate arguments to expr.

  expression
      Expression to be evaluated, formed as explained in the DESCRIPTION
      section.

DESCRIPTION
  The expr command reads an expression, evaluates it, and writes the result
  to standard output.  Within the expression argument, you must separate each
  term with spaces, precede characters special to the shell with a \
  (backslash), and quote strings containing spaces or other special
  characters.  Note that expr returns 0 to indicate a zero value, rather than
  the null string.  Integers can be preceded by a unary minus sign.
  Internally, integers are treated as 64-bit or 32-bit two's complement
  numbers, depending on the word size of the hardware platform.

  The operators and keywords are described in the following listing.
  Characters that need to be escaped are preceded by a \ (backslash).  The
  list is in order of increasing precedence with equal precedence operators
  grouped within {} (braces).

  expression1 \| expression2
      Returns expression1 if it is neither null nor 0 (zero); otherwise,
      returns expression2.

  expression1 \!> expression2
      Returns expression1 if neither expression1 nor expression2 is null nor
      0; otherwise, returns 0.

  expression1 {	 =,  \>,  \>=,	\<, \<=,  !=  } expression2
      Returns the result of an integer comparison if both expressions are
      integers; otherwise, returns the result of a string comparison.

  expression1 {+,  - } expression2
      Adds or subtracts integer-valued arguments.

  expression1 {	 \*,  /,  %  } expression2
      Multiplies, divides, or provides the remainder from the division of
      integer-valued arguments.

  expression1 : expression2 or match expression1 expression2
      Compares expression1 with expression2, which must be a basic regular
      expression, with syntax as described for grep, except that all patterns
      are anchored, so ^ (circumflex) (which anchors a pattern to the
      beginning of a line) is not a special character in this context.

      Normally, the matching operator returns the number of characters
      matched.	Alternatively, you can use the \(...\) symbols in expression2
      to return a portion of expression1.

  (expression)
      Provides expression grouping.

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

  string
      A string argument.  Refer to the STRING OPERAND section.

  To avoid unpredictable results when using a range expression to match a
  class of characters, use a character class expression rather than a
  standard range expression.  For information about character class
  expressions, see the discussion of this topic included in the description
  of the grep command.

  FUNCTIONS

  [Tru64 UNIX]	The expr command provides the following string-expression
  functions.  Strings containing white space must be quoted.  A string
  argument should not be one of the expression operator symbols shown in the
  OPERANDS section or one of the string function names below. You cannot use,
  for example, match "$subject" "$pattern" unless it is confirmed that
  subject and pattern do not match this violation. The first character of a
  string is position 1.	 The information returned by all these functions is
  in the form of a string:

  index string1 string2
      [Tru64 UNIX]  Compares each character in the second string against each
      character in the first string and returns the position in the first
      string of the first match found, where the first match is the match
      closest to the beginning of string1.

  length string
      [Tru64 UNIX]  Returns the length of the string argument.

  match string1 string2
      [Tru64 UNIX]  See the description of the : (colon) match operator,
      above.

  substr string start length
      [Tru64 UNIX]  Returns the substring of string that begins at character
      position start and is length characters long.

  STRING OPERAND

  A string argument is an argument that cannot be identified as an integer
  argument or as one of the expression operator symbols shown in the OPERANDS
  section.

  The use of string arguments length, substr, index or match produces
  unspecified results.

EXIT STATUS
  The expr command returns the following exit values:

  0   The expression is neither null nor 0.

  1   The expression is null or 0.

  2   The expression is invalid.

  >2  An error occurred.

EXAMPLES
   1.  To increment a shell variable, enter:
	    COUNT=`expr $COUNT + 1`

       This adds 1 to the COUNT shell variable (see sh for details).

   2.  To find the length of a shell variable, enter:
	    RES=`expr "$VAR" : ".*"`

       Note that VAR is in double quotes to avoid problems where VAR is NULL
       or contains embedded spaces.  The regular expression is also quoted to
       avoid expansion by the shell. This operation can also be performed as:
	    RES=`expr length "$VAR"`

   3.  To use part of a shell variable, enter:
	    RES=`expr "$VAR" : "-*\(.*\)"`

       This removes leading - (dashes), if any, from VAR. If the \( \)
       characters were omitted, RES would contain the length of VAR.

   4.  To find a character from one string in another string, enter:
	    INDEX=`expr index "Hello World!" "Wo"`

       Note that the returned value is 5, not 7.  The first match is the
       fifth character in string1, matching the o in string2 rather than the
       W, which is the seventh character in string1.

   5.  Special considerations:
	    RES=`expr "x$VAR" : "x-*\(.*\)"`

       This succeeds even if VAR has the value - (dash).
	    RES=`expr "x$VAR" = "x="

       This succeeds even if VAR has the value = (equal sign).

   6.  When CMD_ENV variable is set to bsd:
	    RES=`expr 0001'

       This results in 0001. Otherwise the value is 1.
	    RES=`expr substr 012345 1 3'

       This results in 012. Otherwise the value is 12.

ENVIRONMENT VARIABLES
  The following environment variables affect the execution of expr:

  CMD_ENV
      [Tru64 UNIX]  This variable, if set to bsd, prevents stripping of
      leading zeroes from expressions.

  LANG
      Provides a default value for the internationalization variables that
      are unset or null. If LANG is unset or null, the corresponding value
      from the default locale is used. If any of the internationalization
      variables contain an invalid setting, the utility behaves as if none of
      the variables had been defined.

  LC_ALL
      If set to a non-empty string value, overrides the values of all the
      other internationalization variables.

  LC_CTYPE
      Determines the locale for the interpretation of sequences of bytes of
      text data as characters (for example, single-byte as opposed to
      multibyte characters in arguments) and the behavior of character
      classes in regular expressions..

  LC_MESSAGES
      Determines the locale for the format and contents of diagnostic
      messages written to standard error.

  NLSPATH
      Determines the location of message catalogues for the processing of
      LC_MESSAGES.

SEE ALSO
  Commands:  grep(1), Bourne shell sh(1b), POSIX shell sh(1p), test(1)

  Functions:  string(3), wcscat(3)

  Standards:  standards(5)

Index for Section 1

Alphabetical listing for E

Top of page