Dave’s Ramblings

Substring (substr)

The substring function is a way to get a portion of a string value, rather than using the entire value. The value can then be used in a loop or a conditional statement, or just for its own purposes. For this one, you will probably want the general form of the function first. The function is usually set to a variable so that the variable contains the value of the substring:

$portion = substr($string_variable, start number, length);

Your $string_variable will be the variable from which you wish to create the substring. The start number is the character within the string from which you want to start your substring. Remember, though- the first number in a string here is zero rather than 1, so be careful when you make the count. The length above is the amount of characters you wish to take out of the string.

So, if we had a variable named $toy with a value of "baseball", but we wanted to get the last four characters rather than the full string, we would write something like this:

Yes, the substring turns out to be "ball". It starts at the fith character (which is 4 since the string starts with zero), and uses the next 4 characters. This function can be quite handy when you are trying to get part of a string later.

Length

The length function simply gives you back the number of characters in a string variable. This is handy when you don't know the value of the variable but would like to know the number of characters it has. It is useful with arrays, conditional statements, loops, and such things.

So, if you had a variable named $gold and its value was the string "precious", you could get the length of the string "precious" with the length function:

Since the string "precious" has 8 characters, $length_gold variable will be 8.

Chop & Chomp

The chop function is used to "chop off" the last character of a string variable. It will remove that last character no matter what it is, so it should be used with caution. For example:

me
myself
you

If you had read the "me" line in and assigned it to a variable, say $who_am _I, the value you have for it should be:

me\n

Remembering /n is the same as a carriage return.

The chop command would look like this (assuming we assigned "me\n" to a variable named $who_am_I):

Using the chop function in this case will remove the \n character. However, suppose we use it on the last of the three:

me
myself
you

The "you" is the last piece of text in the file, and could be missing the newline \n character if it was, for instance, typed into the file manually and the "Enter" key was not pressed afterward. If the chop command is used in such a case, it will remove the "u", which was not intended! So code such as:

This would result in the viewer seeing "You are yo!" rather than the expected result.

Now we look at the chomp function.

The chomp function will remove the last character of a string, but only if that character is an input record separator (the current value of $/ in Perl), which defaults to the newline (\n) character. This is often used to remove the \n character when reading from a file. The chomp function is much safer than the chop function for this, as it will not remove the last character if it is not \n.

Now if we run the chomp command on that last line instead, it won't remove the "u".

Now the viewer will see "You are you!" even if there was no \n character at the end of the "you" line.

Simple enough, each having their own purpose in a given circumstance. Chomp being more common as it's less likely to chop off bits you wanted.

Changing & Adding Elements
To change an array element, you can just access it with its list number and assign it a new value:

This changes the value of the element with the list number two (remember, arrays start counting at zero- so the element with the list number two is actually the third element). So, we changed "Opera" to "Mosaic", thus the array now contains "NS", "IE", and "Mosaic".

Now, suppose we want to add a new element to the array. We can add a new element in the last position by just assigning the next position a value. If it doesn't exist, it is added on to the end:

Now, we've added an element, "NS", "IE", "Opera", and "Mosaic".

Splice Function

Using the splice function, you can delete or replace elements within the array. For instance, if you simply want to delete an element, you could write:

You'll see three arguments inside the () of the splice function above. The first one is just the name of the array you want to splice. The second is the list number of the element where you wish to start the splice (starts counting at zero). The third is the number of elements you wish to splice. In this case, we just want to splice one element so we have 1. The code above deletes the element at list number 1, which is "IE" (NS is zero, IE is 1, Opera is 2). So now the array has only "NS" and "Opera", just two elements.

If you want to delete more than one element, change that third number to the number of elements you wish to delete. Let's say we want to get rid of both "NS" and "IE". We could write:

Now, it starts splicing at list number zero, and continues until it splices two elements in a row. Now all that will be left in the array is "Opera".

You can also use splice to replace elements. You just need to list your replacement elements after your other three arguments within the splice function. So, if we wanted to replace "IE" and "Opera" with "NeoPlanet" and "Mosaic", we would write it this way:

Now the array contains the elements "NS", "NeoPlanet", and "Mosaic". As you can see, the splice function can come in handy if you need to make large deletions or replacements.

Unshift/Shift
If you want to simply add or delete an element from the left side of an array (element zero), you can use the unshift and shift functions. To add an element to the left side, you would use the unshift function and write something like this:

As you can see, the first argument tells you which array to operate on, and the second lets you specify an element to be added to the array. So, "Mosaic" takes over position zero and the array now has the four elements "Mosaic", "NS", "IE", and "Opera".

To delete an element from the left side, you would use the shift function. All you have to do here is give the array name as an argument, and the element on the left side is deleted:

Now, the array has only two elements: "IE" and "Opera".

You can keep the value you deleted from the array by assigning the shift function to a variable:

Now the array has only "IE" and "Opera", but you have the variable $old_first_element with the value of "NS" so you can make use of it after taking it from the array.

Push/Pop

These two functions are just like unshift and shift, except they add or delete from the right side of an array (the last position). So, if you want to add an element to the end of an array, you would use the push function:

Now, you have an array with "NS", "IE", "Opera", and Mosaic".

To delete from the right side, you would use the pop function:

Now the array has only "NS" and "IE", but you have the variable $last_element with the value of "Opera" so you can make use of it after taking it from the array.

Chop

If you want to take the last character of each element in an array and "chop it off", or delete it, you can use the chop function. This comes in handy later when we are reading from a file, where we would need to chop the new line (\n) character from each line in a file. For now, let's just see how to use it. You would just write something like this:

This code would take the numbers off the end of each element, so we would be left with "NS", "IE" and "Opera".

Sort

If you want to sort the elements of an array, this can come in handy. You can sort in ascending or descending order with numbers or strings. Numbers will go by the size of the number, strings will go in alphabetical order.

The sub from above is a subroutine, much like what is called a "function" in other languages. We will explain that in more detail later. As you can see, the code above would sort in ascending order, so it would sort our array in alphabetical order. So, we have: "IE", "NS", and "Opera" as the new order. If you want it in reverse alphabetical order, you would use $b < => $a in place of the $a < => $b above. You could change the name of the subroutine to whatever you wish, just be sure you call the subroutine with the same name. This will make a bit more sense after we get to the section on subroutines and reading from files.

Reverse

You can reverse the order of the array elements with the reverse function. You would just write:

Now, the order changes to "Opera", "IE", and "NS".

Join

You can create a flat file database from your array with the join function. Again, this is more useful if you are reading and writing form files. For now, what you will want to know is that it allows you to use a delimiter (a character of your choice) to separate array elements. The function creates a variable for each element, joined by your delimiter. So, if you want to place a : between each element, you would write:

This would create something like this:

NS:IE:Opera

Split
The split function is very handy when dealing with strings. It allows you to create an array of elements by splitting a string every time a certain delimiter (a character of your choice) shows up within the string. Suppose we had the string:

NS:IE:Opera

Using the split function, we could create an array with the elements "NS", "IE", and "Opera" by splitting the string on the colon delimiter (:). We could write:

Notice in the split function that you place your delimiter between two forward slashes. You then place the string you want to split as the second argument, in this case the string was the value of the $browser_list variable. Setting it equal to @browser creates the @browser array from the split.

Define an Array

An array is defined in perl as;

@arrayname = ("element1", "element2");

The array name begins with an "@" symbol. This is how Perl know it is an array and not something else. You can have as many elements as you need, I just listed two above to keep from running on. The elements can be numbers or strings depending on what you need. If you use plain numbers, the string quotes wouldn't be needed here, for example:

This would define an array named @one_two_three with three elements: the numbers 1, 2, and 3. Since the elements are only numbers, they need no quotes around them. On the other hand, if you wanted an array of string values, you'll need the quotes so the interpreter sees the elements as strings:

This time we have an array named @browser with three string elements: NS, IE and Opera. The question now is how do we make use of these elements later?

How to Access Array Elements

Suppose we wanted to grab the element "IE" out of the browser array above. You'll notice "IE" is the second element in the array, but look at the code we will use to get it carefully:

You'll see that we get the element by using a regular variable (the $ sign) with the same name as the array (browser). Then we use brackets with a number to get to a certain element within the array. Each array is ordered, but not starting at the number one like we would like. Arrays instead begin ordering at the number zero! So, the first element of an array is always accessed using:

So, this is why we used $browser[1] to get "IE" above. It is the second element, but its list number is 1. So, be sure to remember this when working with arrays. They start the number list at zero, so be careful when you try to get an element or you might have a hard time figuring out where things went wrong in your script (believe me, I have done this a few times).

In a similar way, we can get the other elements for the array and use them. Let's say we wanted to write a little sentence about the browsers. We could use the array elements as part of the sentence:

Yes, a pretty simple sentence indeed- but here is the result:

I like to use NS, IE, and sometimes Opera.

Not much more useful to us than 3 variables. But if you use a loop, an array can be very useful either to save typing or to manipulate a set of similar values.

Arrays and Loops

This is where an array can be more powerful, if you want to print the three browser names you could now use a loop rather than a separate print line with variable names. This is really handy if the list is a long one, but to keep things short we'll stick to our three element browser array. The following could be used to print the three browser names, one per line:

Notice how we used the foreach loop we looked at in the last section. As you can see, it is very handy with arrays. It loops through enough times to grab each element in @browser and print it. Also, using the foreach loop, we didn't have to add the brackets to access the array element. You'll notice we just used $browser inside the loop. This is because the foreach loop knows which elements to grab- all of them. So it gives back the next element in order each time.