This article will guide you through using awk for arithmetic operations in loops, using simple examples to make the concepts clear.

What is awk?

awk is a scripting language designed for text processing and data extraction, which reads input line by line, splits each line into fields, and allows you to perform operations on those fields. It’s commonly used for tasks like pattern matching, arithmetic calculations, and generating formatted reports.

The basic syntax of awk is:

awk 'BEGIN { initialization } { actions } END { finalization }' file

• BEGIN: Code block executed before processing the input.
• actions: Code block executed for each line of the input.
• END: Code block executed after processing all lines.

Performing Arithmetic Operations in Loops

Let’s explore how to use awk to perform arithmetic operations within loops with the following useful examples to demonstrate key concepts.

Example 1: Calculating the Sum of Numbers

Suppose you have a file named numbers.txt containing the following numbers:

5
10
15
20

You can calculate the sum of these numbers using awk:

awk '{ sum += $1 } END { print "Total Sum:", sum }' numbers.txt

Explanation:

• { sum += $1 }: For each line, the value of the first field $1 is added to the variable sum.
• END { print "Total Sum:", sum }: After processing all lines, the total sum is printed.

Example 2: Calculating the Average

To calculate the average of the numbers:

awk '{ sum += $1; count++ } END { print "Average:", sum / count }' numbers.txt

Explanation:

• count++: Increments the counter for each line.
• sum / count: Divides the total sum by the count to calculate the average.

Example 3: Multiplication Table

You can use awk to generate a multiplication table for a given number. For example, to generate a table for 5:

awk 'BEGIN { for (i = 1; i <= 10; i++) print "5 x", i, "=", 5 * i }'

Explanation:

• for (i = 1; i <= 10; i++): A loop that runs from 1 to 10.
• print "5 x", i, "=", 5 * i: Prints the multiplication table.

Example 4: Factorial Calculation

To calculate the factorial of a number (e.g., 5):

awk 'BEGIN { n = 5; factorial = 1; for (i = 1; i <= n; i++) factorial *= i; print "Factorial of", n, "is", factorial }'

Explanation:

• n = 5: The number for which the factorial is calculated.
• factorial *= i: Multiplies the current value of factorial by i in each iteration.

Example 5: Summing Even Numbers

To sum only the even numbers from a file:

awk '{ if ($1 % 2 == 0) sum += $1 } END { print "Sum of Even Numbers:", sum }' numbers.txt

Explanation:

• if ($1 % 2 == 0): Checks if the number is even.
• sum += $1: Adds the even number to the sum.

Conclusion

The awk command is a versatile tool for performing arithmetic operations in loops. By combining loops, conditions, and arithmetic operators, you can handle a wide range of tasks efficiently.

Practice these examples and experiment with your own scripts to unlock the full potential of awk!

The post How to Use awk for Arithmetic in Loops in Linux appeared first on MASSIVE News.

All along from the beginning of the Awk series up to Part 12, we have been writing small Awk commands and programs on the command line and in shell scripts respectively.

However, Awk, just like Shell, is also an interpreted language, therefore, with all that we have walked through from the start of this series, you can now write Awk executable scripts.

Similar to how we write a shell script, Awk scripts start with the line:

#! /path/to/awk/utility -f 

For example on my system, the Awk utility is located in /usr/bin/awk, therefore, I would start an Awk script as follows:

#! /usr/bin/awk -f 

Explaining the line above:

• #! – referred to as Shebang, which specifies an interpreter for the instructions in a script
• /usr/bin/awk – is the interpreter
• -f – interpreter option, used to read a program file

That said, let us now dive into looking at some examples of Awk executable scripts, we can start with the simple script below. Use your favorite editor to open a new file as follows:

vi script.awk

And paste the code below in the file:

#!/usr/bin/awk -f 
BEGIN { printf "%sn","Writing my first Awk executable script!" }

Save the file and exit, then make the script executable by issuing the command below:

chmod +x script.awk

Thereafter, run it:

./script.awk

Sample Output:

Writing my first Awk executable script!

A critical programmer out there must be asking, “Where are the comments?”, yes, you can also include comments in your Awk script. Writing comments in your code is always a good programming practice.

It helps other programmers look through your code to understand what you are trying to achieve in each section of a script or program file.

Therefore, you can include comments in the script above as follows.

#!/usr/bin/awk -f 

#This is how to write a comment in Awk
#using the BEGIN special pattern to print a sentence 

BEGIN { printf "%sn","Writing my first Awk executable script!" }

Next, we shall look at an example where we read input from a file. We want to search for a system user named aaronkilik in the account file, /etc/passwd, then print the username, user ID, and user GID as follows:

Below is the content of our script called second.awk.

#! /usr/bin/awk -f 

#use BEGIN sepecial character to set FS built-in variable
BEGIN { FS=":" }

#search for username: aaronkilik and print account details 
/aaronkilik/ { print "Username :",$1,"User ID :",$3,"User GID :",$4 }

Save the file and exit, make the script executable, and execute it as below:

chmod +x second.awk
./second.awk /etc/passwd

Sample Output:

Username : aaronkilik User ID : 1000 User GID : 1000

In the last example below, we shall use do while statement to print out numbers from 0-10:

Below is the content of our script called do.awk.

#! /usr/bin/awk -f 

#printing from 0-10 using a do while statement 
#do while statement 
BEGIN {
#initialize a counter
x=0

do {
    print x;
    x+=1;
}
while(x<=10)
}

After saving the file, make the script executable as we have done before. Afterwards, run it:

chmod +x do.awk
./do.awk

Sample Output:

0
1
2
3
4
5
6
7
8
9
10

Summary

We have come to the end of this interesting Awk series, I hope you have learned a lot from all 13 parts, as an introduction to Awk programming language.

As I mentioned from the beginning, Awk is a complete text processing language, for that reason, you can learn more other aspects of Awk programming language such as environmental variables, arrays, functions (built-in & user-defined), and beyond.

There is yet additional parts of Awk programming to learn and master, so, below, I have provided some links to important online resources that you can use to expand your Awk programming skills, these are not necessarily all that you need, you can also look out for useful Awk programming books.

Reference Links: The GNU Awk User’s Guide and AWK Language Programming

For any thoughts you wish to share or questions, use the comment form below. Remember to always stay connected to Tecmint for more exciting series.

For those seeking a comprehensive resource, we’ve compiled all the Awk series articles into a book, that includes 13 chapters and spans 41 pages, covering both basic and advanced Awk usage with practical examples.

The post How to Write Scripts Using Awk Programming – Part 13 appeared first on MASSIVE News.

When you review all the Awk examples we have covered so far, right from the start of the Awk series, you will notice that all the commands in the various examples are executed sequentially, that is one after the other.

But in certain situations, we may want to run some text filtering operations based on some conditions, that is where the approach of flow control statements comes in.

There are various flow control statements in Awk programming and these include:

• if-else statement
• for statement
• while statement
• do-while statement
• break statement
• continue statement
• next statement
• nextfile statement
• exit statement

However, for the scope of this series, we shall expound on: if-else, for, while and do while statements. Remember that we already walked through how to use next statement in Part 6 of this Awk series.

1. The if-else Statement

The expected syntax of the if statement is similar to that of the shell if statement:

if  (condition1) {
     actions1
}
else {
      actions2
}

In the above syntax, condition1 and condition2 are Awk expressions, and actions1 and actions2 are Awk commands executed when the respective conditions are satisfied.

When condition1 is satisfied, meaning it’s true, then actions1 is executed and the if statement exits, otherwise actions2 is executed.

The if statement can also be expanded to a if-else_if-else statement as below:

if (condition1){
     actions1
}
else if (conditions2){
      actions2
}
else{
     actions3
}

In this form, if condition1 is true, then actions1 is executed and the if statement exits, otherwise condition2 is evaluated and if it is true, then actions2 is executed and the if statement exits. However, when condition2 is false then, actions3 is executed and the if statement exits.

Here is a case in point of using if statements, we have a list of users and their ages stored in the file users.txt.

Sarah L			35    	F
Aaron Kili		40    	M
John  Doo		20    	M
Kili  Seth		49    	M    

We want to print a statement indicating a user’s name and whether the user’s age is less or more than 25 years old.

We can write a short shell script to carry out our job above, here is the content of the script:

#!/bin/bash
awk ' { 
        if ( $3 <= 25 ){
           print "User",$1,$2,"is less than 25 years old." ;
        }
        else {
           print "User",$1,$2,"is more than 25 years old" ; 
}
}'    ~/users.txt

Then save the file and exit, make the script executable, and run it as follows:

chmod +x test.sh
./test.sh

Sample Output:

User Sarah L is more than 25 years old
User Aaron Kili is more than 25 years old
User John Doo is less than 25 years old.
User Kili Seth is more than 25 years old

2. The for Statement

In case you want to execute some Awk commands in a loop, then the for statement offers you a suitable way to do that, with the syntax below:

for ( counter-initialization; test-condition; counter-increment ){
      actions
}

Here, the approach is simply defined by the use of a counter to control the loop execution, first, you need to initialize the counter, then run it against a test condition, if it is true, execute the actions, and finally increment the counter. The loop terminates when the counter does not satisfy the condition.

The following Awk command shows how the for statement works, where we want to print the numbers 0-10:

awk 'BEGIN{ for(counter=0;counter<=10;counter++){ print counter} }'

Sample Output:

0
1
2
3
4
5
6
7
8
9
10

3. The while Statement

The conventional syntax of the while statement is as follows:

while ( condition ) {
          actions
}

The condition is an Awk expression and actions are lines of Awk commands executed when the condition is true.

Below is a script to illustrate the use of while statement to print the numbers 0-10:

#!/bin/bash
awk ' BEGIN{ counter=0 ;
         
        while(counter<=10){
              print counter;
              counter+=1 ;
             
}
}  

Save the file and make the script executable, then run it:

chmod +x test.sh
./test.sh

Sample Output:

0
1
2
3
4
5
6
7
8
9
10

4. The do while Statement

The do-while statement is a modification of the while statement with the following syntax:

do {
     actions
}
 while (condition) 

The slight difference is that, under do while, the Awk commands are executed before the condition is evaluated. Using the very example under while statement above, we can illustrate the use of do while by altering the Awk command in the test.sh script as follows:

#!/bin/bash

awk ' BEGIN{ counter=0 ;  
        do{
            print counter;  
            counter+=1 ;    
        }
        while (counter<=10)   
} 
'

After modifying the script, save the file and exit. Then make the script executable and execute it as follows:

chmod +x test.sh
./test.sh

Sample Output:

0
1
2
3
4
5
6
7
8
9
10

Conclusion

This is not a comprehensive guide regarding Awk flow control statements, as I had mentioned earlier on, there are several other flow control statements in Awk.

Nonetheless, this part of the Awk series should give you a clear fundamental idea of how the execution of Awk commands can be controlled based on certain conditions.

You can also expound more on the rest of the flow control statements to gain more understanding of the subject matter. Finally, in the next section of the Awk series, we shall move into writing Awk scripts.

For those seeking a comprehensive resource, we’ve compiled all the Awk series articles into a book, that includes 13 chapters and spans 41 pages, covering both basic and advanced Awk usage with practical examples.

The post How to Use Flow Control Statements in Awk – Part 12 appeared first on MASSIVE News.