expr man page on Scientific

Man page or keyword search:  
man Server   26626 pages
apropos Keyword Search (all sections)
Output format
Scientific logo
[printable version]

EXPR(1P)		   POSIX Programmer's Manual		      EXPR(1P)

       This  manual  page is part of the POSIX Programmer's Manual.  The Linux
       implementation of this interface may differ (consult the	 corresponding
       Linux  manual page for details of Linux behavior), or the interface may
       not be implemented on Linux.

       expr - evaluate arguments as an expression

       expr operand

       The expr utility shall evaluate an expression and write the  result  to
       standard output.


       The  single expression evaluated by expr shall be formed from the oper‐
       ands, as described in the EXTENDED DESCRIPTION section. The application
       shall ensure that each of the expression operator symbols:

	      (	 )  |  &  =  >	>=  <  <=  !=  +  -  *	/  %  :

       and  the	 symbols integer and string in the table are provided as sepa‐
       rate arguments to expr.

       Not used.


       The following environment variables shall affect the execution of expr:

       LANG   Provide a default value for the  internationalization  variables
	      that  are	 unset	or  null.  (See the Base Definitions volume of
	      IEEE Std 1003.1-2001, Section  8.2,  Internationalization	 Vari‐
	      ables  for the precedence of internationalization variables used
	      to determine the values of locale categories.)

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


	      Determine	 the  locale  for  the behavior of ranges, equivalence
	      classes, and multi-character collating elements  within  regular
	      expressions and by the string comparison operators.

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

	      Determine the locale that should be used to  affect  the	format
	      and contents of diagnostic messages written to standard error.

	      Determine the location of message catalogs for the processing of
	      LC_MESSAGES .


       The expr utility shall evaluate the expression and  write  the  result,
       followed by a <newline>, to standard output.

       The standard error shall be used only for diagnostic messages.


       The formation of the expression to be evaluated is shown in the follow‐
       ing table. The symbols expr, expr1,  and	 expr2	represent  expressions
       formed from integer and string symbols and the expression operator sym‐
       bols (all separate arguments) by	 recursive  application	 of  the  con‐
       structs	described in the table. The expressions are listed in order of
       increasing precedence, with equal-precedence operators grouped  between
       horizontal lines. All of the operators shall be left-associative.

	      Expression       Description
	      expr1 | expr2    Returns the evaluation of expr1 if it is
			       neither null nor zero; otherwise,
			       returns the evaluation of expr2 if it is
			       not null; otherwise, zero.
	      expr1 & expr2    Returns the evaluation of expr1 if nei‐
			       ther expression evaluates to null or
			       zero; otherwise, returns zero.
			       Returns the result of a decimal integer
			       comparison if both arguments are inte‐
			       gers; otherwise, returns the result of a
			       string comparison using the locale-spe‐
			       cific collation sequence. The result of
			       each comparison is 1 if the specified
			       relationship is true, or 0 if the rela‐
			       tionship is false.
	      expr1 = expr2    Equal.
	      expr1 > expr2    Greater than.
	      expr1 >= expr2   Greater than or equal.
	      expr1 < expr2    Less than.
	      expr1 <= expr2   Less than or equal.
	      expr1 != expr2   Not equal.
	      expr1 + expr2    Addition of decimal integer-valued argu‐
	      expr1 - expr2    Subtraction of decimal integer-valued
	      expr1 * expr2    Multiplication of decimal integer-valued
	      expr1 / expr2    Integer division of decimal integer-val‐
			       ued arguments, producing an integer
	      expr1 % expr2    Remainder of integer division of decimal
			       integer-valued arguments.
	      expr1 : expr2    Matching expression; see below.
	      ( expr )	       Grouping symbols. Any expression can be
			       placed within parentheses. Parentheses
			       can be nested to a depth of

	      integer	       An argument consisting only of an
			       (optional) unary minus followed by dig‐
	      string	       A string argument; see below.

   Matching Expression
       The ':' matching operator shall compare the string resulting  from  the
       evaluation  of expr1 with the regular expression pattern resulting from
       the evaluation of  expr2.  Regular  expression  syntax  shall  be  that
       defined in the Base Definitions volume of IEEE Std 1003.1-2001, Section
       9.3, Basic Regular Expressions, 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 expression) and,
       therefore, it is unspecified whether '^' is a special character in that
       context. Usually, the matching operator shall return  a	string	repre‐
       senting	the  number  of characters matched ( '0' on failure). Alterna‐
       tively, if the pattern contains at least one regular expression	subex‐
       pression	 "[\(...\)]",  the  string  corresponding  to  "\1"  shall  be

   String Operand
       A string argument is an argument that cannot be identified as an	 inte‐
       ger  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.

       The following exit values shall be returned:

	0     The expression evaluates to neither null nor zero.

	1     The expression evaluates to null or zero.

	2     Invalid expression.

       >2     An error occurred.


       The following sections are informative.

       After argument processing by the shell, expr is not required to be able
       to tell the difference between an operator and an operand except by the
       value. If "$a" is '=', the command:

	      expr $a = '='

       looks like:

	      expr = = =

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

	      expr X$a = X=

       Also note that this volume of IEEE Std 1003.1-2001 permits  implementa‐
       tions  to  extend utilities. The expr utility permits the integer argu‐
       ments to be preceded with a unary minus. This  means  that  an  integer
       argument	 could look like an option. Therefore, the conforming applica‐
       tion must employ the "--" construct of Guideline 10 of the Base Defini‐
       tions  volume  of  IEEE Std 1003.1-2001,	 Section  12.2, Utility Syntax
       Guidelines to protect its operands if there is any chance the first op‐
       erand might be a negative integer (or any string with a leading minus).

       The expr utility has a rather difficult syntax:

	* Many	of  the operators are also shell control operators or reserved
	  words, so they have to be escaped on the command line.

	* Each part of the expression is composed of  separate	arguments,  so
	  liberal usage of <blank>s is required. For example:

			Invalid		   Valid
			expr 1+2	   expr 1 + 2
			expr "1 + 2"	   expr 1 + 2
			expr 1 + (2 * 3)   expr 1 + \( 2 \* 3 \)

       In  many	 cases, the arithmetic and string features provided as part of
       the shell command language are easier to use than their equivalents  in
       expr.  Newly written scripts should avoid expr in favor of the new fea‐
       tures within the shell; see Parameters  and  Variables  and  Arithmetic
       Expansion .

       The following command:

	      a=$(expr $a + 1)

       adds 1 to the variable a.

       The  following  command, for "$a" equal to either /usr/abc/file or just

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

       returns the last segment of a pathname (that  is,  file).  Applications
       should  avoid  the  character  '/'  used alone as an argument; expr may
       interpret it as the division operator.

       The following command:

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

       is a better representation of the previous example. The addition of the
       "//"  characters	 eliminates  any ambiguity about the division operator
       and simplifies the whole expression. Also note that pathnames may  con‐
       tain  characters	 contained in the IFS variable and should be quoted to
       avoid having "$a" expand into multiple arguments.

       The following command:

	      expr "$VAR" : '.*'

       returns the number of characters in VAR.

       In an early proposal, EREs were used in the matching expression syntax.
       This was changed to BREs to avoid breaking historical applications.

       The  use of a leading circumflex in the BRE is unspecified because many
       historical implementations have treated	it  as	a  special  character,
       despite their system documentation. For example:

	      expr foo : ^foo	  expr ^foo : ^foo

       return  3  and  0,  respectively, on those systems; their documentation
       would imply the reverse. Thus, the anchoring condition is left unspeci‐
       fied  to avoid breaking historical scripts relying on this undocumented


       Parameters and Variables, Arithmetic Expansion

       Portions of this text are reprinted and reproduced in  electronic  form
       from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology
       -- Portable Operating System Interface (POSIX),	The  Open  Group  Base
       Specifications  Issue  6,  Copyright  (C) 2001-2003 by the Institute of
       Electrical and Electronics Engineers, Inc and The Open  Group.  In  the
       event of any discrepancy between this version and the original IEEE and
       The Open Group Standard, the original IEEE and The Open Group  Standard
       is  the	referee document. The original Standard can be obtained online
       at http://www.opengroup.org/unix/online.html .

IEEE/The Open Group		     2003			      EXPR(1P)

List of man pages available for Scientific

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net