Bash Tips And Tricks From My Own Experience - Several Instalments

Quick overview of bash

As mentioned in this forum before, bash is the most popular shell environment in the Linux world, and a good tutorial can be found here:
http://www.tldp.org/LDP/abs/html/

The purpose of this topic is to show you a couple of quick how-to nuggets that I'm deriving from personal experience, both from using bash inside of Linux itself, as well as from using cygwin, a Win32 port of a bunch of Linux utilities, which includes bash as one of the shell options for running commands in.

All examples have been made using cygwin in a Windows environment.

Instalment 1:
- How to convert all file names in a directory from mixed (or upper) case to lower case:

Suppose we have a couple of files in our ztmptmp directory, like this:



and we throw another one in, for good measure:



The script that converts the file names to lower case looks like this:



and the result is the one I expected:



Advanced UNIX / Linux users already know what did the trick, but for completeness I am giving a detailed explanation.
When you run the script, the first thing that happens is that the shell sees the wildcard * and expands it into the full list of files, in other words, bash temporarily (and internally) changes the script to look like:



Each of the file names in that list is then in turn subject to the mv command.
mv is a pretty basic command that can be used to move or rename a file.
In this case, we are supplying a target file name as the second argument and not a directory, so it will know to perform a rename operation.
The two arguments of the mv command are:
- $myfile
- `echo $myfile | tr 'A-Z' 'a-z'`
Note the use of backticks with which we surround the Linux command:



These backticks instruct the bash shell to run the command inside and substitute its output for the entire string (including the backticks).
To understand what the command does, let's test it using the first file name:



Here, the output from the first command, which is simply the literal string 02-DeFrag-xvid.avi is fed to the second command as the input.
The tr command expands the character sequences A-Z and a-z into the full-blown ASCII sequences:



and



then makes a positional translation of the text it receives as its input (in our case the file name), therefore the name tr for translate.
So it will loop through each character of the file name and go:
Is this character an A? if yes, replace the A with the character in the same position from the second string, which is a lowercase a. If no, move on to the second position.
Is this character a B? ... you get the idea...
until it exhausts the input string, at which time it will output the modified string.

And the modified string will replace the backticks and become the second argument to the mv command, as explained above.

 

 

 

Comment/Reply (w/o sign-up)

Very interesting topic, thanks for the info. I was very impressed, I learned a lot of things, explained in a very easy-to-understant way, which everyone appreciates in a tutorial.
The only thing I would say is, the topic title is not accurate.
the topic title is "Bash Tips and Trick". This is false, this is not related to bash. It is also not specially Unix nor Linux.
It's simply on the "tr" command usage, which is the same on each Unis shell : ksh, sh, cs, bash.
So, the title should be "tr usage, useful tricks from my own experience". People expecting to learn "bash" tips would less be disappointed.
Regards
Yordan

Comment/Reply (w/o sign-up)

Instalment 2:
- How I use POSIX utilities to process text

One of the problems I have very often is that I would like to extract usable links from a very large web page the source code of which looks messy (when I look at it using "View Source").
Have you ever looked at a cool web page with nice visual effects and the first thing that comes to your mind is "How did he do that? I would also like to have those effects on my own site."
Or otherwise the page has lots of links to pretty pictures and you just want the links without the other "fat".
And you go to view the source and it looks like this:



Now you want to make some sense out of that never ending HTML string.
You probably already have your favorite tool handy to do that easily, and that's fine, but my objective here is to showcase the use of POSIX utilities, that's why I will show you what might look like the hard way of doing it.

For simplicity, I will assume that the above HTML code is stored in file messyHTML.html.

My objective is to obtain a clean list of all the links pointing to jpg files, each one on its own line.
Something like this:



First of all, I would like to get a rough overview of the structure of the web page by having each HTML tag on its own line:



OK, so what did I do?
Let's look at the command again, it might seem complex and cryptic at first, so let's break it down.
To eliminate some confusion related to how I configured my shell prompts (the sets of characters "# " and "> "), let's see what the command looks like without them:



The two utilities cat and sed communicate with each other using a pipe (the character "|"). This pipe redirects the output of the cat command from where it would normally go (the terminal output) into the standard input of the sed command.
Of course I could have done this using only the sed command by pointing it to the file, but I have chosen to use two commands for several reasons, one of which is to make the sed command as easy to understand as possible, which is not an easy task. The other reason was to give this tutorial some integrity. You will see what I mean later on, when I use sed one more time, but in a slightly more complex manner.

You are already wondering why the command spans two lines. Well, try to use your imagination and put the two lines together again, but keep in mind that they are still separated by the binary representation of the carriage return.
The imaginary command might look like this:



The carriage return is a special character that the bash shell will interpret according to its own specification, unless we "escape" it. Escaping a character means instructing the bash shell not to give that character any special mening and to treat it "as-is". Escaping is done in the bash shell by putting a backslash in front of the special character.

Now we need to look at the sed command in more detail.
sed is a stream editor that many people use primarily as a tool to mass replace patterned strings of text.
A very basic example of how sed works is this:



In this example I have used sed to replace the first occurence of "de" with "WWWWW" in the string "abcdefghi".
Look at the following example where I append an additional occurence of "de" to the end of our string "abcdefghi" and run the same command again:



If our objective is to replace ALL occurences of "de", we simply specify the "g" switch, which does a global replace.



On a side note, I personally tend to use the hash mark (the "#" character) as the separator in sed, because I often find myself needing to replace strings that contain slashes, but most people I have seen use the slash as a separator, like this:



Excellent !!!
I'm only interested in links to pictures, so after quickly eyeballing the structure of the web page, I decide that I would only like to keep those lines that contain the string "images".



grep is a very powerful and very underutilized tool - "underutilized" in the sense that it's not utilized to its full potential: 99% of the time people only use 1% of its power. I will probably spend some time in a future instalment exploring its capabilities.

It is that 1% that I am using here as well: basic filtering using plain (unpatterned) text.

At this point we are one step away from reaching our objective and, as always in UNIX, there is more than one way of performing the next step. Let me explain.

In this particular example, all the links that we are interested in begin at the same offset and have the same length, so one is strongly tempted to leverage this feature and use the cut command. For educational purposes, I will go ahead and show you how cut works, but in real life situations I always use an advanced feature of sed called backreferencing, which I will show you further below, so keep reading.

Let's look at how our output lines are structured:



So where's the "beef"?
Well, the "beef" begins at position 9 and ends at position 62.
Let's perform a single test:



It works as expected, let's do the whole thing in one fell swoop:



Excellent !!! Are we done?
Well, yes and no, this was the lazy man's way, let me show you now the right way.



Does that look like command line garbage or what?
Take a deep breath, I'm getting ready to explain to you that scary thing at the end:



But before I do, let us make a quick mental note that, although seemingly vastly more complex, this approach makes absolutely no assumptions whatsoever about where the links begin and where they end.

The following is a regular expression pattern that matches the whole line (each and every line in its entirety):



It matches the whole line because it begins with the character "^" and it ends with the character "$".
When used in a regular expression pattern, the character "^" always matches the beginning of the line and the character "$" always matches the end of the line.

Note that I am making use of terms which I have not already explained, terms like "regular expression" and "pattern". If you want a formal definition for these terms, please feel free to google them, then come back to this tutorial. I prefer to define these entities by showing you how they are used in practice.

When used in a regular expression pattern, a dot matches any character.
A dot followed by an asterisk matches any string of characters, including the empty string.
This is because, when used in a regular expression pattern, an asterisk matches zero or more occurences of the character preceding it. For instance, the pattern a* will match any one of the following strings:
- the empty string
- a
- aa
...
- aaaaaaaaa
etc. ... you get the idea

The regular expression pattern:



makes use of four anchors, two of which we have already discussed (beginning and ending of line).

The other two are: "(http" and "jpg)"
Here I am showing the parentheses without their respective preceding backslashes, but keep in mind that these parentheses are special characters that need to be escaped so that the bash shell leaves them alone and they therefore become available for use by sed.

These two anchors "(http" and "jpg)" mean that whatever text matches the pattern "http.*jpg" inside the parentheses will temporarily be stored in a special location in sed's memory called a backreference. From that moment on, the character string stored in that special location in memory can be referenced by the name of "\1".
sed provides a maximum of nine such backreferences, \1 through \9. Backreferences \2 and above become available as soon as you have more than one set of parentheses.

It should now be obvious that the command



entirely replaces each and every line from the standard input with the string we want.

One more caveat to pattern matching:
sed's regular expression engine is "greedy", meaning that, should there have been several http.*jpg links on one line, the backreferencing trick would only partially provide the expected results.
Let's give an example using a slightly modified version of the web page:



In this case, the first and second patterns of ".*" both behave in a greedy manner, each one of them trying to "swallow" the character string:



but precedence is given to the first.

 

 

 

Comment/Reply (w/o sign-up)