On Apache
Under GNU General Public License
2024-12-22 15:14 @3.147.86.30 CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)
File: coreutils.info, Node: expr invocation, Prev: test invocation, Up: Conditions
16.4 'expr': Evaluate expressions
=================================
'expr' evaluates an expression and writes the result on standard output.
Each token of the expression must be a separate argument.
Operands are either integers or strings. Integers consist of one or
more decimal digits, with an optional leading '-'. 'expr' converts
anything appearing in an operand position to an integer or a string
depending on the operation being applied to it.
Strings are not quoted for 'expr' itself, though you may need to
quote them to protect characters with special meaning to the shell,
e.g., spaces. However, regardless of whether it is quoted, a string
operand should not be a parenthesis or any of 'expr''s operators like
'+', so you cannot safely pass an arbitrary string '$str' to expr merely
by quoting it to the shell. One way to work around this is to use the
GNU extension '+', (e.g., '+ "$str" = foo'); a more portable way is to
use '" $str"' and to adjust the rest of the expression to take the
leading space into account (e.g., '" $str" = " foo"').
You should not pass a negative integer or a string with leading '-'
as 'expr''s first argument, as it might be misinterpreted as an option;
this can be avoided by parenthesization. Also, portable scripts should
not use a string operand that happens to take the form of an integer;
this can be worked around by inserting leading spaces as mentioned
above.
Operators may be given as infix symbols or prefix keywords.
Parentheses may be used for grouping in the usual manner. You must
quote parentheses and many operators to avoid the shell evaluating them,
however.
When built with support for the GNU MP library, 'expr' uses
arbitrary-precision arithmetic; otherwise, it uses native arithmetic
types and may fail due to arithmetic overflow.
The only options are '--help' and '--version'. *Note Common
options::. Options must precede operands.
Exit status:
0 if the expression is neither null nor 0,
1 if the expression is null or 0,
2 if the expression is invalid,
3 if an internal error occurred (e.g., arithmetic overflow).
* Menu:
* String expressions:: + : match substr index length
* Numeric expressions:: + - * / %
* Relations for expr:: | & < <= = == != >= >
* Examples of expr:: Examples.
File: coreutils.info, Node: String expressions, Next: Numeric expressions, Up: expr invocation
16.4.1 String expressions
-------------------------
'expr' supports pattern matching and other string operators. These have
higher precedence than both the numeric and relational operators (in the
next sections).
'STRING : REGEX'
Perform pattern matching. The arguments are converted to strings
and the second is considered to be a (basic, a la GNU 'grep')
regular expression, with a '^' implicitly prepended. The first
argument is then matched against this regular expression.
If the match succeeds and REGEX uses '\(' and '\)', the ':'
expression returns the part of STRING that matched the
subexpression; otherwise, it returns the number of characters
matched.
If the match fails, the ':' operator returns the null string if
'\(' and '\)' are used in REGEX, otherwise 0.
Only the first '\( ... \)' pair is relevant to the return value;
additional pairs are meaningful only for grouping the regular
expression operators.
In the regular expression, '\+', '\?', and '\|' are operators which
respectively match one or more, zero or one, or separate
alternatives. SunOS and other 'expr''s treat these as regular
characters. (POSIX allows either behavior.) *Note Regular
Expression Library: (regex)Top, for details of regular expression
syntax. Some examples are in *note Examples of expr::.
'match STRING REGEX'
An alternative way to do pattern matching. This is the same as
'STRING : REGEX'.
'substr STRING POSITION LENGTH'
Returns the substring of STRING beginning at POSITION with length
at most LENGTH. If either POSITION or LENGTH is negative, zero, or
non-numeric, returns the null string.
'index STRING CHARSET'
Returns the first position in STRING where the first character in
CHARSET was found. If no character in CHARSET is found in STRING,
return 0.
'length STRING'
Returns the length of STRING.
'+ TOKEN'
Interpret TOKEN as a string, even if it is a keyword like MATCH or
an operator like '/'. This makes it possible to test 'expr length
+ "$x"' or 'expr + "$x" : '.*/\(.\)'' and have it do the right
thing even if the value of $X happens to be (for example) '/' or
'index'. This operator is a GNU extension. Portable shell scripts
should use '" $token" : ' \(.*\)'' instead of '+ "$token"'.
To make 'expr' interpret keywords as strings, you must use the
'quote' operator.
File: coreutils.info, Node: Numeric expressions, Next: Relations for expr, Prev: String expressions, Up: expr invocation
16.4.2 Numeric expressions
--------------------------
'expr' supports the usual numeric operators, in order of increasing
precedence. These numeric operators have lower precedence than the
string operators described in the previous section, and higher
precedence than the connectives (next section).
'+ -'
Addition and subtraction. Both arguments are converted to
integers; an error occurs if this cannot be done.
'* / %'
Multiplication, division, remainder. Both arguments are converted
to integers; an error occurs if this cannot be done.
File: coreutils.info, Node: Relations for expr, Next: Examples of expr, Prev: Numeric expressions, Up: expr invocation
16.4.3 Relations for 'expr'
---------------------------
'expr' supports the usual logical connectives and relations. These have
lower precedence than the string and numeric operators (previous
sections). Here is the list, lowest-precedence operator first.
'|'
Returns its first argument if that is neither null nor zero,
otherwise its second argument if it is neither null nor zero,
otherwise 0. It does not evaluate its second argument if its first
argument is neither null nor zero.
'&'
Return its first argument if neither argument is null or zero,
otherwise 0. It does not evaluate its second argument if its first
argument is null or zero.
'< <= = == != >= >'
Compare the arguments and return 1 if the relation is true, 0
otherwise. '==' is a synonym for '='. 'expr' first tries to
convert both arguments to integers and do a numeric comparison; if
either conversion fails, it does a lexicographic comparison using
the character collating sequence specified by the 'LC_COLLATE'
locale.
File: coreutils.info, Node: Examples of expr, Prev: Relations for expr, Up: expr invocation
16.4.4 Examples of using 'expr'
-------------------------------
Here are a few examples, including quoting for shell metacharacters.
To add 1 to the shell variable 'foo', in Bourne-compatible shells:
foo=$(expr $foo + 1)
To print the non-directory part of the file name stored in '$fname',
which need not contain a '/':
expr $fname : '.*/\(.*\)' '|' $fname
An example showing that '\+' is an operator:
expr aaa : 'a\+'
=> 3
expr abc : 'a\(.\)c'
=> b
expr index abcdef cz
=> 3
expr index index a
error-> expr: syntax error
expr index + index a
=> 0
Generated by $Id: phpMan.php,v 4.55 2007/09/05 04:42:51 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2024-12-22 15:14 @3.147.86.30 CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)