There are several ways one can batch rename files in Linux. One of the possibilities is the linux command rename.

Usage

To rename files you have to supply a Perl expression. Using Perl expressions might be scary for beginners (because they look like someone hit his head on the keyboard), but they allow for complex renaming with a minimum of characters.

Although I won’t go into detail about Perl expressions here, I will try to make it a little easier for beginners to use them for batch renaming.

According to the man page of rename, this is the way to use rename:

rename [ -v ] [ -n ] [ -f ] perlexpr [ files ]

If you have not worked with Perl expressions before, this might not be enough to get you started. So let me present you with the way one would probably use rename most of the time:

rename 's/OLD/NEW/' FILES

OLD is an expressions which describes a pattern in the name filenames. If rename can find this pattern in the name of a file, it will replace this part of the filename with what is defined as NEW. The files rename should rename are defined by FILES.

Let me provide you with two examples:

Examples

Example 1 – Replacing a single word/string

Let’s start with a very simple example: Imagine, you have a lot of images that are named

picture 1.jpg
picture 2.jpg
...

and you would like to replace the word “picture” with the word “image”, so that the files will be named like this:

image 1.jpg
image 2.jpg
...

As describes under usage, OLD represents the part that we want to replace. As we want  to replace the word “picture”, in this example OLD will be “picture”.

And because NEW defines with what OLD is replaced with, in our example. We want the OLD(=”picture”) to be replaced with “image”, so here NEW=”image”.

And because we want to do this only for all the pictures which name starts with “picture” FILES will be “picture*.jpg”.

Therefore the general command

rename 's/OLD/NEW/' FILES

becomes:

rename 's/picture/image/' picture*.jpg

It might have not been necessary for us to restrict this to the the files “picture*.jpg”. We might have just used *.jpg (all files in the current directory with the extension .jpg) or even * (all files in the current directory), because rename will only change the filename, if the pattern OLD (here: “picture”) is found in the filename. You have to be careful, though. A file with the name “just a picture.jpg” would have been renamed to “just a image.jpg”, because we told rename to replace “picture” with “image”.

Example 2

Let’s go back to Example 1. One problem I mentioned is that running

rename 's/picture/image' *.jpg

to rename files like “picture 23.jpg” to “image 23.jpg” would also rename files like “just a picture.jpg” to “just a image.jpg”, because rename would find the word “picture” and replace it with “image”, although this is not what we intended.

We could prevent this by calling rename like this:

rename 's/picture/image' picture*.jpg

This would call rename only for the .jpg files starting with the word “picture”. But this is not really a solution, because files like “picture of a sunset.jpg” would still be renamed to “image of a sunset.jpg”.

To make sure that rename really does what we want it to do, we need to be very clear about what should be renamed. Because what we want is not to replace the word “picture” with the word “image” in every case, we want to replace the word “picture” with the word “image”, but only for the files which name consists of the word “picture”, then a space and then a number and then the extension “.jpg”.

This can be achieved with the following command:

rename 's/^picture( [0-9]*\.jpg)$/image$1/' *.jpg

This might look a little scary, but is a good example of what you can do with Perl expressions. Because this would only rename the desired files. Files like “my picture 11.jpg” or “picture 28 (beach).jpg” would not be renamed and in this example that is exactly what we want to do.

Let me go through the different parts of the expression above briefly, to give you an idea of how this works. Keep in mind that this just an example and not intended as a complete tutorial. I will just try to explain to you the various elements of this expression to show you some of the possibilities and to demystify them a little bit.

When you compare the command to the general form under “Usage”, you will see that in this case:

• OLD = ^picture( [0-9]*\.jpg)$
• NEW = image$1
• FILES = *.jpg

In this example OLD makes sure that only the desired files are renamed by defining the structure of what we are looking for exactly. This works, because OLD defines what should be renamed. That means that files where the pattern/structure defined by OLD can not be found will not be renamed. Therefore, OLD automatically works as a filter to make sure that only the desired files get renamed. The trick is to make sure that OLD and NEW reflect what you wish to do. Let’s dissect it:

Let’s ignore the “^” at the beginning, the “$” at the end, the parentheses and the “\”  at the moment. This leaves the following:

picture [0-9]*.jpg

This describes our basic structure. First, we have the word “picture”, then a space. [0-9] means any character from 0 to 9, which essentially means “a digit” and when putting a “*” after it, it means that there can be “any number of” digits. We need this, because we don’t know how many digits there will be. We can have files like “picture 7.jpg”, where there is only 1 digit or files like “picture 1432.jpg”, where he have four of them. So, “[0-9]*” stands for “any number of digits”, which just means: a number. And then we have “.jpg”, our extensions.

It is important to note that  “[0-9]*” really means “any number of digits” and that “any number” could also mean 0. This means that the number is optional and a file named “picture .jpg” would also be renamed. In this example it probably would not make a real difference, but in general you need to be careful. If there really has to be a number and it can not be optional, you can use a “+” instead of a “*”, because “[0-9]+” means “at least one digit”.  But because it will not be a problem in this case, we will keep the “*”.

Now, let’s add the parts we ignored:

The “.” is a special character which stand for “any character”. But in our pattern, we want to make clear that the filename ends with “.jpg”. But “.jpg” would be interpreted as “any character, then j, then p, then g”. Therefore a file like “picture 234Xjpg” would be renamed, because the . (which stand for “any character”) would be “X” in this case. But really want to make sure that the file ends with “.jpg” and therefore need to make it clear that the “.” really stand for “.” and not for “any character”. This can be done by escaping it with a “\”. Therefore, we need to write “\.jpg”.

The parentheses are added, because the pattern we are creating will be matching the complete filename. If we would run a command like this:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

A file like “picture 23.jgp” would be renamed to “image” and not to “image 23.jpg”. This is because our pattern “^picture [0-9]*\.jpg$” describes the whole filename. So the complete filename would be replace with “image”. But we just want to replace “picture” and keep the rest.

We can do this by telling rename that we want to keep everything after “picture”. While we can’t do this directly, we can put every after “picture” in parentheses and then later use this part to build our new filename, because everything within the parentheses will be saved accessible later as “$1″, so if we use the pattern

picture( [0-9]*\.jpg)

We can now see that the space, the number and the extension “.jpg” are within the parentheses and we can access this part as “$1″. When the filename is “picture 83.jpg”, $1 will therefore contain ” 83.jpg”. Then, when we define our replacement, we can tell rename to use “image$1″ as our replacement for the filename. Because $1 contains the space, the number and the extension, this would translate to “image 83.jpg”.

Now, what’s left are “^” and “$”. “^” stand for the beginning of the filename. This makes sure that files like “some picture 44.jpg” would not be renamed. This is because a pattern like “picture” means: find the word picture anywhere. Whereas “^picture” essentially means: find the word picture at the beginning of the input(=filename).

Similarly, “$” stand for the end of the input (here: filename). We use this to make sure that something like “picture 74.jpg.gz” does not get renamed.

Combining “^” and “$” therefore ensures that the filename only consists of the pattern we defined and there is nothing before “picture” and nothing after our “.jpg”.

Therefore, our final pattern is:

^picture( [0-9]*\.jpg)$

And the command to rename the files is, again:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

Example 4 – add a prefix to all filenames (added on 2012-05-20)

In case you want to add a prefix at the beginning of a filename, you can use this line:

rename ‘s/(.*)/PREFIX$1/’ FILES

Substitute PREFIX to whatever you want to put in front of the filename and substitute FILES for the files you want to rename (see Example 6 below for some examples)

If you run

rename ‘s/(.*)/foo_$1/’ *.txt

All the .txt files in the current directory will get an “foo_” in front of of their name. (So info.txt would be renamed to foo_info.txt, for example)

Example 5 – add a suffix to all filenames (added on 2012-05-20)

Adding a suffix at the end of a filename can be as simple as adding a prefix; you could simply run:

rename 's/(.*)/$1SUFFIX/' FILES

The problem is that this might not be what you expected, because the suffix will be added at the end of the filename, which also means after the suffix the file might already have to denote its type (e.g. “.txt”, “.tar”, “.jpg” etc. Running

rename 's/(.*)/$1boo/' info.tar

would rename the file “info.tar” to “info.tar.boo”. If that is what you want, you can use the line above, but if you would want to rename it to “infoboo.tar”, then you can use the following line:

rename 's/(.*)\.(.*)/$1SUFFIX.$2/' FILES

with this, running

rename 's/(.*)\.(.*)/$1boo.$2/' FILES

would rename “info.tar” to “infoboo.tar”.

Be aware that this will not work for files with suffixes that contain two dots (like “archive.tar.gz”).

Improvement 1 (Update 2012-05-22):

The fact that files like “archive.tar.gz” would be renamed as well and the result would certainly not be as hoped, we can try to improve the pattern above a little bit:

rename 's/^([^.]*)\.([^.]*)$/$1SUFFIX.$2/' FILES

This approach will only rename files that only contain a single dot and leave all other files alone.

Improvement 2 (Update 2012-05-22):

If you want to rename files with extensions like “.tar.gz” correctly, you can use the following approach:

rename 's/^([^.]*)\.(.*)$/$1SUFFIX.$2/' FILES

This will essentially add the suffix directly in front of the first dot. However, this approach will not work in case you have files that contain dots that are not supposed to be part of the file extension (in “some.great.file.txt”, the suffix “111″ would be added like this: “some111.great.file.txt”)

Example 6 – how to define which files to rename (added on 2012-05-20)

In the beginning I noted the general form of how to use rename:

rename 's/OLD/NEW/' FILES

I now want to give you some simple examples of what you can do with “FILES”, which tells rename which files it
should try to rename in the first place. This list is by no means complete. It just provides you with a few (hopefully useful) examples.

• to rename a single file just state its name. Example: backup.tar
• to rename several specific files just list all their names. Example: backup.tar mypicture.jpg asong.ogg
• to rename all files in the current directory just use “*” (without the “).
• to rename all files with a specific ending (e.g. .jpg) use “*ENDING”. Example: *.jpg
• to rename files with different endings, just list them all. Example: *.jpg *.jpeg *.mp3 *.txt *.ar
• to rename files that start with the same word/characters use “START*”. Example: my* old*
• to rename files that contain the same word/sequence of characters use “*WITHIN*”. Example: *good*
• you can combine all of those things. Example: my*.txt *boo*.jpg foo* test.tmp

Conclusion

I hope that this article succeeds in demonstrating how rename can be used to batch rename files (not in detail, but at least in pushing you in the right direction). And I also hope that while covering Perl expressions in detail is beyond the scope of this article, the second example gives you an idea of how powerful and useful they can be and why it can make sense to learn more about them.

Basic Usage

Creating directories in the current working directory

The most basic usage of mkdir is the following:

mkdir <name>

This will create a new directory with the given name in the current directory. Therefore, if your username is “me” and in the terminal you are using you are currently in your home folder (/home/me) then running the command

mkdir backup

will create a the directory /home/me/backup.

Creating directories using relative or absolute paths

You do not need to be in a directory do create a new directory in it. You can, for example, use relative or absolute  paths to create them.

Let’s assume you are in your home folder (/home/me) and you just created the folder backup (/home/me/backup). And now you want to create a folder named “old” in it. Then you can either call mkdir with a relative path:

mkdir backup/old

or with the absolute path:

mkdir /home/me/backup/old

Note, however, that if you would call

mkdir backup/old

and the directory “backup” would not exist already in the current folder, then you would get an error.  This is, because calling mkdir like this:

mkdir <path>/<name>

will create the directory <name> in the directory <path> only if <path> already exists. Otherwise, mkdir will quit with an error message. This is the default behavior of mkdir.

Options

There are a few options which can be quite useful when creating directories.

-p, –parents

Under “Basic Usage”, I mentioned that the path you want to create a new directory in, needs to exists or otherwise you will get an error. You can use the option “-p” or “–parents” to change that behavior. With this option, mkdir will create all the directories that don’t exists already, not just the last one. If you would call

mkdir -p backup/old

or

mkdir --parents backup/old

in your home directory and the directory “backup” would not exist already, then the -p options will tell mkdir to create this directory as well instead of quitting with an error message. This option is therefore very useful if you need to create a directory, but you are not sure if the directory you want to create it in already exists. Even if you know that this directory does not exist yet, you can use the -p option to reduce the number of necessary calls.

If you know that there currently is no backup (or are not sure) and you want to create the folder backup/old, then calling

mkdir backup/old

could result in an error if the directory “backup” would not exist. This is a problem especially in scripts. Without the -p option you would have to make two calls to mkdir; one to create the “backup” directory (to ensure it is there) and one to create the directory “old” itself:

mkdir backup
mkdir old

When creating deeper directory structures, more than two calls might be needed. Think about creating the folder “backup/server/2011/11/30″ in your home folder (/home/me). You would have to create every folder separately:

mkdir backup
mkdir backup/server
mkdir backup/server/2011
mkdir backup/server/2011/11
mkdir backup/server/2011/11/30

With the -p option you just need to call mkdir once:

mkdir -p backup/server/2011/11/30

and everything will be created for you.

It is also worth noting that using the “-p” option will prevent errors in case the directory already exists. Without the “-p” option, running

mkdir backup

would result in the following error message in case the directory backup already exists:

mkdir: cannot create directory `backup': File exists

However, running

mkdir -p backup

will prevent the error message from being printed. Running mkdir with the  “-p” can therefore be interpreted as “make sure the following directory exists”.

-v, –verbose

When using the “-v”/”–verbose” option, mkdir will ouput a message for the directory  it created.

Calling

mkdir backup

will therefore either output

mkdir: created directory `backup'

if the directory did not exist already or print the previously mentioned error message in case the directory was already there. When combining the “-v” option” with the “-p” option, mkdir will output a message for every directory it created.

Typing

mkdir -p -v backup/server/2011/11/30

or even shorter

mkdir -pv backup/server/2011/11/30

would create the following output if none of the directories would already exist:

mkdir: created directory `backup'
mkdir: created directory `backup/server'
mkdir: created directory `backup/server/2011'
mkdir: created directory `backup/server/2011/11'
mkdir: created directory `backup/server/2011/11/30'

If, for example, the directory “backup/server” already existed, then mkdir would only need to create the last three directories and therefore the output would be:

mkdir: created directory `backup/server/2011'
mkdir: created directory `backup/server/2011/11'
mkdir: created directory `backup/server/2011/11/30'

Using this option therefore provides feedback about which directories already existed and which had to be created. Because the “-p” option suppresses error messages about already existing directories, you won’t get error messages about the fact that “backup” and “backup/server” could not be created, because they were already there. The messages from mkdir about which directories have been created would therefore only implicitly tell you which directories existed beforehand.

-m, –mode=MODE

Using the “-m” option you can set the permission on the directory you want to create. If you want to create a directory which should be  fully accessible by everyone, you could type

mkdir -m 777 backup

or

mkdir -m a=rwx backup

It is important to note that when combining this option with the “-p” option, the mode only affects the last directory. Calling

mkdir -p -m 777 backup/server/2011/11/30

would therefore create all the directories necessary, but the permissions specified with the “-m” option will be only assigned to the directory “30″ and not to the other directories. Their permissions are instead determined by the current umask.

It is also worthy to note that the permissions of the directory “30″ would not be changed in case it already existed. This is especially important to point out, because the “-p” option will prevent all error messages about already existing directories. Therefore, running this command does not give you any feedback about the permissions the directory “30″ has after running the command. If it already existed, the permissions will be left untouched and if it didn’t exist, the permissions will be set as defined by the “-m” option.

Therefore, if you are not sure if the directory already existed, but want to make sure that the permissions are set correctly, you could either run the command with the -v option (which will then tell you if the directory “30″ was created) and then use chmod if necessary or – if you are writing a script – you should just run chmod afterwards instead of using the “-m” option:

mkdir -p backup/server/2011/11/30
chmod 777 backup/server/2011/11/30

One of the possibilities of taking screenshots in Linux is using

, a utility of the X Window System.

I just want to give a short overview on how to take interactive and non-interactive screenshots, view them and convert them to different formats.

Taking Screenshots

To take a screenshot you could just open a terminal and type ”

“, but by default

does not save the screenshot to a file (it outputs the image to stdout). To save the screenshot in a file, you can either use the

option of

:

xwd -out <filename>

or redirect the output of

to a file using the functionality offered by the shell:

xwd > <filename>

Just replace

with the name of the file you want to use for your screenshot. Examples:

xwd -out myshot.xwd

or

xwd > myshot.xwd

Notice the changed mouse pointer after typing one of these commands ? That’s because you now need to select the window of which you want to take a screenshot. The format

uses for the images it is called “X Window Dump” and the extension often used is

. I will cover the subject of converting the images to different formats (like JPEG or PNG) later.

Including the Window Frame

If you want to include the frame of the window in the screenshot, you have to add the

option. For example:

xwd -frame -out myshot.xwd

or

xwd -frame > myshot.xwd

Taking Screenshots Of The Whole Desktop

If you want to create a screenshot of the whole desktop instead of a single window, you can use the

option for that:

xwd -root -out myshot.xwd

or

xwd -root > myshot.xwd

Automated Screenshots Without Selecting The Window

It’s also possible to create screenshots of windows without the need to select them every time. This is especially useful if you want to make numerous screenshots of a single window (e.g. for a tutorial, a presentation, an article etc.).

To do this, you have to tell xwd which window you want to take a screenshot of on the command line, so that it does not have to ask. You can do this either by using the “resource id” of the window or the ”

property”. The value of the

property basically is the title of your window as it is displayed in the window title bar. Using this to create screenshots can be problematic (With Firefox, for example, this value depends on the title of the active tab, so going to a different tab will change the

property of the window).

To determine the resource id or the value of the

property, you can use the

tool. Just type this in the terminal:

xwininfo

And then, similar to

, click on the window you are interested in. It will then display a bunch of information about the window, which might look like this:

xwininfo: Window id: 0x40000e7 "Home of the Mozilla Project - Mozilla Firefox"

  Absolute upper-left X:  1287
  Absolute upper-left Y:  70
  Relative upper-left X:  0
  Relative upper-left Y:  0
  Width: 1159
  Height: 1501
  Depth: 24
  Visual: 0x21
  Visual Class: TrueColor
  Border width: 0
  Class: InputOutput
  Colormap: 0x20 (installed)
  Bit Gravity State: NorthWestGravity
  Window Gravity State: NorthWestGravity
  Backing Store State: NotUseful
  Save Under State: no
  Map State: IsViewable
  Override Redirect State: no
  Corners:  +1287+70  -114+70  -114-29  +1287-29
  -geometry 1159x1501+1279-21

The red and blue color was something I added for clarification. The red thing is the resource ID we are interested in and the blue thing is the

property that we also could use.

If we wanted to use the resource ID, we would do it like this

xwd -id  -out myshot.xwd

If we want to use the WM_NAME property, we would do this:

xwd -name  -out myshot.xwd

One important thing to note about this approach is that using the -frame option for xwd does not have any effect if you supply the id or name as well. That is, because the resource id for both cases is different. Therefore, if you want to include the window frame, you have to supply the

option to

to retrieve the correct resource id. You would then type:

xwininfo -frame

Just to show you that they really differ: In my case, right now, running

xwininfo

gives me:

xwininfo: Window id: 0x40000e7 "Home of the Mozilla Project - Mozilla Firefox"

while running

xwininfo -frame

and clicking on the same, unchanged window, gives me:

xwininfo: Window id: 0xe002df (has no name).

Viewing Screenshots

You can view the

-screenshots directly with the tool

. Just type:

xwud <filename>

for example:

xwud screenshot.xwd

Converting and Editing Screenshots

Converting Screenshots

You can easily convert the screenshots to “normal” image formats like JPEG or PNG with tools like ImageMagick. If you don’t have ImageMagick installed, it should be available through your repositories. For example, in Ubuntu/Debian you would simply type:

sudo aptitude install imagemagick

or

sudo apt-get install imagemagick

Once you have ImageMagick installed, you can convert an

image by using

. For example, to convert an

-screenshot named

to a JPEG file named

, type:

convert shot.xwd shot.jpg

You can convert the image to other formats as well, like PNG for example:

convert sot.xwd shot.png

Editing Screenshots

I won’t include a tutorial on editing screenshots here, but I just wanted to mention that you might not have to convert your screenshots to JPG or PNG (or something else) in order to edit them, because your image editor might already be able to load

files. GIMP, for example, can open them directly.