Info Catalog gawk: Function Calls gawk: Expressions gawk: Locales

gawk: Precedence

 
 6.5 Operator Precedence (How Operators Nest)
 ============================================
 
 "Operator precedence" determines how operators are grouped when
 different operators appear close by in one expression.  For example, '*'
 has higher precedence than '+'; thus, 'a + b * c' means to multiply 'b'
 and 'c', and then add 'a' to the product (i.e., 'a + (b * c)').
 
    The normal precedence of the operators can be overruled by using
 parentheses.  Think of the precedence rules as saying where the
 parentheses are assumed to be.  In fact, it is wise to always use
 parentheses whenever there is an unusual combination of operators,
 because other people who read the program may not remember what the
 precedence is in this case.  Even experienced programmers occasionally
 forget the exact rules, which leads to mistakes.  Explicit parentheses
 help prevent any such mistakes.
 
    When operators of equal precedence are used together, the leftmost
 operator groups first, except for the assignment, conditional, and
 exponentiation operators, which group in the opposite order.  Thus, 'a -
 b + c' groups as '(a - b) + c' and 'a = b = c' groups as 'a = (b = c)'.
 
    Normally the precedence of prefix unary operators does not matter,
 because there is only one way to interpret them: innermost first.  Thus,
 '$++i' means '$(++i)' and '++$x' means '++($x)'.  However, when another
 operator follows the operand, then the precedence of the unary operators
 can matter.  '$x^2' means '($x)^2', but '-x^2' means '-(x^2)', because
 '-' has lower precedence than '^', whereas '$' has higher precedence.
 Also, operators cannot be combined in a way that violates the precedence
 rules; for example, '$$0++--' is not a valid expression because the
 first '$' has higher precedence than the '++'; to avoid the problem the
 expression can be rewritten as '$($0++)--'.
 
    This list presents 'awk''s operators, in order of highest to lowest
 precedence:
 
 '('...')'
      Grouping.
 
 '$'
      Field reference.
 
 '++ --'
      Increment, decrement.
 
 '^ **'
      Exponentiation.  These operators group right to left.
 
 '+ - !'
      Unary plus, minus, logical "not."
 
 '* / %'
      Multiplication, division, remainder.
 
 '+ -'
      Addition, subtraction.
 
 String concatenation
      There is no special symbol for concatenation.  The operands are
      simply written side by side (Concatenation).
 
 '< <= == != > >= >> | |&'
      Relational and redirection.  The relational operators and the
      redirections have the same precedence level.  Characters such as
      '>' serve both as relationals and as redirections; the context
      distinguishes between the two meanings.
 
      Note that the I/O redirection operators in 'print' and 'printf'
      statements belong to the statement level, not to expressions.  The
      redirection does not produce an expression that could be the
      operand of another operator.  As a result, it does not make sense
      to use a redirection operator near another operator of lower
      precedence without parentheses.  Such combinations (e.g., 'print
      foo > a ? b : c') result in syntax errors.  The correct way to
      write this statement is 'print foo > (a ? b : c)'.
 
 '~ !~'
      Matching, nonmatching.
 
 'in'
      Array membership.
 
 '&&'
      Logical "and."
 
 '||'
      Logical "or."
 
 '?:'
      Conditional.  This operator groups right to left.
 
 '= += -= *= /= %= ^= **='
      Assignment.  These operators group right to left.
 
      NOTE: The '|&', '**', and '**=' operators are not specified by
      POSIX. For maximum portability, do not use them.
 

Info Catalog gawk: Function Calls gawk: Expressions gawk: Locales