<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>

<title>Using the bash shell</title>

<script type="text/javascript">

window.onload = function() {

var imgs = document.getElementsByTagName('img'), i, img;

for (i = 0; i < imgs.length; i++) {

img = imgs[i];

// center an image if it is the only element of its parent

if (img.parentElement.childElementCount === 1)

img.parentElement.style.textAlign = 'center';

}

<script type="text/javascript" src="https://cdn.bootcss.com/mathjax/2.7.0/MathJax.js?config=TeX-MML-AM_CHTML">

<style type="text/css">

body, td {

font-family: sans-serif;

background-color: white;

font-size: 13px;

}

body {

max-width: 800px;

margin: auto;

padding: 1em;

line-height: 20px;

}

tt, code, pre {

font-family: 'DejaVu Sans Mono', 'Droid Sans Mono', 'Lucida Console', Consolas, Monaco, monospace;

}

h1 {

font-size:2.2em;

}

h2 {

font-size:1.8em;

}

h3 {

font-size:1.4em;

}

h4 {

font-size:1.0em;

}

h5 {

font-size:0.9em;

}

h6 {

font-size:0.8em;

}

a:visited {

color: rgb(50%, 0%, 50%);

}

pre, img {

max-width: 100%;

}

pre {

overflow-x: auto;

}

pre code {

display: block; padding: 0.5em;

}

code {

font-size: 92%;

border: 1px solid #ccc;

}

code[class] {

background-color: #F8F8F8;

}

table, td, th {

border: none;

}

blockquote {

color:#666666;

margin:0;

padding-left: 1em;

border-left: 0.5em #EEE solid;

}

hr {

height: 0px;

border-bottom: none;

border-top-width: thin;

border-top-style: dotted;

border-top-color: #999999;

}

@media print {

* {

background: transparent !important;

color: black !important;

filter:none !important;

-ms-filter: none !important;

}

body {

font-size:12pt;

max-width:100%;

}

a, a:visited {

text-decoration: underline;

}

hr {

visibility: hidden;

page-break-before: always;

}

pre, blockquote {

padding-right: 1em;

page-break-inside: avoid;

}

tr, img {

page-break-inside: avoid;

}

img {

max-width: 100% !important;

}

@page :left {

margin: 15mm 20mm 15mm 10mm;

}

@page :right {

margin: 15mm 10mm 15mm 20mm;

}

p, h2, h3 {

orphans: 3; widows: 3;

}

h2, h3 {

page-break-after: avoid;

}

}

<h1>Using the bash shell</h1>

<p><strong>note</strong></p>

<p>Some of the material in this tutorial was adapted from Chris

Paciorek&#39;s <a href="https://github.com/berkeley-stat243/stat243-fall-2014/blob/master/units/unit2-bash.pdf">2014 Statistics 243 lecture notes on

Bash</a>

and his <a href="https://github.com/berkeley-stat243/stat243-fall-2014/blob/master/units/unit4-usingR.pdf">2014 Statistics 243 lecture notes on using

R</a>.</p>

<p>Before reading this, you will want to be familiar with the material in

the &ldquo;Basics of UNIX&rdquo; tutorial and screencast here:

<a href="http://statistics.berkeley.edu/computing/training/tutorials">http://statistics.berkeley.edu/computing/training/tutorials</a></p>

<h2>1) The Interactive Shell</h2>

<p>The shell is an interactive computer programming environment. More

specifically, it is a read-evaluate-print loop (REPL) environment. R and

Python also provide REPL environments. A REPL reads a single

<em>expression</em> or input, parses and <em>evaluates</em> it, <em>prints</em> the results,

and then <em>loops</em>.</p>

<p><strong>note</strong></p>

<p>I will use a <code>$</code> prompt for bash, a <code>&gt;</code> prompt for R, a <code>&gt;&gt;&gt;</code> for

Python, and a <code>In [1]:</code> prompt for IPython. By convention, a regular

user&#39;s prompt in bash is <code>$</code>, while the root (or administrative)

user&#39;s prompt is <code>#</code>. However, it is common practice to never log on

as the root user. If you need to run a command with root privileges,

you should use the <code>sudo</code> command (see the <em>Getting started</em> section

below for more details).</p>

<p>When you are working in a terminal window (i.e., a window with the

command line interface), you&#39;re interacting with a shell. There are

multiple shells (e.g., <em>sh</em>, <em>bash</em>, <em>csh</em>, <em>tcsh</em>, <em>zsh</em>, <em>fish</em>). I&#39;ll

assume you are using <em>bash</em>, as this is the default for Mac OS X, the

BCE VM, the SCF machines and most Linux distributions. However, the

basic ideas are applicable to any Unix shell.</p>

<p>The shell is an amazingly powerful programming environment. From it you

can interactively monitor and control almost any aspect of the OS and

more importantly you can automate it. As you will see, <strong>bash</strong> has a

very extensive set of capabilities intended to make both interactive as

well as automated control simple, effective, and customizable.</p>

<p><strong>note</strong></p>

<p>It can be difficult to distinguish what is shell-specific and what is

just part of UNIX. Some of the material here is not bash-specific but

general to UNIX.</p>

<p>Reference: Newham and Rosenblatt, Learning the bash Shell, 2nd ed.</p>

<h3>1.1) Getting started</h3>

<p>I assume you already have access to a basic bash shell on a computer

with network access. You should also have ssh installed. SSH provides an

encrypted mechanism to connect to a remote Unix terminal. To learn more

about using ssh to connect to the SCF machines and general tips about

using ssh on various operating systems, see:

<a href="http://statistics.berkeley.edu/computing/ssh">http://statistics.berkeley.edu/computing/ssh</a></p>

<p>To ssh to another machine, you need to know its (host)name. For example,

to ssh to <code>scf-ug01.berkeley.edu</code>, one of the SCF machines, you would:</p>

<pre><code>$ ssh scf-ug01.berkeley.edu

Password:

<p>At this point you have to type your password. Alternatively, you can set

up ssh so that you can use it without typing your password. To learn how

to set this up, see: <a href="http://statistics.berkeley.edu/computing/ssh-keys">http://statistics.berkeley.edu/computing/ssh-keys</a></p>

<p>If you have a different username on SCF machines, you will need to

specify it as well. For example, to specify the username <code>jarrod</code>, you

would:</p>

<pre><code>$ ssh jarrod@scf-ug01.berkeley.edu

<p>If you want to view graphical applications on your local computer that

are running on the remote computer you need to use the <code>-X</code> option:</p>

<pre><code>$ ssh -X jarrod@scf-ug01.berkeley.edu

<p>Alternatively, if you want to copy a file (<code>file1.txt</code>) from your local

computer to <code>scf-ug01.berkeley.edu</code>, you can use the <code>scp</code> command,

which securely copies files between machines:</p>

<pre><code>$ scp file1.txt jarrod@scf-ug01.berkeley.edu:.

<p>The above command will copy <code>file1.txt</code> from my current working

directory on my local machine to <code>jarrod</code>&#39;s home directory on

<code>scf-ug01.berkeley.edu</code>. The <code>.</code> following the <code>:</code> indicates that I want

to copy the file to my home directory on the remote machine. I could

also replace <code>.</code> with any relative path from my home directory on the

remote machine or I could use an absolute path.</p>

<p>To copy a file (<code>file2.txt</code>) from <code>scf-ug01.berkeley.edu</code> to my local

machine:</p>

<pre><code>$ scp jarrod@scf-ug01.berkeley.edu:file2.txt .

<p>I can even copy a file (<code>file3.txt</code>) owned by one user (<code>jarrod</code>) on one

remote machine <code>scf-ug01.berkeley.edu</code> to the account of another user

(<code>jmillman</code>) on another remote machine <code>scf-ug02.berkeley.edu</code>:</p>

<pre><code>$ scp jarrod@scf-ug01.berkeley.edu:file3.txt jmillman@scf-ug01.berkeley.edu:.

<p>If instead of copying a single file, I wanted to copy an entire

directory (<code>src</code>) from one machine to another, I would use the <code>-r</code>

option:</p>

<pre><code>$ scp -r src jmillman@scf-ug01.berkeley.edu:.

<p>Regardless of whether you are working on a local computer or a remote

one, it is occasionally useful to operate as a different user. For

instance, you may need root (or administrative) access to change file

permissions or install software. (Note this will only be possible

on machines that you own or have special privileges on; the BCE virtual

machine (bce.berkeley.edu) is one way to have a virtual Linux machine

for which you have root access.)</p>

<p>To upgrade all the software on your BCE machine:</p>

<pre><code>$ sudo apt-get upgrade

<p>To install the text editor vim on a BCE machine:</p>

<pre><code>$ sudo apt-get install vim

<p><strong>tip</strong></p>

<p>Most bash commands have electronic manual pages, which are accessible

directly from the commandline. You will be more efficient and

effective if you become accustomed to using these <code>man</code> pages. To view

the <code>man</code> page for the command <code>sudo</code>, for instance, you would type:</p>

<pre><code>$ man sudo

<h3>1.2) Variables</h3>

<p>Much of how bash behaves can be customized through the use of variables,

which consists of names that have values assigned to them. To access the

value currently assigned to a variable, you can prepend the name with

the dollar sign ($). To print the value you can use the <code>echo</code> command.</p>

<li><p>What is my default shell?</p>

<p><code>$ echo $SHELL</code></p></li>

<li><p>To change to bash on a one-time basis:</p>

<p><code>$ bash</code></p></li>

<li><p>To make it your default:</p>

<p><code>$ chsh /bin/bash</code></p></li>

<p>In the last example, <code>/bin/bash</code> should be whatever the path to the bash

shell is, which you can figure out using <code>which bash</code>.</p>

<p>To declare a variable, just assign a value to its reference. For

example, if you want to make a new variable with the name <code>counter</code> with

the value <code>1</code>:</p>

<pre><code>$ counter=1

<p>Since bash uses spaces to parse the expression you give it as input, it

is important to note the lack of spaces around the equal sign. Try

typing the command with and without spaces and note what happens.</p>

<p>You can also enclose the variable name in curly brackets, which comes in

handy when you&#39;re embedding a variable within a line of code to make

sure the shell knows where the variable name ends:</p>

<pre><code>$ base=/home/jarrod/

$ echo $basesrc

$ echo ${base}src

<p>Make sure you understand the difference in behavior in the last two

lines.</p>

<p>There are also special shell variables called environment variables that

help to control the shell&#39;s behavior. These are generally named in all

caps. Type <code>printenv</code> to see them. You can create your own environment

variable as follows:</p>

<pre><code>$ export base=/home/jarrod/

<p>The <code>export</code> command ensures that other shells created by the current

shell (for example, to run a program) will inherit the variable. Without

the export command, any shell variables that are set will only be

modified within the current shell. More generally, if you want a

variable to always be accessible, you should include the definition of

the variable with an <code>export</code> command in your <code>.bashrc</code> file.</p>

<p>You can control the appearance of the bash prompt using the <code>PS1</code>

variable:</p>

<pre><code>$ echo $PS1

<p>To modify it so that it puts the username, hostname, and current working

directory in the prompt:</p>

<pre><code>$ export PS1=&#39;[\u@\h \W]\$ &#39;

[user1@local1 ~]$

<h3>1.3) Commands</h3>

<p>While each command has its own syntax, there are some rules usually

followed. Generally, a command line consists of 4 things: a command,

command options, arguments, and line acceptance. Consider the following

example:</p>

<pre><code>$ ls -l file.txt

<p>In the above example, <code>ls</code> is the command, <code>-l</code> is a command option

specifying to use the long format, <code>file.txt</code> is the argument, and the

line acceptance is indicated by hitting the <code>Enter</code> key at the end of

the line.</p>

<p>After you type a command at the bash prompt and indicate line acceptance

with the <code>Enter</code> key, bash parses the command and then attempts to

execute the command. To determine what to do, bash first checks whether

the command is a shell function (we will discuss functions below). If

not, it checks to see whether it is a builtin. Finally, if the command

is not a shell function nor a builtin, bash uses the <code>PATH</code> variable.

The <code>PATH</code> variable is a list of directories:</p>

<pre><code>$ echo $PATH

/home/jarrod/usr/bin:/usr/local/bin:/bin:/usr/bin:

<p>For example, consider the following command:</p>

<pre><code>$ grep pdf file.txt

<p>We will discuss <code>grep</code> later. For now, let&#39;s ignore what <code>grep</code> actually

does and focus on what bash would do when you press enter after typing

the above command. First bash checks whether <code>grep</code> a shell function or

a builtin. Once it determines that <code>grep</code> is neither a shell function

nor a builtin, it will look for an executable file named <code>grep</code> first in

<code>/home/jarrod/usr/bin</code>, then in <code>/usr/local/bin</code>, and so on until it

finds a match or runs out of places to look. You can use <code>which</code> to find

out where bash would find it:</p>

<pre><code>$ which grep

/bin/grep

<p><strong>Exercise</strong></p>

<p>Consider the following examples using the <code>ls</code> command:</p>

<pre><code>$ ls --all -l

$ ls -a -l

$ ls -al

<p>Use <code>man ls</code> to see what the command options do. Is there any difference

in what the three versions of the command invocation above return as the

result? What happens if you add a filename to the end of the command?</p>

<h4>1.3.1) Tab completion</h4>

<p>When working in the shell, it is often unnecessary to type out an entire

command or file name, because of a feature known as tab completion. When

you are entering a command or filename in the shell, you can, at any

time, hit the tab key, and the shell will try to figure out how to

complete the name of the command or filename you are typing. If there is

only one command in the search path and you&#39;re using tab completion with

the first token of a line, then the shell will display its value and the

cursor will be one space past the completed name. If there are multiple

commands that match the partial name, the shell will display as much as

it can. In this case, hitting tab twice will display a list of choices,

and redisplay the partial command line for further editing. Similar

behavior with regard to filenames occurs when tab completion is used on

anything other than the first token of a command.</p>

<p><strong>note</strong></p>

<p>Note that R does tab completion for objects (including functions) and

filenames. While the default Python shell does not perform tab

completion, the IPython shell does.</p>

<h4>1.3.2) Command History and Editing</h4>

<p>By using the up and down arrows, you can scroll through commands that

you have entered previously. So if you want to rerun the same command,

or fix a typo in a command you entered, just scroll up to it and hit

enter to run it or edit the line and then hit enter.</p>

<p>To list the history of the commands you entered, use the <code>history</code>

command:</p>

<pre><code>$ history

1 echo $PS1

2 PS1=$

3 bash

4 export PS1=$

5 bash

6 echo $PATH

7 which echo

8 ls --all -l

9 ls -a -l

10 ls -al

11 ls -al manual.xml

<p>The behavior of the <code>history</code> command is controlled by a shell

variables:</p>

<pre><code>$ echo $HISTFILE

$ echo $HISTSIZE

<p>You can also rerun previous commands as follows:</p>

<pre><code>$ !-n

$ !gi

<p>The first example runs the nth previous command and the second one runs

the last command that started with &#39;gi&#39;.</p>

<p><strong>Table. Command History Expansion</strong></p>

<tr class="header">

<th align="left">Designator</th>

<th align="left">Description</th>

<tr class="odd">

<td align="left"><code>!!</code></td>

<td align="left">Last command</td>

<tr class="even">

<td align="left"><code>!n</code></td>

<td align="left">Command numbered <em>n</em> in the history</td>

<tr class="odd">

<td align="left"><code>!-n</code></td>

<td align="left">Command <em>n</em> previous</td>

<tr class="even">

<td align="left"><code>!string</code></td>

<td align="left">Last command starting with <em>string</em></td>

<tr class="odd">

<td align="left"><code>!?string</code></td>

<td align="left">Last command containing <em>string</em></td>

<tr class="even">

<td align="left"><code>^string1^string2</code></td>

<td align="left">Execute the previous command with <em>string2</em> substituted for <em>string1</em></td>

<p>If you&#39;re not sure what command you&#39;re going to recall, you can append

<code>:p</code> at the end of the text you type to do the recall, and the result

will be printed, but not executed. For example:</p>

<pre><code>$ !gi:p

<p>You can then use the up arrow key to bring back that statement for

editing or execution.</p>

<p>You can also search for commands by doing <code>Ctrl-r</code> and typing a string

of characters to search for in the search history. You can hit return to

submit, <code>Ctrl-c</code> to get out, or <code>ESC</code> to put the result on the regular

command line for editing.</p>

<h4>1.3.3) Command Substitution</h4>

<p>You may occasionally need to substitute the results of a command for use

by another command. For example, if you wanted to use the directory

listing returned by <code>ls</code> as the argument to another command, you would

type <code>$(ls)</code> in the location you want the result of <code>ls</code> to appear.</p>

<p>An older notation for command substitution is to use backticks (e.g.,

<code>`ls`</code> versus <code>$(ls)</code>). It is generally preferable to use the new

notation, since there are many annoyances with the backtick notation.

For example, backslashes (<code>\</code>) inside of backticks behave in a

non-intuitive way, nested quoting is more cumbersome inside backticks,

nested substitution is more difficult inside of backticks, and it is

easy to visually mistake backticks for a single quote.</p>

<p><strong>Exercise</strong></p>

<p>Try the following commands:</p>

<pre><code>$ ls -l tr

$ which tr

$ ls -l which tr

$ ls -l $(which tr)

<p>Make sure you understand why each command behaves as it does.</p>

<h3>1.4) Shortcuts</h3>

<h4>1.4.1) Aliases &ndash; command shortcuts</h4>

<p>Aliases allow you to use an abbreviation for a command, to create new

functionality or to insure that certain options are always used when you

call an existing command. For example, I&#39;m lazy and would rather type

<code>q</code> instead of <code>exit</code> to terminate a shell window. You could create the

alias as follow:</p>

<pre><code>$ alias q=exit

<p>As another example, suppose you find the <code>-F</code> option of <code>ls</code> (which

displays <code>/</code> after directories, <code>\</code> after executable files and <code>@</code> after

links) to be very useful. The command :</p>

<pre><code>$ alias ls=&quot;ls -F&quot;

<p>will insure that the <code>-F</code> option will be used whenever you use <code>ls</code>. If

you need to use the unaliased version of something for which you&#39;ve

created an alias, precede the name with a backslash (<code>\</code>). For example,

to use the normal version of <code>ls</code> after you&#39;ve created the alias

described above:</p>

<pre><code>$ \ls

<p>The real power of aliases is only achieved when they are automatically

set up whenever you log in to the computer or open a new shell window.

To achieve that goal with aliases (or any other bash shell commands),

simply insert the commands in the file <code>.bashrc</code> in your home directory.

For example, here is an excerpt from my <code>.bashrc</code>:</p>

<pre><code># .bashrc

# Source global definitions

if [ -f /etc/bashrc ]; then

. /etc/bashrc

fi

# User specific aliases and functions

pushdp () {

pushd &quot;$(python -c &quot;import os.path as _, ${1}; \

print _.dirname(_.realpath(${1}.__file__[:-1]))&quot;

)&quot;

}

export EDITOR=vim

source /usr/share/git-core/contrib/completion/git-prompt.sh

export PS1=&#39;[\u@\h \W$(__git_ps1 &quot; (%s)&quot;)]\$ &#39;

# history settings

export HISTCONTROL=ignoredups # no duplicate entries

shopt -s histappend # append, don&#39;t overwrite

# R settings

export R_LIBS=$HOME/usr/lib64/R/library

alias R=&quot;/usr/bin/R --quiet --no-save&quot;

# Set path

mybin=$HOME/usr/bin

export PATH=$mybin:$HOME/.local/bin:$HOME/usr/local/bin:$PATH:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/usr/local/lib

# Additional aliases

alias grep=&#39;grep --color=auto&#39;

alias hgrep=&#39;history | grep&#39;

alias l.=&#39;ls -d .* --color=auto&#39;

alias ll=&#39;ls -l --color=auto&#39;

alias ls=&#39;ls --color=auto&#39;

alias more=less

alias vi=vim

alias which=&#39;(alias; declare -f) | /usr/bin/which --tty-only \

--read-alias --read-functions --show-tilde --show-dot&#39;

<p><strong>Exercise</strong></p>

<p>Look over the content of the example <code>.bashrc</code> and make sure you

understand what each line does. For instance, use <code>man grep</code> to see what

the option <code>--color=auto</code> does. Use <code>man which</code> to figure out what the

various options passed to it do.</p>

<h4>1.4.2) Keyboard shortcuts</h4>

<p>Note that you can use emacs-like control sequences (<code>Ctrl-a</code>, <code>Ctrl-e</code>,

<code>Ctrl-k</code>) to navigate and delete characters.</p>

<p><strong>Table. Keyboard Shortcuts</strong></p>

<tr class="header">

<th align="left">Key Strokes</th>

<th align="left">Descriptions</th>

<tr class="odd">

<td align="left"><code>Ctrl-a</code></td>

<td align="left">Beginning of line</td>

<tr class="even">

<td align="left"><code>Ctrl-e</code></td>

<td align="left">End of file</td>

<tr class="odd">

<td align="left"><code>Ctrl-k</code></td>

<td align="left">Delete line from cursor forward</td>

<tr class="even">

<td align="left"><code>Ctrl-d</code></td>

<td align="left">EOF; exit</td>

<tr class="odd">

<td align="left"><code>Ctrl-c</code></td>

<td align="left">Interrupt current command</td>

<tr class="even">

<td align="left"><code>Ctrl-z</code></td>

<td align="left">Suspend current command</td>

<tr class="odd">

<td align="left"><code>Ctrl-l</code></td>

<td align="left">Clear screen</td>

<h2>2) Basic File Management</h2>

<p>In Unix, almost &ldquo;everything is a file.&rdquo; This means that a very wide

variety of input and output resources (e.g., documents, directories,

keyboards, harddrives, network devices) are streams of bytes available

through the filesystem interface. This means that the basic file

management tools are extremely powerful in Unix. Not only can you use

these tools to work with files, but you can also use them to monitor and

control many aspects of your computer.</p>

<h3>2.1) Files</h3>

<p>A file typically consist of these attributes:</p>

<li> Name.</li>

<li> Type.</li>

<li> Location.</li>

<li> Size.</li>

<li> Protection.</li>

<li> Time, date, and user identification.</li>

<p><img src="../figs/file.png" alt="Schematic of file attributes."/></p>

<p>Listing file attributes with <code>ls</code>:</p>

<pre><code>$ ls -l

<p>Getting more information with <code>stat</code>:</p>

<pre><code>$ stat manual.xml

<p>Finding out what type of file you have:</p>

<pre><code>$ file manual.xml

<p><strong>tip</strong></p>

<p>The <code>file</code> command relies on many sources</p>

<p>: of information to determine what a file contains. The easiest part

to explain is <em>magic</em>. Specifically, the <code>file</code> command examines

the content of the file and compares it with information found in

the <code>/usr/share/magic/</code> directory.</p>

<p>Changing file attributes with <code>chmod</code>:</p>

<pre><code>$ chmod g+w manual.xml

<p>For more detailed information, please see the &ldquo;Basics of UNIX&rdquo; tutorial

and screencast here:

<a href="http://statistics.berkeley.edu/computing/training/tutorials">http://statistics.berkeley.edu/computing/training/tutorials</a></p>

<h3>2.2) Navigation</h3>

<p>Efficient navigation of the filesystem from the shell is an essential

aspect of mastering Unix. Use <code>pwd</code> to list your current working

directory. If you just enter <code>cd</code> at a prompt, your current working

directory will change to your home directory. You can also refer to your

home directory using the tilde <code>~</code>. For example, if you wanted to change

your current directory to the subdirectory <code>src</code> in your home directory

from any other current directory, you could type:</p>

<pre><code>$ cd ~/src

<p>Also if you want to return to the previous directory, you could type:</p>

<pre><code>$ cd -

<p>You can use the pushd, popd, and dirs commands if you would like to keep

a stack of previous working directories rather than just the last one.</p>

<h3>2.3) Filename Globbing</h3>

<p>Shell file globbing will expand certain special characters (called

wildcards) to match patterns of filenames, before passing those

filenames on to a program. Note that the programs themselves don&#39;t know

anything about wildcards; it is the shell that does the expansion, so

that programs don&#39;t see the wildcards. The following table shows some of

the special characters that the shell uses for expansion.</p>

<p><strong>Table. Filename wildcards</strong></p>

<tr class="header">

<th align="left">Wildcard</th>

<th align="left">Function</th>

<tr class="odd">

<td align="left"><code>*</code></td>

<td align="left">Match zero or more characters.</td>

<tr class="even">

<td align="left"><code>?</code></td>

<td align="left">Match exactly one character.</td>

<tr class="odd">

<td align="left"><code>[characters]</code></td>

<td align="left">Match any single character from among <em>characters</em> listed between brackets.</td>

<tr class="odd">

<td align="left"><code>[!characters]</code></td>

<td align="left">Match any single character other than <em>characters</em> listed between brackets.</td>

<tr class="odd">

<td align="left"><code>[a-z]</code></td>

<td align="left">Match any single character from among the range of characters listed between brackets.</td>

<tr class="odd">

<td align="left"><code>[!a-z]</code></td>

<td align="left">Match any single character from among the characters not in the range listed between brackets</td>

<tr class="odd">

<td align="left"><code>{frag1,frag2,...}</code></td>

<td align="left">Brace expansion: create strings frag1, frag2, etc.</td>

<p>List all files ending with a digit:</p>

<pre><code>$ ls *[0-9]

<p>Make a copy of <code>filename</code> as <code>filename.old</code>:</p>

<pre><code>$ cp filename{,.old}

<p>Remove all files beginning with <em>a</em> or <em>z</em>:</p>

<pre><code>$ rm [az]*

<p>List all the R code files with a variety of suffixes:</p>

<pre><code>$ ls *.{r,q,R}

<p>The <code>echo</code> command can be used to verify that a wildcard expansion will

do what you think it will:</p>

<pre><code>$ echo cp filename{,.old}

cp filename filename.old

<p>If you want to suppress the special meaning of a wildcard in a shell

command, precede it with a backslash (<code>\</code>). Note that this is a general

rule of thumb in many similar situations when a character has a special

meaning but you just want to treat it as a character.</p>

<p>To read more about standard globbing patterns, see the man page:</p>

<pre><code>$ man 7 glob

<p><strong>Exercise</strong></p>

<p>Brace expansion is quite useful and more flexible than I&#39;ve indicated.

Above we saw how to use brace expansion using a comma comma separated

list of items inside the curly braces (e.g., <code>{r,q,R}</code>), but they can

also be used with a sequence specification. A sequence is indicated with

a start and end item separated by two periods (<code>..</code>). Try typing the

following examples at the command line and try to figure out how they

work:</p>

<pre><code>$ echo {1..15}

$ echo {a{1..3},b{1..5},c{c..e}}

$ echo {{d..a},{a..d}}

$ echo {{d..b},a,{b..d}}

$ echo {1..5..2}

$ echo {z..a..-2}

<h3>2.4) Quoting</h3>

<p>Finally, a note about using single vs. double quotes in shell code. In

general, variables inside double quotes will be evaluated, but variables

not inside double quotes will not be:</p>

<pre><code>$ echo &quot;$HOME&quot;

/home/jarrod

$ echo &#39;$HOME&#39;

$HOME

<p><strong>Table. Quotes</strong></p>

<tr class="header">

<th align="left">Types of Quoting</th>

<th align="left">Description</th>

<tr class="odd">

<td align="left"><code>' '</code></td>

<td align="left">hard quote - no substitution allowed</td>

<tr class="even">

<td align="left"><code>&quot; &quot;</code></td>

<td align="left">soft quote - allow substitution</td>

<p>This can be useful, for example, when you have a directory with a space

in its name (of course, it is better to avoid spaces in file and

directory names). Since bash uses spaces to parse the elements of the

command line, you might try escaping the spaces with a backslash:</p>

<pre><code>$ ls $HOME/with\ space

file1.txt

<p>However that can be a pain and may not work in all circumstances. A cleaner

approach is to use soft (or double) quotes:</p>

<pre><code>$ ls &quot;$HOME/with space&quot;

file1.txt

<p>If you used hard quotes, you will get this error:</p>

<pre><code>$ ls &#39;$HOME/with space&#39;

ls: cannot access $HOME/with space: No such file or directory

<p>What if you have double quotes in your file or directory name (again, it

is better to avoid using double quotes in file and directory names)? In

this case, you will need to escape the quote:</p>

<pre><code>$ ls &quot;$HOME/\&quot;with\&quot;quote&quot;

<p>So we&#39;ll generally use double quotes. We can always work with a literal

double quote by escaping it as seen above.</p>

<h3>2.5) Basic utilities</h3>

<p>Since files are such an essential aspect of Unix and working from the

shell is the primary way to work with Unix, there are a large number of

useful commands and tools to view and manipulate files.</p>

<li> cat &ndash; concatenate files and print on the standard output</li>

<li> cp &ndash; copy files and directories</li>

<li> cut &ndash;_remove sections from each line of files</li>

<li> diff&ndash; find differences between two files</li>

<li> grep &ndash; print lines matching a pattern</li>

<li> head &ndash; output the first part of files</li>

<li> find &ndash;  search for files in a directory hierarchy</li>

<li> less &ndash; opposite of more (and better than more)</li>

<li> more &ndash; file perusal filter for crt viewing</li>

<li> mv &ndash; move (rename) files</li>

<li> nl &ndash; number lines of files</li>

<li> paste &ndash; merge lines of files</li>

<li> rm &ndash; remove files or directories</li>