13-B.5: Strings / Arrays / Functions

Linux String Literals

A lot of keys have special meanings in some context or other. Quoting is used to remove the special meaning of characters or words. Quotes can disable special treatment for special characters, they can prevent reserved words from being recognized as such and they can disable parameter expansion.

Escape Characters

Escape characters are used to remove the special meaning from a single character. A non-quoted backslash, \, is used as an escape character in Bash. It preserves the literal value of the next character that follows, with the exception of newline. If a newline character appears immediately after the backslash, it marks the continuation of a line when it is longer than the width of the terminal; the backslash is removed from the input stream and effectively ignored.

pbmac@pbmac-server $ date=20021226
pbmac@pbmac-server $ echo $date
20021226
pbmac@pbmac-server $ echo \$date
$date

In this example, the variable date is created and set to hold a value. The first echo displays the value of the variable, but for the second, the dollar sign is escaped.

Single Quotes

Single quotes ('') are used to preserve the literal value of each character enclosed within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash.

We continue with the previous example:

pbmac@pbmac-server $ echo '$date'
$date

Double Quotes

Using double quotes the literal value of all characters enclosed is preserved, except for the dollar sign, the backticks (backward single quotes, ``) and the backslash.

The dollar sign and the backticks retain their special meaning within the double quotes.

The backslash retains its meaning only when followed by dollar, backtick, double quote, backslash or newline. Within double quotes, the backslashes are removed from the input stream when followed by one of these characters. Backslashes preceding characters that don't have a special meaning are left unmodified for processing by the shell interpreter.

A double quote may be quoted within double quotes by preceding it with a backslash.

pbmac@pbmac-server $ echo "$date"
20021226

Notice the back quote (its the key to the left of the number 1 key) - this runs the command - so the command date is run and its
displayed
pbmac@pbmac-server $ echo "`date`"
Sun Apr 20 11:22:06 CEST 2003

pbmac@pbmac-server $ echo "I'd say: \"Go for it!\""
I'd say: "Go for it!"

pbmac@pbmac-server $ echo "\"
More input>"

pbmac@pbmac-server $ echo "\\"
\

Linux Shell Arrays

An array is a variable containing multiple values. Any variable may be used as an array. There is no maximum limit to the size of an array, nor any requirement that member variables be indexed or assigned contiguously. Arrays are zero-based: the first element is indexed with the number 0.

Indirect declaration is done using the following syntax to declare a variable:

ARRAY[INDEXNR]=value

The INDEXNR is treated as an arithmetic expression that must evaluate to a positive number.

Explicit declaration of an array is done using the declare built-in:

declare -a ARRAYNAME

A declaration with an index number will also be accepted, but the index number will be ignored. Attributes to the array may be specified using the declare and readonly built-ins. Attributes apply to all variables in the array; you can't have mixed arrays.

Array variables may also be created using compound assignments in this format:

ARRAY=(value1 value2 ... valueN)

Each value is then in the form of [indexnumber]=string. The index number is optional. If it is supplied, that index is assigned to it; otherwise the index of the element assigned is the number of the last index that was assigned, plus one. This format is accepted by declare as well. If no index numbers are supplied, indexing starts at zero.

Adding missing or extra members in an array is done using the syntax:

ARRAYNAME[indexnumber]=value

Remember that the read built-in provides the -a option, which allows for reading and assigning values for member variables of an array.

Dereferencing the Variables in an Array

In order to refer to the content of an item in an array, use curly braces. This is necessary, as you can see from the following example, to bypass the shell interpretation of expansion operators. If the index number is @ or *, all members of an array are referenced.

Declare an array with 3 elements
pbmac@pbmac-server $ ARRAY=(one two three)

NOTICE - the curly brackets around the array name
pbmac@pbmac-server $ echo ${ARRAY[*]}
one two three

The brackets are not present - this changes how the shell interprets the value
pbmac@pbmac-server $ echo $ARRAY[*]
one[*]

both the brackets and the index are supplied.
pbmac@pbmac-server $ echo ${ARRAY[2]}
three

add one more value, then print out the entire array
pbmac@pbmac-server $ ARRAY[3]=four
pbmac@pbmac-server $ echo ${ARRAY[*]}
one two three four

Linux Shell Functions

As in almost any programming language, you can use functions to group pieces of code in a more logical way or practice the divine art of recursion.

Declaring a function is just a matter of writing function my_func { my_code }.

Calling a function is just like calling another program, you just write its name.

Example - call this script hello.sh:

#!/bin/bash 
function quit {
     exit
}
function hello {
     echo Hello!
}

# The next line calls the hello function
hello
# The next line calls the quit function
quit
# The next line simply echos foo
echo foo 
          

Notice that functions don't need to be declared in any specific order.

Lines 2-4 contain the 'quit' function. Lines 5-7 contain the 'hello' function. If you are not absolutely sure about what this script does, please try it!

When running the script you'll notice that first, the function 'hello' is called, second the 'quit' function, and the program never reaches line 10.

Functions with Parameters Sample

#!/bin/bash 

function quit {
      exit
}  

function e {
   echo $1 
}  

e Hello
e World
quit

This script is almost identical to the previous one. The main difference is the function 'e.' This function prints the first argument it receives. Arguments within functions are treated in the same manner as arguments given to the script.

Script Comments

Using comments in a script will make the script more understandable. Comments are like inline documentation for the script. Anyone reading the script can easily understand each step if it has comments included. Comments will be ignored when the script executes. A single line can be commented very easily by inserting a hash tag - # - in the line. Anything after the hash tag until the end of the line is a comment. It is also possible to have comments across multiple lines.

Using an earlier script example, we can show single line comments:

#!/bin/bash

# Set the Dir variable to some directory
Dir=~/testdir

# Test to see if the mkdir command completes successfully
# IF it succeeds - then does the cd command complete successfully
if [ "mkdir $Dir" ] && [ "cd $Dir" ]
then
   echo "$Dir was not created." # We print a failure message
fi

To create a multi-line comment the syntax is a bit odd, but it works just as well:

#!/bin/bash

# Set the Dir variable to some directory
Dir=~/testdir

<<MYCOMMENT-1
Test to see if the mkdir command completes successfully
IF it succeeds - then does the cd command complete successfully
MYCOMMENT-1
if [ "mkdir $Dir" ] && [ "cd $Dir" ]
then
   echo "$Dir was not created." # We print a failure message
fi

The multi-line comment MUST begin with <<, followed by some sequence of characters.There is NOTHING special about the MYCOMMENT-1 - you can use any sequence of characters as a delimiter, it just has to be the same at the beginning and the end.

Adapted from:
"3.3. Quoting characters" by Multiple Contributors, The Linux Documentation Project is licensed under CC BY-SA 3.0
"10.2. Array variables" by Multiple Contributors, The Linux Documentation Project is licensed under CC BY-SA 3.0