# 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.

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.