Go to the first, previous, next, last section, table of contents.

# Expressions

Expressions are the basic building blocks of `awk` patterns and actions. An expression evaluates to a value, which you can print, test, store in a variable or pass to a function. Additionally, an expression can assign a new value to a variable or a field, with an assignment operator.

An expression can serve as a pattern or action statement on its own. Most other kinds of statements contain one or more expressions which specify data on which to operate. As in other languages, expressions in `awk` include variables, array references, constants, and function calls, as well as combinations of these with various operators.

- Constants: String, numeric, and regexp constants.
- Using Constant Regexps: When and how to use a regexp constant.
- Variables: Variables give names to values for later use.
- Conversion: The conversion of strings to numbers and vice versa.
- Arithmetic Ops: Arithmetic operations (``+'`, ``-'`, etc.)
- Concatenation: Concatenating strings.
- Assignment Ops: Changing the value of a variable or a field.
- Increment Ops: Incrementing the numeric value of a variable.
- Truth Values: What is "true" and what is "false".
- Typing and Comparison: How variables acquire types, and how this affects comparison of numbers and strings with ``<'`, etc.
- Boolean Ops: Combining comparison expressions using boolean operators ``||'` ("or"), ``&&'` ("and") and ``!'` ("not").
- Conditional Exp: Conditional expressions select between two subexpressions under control of a third subexpression.
- Function Calls: A function call is an expression.
- Precedence: How various operators nest.

## Constant Expressions

The simplest type of expression is the constant, which always has the same value. There are three types of constants: numeric constants, string constants, and regular expression constants.

- Scalar Constants: Numeric and string constants.
- Regexp Constants: Regular Expression constants.

### Numeric and String Constants

A numeric constant stands for a number. This number can be an integer, a decimal fraction, or a number in scientific (exponential) notation.(7) Here are some examples of numeric constants, which all have the same value:

    105
    1.05e+2
    1050e-1

A string constant consists of a sequence of characters enclosed in double-quote marks. For example:

    "parrot"

represents the string whose contents are ``parrot'`. Strings in `gawk` can be of any length and they can contain any of the possible eight-bit ASCII characters including ASCII NUL (character code zero). Other `awk` implementations may have difficulty with some character codes.

### Regular Expression Constants

A regexp constant is a regular expression description enclosed in slashes, such as `/^beginning and end$/`. Most regexps used in `awk` programs are constant, but the ``~'` and ``!~'` matching operators can also match computed or "dynamic" regexps (which are just ordinary strings or variables that contain a regexp).

## Using Regular Expression Constants

When used on the right hand side of the ``~'` or ``!~'` operators, a regexp constant merely stands for the regexp that is to be matched.

Regexp constants (such as `/foo/`) may be used like simple expressions. When a regexp constant appears by itself, it has the same meaning as if it appeared in a pattern, i.e. ``($0 ~ /foo/)'` (d.c.) (see section Expressions as Patterns). This means that the two code segments,

    if ($0 ~ /barfly/ || $0 ~ /camelot/)
        print "found"

and

    if (/barfly/ || /camelot/)
        print "found"

are exactly equivalent.

One rather bizarre consequence of this rule is that the following boolean expression is valid, but does not do what the user probably intended:

    # note that /foo/ is on the left of the ~
    if (/foo/ ~ $1) print "found foo"

This code is "obviously" testing `$1` for a match against the regexp `/foo/`. But in fact, the expression ``/foo/ ~ $1'` actually means ``($0 ~ /foo/) ~ $1'`. In other words, first match the input record against the regexp `/foo/`. The result will be either zero or one, depending upon the success or failure of the match. Then match that result against the first field in the record.

Since it is unlikely that you would ever really wish to make this kind of test, `gawk` will issue a warning when it sees this construct in a program.

Another consequence of this rule is that the assignment statement

    matches = /foo/

will assign either zero or one to the variable `matches`, depending upon the contents of the current input record.

This feature of the language was never well documented until the POSIX specification.

Constant regular expressions are also used as the first argument for the `gensub`, `sub` and `gsub` functions, and as the second argument of the `match` function (see section Built-in Functions for String Manipulation). Modern implementations of `awk`, including `gawk`, allow the third argument of `split` to be a regexp constant, while some older implementations do not (d.c.).

This can lead to confusion when attempting to use regexp constants as arguments to user defined functions (see section User-defined Functions). For example:

    function mysub(pat, repl, str, global)
    {
        if (global)
            gsub(pat, repl, str)
        else
            sub(pat, repl, str)
        return str
    }

    {
        ...
        text = "hi! hi yourself!"
        mysub(/hi/, "howdy", text, 1)
        ...
    }

In this example, the programmer wishes to pass a regexp constant to the user-defined function `mysub`, which will in turn pass it on to either `sub` or `gsub`. However, what really happens is that the `pat` parameter will be either one or zero, depending upon whether or not `$0` matches `/hi/`.

As it is unlikely that you would ever really wish to pass a truth value in this way, `gawk` will issue a warning when it sees a regexp constant used as a parameter to a user-defined function.

## Variables

Variables are ways of storing values at one point in your program for use later in another part of your program. You can manipulate them entirely within your program text, and you can also assign values to them on the `awk` command line.

- Using Variables: Using variables in your programs.
- Assignment Options: Setting variables on the command line and a summary of command line syntax. This is an advanced method of input.

### Using Variables in a Program

Variables let you give names to values and refer to them later. You have already seen variables in many of the examples. The name of a variable must be a sequence of letters, digits and underscores, but it may not begin with a digit. Case is significant in variable names; `a` and `A` are distinct variables.

A variable name is a valid expression by itself; it represents the variable's current value. Variables are given new values with assignment operators, increment operators and decrement operators. See section Assignment Expressions.

A few variables have special built-in meanings, such as `FS`, the field separator, and `NF`, the number of fields in the current input record. See section Built-in Variables, for a list of them. These built-in variables can be used and assigned just like all other variables, but their values are also used or changed automatically by `awk`. All built-in variables names are entirely upper-case.

Variables in `awk` can be assigned either numeric or string values. By default, variables are initialized to the empty string, which is zero if converted to a number. There is no need to "initialize" each variable explicitly in `awk`, the way you would in C and in most other traditional languages.

### Assigning Variables on the Command Line

You can set any `awk` variable by including a variable assignment among the arguments on the command line when you invoke `awk` (see section Other Command Line Arguments). Such an assignment has this form:

    variable=text

With it, you can set a variable either at the beginning of the `awk` run or in between input files.

If you precede the assignment with the ``-v'` option, like this:

    -v variable=text

then the variable is set at the very beginning, before even the `BEGIN` rules are run. The ``-v'` option and its assignment must precede all the file name arguments, as well as the program text. (See section Command Line Options, for more information about the ``-v'` option.)

Otherwise, the variable assignment is performed at a time determined by its position among the input file arguments: after the processing of the preceding input file argument. For example:

    awk '{ print $n }' n=4 inventory-shipped n=2 BBS-list

prints the value of field number `n` for all input records. Before the first file is read, the command line sets the variable `n` equal to four. This causes the fourth field to be printed in lines from the file ``inventory-shipped'`. After the first file has finished, but before the second file is started, `n` is set to two, so that the second field is printed in lines from ``BBS-list'`.

    $ awk '{ print $n }' n=4 inventory-shipped n=2 BBS-list
    -| 15
    -| 24
    ...
    -| 555-5553
    -| 555-3412
    ...

Command line arguments are made available for explicit examination by the `awk` program in an array named `ARGV` (see section Using `ARGC` and `ARGV`).

`awk` processes the values of command line assignments for escape sequences (d.c.) (see section Escape Sequences).

## Conversion of Strings and Numbers

Strings are converted to numbers, and numbers to strings, if the context of the `awk` program demands it. For example, if the value of either `foo` or `bar` in the expression ``foo + bar'` happens to be a string, it is converted to a number before the addition is performed. If numeric values appear in string concatenation, they are converted to strings. Consider this:

    two = 2; three = 3
    print (two three) + 4

This prints the (numeric) value 27. The numeric values of the variables `two` and `three` are converted to strings and concatenated together, and the resulting string is converted back to the number 23, to which four is then added.

If, for some reason, you need to force a number to be converted to a string, concatenate the empty string, `""`, with that number. To force a string to be converted to a number, add zero to that string.

A string is converted to a number by interpreting any numeric prefix of the string as numerals: `"2.5"` converts to 2.5, `"1e3"` converts to 1000, and `"25fix"` has a numeric value of 25. Strings that can't be interpreted as valid numbers are converted to zero.

The exact manner in which numbers are converted into strings is controlled by the `awk` built-in variable `CONVFMT` (see section Built-in Variables). Numbers are converted using the `sprintf` function (see section Built-in Functions for String Manipulation) with `CONVFMT` as the format specifier.

`CONVFMT`'s default value is `"%.6g"`, which prints a value with at least six significant digits. For some applications you will want to change it to specify more precision. Double precision on most modern machines gives you 16 or 17 decimal digits of precision.

Strange results can happen if you set `CONVFMT` to a string that doesn't tell `sprintf` how to format floating point numbers in a useful way. For example, if you forget the ``%'` in the format, all numbers will be converted to the same constant string.

As a special case, if a number is an integer, then the result of converting it to a string is always an integer, no matter what the value of `CONVFMT` may be. Given the following code fragment:

    CONVFMT = "%2.2f"
    a = 12
    b = a ""

`b` has the value `"12"`, not `"12.00"` (d.c.).

Prior to the POSIX standard, `awk` specified that the value of `OFMT` was used for converting numbers to strings. `OFMT` specifies the output format to use when printing numbers with `print`. `CONVFMT` was introduced in order to separate the semantics of conversion from the semantics of printing. Both `CONVFMT` and `OFMT` have the same default value: `"%.6g"`. In the vast majority of cases, old `awk` programs will not change their behavior. However, this use of `OFMT` is something to keep in mind if you must port your program to other implementations of `awk`; we recommend that instead of changing your programs, you just port `gawk` itself! See section The `print` Statement, for more information on the `print` statement.

## Arithmetic Operators

The `awk` language uses the common arithmetic operators when evaluating expressions. All of these arithmetic operators follow normal precedence rules, and work as you would expect them to.

Here is a file ``grades'` containing a list of student names and three test scores per student (it's a small class):

    Pat   100 97 58
    Sandy  84 72 93
    Chris  72 92 89

This programs takes the file ``grades'`, and prints the average of the scores.

    $ awk '{ sum = $2 + $3 + $4 ; avg = sum / 3
    >        print $1, avg }' grades
    -| Pat 85
    -| Sandy 83
    -| Chris 84.3333

This table lists the arithmetic operators in `awk`, in order from highest precedence to lowest:

`- x`
  Negation.
`+ x`
  Unary plus. The expression is converted to a number.
`x ^ y`
`x ** y`
  Exponentiation: x raised to the y power. ``2 ^ 3'` has the value eight. The character sequence ``**'` is equivalent to ``^'`. (The POSIX standard only specifies the use of ``^'` for exponentiation.)
`x * y`
  Multiplication.
`x / y`
  Division. Since all numbers in `awk` are real numbers, the result is not rounded to an integer: ``3 / 4'` has the value 0.75.
`x % y`
  Remainder. The quotient is rounded toward zero to an integer, multiplied by y and this result is subtracted from x. This operation is sometimes known as "trunc-mod." The following relation always holds:

      b * int(a / b) + (a % b) == a

  One possibly undesirable effect of this definition of remainder is that `x % y` is negative if x is negative. Thus,

      -17 % 8 = -1

  In other `awk` implementations, the signedness of the remainder may be machine dependent.
`x + y`
  Addition.
`x - y`
  Subtraction.

For maximum portability, do not use the ``**'` operator.

Unary plus and minus have the same precedence, the multiplication operators all have the same precedence, and addition and subtraction have the same precedence.

## String Concatenation

    It seemed like a good idea at the time.
    Brian Kernighan

There is only one string operation: concatenation. It does not have a specific operator to represent it. Instead, concatenation is performed by writing expressions next to one another, with no operator. For example:

    $ awk '{ print "Field number one: " $1 }' BBS-list
    -| Field number one: aardvark
    -| Field number one: alpo-net
    ...

Without the space in the string constant after the ``:'`, the line would run together. For example:

    $ awk '{ print "Field number one:" $1 }' BBS-list
    -| Field number one:aardvark
    -| Field number one:alpo-net
    ...

Since string concatenation does not have an explicit operator, it is often necessary to insure that it happens where you want it to by using parentheses to enclose the items to be concatenated. For example, the following code fragment does not concatenate `file` and `name` as you might expect:

    file = "file"
    name = "name"
    print "something meaningful" > file name

It is necessary to use the following:

    print "something meaningful" > (file name)

We recommend that you use parentheses around concatenation in all but the most common contexts (such as on the right-hand side of ``='`).

## Assignment Expressions

An assignment is an expression that stores a new value into a variable. For example, let's assign the value one to the variable `z`:

    z = 1

After this expression is executed, the variable `z` has the value one. Whatever old value `z` had before the assignment is forgotten.

Assignments can store string values also. For example, this would store the value `"this food is good"` in the variable `message`:

    thing = "food"
    predicate = "good"
    message = "this " thing " is " predicate

(This also illustrates string concatenation.)

The ``='` sign is called an assignment operator. It is the simplest assignment operator because the value of the right-hand operand is stored unchanged.

Most operators (addition, concatenation, and so on) have no effect except to compute a value. If you ignore the value, you might as well not use the operator. An assignment operator is different; it does produce a value, but even if you ignore the value, the assignment still makes itself felt through the alteration of the variable. We call this a side effect.

The left-hand operand of an assignment need not be a variable (see section Variables); it can also be a field (see section Changing the Contents of a Field) or an array element (see section Arrays in `awk`). These are all called lvalues, which means they can appear on the left-hand side of an assignment operator. The right-hand operand may be any expression; it produces the new value which the assignment stores in the specified variable, field or array element. (Such values are called rvalues).

It is important to note that variables do not have permanent types. The type of a variable is simply the type of whatever value it happens to hold at the moment. In the following program fragment, the variable `foo` has a numeric value at first, and a string value later on:

    foo = 1
    print foo
    foo = "bar"
    print foo

When the second assignment gives `foo` a string value, the fact that it previously had a numeric value is forgotten.

String values that do not begin with a digit have a numeric value of zero. After executing this code, the value of `foo` is five:

    foo = "a string"
    foo = foo + 5

(Note that using a variable as a number and then later as a string can be confusing and is poor programming style. The above examples illustrate how `awk` works, not how you should write your own programs!)

An assignment is an expression, so it has a value: the same value that is assigned. Thus, ``z = 1'` as an expression has the value one. One consequence of this is that you can write multiple assignments together:

    x = y = z = 0

stores the value zero in all three variables. It does this because the value of ``z = 0'`, which is zero, is stored into `y`, and then the value of ``y = z = 0'`, which is zero, is stored into `x`.

You can use an assignment anywhere an expression is called for. For example, it is valid to write ``x != (y = 1)'` to set `y` to one and then test whether `x` equals one. But this style tends to make programs hard to read; except in a one-shot program, you should not use such nesting of assignments.

Aside from ``='`, there are several other assignment operators that do arithmetic with the old value of the variable. For example, the operator ``+='` computes a new value by adding the right-hand value to the old value of the variable. Thus, the following assignment adds five to the value of `foo`:

    foo += 5

This is equivalent to the following:

    foo = foo + 5

Use whichever one makes the meaning of your program clearer.

There are situations where using ``+='` (or any assignment operator) is not the same as simply repeating the left-hand operand in the right-hand expression. For example:

    # Thanks to Pat Rankin for this example
    BEGIN  {
        foo[rand()] += 5
        for (x in foo)
           print x, foo[x]

        bar[rand()] = bar[rand()] + 5
        for (x in bar)
           print x, bar[x]
    }

The indices of `bar` are guaranteed to be different, because `rand` will return different values each time it is called. (Arrays and the `rand` function haven't been covered yet. See section Arrays in `awk`, and see section Numeric Built-in Functions, for more information). This example illustrates an important fact about the assignment operators: the left-hand expression is only evaluated once.

It is also up to the implementation as to which expression is evaluated first, the left-hand one or the right-hand one. Consider this example:

    i = 1
    a[i += 2] = i + 1

The value of `a[3]` could be either two or four.

Here is a table of the arithmetic assignment operators. In each case, the right-hand operand is an expression whose value is converted to a number.

`lvalue += increment`
  Adds increment to the value of lvalue to make the new value of lvalue.
`lvalue -= decrement`
  Subtracts decrement from the value of lvalue.
`lvalue *= coefficient`
  Multiplies the value of lvalue by coefficient.
`lvalue /= divisor`
  Divides the value of lvalue by divisor.
`lvalue %= modulus`
  Sets lvalue to its remainder by modulus.
`lvalue ^= power`
`lvalue **= power`
  Raises lvalue to the power power. (Only the ``^='` operator is specified by POSIX.)

For maximum portability, do not use the ``**='` operator.

## Increment and Decrement Operators

Increment and decrement operators increase or decrease the value of a variable by one. You could do the same thing with an assignment operator, so the increment operators add no power to the `awk` language; but they are convenient abbreviations for very common operations.

The operator to add one is written ``++'`. It can be used to increment a variable either before or after taking its value.

To pre-increment a variable v, write ``++v'`. This adds one to the value of v and that new value is also the value of this expression. The assignment expression ``v += 1'` is completely equivalent.

Writing the ``++'` after the variable specifies post-increment. This increments the variable value just the same; the difference is that the value of the increment expression itself is the variable's old value. Thus, if `foo` has the value four, then the expression ``foo++'` has the value four, but it changes the value of `foo` to five.

The post-increment ``foo++'` is nearly equivalent to writing ``(foo += 1) - 1'`. It is not perfectly equivalent because all numbers in `awk` are floating point: in floating point, ``foo + 1 - 1'` does not necessarily equal `foo`. But the difference is minute as long as you stick to numbers that are fairly small (less than 10e12).

Any lvalue can be incremented. Fields and array elements are incremented just like variables. (Use ``$(i++)'` when you wish to do a field reference and a variable increment at the same time. The parentheses are necessary because of the precedence of the field reference operator, ``$'`.)

The decrement operator ``--'` works just like ``++'` except that it subtracts one instead of adding. Like ``++'`, it can be used before the lvalue to pre-decrement or after it to post-decrement.

Here is a summary of increment and decrement expressions.

`++lvalue`
  This expression increments lvalue and the new value becomes the value of the expression.
`lvalue++`
  This expression increments lvalue, but the value of the expression is the old value of lvalue.
`--lvalue`
  Like ``++lvalue'`, but instead of adding, it subtracts. It decrements lvalue and delivers the value that results.
`lvalue--`
  Like ``lvalue++'`, but instead of adding, it subtracts. It decrements lvalue. The value of the expression is the old value of lvalue.

## True and False in `awk`

Many programming languages have a special representation for the concepts of "true" and "false." Such languages usually use the special constants `true` and `false`, or perhaps their upper-case equivalents.

`awk` is different. It borrows a very simple concept of true and false from C. In `awk`, any non-zero numeric value, or any non-empty string value is true. Any other value (zero or the null string, `""`) is false. The following program will print ``A strange truth value'` three times:

    BEGIN {
       if (3.1415927)
           print "A strange truth value"
       if ("Four Score And Seven Years Ago")
           print "A strange truth value"
       if (j = 57)
           print "A strange truth value"
    }

There is a surprising consequence of the "non-zero or non-null" rule: The string constant `"0"` is actually true, since it is non-null (d.c.).

## Variable Typing and Comparison Expressions

    The Guide is definitive. Reality is frequently inaccurate.
    The Hitchhiker's Guide to the Galaxy

Unlike other programming languages, `awk` variables do not have a fixed type. Instead, they can be either a number or a string, depending upon the value that is assigned to them.

The 1992 POSIX standard introduced the concept of a numeric string, which is simply a string that looks like a number, for example, `" +2"`. This concept is used for determining the type of a variable.

The type of the variable is important, since the types of two variables determine how they are compared.

In `gawk`, variable typing follows these rules.

1. A numeric literal or the result of a numeric operation has the numeric attribute.
2. A string literal or the result of a string operation has the string attribute.
3. Fields, `getline` input, `FILENAME`, `ARGV` elements, `ENVIRON` elements and the elements of an array created by `split` that are numeric strings have the strnum attribute. Otherwise, they have the string attribute. Uninitialized variables also have the strnum attribute.
4. Attributes propagate across assignments, but are not changed by any use.

The last rule is particularly important. In the following program, `a` has numeric type, even though it is later used in a string operation.

    BEGIN {
             a = 12.345
             b = a " is a cute number"
             print b
    }

When two operands are compared, either string comparison or numeric comparison may be used, depending on the attributes of the operands, according to the following, symmetric, matrix:

The basic idea is that user input that looks numeric, and only user input, should be treated as numeric, even though it is actually made of characters, and is therefore also a string.

Comparison expressions compare strings or numbers for relationships such as equality. They are written using relational operators, which are a superset of those in C. Here is a table of them:

`x < y`
  True if x is less than y.
`x <= y`
  True if x is less than or equal to y.
`x > y`
  True if x is greater than y.
`x >= y`
  True if x is greater than or equal to y.
`x == y`
  True if x is equal to y.
`x != y`
  True if x is not equal to y.
`x ~ y`
  True if the string x matches the regexp denoted by y.
`x !~ y`
  True if the string x does not match the regexp denoted by y.
`subscript in array`
  True if the array array has an element with the subscript subscript.

Comparison expressions have the value one if true and zero if false.

When comparing operands of mixed types, numeric operands are converted to strings using the value of `CONVFMT` (see section Conversion of Strings and Numbers).

Strings are compared by comparing the first character of each, then the second character of each, and so on. Thus `"10"` is less than `"9"`. If there are two strings where one is a prefix of the other, the shorter string is less than the longer one. Thus `"abc"` is less than `"abcd"`.

It is very easy to accidentally mistype the ``=='` operator, and leave off one of the ``='`s. The result is still valid `awk` code, but the program will not do what you mean:

    if (a = b)   # oops! should be a == b
       ...
    else
       ...

Unless `b` happens to be zero or the null string, the `if` part of the test will always succeed. Because the operators are so similar, this kind of error is very difficult to spot when scanning the source code.

Here are some sample expressions, how `gawk` compares them, and what the result of the comparison is.

`1.5 <= 2.0`
  numeric comparison (true)
`"abc" >= "xyz"`
  string comparison (false)
`1.5 != " +2"`
  string comparison (true)
`"1e2" < "3"`
  string comparison (true)
`a = 2; b = "2"`
`a == b`
  string comparison (true)
`a = 2; b = " +2"`
`a == b`
  string comparison (false)

In this example,

    $ echo 1e2 3 | awk '{ print ($1 < $2) ? "true" : "false" }'
    -| false

the result is ``false'` since both `$1` and `$2` are numeric strings and thus both have the strnum attribute, dictating a numeric comparison.

The purpose of the comparison rules and the use of numeric strings is to attempt to produce the behavior that is "least surprising," while still "doing the right thing."

String comparisons and regular expression comparisons are very different. For example,

    x == "foo"

has the value of one, or is true, if the variable `x` is precisely ``foo'`. By contrast,

    x ~ /foo/

has the value one if `x` contains ``foo'`, such as `"Oh, what a fool am I!"`.

The right hand operand of the ``~'` and ``!~'` operators may be either a regexp constant (`/.../`), or an ordinary expression, in which case the value of the expression as a string is used as a dynamic regexp (see section How to Use Regular Expressions; also see section Using Dynamic Regexps).

In recent implementations of `awk`, a constant regular expression in slashes by itself is also an expression. The regexp `/regexp/` is an abbreviation for this comparison expression:

    $0 ~ /regexp/

One special place where `/foo/` is not an abbreviation for ``$0 ~ /foo/'` is when it is the right-hand operand of ``~'` or ``!~'`! See section Using Regular Expression Constants, where this is discussed in more detail.

## Boolean Expressions

A boolean expression is a combination of comparison expressions or matching expressions, using the boolean operators "or" (``||'`), "and" (``&&'`), and "not" (``!'`), along with parentheses to control nesting. The truth value of the boolean expression is computed by combining the truth values of the component expressions. Boolean expressions are also referred to as logical expressions. The terms are equivalent.

Boolean expressions can be used wherever comparison and matching expressions can be used. They can be used in `if`, `while`, `do` and `for` statements (see section Control Statements in Actions). They have numeric values (one if true, zero if false), which come into play if the result of the boolean expression is stored in a variable, or used in arithmetic.

In addition, every boolean expression is also a valid pattern, so you can use one as a pattern to control the execution of rules.

Here are descriptions of the three boolean operators, with examples.

`boolean1 && boolean2`
  True if both boolean1 and boolean2 are true. For example, the following statement prints the current input record if it contains both ``2400'` and ``foo'`.

      if ($0 ~ /2400/ && $0 ~ /foo/) print

  The subexpression boolean2 is evaluated only if boolean1 is true. This can make a difference when boolean2 contains expressions that have side effects: in the case of ``$0 ~ /foo/ && ($2 == bar++)'`, the variable `bar` is not incremented if there is no ``foo'` in the record.
`boolean1 || boolean2`
  True if at least one of boolean1 or boolean2 is true. For example, the following statement prints all records in the input that contain either ``2400'` or ``foo'`, or both.

      if ($0 ~ /2400/ || $0 ~ /foo/) print

  The subexpression boolean2 is evaluated only if boolean1 is false. This can make a difference when boolean2 contains expressions that have side effects.
`! boolean`
  True if boolean is false. For example, the following program prints all records in the input file ``BBS-list'` that do not contain the string ``foo'`.

      awk '{ if (! ($0 ~ /foo/)) print }' BBS-list

The ``&&'` and ``||'` operators are called short-circuit operators because of the way they work. Evaluation of the full expression is "short-circuited" if the result can be determined part way through its evaluation.

You can continue a statement that uses ``&&'` or ``||'` simply by putting a newline after them. But you cannot put a newline in front of either of these operators without using backslash continuation (see section `awk` Statements Versus Lines).

The actual value of an expression using the ``!'` operator will be either one or zero, depending upon the truth value of the expression it is applied to.

The ``!'` operator is often useful for changing the sense of a flag variable from false to true and back again. For example, the following program is one way to print lines in between special bracketing lines:

    $1 == "START"   { interested = ! interested }
    interested == 1 { print }
    $1 == "END"     { interested = ! interested }

The variable `interested`, like all `awk` variables, starts out initialized to zero, which is also false. When a line is seen whose first field is ``START'`, the value of `interested` is toggled to true, using ``!'`. The next rule prints lines as long as `interested` is true. When a line is seen whose first field is ``END'`, `interested` is toggled back to false.

## Conditional Expressions

A conditional expression is a special kind of expression with three operands. It allows you to use one expression's value to select one of two other expressions.

The conditional expression is the same as in the C language:

    selector ? if-true-exp : if-false-exp

There are three subexpressions. The first, selector, is always computed first. If it is "true" (not zero and not null) then if-true-exp is computed next and its value becomes the value of the whole expression. Otherwise, if-false-exp is computed next and its value becomes the value of the whole expression.

For example, this expression produces the absolute value of `x`:

    x > 0 ? x : -x

Each time the conditional expression is computed, exactly one of if-true-exp and if-false-exp is computed; the other is ignored. This is important when the expressions contain side effects. For example, this conditional expression examines element `i` of either array `a` or array `b`, and increments `i`.

    x == y ? a[i++] : b[i++]

This is guaranteed to increment `i` exactly once, because each time only one of the two increment expressions is executed, and the other is not. See section Arrays in `awk`, for more information about arrays.

As a minor `gawk` extension, you can continue a statement that uses ``?:'` simply by putting a newline after either character. However, you cannot put a newline in front of either character without using backslash continuation (see section `awk` Statements Versus Lines).

## Function Calls

A function is a name for a particular calculation. Because it has a name, you can ask for it by name at any point in the program. For example, the function `sqrt` computes the square root of a number.

A fixed set of functions are built-in, which means they are available in every `awk` program. The `sqrt` function is one of these. See section Built-in Functions, for a list of built-in functions and their descriptions. In addition, you can define your own functions for use in your program. See section User-defined Functions, for how to do this.

The way to use a function is with a function call expression, which consists of the function name followed immediately by a list of arguments in parentheses. The arguments are expressions which provide the raw materials for the function's calculations. When there is more than one argument, they are separated by commas. If there are no arguments, write just ``()'` after the function name. Here are some examples:

    sqrt(x^2 + y^2)        one argument
    atan2(y, x)            two arguments
    rand()                 no arguments

Do not put any space between the function name and the open-parenthesis! A user-defined function name looks just like the name of a variable, and space would make the expression look like concatenation of a variable with an expression inside parentheses. Space before the parenthesis is harmless with built-in functions, but it is best not to get into the habit of using space to avoid mistakes with user-defined functions.

Each function expects a particular number of arguments. For example, the `sqrt` function must be called with a single argument, the number to take the square root of:

    sqrt(argument)

Some of the built-in functions allow you to omit the final argument. If you do so, they use a reasonable default. See section Built-in Functions, for full details. If arguments are omitted in calls to user-defined functions, then those arguments are treated as local variables, initialized to the empty string (see section User-defined Functions).

Like every other expression, the function call has a value, which is computed by the function based on the arguments you give it. In this example, the value of ``sqrt(argument)'` is the square root of argument. A function can also have side effects, such as assigning values to certain variables or doing I/O.

Here is a command to read numbers, one number per line, and print the square root of each one:

    $ awk '{ print "The square root of", $1, "is", sqrt($1) }'
    1
    -| The square root of 1 is 1
    3
    -| The square root of 3 is 1.73205
    5
    -| The square root of 5 is 2.23607
    Control-d

## 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)'`).

You can overrule the precedence of the operators by using parentheses. You can think of the precedence rules as saying where the parentheses are assumed to be if you do not write parentheses yourself. In fact, it is wise to always use parentheses whenever you have an unusual combination of operators, because other people who read the program may not remember what the precedence is in this case. You might forget, too; then you could make a mistake. Explicit parentheses will help prevent any such mistake.

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)'`.

The precedence of prefix unary operators does not matter as long as only unary operators are involved, 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. Thus, ``$x^2'` means ``($x)^2'`, but ``-x^2'` means ``-(x^2)'`, because ``-'` has lower precedence than ``^'` while ``$'` has higher precedence.

Here is a table of `awk`'s operators, in order from highest precedence to lowest:

`(...)`
  Grouping.
`$`
  Field.
`++ --`
  Increment, decrement.
`^ **`
  Exponentiation. These operators group right-to-left. (The ``**'` operator is not specified by POSIX.)
`+ - !`
  Unary plus, minus, logical "not".
`* / %`
  Multiplication, division, modulus.
`+ -`
  Addition, subtraction.
`Concatenation`
  No special token is used to indicate concatenation. The operands are simply written side by side.
`< <= == !=`
`> >= >> |`
  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 which 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, for example ``print foo > a ? b : c'`, result in syntax errors. The correct way to write this statement is ``print foo > (a ? b : c)'`.
`~ !~`
  Matching, non-matching.
`in`
  Array membership.
`&&`
  Logical "and".
`||`
  Logical "or".
`?:`
  Conditional. This operator groups right-to-left.
`= += -= *=`
`/= %= ^= **=`
  Assignment. These operators group right-to-left. (The ``**='` operator is not specified by POSIX.)

Go to the first, previous, next, last section, table of contents.