{"id":13612,"date":"2019-04-03T14:51:02","date_gmt":"2019-04-03T14:51:02","guid":{"rendered":"http:\/\/www.appservgrid.com\/paw92\/?p=13612"},"modified":"2019-04-03T14:58:25","modified_gmt":"2019-04-03T14:58:25","slug":"awk","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2019\/04\/03\/awk\/","title":{"rendered":"AWK (Alfred V. Aho – Peter J. Weinberger – Brian W. Kernighan)"},"content":{"rendered":"

Ebook: Introducing the Awk Getting Started Guide for Beginners<\/h1>\n

As a Linux system administrator, many times, you will get into situations where you need to manipulate and reformat the output from different commands, to simply display part of a output by filtering out a few lines. This process can be referred to as text filtering, using a collection of Linux programs known as filters.<\/p>\n

There are several Linux utilities for text filtering and some of the well known filters include\u00a0head<\/strong>,\u00a0tail<\/strong>,\u00a0grep<\/strong>,\u00a0tr<\/strong>,\u00a0fmt<\/strong>,\u00a0sort<\/strong>,\u00a0uniq<\/strong>,\u00a0pr<\/strong>\u00a0and more advanced and powerful tools such as\u00a0Awk<\/strong>\u00a0and\u00a0Sed<\/strong>.<\/p>\n

\n

\"Introducing<\/p>\n

Introducing the Awk Getting Started Guide for Beginners<\/p>\n<\/div>\n

Unlike\u00a0Sed<\/strong>,\u00a0Awk<\/strong>\u00a0is more than just a text filtering tool, it is a comprehensive and flexible text pattern scanning and processing language.<\/p>\n

Awk<\/strong>\u00a0is a strongly recommended text filtering tool for Linux, it can be utilized directly from the command line together with several other commands, within shell scripts or in independent Awk scripts. It searches through input data or a single or multiple files for user defined patterns and modifies the input or file(s) based on certain conditions.<\/p>\n

Since\u00a0Awk<\/strong>\u00a0is a sophisticated programming language, learning it requires a lot of time and dedication just as any other programming language out there. However, mastering a few basic concepts of this powerful text filtering language can enable you to understand how it actually works and sets you on track to learn more advanced Awk programming techniques.<\/p>\n

After carefully and critically revising our 13 articles in the Awk programming series, with high consideration of the vital feedback from our followers and readers over the last 5 months, we have managed to organize the Introduction to Awk programming language eBook.<\/p>\n

Therefore, if you are ready to start learning Awk programming language from the basic concepts, with simple and easy-to-understand, well explained examples, then you may consider reading this concise and precise eBook.<\/p>\n

What\u2019s Inside this eBook?<\/h3>\n

This book contains 13 chapters with a total of 41 pages, which covers all Awk basic and advance usage with practical examples:<\/p>\n

    \n
  1. Chapter 1<\/strong>: Awk Regular Expressions to Filter Text in Files<\/li>\n
  2. Chapter 2<\/strong>: Use Awk to Print Fields and Columns in File<\/li>\n
  3. Chapter 3<\/strong>: Use Awk to Filter Text Using Pattern Specific Actions<\/li>\n
  4. Chapter 4<\/strong>: Learn Comparison Operators with Awk<\/li>\n
  5. Chapter 5<\/strong>: Learn Compound Expressions with Awk<\/li>\n
  6. Chapter 6<\/strong>: Learn \u2018next\u2019 Command with Awk<\/li>\n
  7. Chapter 7<\/strong>: Read Awk Input from STDIN in Linux<\/li>\n
  8. Chapter 8<\/strong>: Learn Awk Variables, Numeric Expressions and Assignment Operators<\/li>\n
  9. Chapter 9<\/strong>: Learn Awk Special Patterns \u2018BEGIN and END\u2019<\/li>\n
  10. Chapter 10<\/strong>: Learn Awk Built-in Variables<\/li>\n
  11. Chapter 11<\/strong>: Learn Awk to Use Shell Variables<\/li>\n
  12. Chapter 12<\/strong>: Learn Flow Control Statements in Awk<\/li>\n
  13. Chapter 13<\/strong>: Write Scripts Using Awk Programming Language<\/li>\n<\/ol>\n

    How to Use Awk and Regular Expressions to Filter Text or String in Files<\/h1>\n

    When we run certain commands in Unix\/Linux to read or edit text from a string or file, we most times try to filter output to a given section of interest. This is where using regular expressions comes in handy.<\/p>\n

    Read Also:<\/b>\u00a010 Useful Linux Chaining Operators with Practical Examples<\/a><\/p>\n

    What are Regular Expressions?<\/h4>\n

    A regular expression can be defined as a strings that represent several sequence of characters. One of the most important things about regular expressions is that they allow you to filter the output of a command or file, edit a section of a text or configuration file and so on.<\/p>\n

    Features of Regular Expression<\/h4>\n

    Regular expressions are made of:<\/p>\n

      \n
    1. Ordinary characters<\/strong>\u00a0such as space, underscore(_), A-Z, a-z, 0-9.<\/li>\n
    2. Meta characters<\/strong>\u00a0that are expanded to ordinary characters, they include:\n
        \n
      1. (.)<\/code>\u00a0it matches any single character except a newline.<\/li>\n
      2. (*)<\/code>\u00a0it matches zero or more existences of the immediate character preceding it.<\/li>\n
      3. [ character(s) ]<\/code>\u00a0it matches any one of the characters specified in character(s), one can also use a hyphen\u00a0(-)<\/code>\u00a0to mean a range of characters such as\u00a0[a-f]<\/code>,\u00a0[1-5]<\/code>, and so on.<\/li>\n
      4. ^<\/code>\u00a0it matches the beginning of a line in a file.<\/li>\n
      5. $<\/code>\u00a0matches the end of line in a file.<\/li>\n
      6. \\<\/code>\u00a0it is an escape character.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n

        In order to filter text, one has to use a text filtering tool such as\u00a0awk<\/strong>. You can think of\u00a0awk<\/strong>\u00a0as a programming language of its own. But for the scope of this guide to using\u00a0awk<\/strong>, we shall cover it as a simple command line filtering tool.<\/p>\n

        The general syntax of awk is:<\/p>\n

        # awk 'script' filename\r\n<\/pre>\n
        Where\u00a0'script'<\/code>\u00a0is a set of commands that are understood by\u00a0awk<\/strong>\u00a0and are execute on file, filename.<\/p>\n
        It works by reading a given line in the file, makes a copy of the line and then executes the script on the line. This is repeated on all the lines in the file.<\/p>\n
        The\u00a0'script'<\/code>\u00a0is in the form\u00a0'\/pattern\/ action'<\/code>\u00a0where\u00a0pattern<\/strong>\u00a0is a regular expression and the\u00a0action<\/strong>\u00a0is what awk will do when it finds the given pattern in a line.<\/p>\n
        How to Use Awk Filtering Tool in Linux<\/h3>\n
        In the following examples, we shall focus on the meta characters that we discussed above under the features of awk.<\/p>\n
        A simple example of using awk:<\/h4>\n
        The example below prints all the lines in the file\u00a0\/etc\/hosts<\/strong>\u00a0since no pattern is given.<\/p>\n
        # awk '\/\/<\/strong>{print}'\/etc\/hosts\r\n<\/pre>\n
        \n
        \"Awk<\/a><\/p>\n
        Awk Prints all Lines in a File<\/p>\n<\/div>\n
        Use Awk with Pattern:<\/h4>\n
        I the example below, a pattern\u00a0localhost<\/code>\u00a0has been given, so awk will match line having\u00a0localhost<\/strong>\u00a0in the\u00a0\/etc\/hosts<\/code>\u00a0file.<\/p>\n
        # awk '\/localhost\/<\/strong>{print}' \/etc\/hosts \r\n<\/pre>\n
        \n
        \"Awk<\/a><\/p>\n
        Awk Print Given Matching Line in a File<\/p>\n<\/div>\n
        Using Awk with (.) wild card in a Pattern<\/h4>\n
        The\u00a0(.)<\/code>\u00a0will match strings containing\u00a0loc<\/strong>,\u00a0localhost<\/strong>,\u00a0localnet<\/strong>\u00a0in the example below.<\/p>\n
        That is to say\u00a0* l some_single_character c *<\/strong>.<\/p>\n
        # awk '\/l.c\/<\/strong>{print}' \/etc\/hosts\r\n<\/pre>\n
        \n
        \"Use<\/a><\/p>\n
        Use Awk to Print Matching Strings in a File<\/p>\n<\/div>\n
        Using Awk with (*) Character in a Pattern<\/h4>\n
        It will match strings containing\u00a0localhost<\/strong>,\u00a0localnet<\/strong>,\u00a0lines<\/strong>,\u00a0capable<\/strong>, as in the example below:<\/p>\n
        # awk '\/l*c\/<\/strong>{print}' \/etc\/localhost\r\n<\/pre>\n
        \n
        \"Use<\/a><\/p>\n
        Use Awk to Match Strings in File<\/p>\n<\/div>\n
        You will also realize that\u00a0(*)<\/code>\u00a0tries to a get you the longest match possible it can detect.<\/p>\n
        Let look at a case that demonstrates this, take the regular expression\u00a0t*t<\/code>\u00a0which means match strings that start with letter\u00a0t<\/code>\u00a0and end with\u00a0t<\/code>\u00a0in the line below:<\/p>\n
        this is tecmint, where you get the best good tutorials, how to's, guides, tecmint. \r\n<\/pre>\n
        You will get the following possibilities when you use the pattern\u00a0\/t*t\/<\/code>:<\/p>\n
        this is t\r\nthis is tecmint\r\nthis is tecmint, where you get t\r\nthis is tecmint, where you get the best good t\r\nthis is tecmint, where you get the best good tutorials, how t\r\nthis is tecmint, where you get the best good tutorials, how tos, guides, t\r\nthis is tecmint, where you get the best good tutorials, how tos, guides, tecmint\r\n<\/pre>\n
        And\u00a0(*)<\/code>\u00a0in\u00a0\/t*t\/<\/code>\u00a0wild card character allows awk to choose the the last option:<\/p>\n
        this is tecmint, where you get the best good tutorials, how to's, guides, tecmint\r\n<\/pre>\n
        Using Awk with set [ character(s) ]<\/h4>\n
        Take for example the set\u00a0[al1]<\/code>, here awk will match all strings containing character\u00a0a<\/code>\u00a0or\u00a0l<\/code>\u00a0or\u00a01<\/code>\u00a0in a line in the file\u00a0\/etc\/hosts<\/strong>.<\/p>\n
        # awk '\/[al1]\/<\/strong>{print}' \/etc\/hosts\r\n<\/pre>\n
        \n
        \"Use-Awk<\/a><\/p>\n
        Use-Awk to Print Matching Character in File<\/p>\n<\/div>\n
        The next example matches strings starting with either\u00a0K<\/code>\u00a0or\u00a0k<\/code>\u00a0followed by\u00a0T<\/code>:<\/p>\n
        # awk '\/[Kk]T\/<\/strong>{print}' \/etc\/hosts \r\n<\/pre>\n
        \n
        \"Use<\/a><\/p>\n
        Use Awk to Print Matched String in File<\/p>\n<\/div>\n
        Specifying Characters in a Range<\/h4>\n
        Understand characters with awk:<\/p>\n
          \n
        1. [0-9]<\/code>\u00a0means a single number<\/li>\n
        2. [a-z]<\/code>\u00a0means match a single lower case letter<\/li>\n
        3. [A-Z]<\/code>\u00a0means match a single upper case letter<\/li>\n
        4. [a-zA-Z]<\/code>\u00a0means match a single letter<\/li>\n
        5. [a-zA-Z 0-9]<\/code>\u00a0means match a single letter or number<\/li>\n<\/ol>\n
          Lets look at an example below:<\/p>\n
          # awk '\/[0-9]\/<\/strong>{print}' \/etc\/hosts \r\n<\/pre>\n
          \n
          \"Use<\/a><\/p>\n
          Use Awk To Print Matching Numbers in File<\/p>\n<\/div>\n
          All the line from the file\u00a0\/etc\/hosts<\/strong>\u00a0contain at least a single number\u00a0[0-9]<\/code>\u00a0in the above example.<\/p>\n
          Use Awk with (^) Meta Character<\/h4>\n
          It matches all the lines that start with the pattern provided as in the example below:<\/p>\n
          # awk '\/^fe\/<\/strong>{print}' \/etc\/hosts\r\n# awk '\/^ff\/<\/strong>{print}' \/etc\/hosts\r\n<\/pre>\n
          \n
          \"Use<\/a><\/p>\n
          Use Awk to Print All Matching Lines with Pattern<\/p>\n<\/div>\n
          Use Awk with ($) Meta Character<\/h4>\n
          It matches all the lines that end with the pattern provided:<\/p>\n
          # awk '\/ab$\/<\/strong>{print}' \/etc\/hosts\r\n# awk '\/ost$\/<\/strong>{print}' \/etc\/hosts\r\n# awk '\/rs$\/<\/strong>{print}' \/etc\/hosts\r\n<\/pre>\n
          \n
          \"Use<\/a><\/p>\n
          Use Awk to Print Given Pattern String<\/p>\n<\/div>\n
          Use Awk with (\\) Escape Character<\/h4>\n
          It allows you to take the character following it as a literal that is to say consider it just as it is.<\/p>\n
          In the example below, the first command prints out all line in the file, the second command prints out nothing because I want to match a line that has\u00a0$25.00<\/strong>, but no escape character is used.<\/p>\n
          The third command is correct since a an escape character has been used to read\u00a0$<\/strong>\u00a0as it is.<\/p>\n
          # awk '\/\/<\/strong>{print}' deals.txt\r\n# awk '\/$25.00\/<\/strong>{print}' deals.txt\r\n# awk '\/\\.00\/<\/strong>{print}' deals.txt\r\n<\/pre>\n
          \n
          \"Use<\/a><\/p>\n
          Use Awk with Escape Character<\/p>\n<\/div>\n
          Summary<\/h3>\n
          That is not all with the\u00a0awk<\/strong>\u00a0command line filtering tool, the examples above a the basic operations of awk. In the next parts we shall be advancing on how to use complex features of awk. Thanks for reading through and for any additions or clarifications, post a comment in the comments section.<\/p>\n
          How to Use Awk to Print Fields and Columns in File<\/h1>\n
          In this part of our\u00a0Linux Awk command series<\/a>, we shall have a look at one of the most important features of\u00a0Awk<\/strong>, which is field editing.<\/p>\n
          It is good to know that\u00a0Awk<\/strong>\u00a0automatically divides input lines provided to it into fields, and a field can be defined as a set of characters that are separated from other fields by an internal field separator.<\/p>\n
          \n
          \"Awk<\/a><\/p>\n
          Awk Print Fields and Columns<\/p>\n<\/div>\n
          If you are familiar with the Unix\/Linux or do\u00a0bash shell programming<\/a>, then you should know what internal field separator (IFS<\/strong>) variable is. The default IFS in Awk are tab and space.<\/p>\n
          This is how the idea of field separation works in\u00a0Awk<\/strong>: when it encounters an input line, according to the IFS defined, the first set of characters is field one, which is accessed using\u00a0$1<\/strong>, the second set of characters is field two, which is accessed using\u00a0$2<\/strong>, the third set of characters is field three, which is accessed using\u00a0$3<\/strong>\u00a0and so forth till the last set of character(s).<\/p>\n
          To understand this Awk field editing better, let us take a look at the examples below:<\/p>\n
          Example 1:<\/strong>\u00a0I have created a text file called\u00a0tecmintinfo.txt<\/strong>.<\/p>\n
          # vi tecmintinfo.txt\r\n# cat tecmintinfo.txt\r\n<\/pre>\n
          \n
          \"Create<\/a><\/p>\n
          Create File in Linux<\/p>\n<\/div>\n
          Then from the command line, I try to print the\u00a0first<\/strong>,\u00a0second<\/strong>\u00a0and\u00a0third<\/strong>\u00a0fields from the file\u00a0tecmintinfo.txt<\/strong>\u00a0using the command below:<\/p>\n
          $ awk '\/\/{print $1 $2 $3 }' tecmintinfo.txt<\/strong>\r\n\r\nTecMint.comisthe\r\n<\/pre>\n
          From the output above, you can see that the characters from the first three fields are printed based on the\u00a0IFS<\/strong>defined which is space:<\/p>\n
            \n
          1. Field one which is\u00a0\u201cTecMint.com\u201d<\/strong>\u00a0is accessed using\u00a0$1<\/code>.<\/li>\n
          2. Field two which is\u00a0\u201cis\u201d<\/strong>\u00a0is accessed using\u00a0$2<\/code>.<\/li>\n
          3. Field three which is\u00a0\u201cthe\u201d<\/strong>\u00a0is accessed using\u00a0$3<\/code>.<\/li>\n<\/ol>\n
            If you have noticed in the printed output, the field values are not separated and this is how print behaves by default.<\/p>\n
            To view the output clearly with space between the field values, you need to add\u00a0(,)<\/code>\u00a0operator as follows:<\/p>\n
            $ awk '\/\/{print $1, $2, $3; }' tecmintinfo.txt<\/strong>\r\n\r\nTecMint.com is the\r\n<\/pre>\n
            One important thing to note and always remember is that the use of\u00a0($)<\/code>\u00a0in\u00a0Awk<\/strong>\u00a0is different from its use in shell scripting.<\/p>\n
            Under shell scripting\u00a0($)<\/code>\u00a0is used to access the value of variables while in\u00a0Awk<\/strong>\u00a0($)<\/code>\u00a0it is used only when accessing the contents of a field but not for accessing the value of variables.<\/p>\n
            Example 2:<\/strong>\u00a0Let us take a look at one other example using a file which contains multiple lines called\u00a0my_shoping.list<\/strong>.<\/p>\n
            No\tItem_Name\t\tUnit_Price\tQuantity\tPrice\r\n1\tMouse\t\t\t#20,000\t\t   1\t\t#20,000\r\n2 \tMonitor\t\t\t#500,000\t   1\t\t#500,000\r\n3\tRAM_Chips\t\t#150,000\t   2\t\t#300,000\r\n4\tEthernet_Cables\t        #30,000\t\t   4\t\t#120,000\t\t\r\n<\/pre>\n
            Say you wanted to only print\u00a0Unit_Price<\/code>\u00a0of each item on the shopping list, you will need to run the command below:<\/p>\n
            $ awk '\/\/{print $2, $3 }' my_shopping.txt <\/strong>\r\n\r\nItem_Name Unit_Price\r\nMouse #20,000\r\nMonitor #500,000\r\nRAM_Chips #150,000\r\nEthernet_Cables #30,000\r\n<\/pre>\n
            Awk<\/strong>\u00a0also has a\u00a0printf<\/code>\u00a0command that helps you to format your output is a nice way as you can see the above output is not clear enough.<\/p>\n
            Using\u00a0printf<\/code>\u00a0to format output of the\u00a0Item_Name<\/strong>\u00a0and\u00a0Unit_Price<\/strong>:<\/p>\n
            $ awk '\/\/{printf \"%-10s %s\\n\",$2, $3 }' my_shopping.txt<\/strong> \r\n\r\nItem_Name  Unit_Price\r\nMouse      #20,000\r\nMonitor    #500,000\r\nRAM_Chips  #150,000\r\nEthernet_Cables #30,000\r\n<\/pre>\n
            Summary<\/h3>\n
            Field editing is very important when using\u00a0Awk<\/strong>\u00a0to filter text or strings, it helps you get particular data in columns in a list. And always remember that the use of\u00a0($)<\/code>\u00a0operator in\u00a0Awk<\/strong>\u00a0is different from that in shell scripting.<\/p>\n
            I hope the article was helpful to you and for any additional information required or questions, you can post a comment in the comment section.<\/p>\n
            How to Use Awk to Filter Text or Strings Using Pattern Specific Actions<\/h1>\n
            In the third part of the\u00a0Awk command series<\/a>, we shall take a look at filtering text or strings based on specific patterns that a user can define.<\/p>\n
            Sometimes, when filtering text, you want to indicate certain lines from an input file or lines of strings based on a given condition or using a specific pattern that can be matched. Doing this with\u00a0Awk<\/strong>\u00a0is very easy, it is one of the great features of\u00a0Awk<\/strong>\u00a0that you will find helpful.<\/p>\n
            Let us take a look at an example below, say you have a shopping list for food items that you want to buy, called\u00a0food_prices.list<\/strong>. It has the following list of food items and their prices.<\/p>\n
            $ cat food_prices.list <\/strong>\r\nNo\tItem_Name\t\tQuantity\tPrice\r\n1\tMangoes\t\t\t   10\t\t$2.45\r\n2\tApples\t\t\t   20\t\t$1.50\r\n3\tBananas\t\t\t   5\t\t$0.90\r\n4\tPineapples\t\t   10\t\t$3.46\r\n5\tOranges\t\t\t   10\t\t$0.78\r\n6\tTomatoes\t\t   5\t\t$0.55\r\n7\tOnions\t\t\t   5            $0.45\r\n<\/pre>\n
            And then, you want to indicate a\u00a0(*)<\/code>\u00a0sign on food items whose price is greater than\u00a0$2<\/code>, this can be done by running the following command:<\/p>\n
            $ awk '\/ *$[2-9]\\.[0-9][0-9] *\/ { print $1, $2, $3, $4, \"*\" ; } \/ *$[0-1]\\.[0-9][0-9] *\/ { print ; }' food_prices.list\r\n<\/pre>\n
            \n
            \"Print<\/a><\/p>\n
            Print Items Whose Price is Greater Than $2<\/p>\n<\/div>\n
            From the output above, you can see that the there is a\u00a0(*)<\/code>\u00a0sign at the end of the lines having food items,\u00a0mangoes<\/strong>\u00a0and\u00a0pineapples<\/strong>. If you check their prices, they are above\u00a0$2<\/strong>.<\/p>\n
            In this example, we have used used two patterns:<\/p>\n
              \n
            1. the first:\u00a0\/ *\\$[2-9]\\.[0-9][0-9] *\/<\/code>\u00a0gets the lines that have food item price greater than\u00a0$2<\/strong>\u00a0and<\/li>\n
            2. the second:\u00a0\/*\\$[0-1]\\.[0-9][0-9] *\/<\/code>\u00a0looks for lines with food item price less than\u00a0$2<\/strong>.<\/li>\n<\/ol>\n
              This is what happens, there are four fields in the file, when pattern one encounters a line with food item price greater than\u00a0$2<\/strong>, it prints all the four fields and a\u00a0(*)<\/code>\u00a0sign at the end of the line as a flag.<\/p>\n
              The second pattern simply prints the other lines with food price less than\u00a0$2<\/strong>\u00a0as they appear in the input file,\u00a0food_prices.list<\/strong>.<\/p>\n
              This way you can use pattern specific actions to filter out food items that are priced above\u00a0$2<\/strong>, though there is a problem with the output, the lines that have the\u00a0(*)<\/code>\u00a0sign are not formatted out like the rest of the lines making the output not clear enough.<\/p>\n
              We saw the same problem in\u00a0Part 2 of the awk series<\/a>, but we can solve it in two ways:<\/p>\n
              1.<\/strong>\u00a0Using\u00a0printf<\/strong>\u00a0command which is a long and boring way using the command below:<\/p>\n
              $ awk '\/ *$[2-9]\\.[0-9][0-9] *\/ { printf \"%-10s %-10s %-10s %-10s\\n\", $1, $2, $3, $4 \"*\" ; } \/ *$[0-1]\\.[0-9][0-9] *\/ { printf \"%-10s %-10s %-10s %-10s\\n\", $1, $2, $3, $4; }' food_prices.list \r\n<\/pre>\n
              \n
              \"Filter<\/a><\/p>\n
              Filter and Print Items Using Awk and Printf<\/p>\n<\/div>\n
              2.<\/strong>\u00a0Using\u00a0$0<\/strong>\u00a0field.\u00a0Awk<\/strong>\u00a0uses the variable\u00a00<\/strong>\u00a0to store the whole input line. This is handy for solving the problem above and it is simple and fast as follows:<\/p>\n
              $ awk '\/ *$[2-9]\\.[0-9][0-9] *\/ { print $0 \"*\" ; } \/ *$[0-1]\\.[0-9][0-9] *\/ { print ; }' food_prices.list \r\n<\/pre>\n
              \n
              \"Filter<\/a><\/p>\n
              Filter and Print Items Using Awk and Variable<\/p>\n<\/div>\n
              Conclusion<\/h3>\n
              That\u2019s it for now and these are simple ways of filtering text using pattern specific action that can help in flagging lines of text or strings in a file using\u00a0Awk<\/strong>\u00a0command.<\/p>\n
              Hope you find this article helpful and remember to read the next part of the series which will focus on using comparison operators using awk tool.<\/p>\n
              How to Use Comparison Operators with Awk in Linux \u2013 Part 4<\/h1>\n
              When dealing with numerical or string values in a line of text, filtering text or strings using comparison operators comes in handy for\u00a0Awk<\/strong>\u00a0command users.<\/p>\n
              In this part of the\u00a0Awk series<\/a>, we shall take a look at how you can filter text or strings using comparison operators. If you are a programmer then you must already be familiar with comparison operators but those who are not, let me explain in the section below.<\/p>\n
              What are Comparison operators in Awk?<\/h4>\n
              Comparison operators in Awk are used to compare the value of numbers or strings and they include the following:<\/p>\n
                \n
              1. ><\/code>\u00a0\u2013 greater than<\/li>\n
              2. <<\/code>\u00a0\u2013 less than<\/li>\n
              3. >=<\/code>\u00a0\u2013 greater than or equal to<\/li>\n
              4. <=<\/code>\u00a0\u2013 less than or equal to<\/li>\n
              5. ==<\/code>\u00a0\u2013 equal to<\/li>\n
              6. !=<\/code>\u00a0\u2013 not equal to<\/li>\n
              7. some_value ~ \/ pattern\/<\/code>\u00a0\u2013 true if some_value matches pattern<\/li>\n
              8. some_value !~ \/ pattern\/<\/code>\u00a0\u2013 true if some_value does not match pattern<\/li>\n<\/ol>\n
                Now that we have looked at the various comparison operators in Awk, let us understand them better using an example.<\/p>\n
                In this example, we have a file named\u00a0food_list.txt<\/strong>\u00a0which is a shopping list for different food items and I would like to flag food items whose quantity is less than or equal 20 by adding\u00a0(**)<\/code>\u00a0at the end of each line.<\/p>\n
                File \u2013 food_list.txt<\/div>\n
                No      Item_Name               Quantity        Price\r\n1       Mangoes                    45           $3.45\r\n2       Apples                     25           $2.45\r\n3       Pineapples                 5            $4.45\r\n4       Tomatoes                   25           $3.45\r\n5       Onions                     15           $1.45\r\n6       Bananas                    30           $3.45\r\n<\/pre>\n
                The general syntax for using comparison operators in Awk is:<\/p>\n
                # expression { actions; }\r\n<\/pre>\n
                To achieve the above goal, I will have to run the command below:<\/p>\n
                # awk '$3 <= 30 { printf \"%s\\t%s\\n\", $0,\"**\" ; } $3 > 30 { print $0 ;}' food_list.txt<\/strong>\r\n\r\nNo\tItem_Name`\t\tQuantity\tPrice\r\n1\tMangoes\t      \t\t   45\t\t$3.45\r\n2\tApples\t\t\t   25\t\t$2.45\t**\r\n3\tPineapples\t\t   5\t\t$4.45\t**\r\n4\tTomatoes\t\t   25\t\t$3.45\t**\r\n5\tOnions\t\t\t   15           $1.45\t**\r\n6\tBananas\t\t\t   30           $3.45\t**\r\n<\/pre>\n
                In the above example, there are two important things that happen:<\/p>\n
                  \n
                1. The first expression\u00a0{ action ; }<\/strong>\u00a0combination,\u00a0$3 <= 30<\/strong>\u00a0{ printf \u201c%s\\t%s\\n\u201d, $0,\u201d**\u201d ; }<\/strong>\u00a0prints out lines with quantity less than or equal to\u00a030<\/strong>\u00a0and adds a\u00a0(**)<\/strong>\u00a0at the end of each line. The value of quantity is accessed using\u00a0$3<\/strong>\u00a0field variable.<\/li>\n
                2. The second expression\u00a0{ action ; }<\/strong>\u00a0combination,\u00a0$3 > 30<\/strong>\u00a0{ print $0 ;}<\/strong>\u00a0prints out lines unchanged since their quantity is greater then\u00a030<\/strong>.<\/li>\n<\/ol>\n
                  One more example:<\/p>\n
                  # awk '$3 <= 20 { printf \"%s\\t%s\\n\", $0,\"TRUE\" ; } $3 > 20  { print $0 ;} ' food_list.txt <\/strong>\r\n\r\nNo\tItem_Name\t\tQuantity\tPrice\r\n1\tMangoes\t\t\t   45\t\t$3.45\r\n2\tApples\t\t\t   25\t\t$2.45\r\n3\tPineapples\t\t   5\t\t$4.45\tTRUE\r\n4\tTomatoes\t\t   25\t\t$3.45\r\n5\tOnions\t\t\t   15           $1.45\tTRUE\r\n6       Bananas\t                   30           $3.45\r\n<\/pre>\n
                  In this example, we want to indicate lines with quantity less or equal to\u00a020<\/strong>\u00a0with the word\u00a0(TRUE)<\/strong>\u00a0at the end.<\/p>\n
                  Summary<\/h3>\n
                  This is an introductory tutorial to comparison operators in\u00a0Awk<\/strong>, therefore you need to try out many other options and discover more.<\/p>\n
                  In case of any problems you face or any additions that you have in mind, then drop a comment in the comment section below. Remember to read the next part of the Awk series where I will take you through compound expressions.<\/p>\n
                  How to Use Compound Expressions with Awk in Linux \u2013 Part 5<\/h1>\n
                  All along, we have been looking at simple expressions when checking whether a condition has been meet or not. What if you want to use more then one expression to check for a particular condition in?<\/p>\n
                  In this article, we shall take a look at the how you can combine multiple expressions referred to as compound expressions to check for a condition when filtering text or strings.<\/p>\n
                  In\u00a0Awk<\/strong>,\u00a0compound expressions<\/strong>\u00a0are built using the\u00a0&&<\/code>\u00a0referred to as\u00a0(and)<\/code>\u00a0and the\u00a0||<\/code>\u00a0referred to as\u00a0(or)<\/code>compound operators.<\/p>\n
                  The general syntax for compound expressions is:<\/p>\n
                  ( first_expression ) && ( second_expression )\r\n<\/pre>\n
                  Here,\u00a0first_expression<\/code>\u00a0and\u00a0second_expression<\/code>\u00a0must be true to make the whole expression true.<\/p>\n
                  ( first_expression ) || ( second_expression) \r\n<\/pre>\n
                  Here, one of the expressions either\u00a0first_expression<\/code>\u00a0or\u00a0second_expression<\/code>\u00a0must be true for the whole expression to be true.<\/p>\n
                  Caution<\/strong>: Remember to always include the parenthesis.<\/p>\n
                  The expressions can be built using the comparison operators that we looked at in\u00a0Part 4 of the awk series<\/a>.<\/p>\n
                  Let us now get a clear understanding using an example below:<\/p>\n
                  In this example, a have a text file named\u00a0tecmint_deals.txt<\/code>, which contains a list of some amazing random Tecmint deals, it includes the name of the deal, the price and type.<\/p>\n
                  TecMint Deal List<\/div>\n
                  No      Name                                    Price           Type\r\n1       Mac_OS_X_Cleanup_Suite                  $9.99           Software\r\n2       Basics_Notebook                         $14.99          Lifestyle\r\n3       Tactical_Pen                            $25.99          Lifestyle\r\n4       Scapple                                 $19.00          Unknown\r\n5       Nano_Tool_Pack                          $11.99          Unknown\r\n6       Ditto_Bluetooth_Altering_Device         $33.00          Tech\r\n7       Nano_Prowler_Mini_Drone                 $36.99          Tech \r\n<\/pre>\n
                  Say that we want only print and flag deals that are above\u00a0$20<\/strong>\u00a0and of type\u00a0\u201cTech\u201d<\/strong>\u00a0using the\u00a0(**)<\/code>\u00a0sign at the end of each line.<\/p>\n
                  We shall need to run the command below.<\/p>\n
                  # awk '($3 ~ \/^$[2-9][0-9]*\\.[0-9][0-9]$\/) && ($4==\"Tech\") { printf \"%s\\t%s\\n\",$0,\"*\"; } ' tecmint_deals.txt <\/strong>\r\n\r\n6\tDitto_Bluetooth_Altering_Device\t\t$33.00<\/strong>\t\tTech\t*<\/strong>\r\n7\tNano_Prowler_Mini_Drone\t\t\t$36.99<\/strong>          Tech\t *<\/strong>\r\n<\/pre>\n
                  In this example, we have used two expressions in a compound expression:<\/p>\n
                    \n
                  1. First expression,\u00a0($3 ~ \/^\\$[2-9][0-9]*\\.[0-9][0-9]$\/)<\/strong>\u00a0; checks the for lines with deals with price above\u00a0$20<\/strong>, and it is only true if the value of\u00a0$3<\/strong>\u00a0which is the price matches the pattern\u00a0\/^\\$[2-9][0-9]*\\.[0-9][0-9]$\/<\/strong><\/li>\n
                  2. And the second expression,\u00a0($4 == \u201cTech\u201d)<\/strong>\u00a0; checks whether the deal is of type\u00a0\u201cTech\u201d<\/strong>\u00a0and it is only true if the value of\u00a0$4<\/strong>\u00a0equals to\u00a0\u201cTech\u201d<\/strong>.<\/li>\n<\/ol>\n
                    Remember, a line will only be flagged with the\u00a0(**)<\/code>, if\u00a0first expression<\/strong>\u00a0and\u00a0second expression<\/strong>\u00a0are true as states the principle of the\u00a0&&<\/code>\u00a0operator.<\/p>\n
                    Summary<\/h3>\n
                    Some conditions always require building compound expressions for you to match exactly what you want. When you understand the use of comparison and compound expression operators then, filtering text or strings based on some difficult conditions will become easy.<\/p>\n
                    Hope you find this guide useful and for any questions or additions, always remember to leave a comment and your concern will be solved accordingly.<\/p>\n
                    How to Use \u2018next\u2019 Command with Awk in Linux \u2013 Part 6<\/h1>\n
                    In this sixth part of\u00a0Awk series<\/a>, we shall look at using\u00a0next<\/code>\u00a0command, which tells\u00a0Awk<\/strong>\u00a0to skip all remaining patterns and expressions that you have provided, but instead read the next input line.<\/p>\n
                    The\u00a0next<\/code>\u00a0command helps you to prevent executing what I would refer to as time-wasting steps in a command execution.<\/p>\n
                    To understand how it works, let us consider a file called\u00a0food_list.txt<\/strong>\u00a0that looks like this:<\/p>\n
                    Food List Items<\/div>\n
                    No      Item_Name               Price           Quantity\r\n1       Mangoes                 $3.45              5\r\n2       Apples                  $2.45              25\r\n3       Pineapples              $4.45              55\r\n4       Tomatoes                $3.45              25\r\n5       Onions                  $1.45              15\r\n6       Bananas                 $3.45              30\r\n<\/pre>\n
                    Consider running the following command that will flag food items whose quantity is less than or equal to\u00a020<\/strong>with a\u00a0(*)<\/code>\u00a0sign at the end of each line:<\/p>\n
                    # awk '$4 <= 20 { printf \"%s\\t%s\\n\", $0,\"*\" ; } $4 > 20 { print $0 ;} ' food_list.txt<\/strong> \r\n\r\nNo\tItem_Name\t\tPrice\t\tQuantity\r\n1\tMangoes\t\t\t$3.45\t\t   5<\/strong>\t*<\/strong>\r\n2\tApples\t\t\t$2.45              25\r\n3\tPineapples\t\t$4.45              55\r\n4\tTomatoes\t\t$3.45              25 \r\n5\tOnions\t\t\t$1.45              15<\/strong>\t*<\/strong>\r\n6\tBananas\t                $3.45              30\r\n<\/pre>\n
                    The command above actually works as follows:<\/p>\n
                      \n
                    1. First, it checks whether the quantity, fourth field of each input line is less than or equal to\u00a020<\/strong>, if a value meets that condition, it is printed and flagged with the\u00a0(*)<\/code>\u00a0sign at the end using expression one:\u00a0$4 <= 20<\/code><\/li>\n
                    2. Secondly, it checks if the fourth field of each input line is greater than\u00a020<\/strong>, and if a line meets the condition it gets printed using expression two:\u00a0$4 > 20<\/code><\/li>\n<\/ol>\n
                      But there is one problem here, when the\u00a0first expression<\/strong>\u00a0is executed, a line that we want to flag is printed using:\u00a0{ printf \"%s\\t%s\\n\", $0,\"**\" ; }<\/code>\u00a0and then in the same step, the\u00a0second expression<\/strong>\u00a0is also checked which becomes a time wasting factor.<\/p>\n
                      So there is no need to execute the second expression,\u00a0$4 > 20<\/code>\u00a0again after printing already flagged lines that have been printed using the first expression.<\/p>\n
                      To deal with this problem, you have to use the\u00a0next<\/code>\u00a0command as follows:<\/p>\n
                      # awk '$4 <= 20 { printf \"%s\\t%s\\n\", $0,\"*\" ; next; } $4 > 20 { print $0 ;} ' food_list.txt<\/strong>\r\n\r\nNo\tItem_Name\t\tPrice\t\tQuantity\r\n1\tMangoes\t\t\t$3.45\t\t   5<\/strong>\t*<\/strong>\r\n2\tApples\t\t\t$2.45              25\r\n3\tPineapples\t\t$4.45              55\r\n4\tTomatoes\t\t$3.45              25 \r\n5\tOnions\t\t\t$1.45              15<\/strong>\t*<\/strong>\r\n6\tBananas\t                $3.45              30\r\n<\/pre>\n
                      After a single input line is printed using\u00a0$4 <= 20<\/code>\u00a0{ printf \"%s\\t%s\\n\", $0,\"*\" ; next ; }<\/code>, the\u00a0next<\/code>\u00a0command included will help skip the second expression\u00a0$4 > 20<\/code>\u00a0{ print $0 ;}<\/code>, so execution goes to the next input line without having to waste time on checking whether the quantity is greater than\u00a020<\/strong>.<\/p>\n
                      The\u00a0next<\/strong>\u00a0command is very important is writing efficient commands and where necessary, you can always use to speed up the execution of a script. Prepare for the next part of the series where we shall look at using standard input\u00a0(STDIN)<\/strong>\u00a0as input for\u00a0Awk<\/strong>.<\/p>\n
                      Hope you find this how to guide helpful and you can as always put your thoughts in writing by leaving a comment in the comment section below.<\/p>\n
                      How to Read Awk Input from STDIN in Linux \u2013 Part 7<\/h1>\n
                      In the previous parts of the\u00a0Awk tool series<\/a>, we looked at reading input mostly from a file(s), but what if you want to read input from\u00a0STDIN<\/strong>.<\/p>\n
                      In this Part 7 of Awk series, we shall look at few examples where you can filter the output of other commands instead of reading input from a file.<\/p>\n
                      We shall start with the\u00a0dir utility<\/a>\u00a0that works similar to\u00a0ls command<\/a>, in the first example below, we use the output of\u00a0dir -l<\/code>\u00a0command as input for Awk to print owner\u2019s username, groupname and the files he\/she owns in the current directory:<\/p>\n
                      # dir -l | awk '{print $3, $4, $9;}'\r\n<\/pre>\n
                      \n
                      \"List<\/a><\/p>\n
                      List Files Owned By User in Directory<\/p>\n<\/div>\n
                      Take a look at another example where we\u00a0employ awk expressions<\/a>, here, we want to print files owned by the\u00a0root<\/strong>\u00a0user by using an expression to filter strings as in the awk command below:<\/p>\n
                      # dir -l | awk '$3==\"root\" {print $1,$3,$4, $9;} '\r\n<\/pre>\n
                      \n
                      \"List<\/a><\/p>\n
                      List Files Owned by Root User<\/p>\n<\/div>\n
                      The command above includes the\u00a0(==)<\/code>\u00a0comparison operator to help us filter out files in the current directory which are owned by the root user. This is achieved using the expression\u00a0$3==\u201droot\u201d<\/code>.<\/p>\n
                      Let us look at another example of where we use a\u00a0awk comparison operator<\/a>\u00a0to match a certain string.<\/p>\n
                      Here, we have used the\u00a0cat utility<\/a>\u00a0to view the contents of a file named\u00a0tecmint_deals.txt<\/strong>\u00a0and we want to view the deals of type\u00a0Tech<\/strong>\u00a0only, so we shall run the following commands:<\/p>\n
                      # cat tecmint_deals.txt\r\n# cat tecmint_deals.txt | awk '$4 ~ \/tech\/{print}'\r\n# cat tecmint_deals.txt | awk '$4 ~ \/Tech\/{print}'\r\n<\/pre>\n
                      \n
                      \"Use<\/a><\/p>\n
                      Use Awk Comparison Operator to Match String<\/p>\n<\/div>\n
                      In the example above, we have used the value\u00a0~ \/pattern\/<\/code>\u00a0comparison operator, but there are two commands to try and bring out something very important.<\/p>\n
                      When you run the command with pattern\u00a0tech<\/strong>\u00a0nothing is printed out because there is no\u00a0deal<\/strong>\u00a0of that type, but with\u00a0Tech<\/strong>, you get deals of type\u00a0Tech<\/strong>.<\/p>\n
                      So always be careful when using this comparison operator, it is case sensitive as we have seen above.<\/p>\n
                      You can always use the output of another command instead as input for awk instead of reading input from a file, this is very simple as we have looked at in the examples above.<\/p>\n
                      Hope the examples were clear enough for you to understand, if you have any concerns, you can express them through the comment section below and remember to check the next part of the series where we shall look at\u00a0awk<\/strong>\u00a0features such as\u00a0variables<\/strong>,\u00a0numeric expressions<\/strong>\u00a0and\u00a0assignment operators<\/strong>.<\/p>\n
                      Learn How to Use Awk Variables, Numeric Expressions and Assignment Operators \u2013 Part 8<\/h1>\n
                      The\u00a0Awk command series<\/a>\u00a0is getting exciting I believe, in the previous seven parts, we walked through some fundamentals of\u00a0Awk<\/strong>\u00a0that you need to master to enable you perform some basic text or string filtering in Linux.<\/p>\n
                      Starting with this part, we shall dive into advance areas of\u00a0Awk<\/strong>\u00a0to handle more complex text or string filtering operations. Therefore, we are going to cover\u00a0Awk<\/strong>\u00a0features such as variables, numeric expressions and assignment operators.<\/p>\n
                      \n
                      \"Learn<\/a><\/p>\n
                      Learn Awk Variables, Numeric Expressions and Assignment Operators<\/p>\n<\/div>\n
                      These concepts are not comprehensively distinct from the ones you may have probably encountered in many programming languages before such shell, C, Python plus many others, so there is no need to worry much about this topic, we are simply revising the common ideas of using these mentioned features.<\/p>\n
                      This will probably be one of the easiest\u00a0Awk<\/strong>\u00a0command sections to understand, so sit back and lets get going.<\/p>\n
                      1. Awk Variables<\/h3>\n
                      In any programming language, a variable is a place holder which stores a value, when you create a variable in a program file, as the file is executed, some space is created in memory that will store the value you specify for the variable.<\/p>\n
                      You can define\u00a0Awk<\/strong>\u00a0variables in the same way you define shell variables as follows:<\/p>\n
                      variable_name=value \r\n<\/pre>\n
                      In the syntax above:<\/p>\n
                        \n
                      1. variable_name<\/code>: is the name you give a variable<\/li>\n
                      2. value<\/code>: the value stored in the variable<\/li>\n<\/ol>\n
                        Let\u2019s look at some examples below:<\/p>\n
                        computer_name=\u201dtecmint.com\u201d\r\nport_no=\u201d22\u201d\r\nemail=\u201dadmin@tecmint.com\u201d\r\nserver=\u201dcomputer_name\u201d\r\n<\/pre>\n
                        Take a look at the simple examples above, in the first variable definition, the value\u00a0tecmint.com<\/code>\u00a0is assigned to the variable\u00a0computer_name<\/code>.<\/p>\n
                        Furthermore, the value\u00a022<\/code>\u00a0is assigned to the variable\u00a0port_no<\/code>, it is also possible to assign the value of one variable to another variable as in the last example where we assigned the value of\u00a0computer_name<\/code>\u00a0to the variable server.<\/p>\n
                        If you can recall, right from\u00a0part 2 of this Awk series<\/a>\u00a0were we covered field editing, we talked about how Awk divides input lines into fields and uses standard field access operator,\u00a0$<\/code>\u00a0to read the different fields that have been parsed. We can also use variables to store the values of fields as follows.<\/p>\n
                        first_name=$2\r\nsecond_name=$3\r\n<\/pre>\n
                        In the examples above, the value of\u00a0first_name<\/code>\u00a0is set to second field and\u00a0second_name<\/code>\u00a0is set to the third field.<\/p>\n
                        As an illustration, consider a file named\u00a0names.txt<\/code>\u00a0which contains a list of an application\u2019s users indicating their first and last names plus gender. Using the\u00a0cat command<\/a>, we can view the contents of the file as follows:<\/p>\n
                        $ cat names.txt\r\n<\/pre>\n
                        \n
                        \"List<\/a><\/p>\n
                        List File Content Using cat Command<\/p>\n<\/div>\n
                        Then, we can also use the variables\u00a0first_name<\/code>\u00a0and\u00a0second_name<\/code>\u00a0to store the first and second names of the first user on the list as by running the\u00a0Awk<\/strong>\u00a0command below:<\/p>\n
                        $ awk '\/Aaron\/{ first_name=$2 ; second_name=$3 ; print first_name, second_name ; }' names.txt\r\n<\/pre>\n
                        \n
                        \"Store<\/a><\/p>\n
                        Store Variables Using Awk Command<\/p>\n<\/div>\n
                        Let us also take a look at another case, when you issue the command\u00a0uname -a<\/code>\u00a0on your terminal, it prints out all your system information.<\/p>\n
                        The second field contains your\u00a0hostname<\/code>, therefore we can store the\u00a0hostname<\/strong>\u00a0in a variable called\u00a0hostname<\/code>and print it using\u00a0Awk<\/strong>\u00a0as follows:<\/p>\n
                        $ uname -a\r\n$ uname -a | awk '{hostname=$2 ; print hostname ; }' \r\n<\/pre>\n
                        \n
                        \"Store<\/a><\/p>\n
                        Store Command Output to Variable Using Awk<\/p>\n<\/div>\n
                        2. Numeric Expressions<\/h3>\n
                        In\u00a0Awk<\/strong>, numeric expressions are built using the following numeric operators:<\/p>\n
                          \n
                        1. *<\/code>\u00a0: multiplication operator<\/li>\n
                        2. +<\/code>\u00a0: addition operator<\/li>\n
                        3. \/<\/code>\u00a0: division operator<\/li>\n
                        4. -<\/code>\u00a0: subtraction operator<\/li>\n
                        5. %<\/code>\u00a0: modulus operator<\/li>\n
                        6. ^<\/code>\u00a0: exponentiation operator<\/li>\n<\/ol>\n
                          The syntax for a numeric expressions is:<\/p>\n
                          $ operand1 operator operand2\r\n<\/pre>\n
                          In the form above,\u00a0operand1<\/code>\u00a0and\u00a0operand2<\/code>\u00a0can be numbers or variable names, and\u00a0operator<\/code>\u00a0is any of the operators above.<\/p>\n
                          Below are some examples to demonstrate how to build numeric expressions:<\/p>\n
                          counter=0\r\nnum1=5\r\nnum2=10\r\nnum3=num2-num1\r\ncounter=counter+1\r\n<\/pre>\n
                          To understand the use of numeric expressions in\u00a0Awk<\/strong>, we shall consider the following example below, with the file\u00a0domains.txt<\/code>\u00a0which contains all domains owned by\u00a0Tecmint<\/strong>.<\/p>\n
                          news.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\nwindows.tecmint.com\r\ntecmint.com\r\nnews.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\ntecmint.com\r\nnews.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\nwindows.tecmint.com\r\ntecmint.com\r\n<\/pre>\n
                          To view the contents of the file, use the command below:<\/p>\n
                          $ cat domains.txt\r\n<\/pre>\n
                          \n
                          \"View<\/a><\/p>\n
                          View Contents of File<\/p>\n<\/div>\n
                          If we want to count the number of times the domain\u00a0tecmint.com<\/code>\u00a0appears in the file, we can write a simple script to do that as follows:<\/p>\n
                          #!\/bin\/bash\r\nfor file in $@; do\r\n        if [ -f $file ] ; then\r\n                #print out filename\r\n                echo \"File is: $file\"\r\n                #print a number incrementally for every line containing tecmint.com \r\n                awk  '\/^tecmint.com\/ { counter=counter+1 ; printf \"%s\\n\", counter ; }'   $file\r\n        else\r\n                #print error info incase input is not a file\r\n                echo \"$file is not a file, please specify a file.\" >&2 && exit 1\r\n        fi\r\ndone\r\n#terminate script with exit code 0 in case of successful execution \r\nexit 0\r\n<\/pre>\n
                          \n
                          \"Shell<\/a><\/p>\n
                          Shell Script to Count a String or Text in File<\/p>\n<\/div>\n
                          After creating the script, save it and make it executable, when we run it with the file,\u00a0domains.txt<\/code>\u00a0as out input, we get the following output:<\/p>\n
                          $ .\/script.sh  ~\/domains.txt\r\n<\/pre>\n
                          \n
                          \"Script<\/a><\/p>\n
                          Script to Count String or Text<\/p>\n<\/div>\n
                          From the output of the script, there are 6 lines in the file\u00a0domains.txt<\/code>\u00a0which contain\u00a0tecmint.com<\/code>, to confirm that you can manually count them.<\/p>\n
                          3. Assignment Operators<\/h3>\n
                          The last\u00a0Awk<\/strong>\u00a0feature we shall cover is assignment operators, there are several assignment operators in Awk and these include the following:<\/p>\n
                            \n
                          1. *=<\/code>\u00a0: multiplication assignment operator<\/li>\n
                          2. +=<\/code>\u00a0: addition assignment operator<\/li>\n
                          3. \/=<\/code>\u00a0: division assignment operator<\/li>\n
                          4. -=<\/code>\u00a0: subtraction assignment operator<\/li>\n
                          5. %=<\/code>\u00a0: modulus assignment operator<\/li>\n
                          6. ^=<\/code>\u00a0: exponentiation assignment operator<\/li>\n<\/ol>\n
                            The simplest syntax of an assignment operation in\u00a0Awk<\/strong>\u00a0is as follows:<\/p>\n
                            $ variable_name=variable_name operator operand\r\n<\/pre>\n
                            Examples:<\/p>\n
                            counter=0\r\ncounter=counter+1\r\n\r\nnum=20\r\nnum=num-1\r\n<\/pre>\n
                            You can use the assignment operators above to shorten assignment operations in\u00a0Awk<\/strong>, consider the previous examples, we could perform the assignment in the following form:<\/p>\n
                            variable_name operator=operand\r\n<\/pre>\n
                            counter=0\r\ncounter+=1\r\n\r\nnum=20\r\nnum-=1\r\n<\/pre>\n
                            Therefore, we can alter the\u00a0Awk<\/strong>\u00a0command in the shell script we just wrote above using\u00a0+=<\/code>\u00a0assignment operator as follows:<\/p>\n
                            #!\/bin\/bash\r\nfor file in $@; do\r\n        if [ -f $file ] ; then\r\n                #print out filename\r\n                echo \"File is: $file\"\r\n                #print a number incrementally for every line containing tecmint.com \r\n                awk  '\/^tecmint.com\/ { counter+=1 ; printf  \"%s\\n\",  counter ; }'   $file\r\n        else\r\n                #print error info incase input is not a file\r\n                echo \"$file is not a file, please specify a file.\" >&2 && exit 1\r\n        fi\r\ndone\r\n#terminate script with exit code 0 in case of successful execution \r\nexit 0\r\n<\/pre>\n
                            \n
                            \"Alter<\/a><\/p>\n
                            Alter Shell Script<\/p>\n<\/div>\n
                            In this segment of the\u00a0Awk series<\/a>, we covered some powerful\u00a0Awk<\/strong>\u00a0features, that is variables, building numeric expressions and using assignment operators, plus some few illustrations of how we can actually use them.<\/p>\n
                            These concepts are not any different from the one in other programming languages but there may be some significant distinctions under Awk programming.<\/p>\n
                            In\u00a0part 9<\/strong>, we shall look at more\u00a0Awk<\/strong>\u00a0features that is special patterns:\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>.<\/p>\n
                            Learn How to Use Awk Special Patterns \u2018BEGIN and END\u2019 \u2013 Part 9<\/h1>\n
                            In\u00a0Part 8<\/strong>\u00a0of\u00a0this Awk series<\/a>, we introduced some powerful Awk command features, that is\u00a0variables, numeric expressions and assignment operators<\/a>.<\/p>\n
                            As we advance, in this segment, we shall cover more\u00a0Awk<\/strong>\u00a0features, and that is the special patterns:\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>.<\/p>\n
                            \n
                            \"Learn<\/a><\/p>\n
                            Learn Awk Patterns BEGIN and END<\/p>\n<\/div>\n
                            These special features will prove helpful as we try to expand on and explore more methods of building complex\u00a0Awk<\/strong>\u00a0operations.<\/p>\n
                            To get started, let us drive our thoughts back to the introduction of the\u00a0Awk<\/strong>\u00a0series, remember when we started this series, I pointed out that the general syntax of a running an\u00a0Awk<\/strong>\u00a0command is:<\/p>\n
                            # awk 'script' filenames  \r\n<\/pre>\n
                            And in the syntax above, the\u00a0Awk<\/strong>\u00a0script has the form:<\/p>\n
                            \/pattern\/ { actions } \r\n<\/pre>\n
                            When you consider the pattern in the script, it is normally a regular expression, additionally, you can also think of pattern as special patterns\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>. Therefore, we can also write an\u00a0Awk<\/strong>\u00a0command in the form below:<\/p>\n
                            awk '\r\n \tBEGIN { actions } \r\n \t\/pattern\/ { actions }\r\n \t\/pattern\/ { actions }\r\n            \u2026\u2026\u2026.\r\n\t END { actions } \r\n' filenames  \r\n<\/pre>\n
                            In the event that you use the special patterns:\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>\u00a0in an\u00a0Awk<\/strong>\u00a0script, this is what each of them means:<\/p>\n
                              \n
                            1. BEGIN pattern<\/strong>: means that Awk will execute the action(s) specified in\u00a0BEGIN<\/strong>\u00a0once before any input lines are read.<\/li>\n
                            2. END pattern<\/strong>: means that Awk will execute the action(s) specified in\u00a0END<\/strong>\u00a0before it actually exits.<\/li>\n<\/ol>\n
                              And the flow of execution of the an\u00a0Awk<\/strong>\u00a0command script which contains these special patterns is as follows:<\/p>\n
                                \n
                              1. When the\u00a0BEGIN<\/code>\u00a0pattern is used in a script, all the actions for\u00a0BEGIN<\/strong>\u00a0are executed once before any input line is read.<\/li>\n
                              2. Then an input line is read and parsed into the different fields.<\/li>\n
                              3. Next, each of the non-special patterns specified is compared with the input line for a match, when a match is found, the action(s) for that pattern are then executed. This stage will be repeated for all the patterns you have specified.<\/li>\n
                              4. Next, stage 2 and 3 are repeated for all input lines.<\/li>\n
                              5. When all input lines have been read and dealt with, in case you specify the\u00a0END<\/code>\u00a0pattern, the action(s) will be executed.<\/li>\n<\/ol>\n
                                You should always remember this sequence of execution when working with the special patterns to achieve the best results in an\u00a0Awk<\/strong>\u00a0operation.<\/p>\n
                                To understand it all, let us illustrate using the example from\u00a0part 8<\/a>, about the list of domains owned by\u00a0Tecmint<\/strong>, as stored in a file named\u00a0domains.txt<\/strong>.<\/p>\n
                                news.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\nwindows.tecmint.com\r\ntecmint.com\r\nnews.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\ntecmint.com\r\nnews.tecmint.com\r\ntecmint.com\r\nlinuxsay.com\r\nwindows.tecmint.com\r\ntecmint.com\r\n<\/pre>\n
                                $ cat ~\/domains.txt\r\n<\/pre>\n
                                \n
                                \"View<\/a><\/p>\n
                                View Contents of File<\/p>\n<\/div>\n
                                In this example, we want to count the number of times the domain\u00a0tecmint.com<\/code>\u00a0is listed in the file\u00a0domains.txt<\/strong>. So we wrote a small shell script to help us do that using the idea of variables, numeric expressions and assignment operators which has the following content:<\/p>\n
                                #!\/bin\/bash\r\nfor file in $@; do\r\n        if [ -f $file ] ; then\r\n                #print out filename\r\n                echo \"File is: $file\"\r\n                #print a number incrementally for every line containing tecmint.com \r\n                awk '\/^tecmint.com\/ { counter+=1 ; printf \"%s\\n\", counter ; }' $file\r\n        else\r\n                #print error info incase input is not a file\r\n                echo \"$file is not a file, please specify a file.\" >&2 && exit 1\r\n        fi\r\ndone\r\n#terminate script with exit code 0 in case of successful execution \r\nexit 0\r\n<\/pre>\n
                                Let us now employ the two special patterns:\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>\u00a0in the\u00a0Awk<\/strong>\u00a0command in the script above as follows:<\/p>\n
                                We shall alter the script:<\/p>\n
                                awk '\/^tecmint.com\/ { counter+=1 ; printf \"%s\\n\", counter ; }' $file\r\n<\/pre>\n
                                To:<\/p>\n
                                awk ' BEGIN<\/strong> {  print \"The number of times tecmint.com appears in the file is:\" ; }\r\n                      \/^tecmint.com\/ {  counter+=1  ;  }\r\n                      END<\/strong> {  printf \"%s\\n\",  counter  ; } \r\n                    '  $file\r\n<\/pre>\n
                                After making the changes to the\u00a0Awk<\/strong>\u00a0command, the complete shell script now looks like this:<\/p>\n
                                #!\/bin\/bash\r\nfor file in $@; do\r\n        if [ -f $file ] ; then\r\n                #print out filename\r\n                echo \"File is: $file\"\r\n                #print the total number of times tecmint.com appears in the file\r\n                awk ' BEGIN<\/strong> {  print \"The number of times tecmint.com appears in the file is:\" ; }\r\n                      \/^tecmint.com\/ {  counter+=1  ;  }\r\n                      END<\/strong> {  printf \"%s\\n\",  counter  ; } \r\n                    '  $file\r\n        else\r\n                #print error info incase input is not a file\r\n                echo \"$file is not a file, please specify a file.\" >&2 && exit 1\r\n        fi\r\ndone\r\n#terminate script with exit code 0 in case of successful execution \r\nexit 0\r\n<\/pre>\n
                                \n
                                \"Awk<\/a><\/p>\n
                                Awk BEGIN and END Patterns<\/p>\n<\/div>\n
                                When we run the script above, it will first of all print the location of the file\u00a0domains.txt<\/strong>, then the\u00a0Awk<\/strong>\u00a0command script is executed, where the\u00a0BEGIN<\/code>\u00a0special pattern helps us print out the message \u201cThe number of times tecmint.com appears in the file is:<\/code>\u201d before any input lines are read from the file.<\/p>\n
                                Then our pattern,\u00a0\/^tecmint.com\/<\/code>\u00a0is compared against every input line and the action,\u00a0{ counter+=1 ; }<\/code>is executed for each input line, which counts the number of times\u00a0tecmint.com<\/code>\u00a0appears in the file.<\/p>\n
                                Finally, the\u00a0END<\/code>\u00a0pattern will print the total the number of times the domain\u00a0tecmint.com<\/code>\u00a0appears in the file.<\/p>\n
                                $ .\/script.sh ~\/domains.txt \r\n<\/pre>\n
                                \n
                                \"Script<\/a><\/p>\n
                                Script to Count Number of Times String Appears<\/p>\n<\/div>\n
                                To conclude, we walked through more\u00a0Awk<\/strong>\u00a0features exploring on the concepts of special pattern:\u00a0BEGIN<\/code>\u00a0and\u00a0END<\/code>.<\/p>\n
                                As I pointed out before, these Awk features will help us build more complex\u00a0text filtering operations<\/a>, there is more to cover under\u00a0Awk<\/strong>\u00a0features and in\u00a0part 10<\/strong>, we shall approach the idea of Awk built-in variables, so stay connected.<\/p>\n
                                Learn How to Use Awk Built-in Variables \u2013 Part 10<\/h1>\n
                                As we uncover the section of\u00a0Awk<\/strong>\u00a0features, in this part of the series, we shall walk through the concept of built-in variables in Awk. There are two types of variables you can use in Awk, these are;\u00a0user-defined<\/strong>\u00a0variables, which we covered in\u00a0Part 8<\/a>\u00a0and\u00a0built-in<\/strong>\u00a0variables.<\/p>\n
                                \n
                                \"Awk<\/a><\/p>\n
                                Awk Built in Variables Examples<\/p>\n<\/div>\n
                                Built-in<\/strong>\u00a0variables have values already defined in\u00a0Awk<\/strong>, but we can also carefully alter those values, the built-in variables include:<\/p>\n
                                  \n
                                1. FILENAME<\/code>\u00a0: current input file name( do not change variable name)<\/li>\n
                                2. FR<\/code>\u00a0: number of the current input line (that is input line 1, 2, 3\u2026 so on, do not change variable name)<\/li>\n
                                3. NF<\/code>\u00a0: number of fields in current input line (do not change variable name)<\/li>\n
                                4. OFS<\/code>\u00a0: output field separator<\/li>\n
                                5. FS<\/code>\u00a0: input field separator<\/li>\n
                                6. ORS<\/code>\u00a0: output record separator<\/li>\n
                                7. RS<\/code>\u00a0: input record separator<\/li>\n<\/ol>\n
                                  Let us proceed to illustrate the use of some of the Awk built-in variables above:<\/p>\n
                                  To read the filename of the current input file, you can use the\u00a0FILENAME<\/code>\u00a0built-in variable as follows:<\/p>\n
                                  $ awk ' { print FILENAME } ' ~\/domains.txt \r\n<\/pre>\n
                                  \n
                                  \"Awk<\/a><\/p>\n
                                  Awk FILENAME Variable<\/p>\n<\/div>\n
                                  You will realize that, the filename is printed out for each input line, that is the default behavior of\u00a0Awk<\/strong>\u00a0when you use\u00a0FILENAME<\/code>\u00a0built-in variable.<\/p>\n
                                  Using\u00a0NR<\/code>\u00a0to count the number of lines (records) in an input file, remember that, it also counts the empty lines, as we shall see in the example below.<\/p>\n
                                  When we view the file\u00a0domains.txt<\/strong>\u00a0using\u00a0cat command<\/a>, it contains\u00a014<\/strong>\u00a0lines with text and empty\u00a02<\/strong>\u00a0lines:<\/p>\n
                                  $ cat ~\/domains.txt\r\n<\/pre>\n
                                  \n
                                  \"Print<\/a><\/p>\n
                                  Print Contents of File<\/p>\n<\/div>\n
                                  $ awk ' END { print \"Number of records in file is: \", NR } ' ~\/domains.txt \r\n<\/pre>\n
                                  \n
                                  \"Awk<\/a><\/p>\n
                                  Awk Count Number of Lines<\/p>\n<\/div>\n
                                  To count the number of fields in a record or line, we use the NR built-in variable as follows:<\/p>\n
                                  $ cat ~\/names.txt\r\n<\/pre>\n
                                  \n
                                  \"List<\/a><\/p>\n
                                  List File Contents<\/p>\n<\/div>\n
                                  $ awk '{ print \"Record:\",NR,\"has\",NF,\"fields\" ; }' ~\/names.txt\r\n<\/pre>\n
                                  \n
                                  \"Awk<\/a><\/p>\n
                                  Awk Count Number of Fields in File<\/p>\n<\/div>\n
                                  Next, you can also specify an input field separator using the\u00a0FS<\/code>\u00a0built-in variable, it defines how\u00a0Awk<\/strong>\u00a0divides input lines into fields.<\/p>\n
                                  The default value for\u00a0FS<\/code>\u00a0is\u00a0space<\/strong>\u00a0and\u00a0tab<\/strong>, but we can change the value of\u00a0FS<\/code>\u00a0to any character that will instruct Awk to divide input lines accordingly.<\/p>\n
                                  There are two methods to do this:<\/p>\n
                                    \n
                                  1. one method is to use the\u00a0FS<\/strong>\u00a0built-in variable<\/li>\n
                                  2. and the second is to invoke the\u00a0-F<\/strong>\u00a0Awk option<\/li>\n<\/ol>\n
                                    Consider the file\u00a0\/etc\/passwd<\/strong>\u00a0on a Linux system, the fields in this file are divided using the\u00a0:<\/code>\u00a0character, so we can specify it as the new input field separator when we want to filter out certain fields as in the following examples:<\/p>\n
                                    We can use the\u00a0-F<\/code>\u00a0option as follows:<\/p>\n
                                    $ awk -F':' '{ print $1, $4 ;}' \/etc\/passwd\r\n<\/pre>\n
                                    \n
                                    \"Awk<\/a><\/p>\n
                                    Awk Filter Fields in Password File<\/p>\n<\/div>\n
                                    Optionally, we can also take advantage of the\u00a0FS<\/code>\u00a0built-in variable as below:<\/p>\n
                                    $ awk ' BEGIN {  FS=\u201c:\u201d ; }  { print $1, $4  ; } ' \/etc\/passwd\r\n<\/pre>\n
                                    \n
                                    \"Filter<\/a><\/p>\n
                                    Filter Fields in File Using Awk<\/p>\n<\/div>\n
                                    To specify an output field separator, use the\u00a0OFS<\/code>\u00a0built-in variable, it defines how the output fields will be separated using the character we use as in the example below:<\/p>\n
                                    $ awk -F':' ' BEGIN { OFS=\"==>\" ;} { print $1, $4 ;}' \/etc\/passwd\r\n<\/pre>\n
                                    \n
                                    \"Add<\/a><\/p>\n
                                    Add Separator to Field in File<\/p>\n<\/div>\n
                                    In this\u00a0Part 10<\/strong>, we have explored the idea of using Awk built-in variables which come with predefined values. But we can also change these values, though, it is not recommended to do so unless you know what you are doing, with adequate understanding.\u00a0After this, we shall progress to cover how we can use shell variables in Awk command operations.<\/p>\n
                                    How to Allow Awk to Use Shell Variables \u2013 Part 11<\/h1>\n
                                    When we write shell scripts, we normally include other smaller programs or commands such as\u00a0Awk<\/strong>\u00a0operations in our scripts. In the case of Awk, we have to find ways of passing some values from the shell to Awk operations.<\/p>\n
                                    This can be done by using shell variables within Awk commands, and in this part of the series, we shall learn how to allow Awk to use shell variables that may contain values we want to pass to Awk commands.<\/p>\n
                                    There possibly two ways you can enable Awk to use shell variables:<\/p>\n
                                    1. Using Shell Quoting<\/h3>\n
                                    Let us take a look at an example to illustrate how you can actually use shell quoting to substitute the value of a shell variable in an Awk command. In this example, we want to search for a\u00a0username<\/strong>\u00a0in the file\u00a0\/etc\/passwd<\/strong>, filter and print the user\u2019s account information.<\/p>\n
                                    Therefore, we can write a\u00a0test.sh<\/code>\u00a0script with the following content:<\/p>\n
                                    #!\/bin\/bash\r\n\r\n#read user input\r\nread -p \"Please enter username:\" username\r\n\r\n#search for username in \/etc\/passwd file and print details on the screen\r\ncat \/etc\/passwd | awk \"\/$username\/ \"' { print $0 }'\r\n<\/pre>\n
                                    Thereafter, save the file and exit.<\/p>\n
                                    Interpretation of the Awk command in the\u00a0test.sh<\/code>\u00a0script above:<\/p>\n
                                    cat \/etc\/passwd | awk \"\/$username\/ \"' { print $0 }'\r\n<\/pre>\n
                                    \"\/$username\/ \"<\/code>\u00a0\u2013 shell quoting used to substitute value of shell variable\u00a0username<\/strong>\u00a0in Awk command. The value of\u00a0username<\/strong>\u00a0is the pattern to be searched in the file\u00a0\/etc\/passwd<\/strong>.<\/p>\n
                                    Note that the double quote is outside the Awk script,\u00a0\u2018{ print $0 }\u2019<\/code>.<\/p>\n
                                    Then make the script executable and run it as follows:<\/p>\n
                                    $ chmod  +x  test.sh\r\n$ .\/text.sh \r\n<\/pre>\n
                                    After running the script, you will be prompted to enter a\u00a0username<\/strong>, type a valid\u00a0username<\/strong>\u00a0and hit\u00a0Enter<\/strong>. You will view the user\u2019s account details from the\u00a0\/etc\/passwd<\/strong>\u00a0file as below:<\/p>\n
                                    \n
                                    \"Shell<\/a><\/p>\n
                                    Shell Script to Find Username in Password File<\/p>\n<\/div>\n
                                    2. Using Awk\u2019s Variable Assignment<\/h3>\n
                                    This method is much simpler and better in comparison to method one above. Considering the example above, we can run a simple command to accomplish the job. Under this method, we use the\u00a0-v<\/code>\u00a0option to assign a shell variable to a Awk variable.<\/p>\n
                                    Firstly, create a shell variable,\u00a0username<\/code>\u00a0and assign it the name that we want to search in the\u00a0\/etc\/passswd<\/code>file:<\/p>\n
                                    username=\"aaronkilik\"\r\n<\/pre>\n
                                    Then type the command below and hit Enter:<\/p>\n
                                    # cat \/etc\/passwd | awk -v name=\"$username\" ' $0 ~ name {print $0}'\r\n<\/pre>\n
                                    \n
                                    \"Find<\/a><\/p>\n
                                    Find Username in Password File Using Awk<\/p>\n<\/div>\n
                                    Explanation of the above command:<\/p>\n
                                      \n
                                    1. -v<\/code>\u00a0\u2013 Awk option to declare a variable<\/li>\n
                                    2. username<\/code>\u00a0\u2013 is the shell variable<\/li>\n
                                    3. name<\/code>\u00a0\u2013 is the Awk variable<\/li>\n<\/ol>\n
                                      Let us take a careful look at\u00a0$0 ~ name<\/code>\u00a0inside the Awk script,\u00a0' $0 ~ name {print $0}'<\/code>. Remember, when we covered\u00a0Awk comparison operators in Part 4<\/a>\u00a0of this series, one of the comparison operators was value\u00a0~<\/code>pattern, which means: true if value matches the pattern.<\/p>\n
                                      The\u00a0output($0)<\/code>\u00a0of\u00a0cat command<\/a>\u00a0piped to Awk matches the pattern\u00a0(aaronkilik)<\/code>\u00a0which is the name we are searching for in\u00a0\/etc\/passwd<\/strong>, as a result, the comparison operation is true. The line containing the user\u2019s account information is then printed on the screen.<\/p>\n
                                      Conclusion<\/h3>\n
                                      We have covered an important section of Awk features, that can help us use shell variables within Awk commands. Many times, you will write small Awk programs or commands within shell scripts and therefore, you need to have a clear understanding of how to use shell variables within Awk commands.<\/p>\n
                                      In the next part of the Awk series, we shall dive into yet another critical section of Awk features, that is flow control statements. So stay tunned and let\u2019s keep learning and sharing.<\/p>\n
                                      How to Use Flow Control Statements in Awk \u2013 Part 12<\/h1>\n
                                      When you review all the Awk examples we have covered so far, right from the start of the\u00a0Awk series<\/a>, 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\u00a0text filtering operations<\/a>\u00a0based on some conditions, that is where the approach of flow control statements sets in.<\/p>\n
                                      \n
                                      \"Use<\/a><\/p>\n
                                      Use Flow Control Statements in Awk<\/p>\n<\/div>\n
                                      There are various flow control statements in\u00a0Awk programming<\/a>\u00a0and these include:<\/p>\n
                                        \n
                                      1. if-else statement<\/li>\n
                                      2. for statement<\/li>\n
                                      3. while statement<\/li>\n
                                      4. do-while statement<\/li>\n
                                      5. break statement<\/li>\n
                                      6. continue statement<\/li>\n
                                      7. next statement<\/li>\n
                                      8. nextfile statement<\/li>\n
                                      9. exit statement<\/li>\n<\/ol>\n
                                        However, for the scope of this series, we shall expound on:\u00a0if-else<\/code>,\u00a0for<\/code>,\u00a0while<\/code>\u00a0and\u00a0do while<\/code>\u00a0statements. Remember that we already walked through\u00a0how to use next statement in Part 6<\/a>\u00a0of this\u00a0Awk series<\/a>.<\/p>\n
                                        1. The if-else Statement<\/h3>\n
                                        The expected syntax of the\u00a0if statement<\/code>\u00a0is similar to that of the shell\u00a0if statement<\/strong>:<\/p>\n
                                        if  (condition1) {\r\n     actions1\r\n}\r\nelse {\r\n      actions2\r\n}\r\n<\/pre>\n
                                        In the above syntax,\u00a0condition1<\/code>\u00a0and\u00a0condition2<\/code>\u00a0are Awk expressions, and\u00a0actions1<\/code>\u00a0and\u00a0actions2<\/code>\u00a0are Awk commands executed when the respective conditions are satisfied.<\/p>\n
                                        When\u00a0condition1<\/strong>\u00a0is satisfied, meaning it\u2019s true, then\u00a0actions1<\/strong>\u00a0is executed and the\u00a0if statement<\/strong>\u00a0exits, otherwise\u00a0actions2<\/strong>\u00a0is executed.<\/p>\n
                                        The\u00a0if statement<\/strong>\u00a0can also be expanded to a\u00a0if-else_if-else<\/code>\u00a0statement as below:<\/p>\n
                                        if (condition1){\r\n     actions1\r\n}\r\nelse if (conditions2){\r\n      actions2\r\n}\r\nelse{\r\n     actions3\r\n}\r\n<\/pre>\n
                                        For the form above, if\u00a0condition1<\/strong>\u00a0is true, then\u00a0actions1<\/strong>\u00a0is executed and the\u00a0if statement<\/strong>\u00a0exits, otherwise\u00a0condition2<\/strong>\u00a0is evaluated and if it is true, then\u00a0actions2<\/strong>\u00a0is executed and the\u00a0if statement<\/strong>\u00a0exits. However, when\u00a0condition2<\/strong>\u00a0is false then,\u00a0actions3<\/strong>\u00a0is executed and the\u00a0if statement<\/strong>\u00a0exits.<\/p>\n
                                        Here is a case in point of using\u00a0if statements<\/strong>, we have a list of\u00a0users<\/strong>\u00a0and their\u00a0ages<\/strong>\u00a0stored in the file,\u00a0users.txt<\/strong>.<\/p>\n
                                        We want to print a statement indicating a user\u2019s name and whether the user\u2019s age is less or more than\u00a025<\/strong>\u00a0years old.<\/p>\n
                                        aaronkilik@tecMint ~ $<\/strong> cat users.txt<\/strong>\r\nSarah L\t\t\t35    \tF\r\nAaron Kili\t\t40    \tM\r\nJohn  Doo\t\t20    \tM\r\nKili  Seth\t\t49    \tM    \r\n<\/pre>\n
                                        We can write a short shell script to carry out our job above, here is the content of the script:<\/p>\n
                                        #!\/bin\/bash\r\nawk ' { \r\n        if ( $3 <= 25 ){\r\n           print \"User\",$1,$2,\"is less than 25 years old.\" ;\r\n        }\r\n        else {\r\n           print \"User\",$1,$2,\"is more than 25 years old\" ; \r\n}\r\n}'    ~\/users.txt\r\n<\/pre>\n
                                        Then save the file and exit, make the script executable and run it as follows:<\/p>\n
                                        $ chmod +x test.sh\r\n$ .\/test.sh\r\n<\/pre>\n
                                        Sample Output<\/h5>\n
                                        User Sarah L is more than 25 years old\r\nUser Aaron Kili is more than 25 years old\r\nUser John Doo is less than 25 years old.\r\nUser Kili Seth is more than 25 years old\r\n<\/pre>\n
                                        2. The for Statement<\/h3>\n
                                        In case you want to execute some Awk commands in a loop, then the\u00a0for statement<\/strong>\u00a0offers you a suitable way to do that, with the syntax below:<\/p>\n
                                        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.<\/p>\n
                                        for ( counter-initialization; test-condition; counter-increment ){\r\n      actions\r\n}\r\n<\/pre>\n
                                        The following Awk command shows how the\u00a0for statement<\/strong>\u00a0works, where we want to print the numbers\u00a00-10<\/strong>:<\/p>\n
                                        $ awk 'BEGIN{ for(counter=0;counter<=10;counter++){ print counter} }'\r\n<\/pre>\n
                                        Sample Output<\/h5>\n
                                        0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n<\/pre>\n
                                        3. The while Statement<\/h3>\n
                                        The conventional syntax of the\u00a0while statement<\/strong>\u00a0is as follows:<\/p>\n
                                        while ( condition ) {\r\n          actions\r\n}\r\n<\/pre>\n
                                        The condition is an Awk expression and actions are lines of Awk commands executed when the condition is true.<\/p>\n
                                        Below is a script to illustrate the use of\u00a0while statement<\/strong>\u00a0to print the numbers\u00a00-10<\/strong>:<\/p>\n
                                        #!\/bin\/bash\r\nawk ' BEGIN{ counter=0 ;\r\n         \r\n        while(counter<=10){\r\n              print counter;\r\n              counter+=1 ;\r\n             \r\n}\r\n}  \r\n<\/pre>\n
                                        Save the file and make the script executable, then run it:<\/p>\n
                                        $ chmod +x test.sh\r\n$ .\/test.sh\r\n<\/pre>\n
                                        Sample Output<\/h5>\n
                                        0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n<\/pre>\n
                                        4. The do while Statement<\/h3>\n
                                        It is a modification of the\u00a0while statement<\/strong>\u00a0above, with the following underlying syntax:<\/p>\n
                                        do {\r\n     actions\r\n}\r\n while (condition) \r\n<\/pre>\n
                                        The slight difference is that, under\u00a0do while<\/strong>, the Awk commands are executed before the condition is evaluated. Using the very example under\u00a0while statement<\/strong>\u00a0above, we can illustrate the use of\u00a0do while<\/strong>\u00a0by altering the Awk command in the\u00a0test.sh<\/strong>\u00a0script as follows:<\/p>\n
                                        #!\/bin\/bash\r\n\r\nawk ' BEGIN{ counter=0 ;  \r\n        do{\r\n            print counter;  \r\n            counter+=1 ;    \r\n        }\r\n        while (counter<=10)   \r\n} \r\n'\r\n<\/pre>\n
                                        After modifying the script, save the file and exit. Then make the script executable and execute it as follows:<\/p>\n
                                        $ chmod +x test.sh\r\n$ .\/test.sh\r\n<\/pre>\n
                                        Sample Output<\/h5>\n
                                        0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n<\/pre>\n
                                        Conclusion<\/h3>\n
                                        This is not a comprehensive guide regarding Awk flow control statements, as I had mentioned earlier on, there are several other\u00a0flow control statements<\/strong>\u00a0in Awk.<\/p>\n
                                        Nonetheless, this part of the\u00a0Awk series\u00a0should give you a clear fundamental idea of how execution of Awk commands can be controlled based on certain conditions.<\/p>\n
                                        You can as well expound more on the rest of the flow control statements to gain more understanding on the subject matter. Finally, in the next section of the Awk series, we shall move into writing Awk scripts.<\/p>\n
                                        How to Write Scripts Using Awk Programming Language \u2013 Part 13<\/h1>\n
                                        All along from the beginning of the\u00a0Awk series up to Part 12<\/a>, we have been writing small Awk commands and programs on the command line and in shell scripts respectively.<\/p>\n
                                        However,\u00a0Awk<\/strong>, just as 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.<\/p>\n
                                        Similar to how we write a shell script, Awk scripts start with the line:<\/p>\n
                                        #! \/path\/to\/awk\/utility -f \r\n<\/pre>\n
                                        For example on my system, the\u00a0Awk<\/strong>\u00a0utility is located in\u00a0\/usr\/bin\/awk<\/strong>, therefore, I would start an Awk script as follows:<\/p>\n
                                        #! \/usr\/bin\/awk -f \r\n<\/pre>\n