


Expressions are the basic building blocks of @command{awk} patterns and actions. An expression evaluates to a value that you can print, test, or pass to a function. Additionally, an expression can assign a new value to a variable or a field by using 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 that specify the data on which to operate. As in other languages, expressions in @command{awk} include variables, array references, constants, and function calls, as well as combinations of these with various operators.

Constant Expressions


Each is used in the appropriate context when you need a data value that isn't going to change. Numeric constants can have different forms, but are stored identically internally.

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.(20) Here are some examples of numeric constants that all have the same value:


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


represents the string whose contents are `parrot'. Strings in @command{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 @command{awk} implementations may have difficulty with some character codes.

Octal and Hexadecimal Numbers

In @command{awk}, all numbers are in decimal; i.e., base 10. Many other programming languages allow you to specify numbers in other bases, often octal (base 8) and hexadecimal (base 16). In octal, the numbers go 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, etc.. Just as `11' in decimal is 1 times 10 plus 1, so `11' in octal is 1 times 8, plus 1. This equals nine in decimal. In hexadecimal, there are 16 digits. Since the everyday decimal number system only has ten digits (`0'---`9'), the letters `a' through `f' are used to represent the rest. (Case in the letters is usually irrelevant; hexadecimal `a' and `A' have the same value.) Thus, `11' in hexadecimal is 1 times 16 plus 1, which equals 17 in decimal.

Just by looking at plain `11', you can't tell what base it's in. So, in C, C++, and other languages derived from C, there is a special notation to help signify the base. Octal numbers start with a leading `0', and hexadecimal numbers start with a leading `0x' or `0X':

Decimal 11.
Octal 11, decimal value 9.
Hexadecimal 11, decimal value 17.

This example shows the difference:

-| 9, 11, 17


@command{gawk} allows the use of octal and hexadecimal constants in your program text. However, such numbers in the input data are not treated differently; doing so by default would break old programs. (If you really need to do this, use the @option{--non-decimal-data} command-line option, see section Allowing Non-Decimal Input Data.) If you have octal or hexadecimal data, you can use the strtonum function (see section String Manipulation Functions) to convert the data into a number. Most of the time, you will want to use octal or hexadecimal constants when working with the built-in bit manipulation functions; see @ref{Bitwise Functions, ,Using @command{gawk}'s Bit Manipulation Functions}, for more information.

Unlike some early C implementations, `8' and `9' are not valid in octal constants; e.g., @command{gawk} treats `018' as decimal 18.

-| 021 is 17
-| 18

Octal and hexadecimal source code constants are a @command{gawk} extension. If @command{gawk} is in compatibility mode (see section Command-Line Options), they are not available.

Advanced Notes: A Constant's Base Does Not Affect Its Value

Once a numeric constant has been converted internally into a number, @command{gawk} no longer remembers what the original form of the constant was; the internal value is always used. This has particular consequences for conversion of numbers to strings:

-| 0x11 is <17>

Regular Expression Constants

A regexp constant is a regular expression description enclosed in slashes, such as /^beginning and end$/. Most regexps used in @command{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 righthand side of the `~' or `!~' operators, a regexp constant merely stands for the regexp that is to be matched. However, 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 following two code segments:

    print "found"


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 ~

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 is either zero or one, depending upon the success or failure of the match. That result is then matched against the first field in the record. Because it is unlikely that you would ever really want to make this kind of test, @command{gawk} issues a warning when it sees this construct in a program. Another consequence of this rule is that the assignment statement:

matches = /foo/

assigns either zero or one to the variable matches, depending upon the contents of the current input record. This feature of the language has never been 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 String Manipulation Functions). Modern implementations of @command{awk}, including @command{gawk}, allow the third argument of split to be a regexp constant, but 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)
        sub(pat, repl, str)
    return str

    text = "hi! hi yourself!"

In this example, the programmer wants to pass a regexp constant to the user-defined function mysub, which in turn passes it on to either sub or gsub. However, what really happens is that the pat parameter is either one or zero, depending upon whether or not $0 matches /hi/. @command{gawk} issues a warning when it sees a regexp constant used as a parameter to a user-defined function, since passing a truth value in this way is probably not what was intended.


Variables are ways of storing values at one point in your program for use later in another part of your program. They can be manipulated entirely within the program text, and they can also be assigned values on the @command{awk} command line.

Using Variables in a Program

Variables let you give names to values and refer to them later. Variables have already been used in many of the examples. The name of a variable must be a sequence of letters, digits, or underscores, and 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 the built-in variables. These built-in variables can be used and assigned just like all other variables, but their values are also used or changed automatically by @command{awk}. All built-in variables' names are entirely uppercase.

Variables in @command{awk} can be assigned either numeric or string values. The kind of value a variable holds can change over the life of a program. 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 @command{awk}, which is what you would do in C and in most other traditional languages.

Assigning Variables on the Command Line

Any @command{awk} variable can be set by including a variable assignment among the arguments on the command line when @command{awk} is invoked (see section Other Command-Line Arguments). Such an assignment has the following form:


With it, a variable is set either at the beginning of the @command{awk} run or in between input files. When the assignment is preceded with the @option{-v} option, as in the following:

-v variable=text

the variable is set at the very beginning, even before the BEGIN rules are run. The @option{-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 @option{-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':

-| 15
-| 24
-| 555-5553
-| 555-3412

Command-line arguments are made available for explicit examination by the @command{awk} program in an array named ARGV (see section Using ARGC and ARGV). @command{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 are converted to strings, if the context of the @command{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 the following:

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. 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 convert to zero.

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

CONVFMT's default value is "%.6g", which prints a value with at least six significant digits. For some applications, you might want to change it to specify more precision. On most modern machines, 17 digits is enough to capture a floating-point number's value exactly, most of the time.(21)

Strange results can occur 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, @command{awk} converts all numbers 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, @command{awk} used the value of OFMT 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 @command{awk} programs do not change their behavior. However, these semantics for OFMT are something to keep in mind if you must port your new style program to older implementations of @command{awk}. We recommend that instead of changing your programs, just port @command{gawk} itself. See section The print Statement, for more information on the print statement.

Arithmetic Operators

The @command{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.

The following example uses a file named `grades', which contains a list of student names as well as 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:

>        print $1, avg }' grades
-| Pat 85
-| Sandy 83
-| Chris 84.3333

The following list provides the arithmetic operators in @command{awk}, in order from the highest precedence to the lowest:

- x
+ 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 `^'.
x * y
x / y
Division; because all numbers in @command{awk} are floating-point numbers, the result is not rounded to an integer---`3 / 4' has the value 0.75. (It is a common mistake, especially for C programmers, to forget that all numbers in @command{awk} are floating-point, and that division of integer-looking constants produces a real number, not an integer.)
x % y
x + y
x - y


When computing the remainder of x % y, the quotient is rounded toward zero to an integer and multiplied by y. This result is subtracted from x; this operation is sometimes known as "trunc-mod." The following relation always holds:



-17 % 8 = -1

In other @command{awk} implementations, the signedness of the remainder may be machine dependent.

Note: The POSIX standard only specifies the use of `^' for exponentiation. For maximum portability, do not use the `**' operator.

String Concatenation

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


$ 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 runs together. For example:

-| Field number one:aardvark
-| Field number one:alpo-net

Because string concatenation does not have an explicit operator, it is often necessary to insure that it happens at the right time by using parentheses to enclose the items to concatenate. 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)

Parentheses should be used around concatenation in all but the most common contexts, such as on the righthand side of `='. Be careful about the kinds of expressions used in string concatenation. In particular, the order of evaluation of expressions used for concatenation is undefined in the @command{awk} language. Consider this example:

    a = "don't"

It is not defined whether the assignment to a happens before or after the value of a is retrieved for producing the concatenated value. The result could be either `don't panic', or `panic panic'. The precedence of concatenation, when mixed with other operators, is often counter-intuitive. Consider this example:

-| -12-24

This "obviously" is concatenating -12, a space, and -24. But where did the space disappear to? The answer lies in the combination of operator precedences and @command{awk}'s automatic conversion rules. To get the desired result, write the program in the following manner:

-| -12 -24

This forces @command{awk} to treat the `-' on the `-24' as unary. Otherwise, it's parsed as follows:

    -12 (" " - 24)
=> -12 (0 - 24)
=> -12 (-24)
=> -12-24

As mentioned earlier, when doing concatenation, parenthesize. Otherwise, you're never quite sure what you'll get.

Assignment Expressions

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

z = 1



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 righthand operand is stored unchanged. Most operators (addition, concatenation, and so on) have no effect except to compute a value. If the value isn't used, there's no reason to use the operator. An assignment operator is different; it does produce a value, but even if you ignore it, the assignment still makes itself felt through the alteration of the variable. We call this a side effect.

The lefthand 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 (@pxref{Arrays, ,Arrays in @command{awk}}). These are all called lvalues, which means they can appear on the lefthand side of an assignment operator. The righthand operand may be any expression; it produces the new value that 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. A variable's type 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



foo = "a string"
foo = foo + 5

Note: Using a variable as a number and then later as a string can be confusing and is poor programming style. The previous two examples illustrate how @command{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' is an expression with the value one. One consequence of this is that you can write multiple assignments together, such as:

x = y = z = 5

This example stores the value five in all three variables (x, y, and z). It does so because the value of `z = 5', which is five, is stored into y and then the value of `y = z = 5', which is five, is stored into x.

Assignments may be used 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; such nesting of assignments should be avoided, except perhaps in a one-shot program.

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 righthand 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 makes the meaning of your program clearer.

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

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

    for (x in bar)
       print x, bar[x]

The indices of bar are practically guaranteed to be different, because rand returns different values each time it is called. (Arrays and the rand function haven't been covered yet. @xref{Arrays, ,Arrays in @command{awk}}, and see section Numeric Functions, for more information). This example illustrates an important fact about assignment operators: the lefthand expression is only evaluated once. It is up to the implementation as to which expression is evaluated first, the lefthand or the righthand. Consider this example:

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


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

Adds increment to the value of lvalue.
Subtracts decrement from the value of lvalue.
Multiplies the value of lvalue by coefficient.
Divides the value of lvalue by divisor.
Sets lvalue to its remainder by modulus.

Raises lvalue to the power power.
Note: Only the `^=' operator is specified by POSIX. For maximum portability, do not use the `**=' operator.

Advanced Notes: Syntactic Ambiguities Between `/=' and Regular Expressions

There is a syntactic ambiguity between the `/=' assignment operator and regexp constants whose first character is an `='. (d.c.) This is most notable in commercial @command{awk} versions. For example:
$ awk /==/ /dev/null
error--> awk: syntax error at source line 1
error-->  context is
error-->         >>> /= <<<
error--> awk: bailing out at source line 1
A workaround is:
@command{gawk} does not have this problem, nor do the other freely-available versions described in @ref{Other Versions, , Other Freely Available @command{awk} Implementations}.

Increment and Decrement Operators

Increment and decrement operators increase or decrease the value of a variable by one. An assignment operator can do the same thing, so the increment operators add no power to the @command{awk} language; however they are convenient abbreviations for very common operations.

The operator used for adding 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---that new value is also the value of the 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. In other words, the operator returns the old value of the variable, but with the side effect of incrementing it.

The post-increment `foo++' is nearly the same as writing `(foo += 1) - 1'. It is not perfectly equivalent because all numbers in @command{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).

Fields and array elements are incremented just like variables. (Use `$(i++)' when you want 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 it. As with `++', it can be used before the lvalue to pre-decrement or after it to post-decrement. Following is a summary of increment and decrement expressions:

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

Advanced Notes: Operator Evaluation Order

Doctor, doctor! It hurts when I do this!
So don't do that!

Groucho Marx

What happens for something like the following?

b = 6
print b += b++

Or something even stranger?

b = 6
b += ++b + b++
print b

In other words, when do the various side effects prescribed by the postfix operators (`b++') take effect? When side effects happen is implementation defined. In other words, it is up to the particular version of @command{awk}. The result for the first example may be 12 or 13, and for the second, it may be 22 or 23.

In short, doing things like this is not recommended and definitely not anything that you can rely upon for portability. You should avoid such things in your own programs.

True and False in @command{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 uppercase equivalents. However, @command{awk} is different. It borrows a very simple concept of true and false from C. In @command{awk}, any nonzero numeric value or any non-empty string value is true. Any other value (zero or the null string "") is false. The following program prints `A strange truth value' three times:

   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 "nonzero or non-null" rule: the string constant "0" is actually true, because 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, @command{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 because the types of two variables determine how they are compared. In @command{gawk}, variable typing follows these rules:

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

         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. This depends upon the attributes of the operands, according to the following symmetric matrix:


        |       STRING          NUMERIC         STRNUM
STRING  |       string          string          string
NUMERIC |       string          numeric         numeric
STRNUM  |       string          numeric         numeric

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. Thus, for example, the string constant " +3.14" is a string, even though it looks numeric, and is never treated as number for comparison purposes.

In short, when one operand is a "pure" string, such as a string constant, then a string comparison is performed. Otherwise, a numeric comparison is performed.(22).}

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 `=' characters. The result is still valid @command{awk} code, but the program does not do what is intended:

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

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

The following table of expressions illustrates the kind of comparison @command{gawk} performs, as well as 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 the next example:

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

the result is `false' because both $1 and $2 are user input. They are numeric strings--therefore 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 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 righthand operand of the `~' and `!~' operators may be either a regexp constant (/.../) or an ordinary expression. In the latter 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 modern implementations of @command{awk}, a constant regular expression in slashes by itself is also an expression. The regexp /regexp/ is an abbreviation for the following comparison expression:

$0 ~ /regexp/

One special place where /foo/ is not an abbreviation for `$0 ~ /foo/' is when it is the righthand 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), that 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. The Boolean operators are:

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 substring `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 `no home!' in the unusual event that the @env{HOME} environment variable is not defined:
BEGIN { if (! ("HOME" in ENVIRON))
               print "no home!" }
(The in operator is described in section Referring to an Array Element.)

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.

Statements that use `&&' or `||' can be continued simply by putting a newline after them. But you cannot put a newline in front of either of these operators without using backslash continuation (@pxref{Statements/Lines, ,@command{awk} Statements Versus Lines}).

The actual value of an expression using the `!' operator is 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; next }
interested == 1 { print }
$1 == "END"     { interested = ! interested; next }

The variable interested, as with all @command{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.

Note: The next statement is discussed in section The next Statement. next tells @command{awk} to skip the rest of the rules, get the next record, and start processing the rules over again at the top. The reason it's there is to avoid printing the bracketing `START' and `END' lines.

Conditional Expressions

A conditional expression is a special kind of expression that has 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, as shown here:

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

There are three subexpressions. The first, selector, is always computed first. If it is "true" (not zero or 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, the following expression produces the absolute value of x:

x >= 0 ? x : -x

Each time the conditional expression is computed, only one of if-true-exp and if-false-exp is used; the other is ignored. This is important when the expressions have 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. @xref{Arrays, ,Arrays in @command{awk}}, for more information about arrays.

As a minor @command{gawk} extension, a statement that uses `?:' can be continued simply by putting a newline after either character. However, putting a newline in front of either character does not work without using backslash continuation (@pxref{Statements/Lines, ,@command{awk} Statements Versus Lines}). If @option{--posix} is specified (see section Command-Line Options), then this extension is disabled.

Function Calls

A function is a name for a particular calculation. This enables you to 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 @command{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 functions for use in your program. See section User-Defined Functions, for instructions on 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 that 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, just write `()' after the function name. The following examples show function calls with and without arguments:

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

Caution: 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--a space would make the expression look like concatenation of a variable with an expression inside parentheses.

With built-in functions, space before the parenthesis is harmless, 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:


Some of the built-in functions have one or more optional arguments. If those arguments are not supplied, the functions use a reasonable default value. 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 and 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. The following program reads numbers, one number per line, and prints the square root of each one:

-| The square root of 1 is 1
-| The square root of 3 is 1.73205
-| The square root of 5 is 2.23607

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


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. `$x^2' means `($x)^2', but `-x^2' means `-(x^2)', because `-' has lower precedence than `^', whereas `$' has higher precedence. This table presents @command{awk}'s operators, in order of highest precedence to lowest:

++ --
Increment, decrement.
^ **
Exponentiation. These operators group right-to-left.
+ - !
Unary plus, minus, logical "not."
* / %
Multiplication, division, modulus.
+ -
Addition, subtraction.
String Concatenation
No special symbol is used to indicate concatenation. The operands are simply written side by side (see section String 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 (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.
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.
