Handout 2

Overview

Questions from last time
Programming logic
Variables: simple and array
Control structures

Programming logic

Interacting with the computer
Logic in general
"Procedural logic"

Variables

There are basically two kinds of data that we might want to manipulate: strings and numbers. (Strings go in quotes; numbers don't.) Variables can be used to store either type.
Basic variables in perl are marked with a leading dollar sign: $, e.g. $a, $myvar, or $aReallyLongVariableName.
Contents can be assigned to any kind of variable with the assignment operator: =.
```
		$myvar = 3;
		print($myvar);
```
This does the same thing as the following code snippet:
```
		print(3);
```
We'll see below that while they seem redundant at the moment, there are good reasons to have variables.
Perl also provides for "arrays", sets of related variables. Array set names are preceded by a leading @, e.g. @a, @myarray, @sillylongarrayname.
Individual array variables are referred to with a leading $ and a following index in square brackets, e.g. $a[3], $myarray[0], $sillylongarrayname[3005].
Array contents can be assigned to and referred to in the same way as simple variables.
```
		$myvar[0] = "hat";
		$myvar[1] = 47;
		print($myvar[1]);
		print($myvar[0]);
```

Control structures

A perl program is a sequence of statements, each terminated with a semicolon. Control structures allow you to group those statements together and control which ones get executed when. We will cover the four most useful control structures: if, while, for, and foreach.
if. The if structure allows you to apply some set of statements only if some condition is true. It has the following form:
```
		if ( if-test ) {
			list of statements
		}
```
The if-test is a statement that is either true or false; The curly brackets can contain any number of statements to execute (example).
while. The while-structure allows you to loop some number of times while some statement is true. It has the following form:
```
		while (while-test) {
			list of statements
			exit condition!
		}
```
As long as the while-test is true, the list of statements will keep executing. It is therefore essential that you provide some mechanism for the while to eventually be false (example). If you don't, it will loop forever (example).
for. The numerical incrementing we did with the while structure is quite typical. There is thus a special structure just for that sort of counting: for. It does much the same thing as we just did, except that all three parts are given at the top of the loop: the initial assignment to the variable, what the test is, and how the variable is incremented or decremented before each loop. Here's how it looks:
```
		for (assignment; test; increment/decrement) {
			list of statements
		}
```
This works just the same way, but it makes it easier to remember to do all three things (example).