In a break from common Linux command line tools, I’m going to show you a silly command that exists in Linux® called touch. It’s silly in that it looks ridiculous to begin with but someone created it for a reason.

touch means you’re going to touch a file or directory.   It is often used to create empty new files, like this:

Alpha:~ computerlamp$ touch Avengers

If you ls, you’ll see a file named Avengers in the current directory. Now try the command cat on Avengers.

Alpha:~ computerlamp$ cat Avengers

Hey, nothing there! You created a file with nothing in it. Not a single Avenger to be found in the Avengers file. Not even a Hawkeye or a Black Widow.  This means that if you need a new file, you cause this command to create it just like you can use echo.  Unlike touch, echo actually puts words into the file.

There’s nothing stopping you from touching a file that already exists.

Alpha:~ computerlamp$ touch Avengers

Run ls again and nothing has changed. You can also try find and you won’t see anything different.  it doesn’t look like my command did anything.

So why did I touch it? I touched it for some reason, something must have changed, I just need to find out what.  It turns out there’s another flag to ls that will let me see the changes I made

Try this, run ls with the -l flag. It looks like:

Alpha:~ computerlamp$  ls -l
total 0
-rw-r--r--  1 computerlamp  staff  0 Nov 12 11:33 Avengers

See that date in there? That’s the date the of the last time the file was modified. Every time you touch a file, that gets updated. Try it a few times and see. touch was made so it’s easy to change that time. The 0 before the Nov in the date is the size of the file in bytes. The other things we’ll discuss in the next post.

The pipe command in this post didn’t work with every command, so now we’re going to fix those pipes. Remember that the pipe takes the standard out from one command and turns it into standard in for another and how that doesn’t always work with every command. One command it doesn’t work with is rm. Let’s start by making a file.

Alpha:~ computerlamp$ echo "Mario Rocks!" > Nintendo

Now we’re going to use find to remove it. I know that’s kind of silly, but hey, we need to be able to try these things out. Here’s the command to use find and rmove it:

Alpha:~ computerlamp$ find . -name 'Nintendo' | rm

What we get back is an error telling us how rm works:

Alpha:~ computerlamp$ find Nintendo | rm
usage: rm [-f | -i] [-dPRrvW] file ...
       unlink file

This looks like I can’t use find with rm and a pipe.

Wait, this is Linux, there’s another way around this, I can fix those pipes! It’s the command xargs. It takes the output from one command and turns it into the command line string for another. This is for those commands that don’t read input from standard in, like ls does.

It works like:

Alpha:~ computerlamp$ find . -name 'Nintendo' | xargs rm

See where I stuck that xargs? Try it and the error we saw before has gone away! I fixed those pipes!

But wait, isn’t this a different way of doing what the -exec flag to find did that we saw in this post? Well, yes it is. It’s also a more efficient way of doing things.

The -exec flag works on each individual file. When it finds something, it carefully removes it then goes back to looking. Using xargs lets us group the files together and remove them all at once. This is actually must faster than using the -exec flag with find.

So when Mario jumped into a pipe he’d come out in a different area. Well, technically it’s a sewer pipe, but close enough. He’d go out one area and into the other.

Linux® has pipes too. They take the results out from one command and put them in to another. It’s not a sewer pipe, so you don’t have to worry about figuring how to make a pipe on the command line. It’s the | character. It kind of looks like a pipe… ish. It isn’t hollow, but it’ll do.

So what can we do with it? Well, let’s start with something simple. Suppose when I run ls in a directory I get waaaaaay too many files to look at.  It’s just pages and pages of results.  Rather than trying to read all those lines scrolling by, I can pipe the results from ls into more

Alpha:~ computerlamp$ ls | more

I could also pipe the results through less:

Alpha:~ computerlamp$ ls | less

For silliness, I can pipe the command echo through less:

Alpha:~ computerlamp$ echo "Mario Rocks" | less

Now if you don’t give a command after the pipe, things just hang around.

Alpha:~ computerlamp$ echo "Mario Rocks" |

The command line is waiting for me to give another command to pipe the results of that echo in to. I can either type another command or hit control-C to exit that. That’s holding down the control key and then hitting C. It’s a common way to interrupt things on Linux®.

If you remember way back from post on Linux® and Files, we talked about standard file types. What technically is happening with a | is that the first command writes to standard out and that is written to the standard in of the second command through the pipe. This means that in order for it to work, the second command has to take input from standard in. Not every command does this. We’ll talk about how to fix that next time.

In the Linux® system, there is a fle that contains a list of dictionary words. This file is normally in /usr/share/dict/words. Each line on that file contains a single word. If you want to know how many words are in the file, try:

Alpha:~ computerlamp$  wc -l /usr/share/dict/words

Wow, isn’t that a lot of words in a single file?  The one on my system has 235,886 words.  That’s a lot.

Now imagine using more (or less) on the file and looking for a single word. This could take forever. Especially if we’re looking for vulcan because we want to make sure we spelled it right. There has to be an easier way to find this… And of course there is. If we are using more (or less) to look through the file, then we can use the ⁄. Try

Alpha:~ computerlamp$ more /usr/share/dict/words

and hit the ⁄ key. Then type the word you’re looking for and it will hopefully take you to it.  Try that with turtle.  Now pretend we tried to page through the file looking for turtle.  We’d still be looking.

Now suppose we’re looking for the word way. If we type that, the command takes is to the word airway. Which is almost, but not quite, what we need. I could keep looking through the file, but that would give me every word that had way in it.  Like alway, or away or backway or cartway.  There’s an awful lot of words with way in it.

We need to tell more that we’re looking for the word that begins with way. We can do this by typing ^way (see the ^) which tells more that the word should begin with way. Now if the word isn’t found in the file, then… either you spelled it wrong (vulcan begins with a v not a w!) or it doesn’t exist in the file.  For example, google isn’t in my file!

And that’s how you find words in your files.

Suppose you made a directory that you thought you needed called penguin. As it turns out, you don’t need penguin at all, but due to a brief brain fart you’ve forgotten how to remove directories. Unfortunately, we haven’t yet progressed to the point where you can tell your computer ‘remove that directory’. We have to know what command to type.

Luckily for us, Linux® has a command that will help us find the command we need. It is called apropros. If we try:

Alpha:~ computerlamp$  apropros directory

That gives us a list of every man page on the system that has something to do with directory. Luckily for us, the command uses the more or less command for the output of apropros so we can look through the results and find the command that will remove the directory. Which, as we know from a previous post, is rmdir.

As Linux® always has another way to do things, there is another way to search through man pages. In this case, it is a flag for man, man -k. It will give the same results as apropros.

Alpha:~ computerlamp$  man -k directory

Sometimes apropos finds nothing. Try

Alpha:~ computerlamp$ apropos penguin