Week 5: Arrays, Functions and the "foreach" loop

Introduction to Lists

When you think of a list on the Web, you likely think of ordered and unordered lists implemented by the <OL></OL> and <UL></UL> HTML elements. Within both of these elements, the LI element produces a list item. This use of the word list is the common use of the word list in everyday conversation. For example: "Did you add carrots to the shopping list?". Very rarely does someone create an ordered shopping list that matters (perhaps ordered in terms of importance should money be short makes sense - or how about in order of how they are spatially encountered in the grocery store?).

Well, computer scientists have a very specific use of the word list in mind when they refer to a list as an organized container of information existing in computer memory or on a storage medium (your hard drive, for example). Let's use the shopping list as a container of information and look at how PHP creates, stores, and modifies a list for you to use in your Web pages. The biggest advantage of using a list is that it is dynamic. You can have four items on your shopping list one week and forty the next week and still use the same PHP code for both to present it on a Web page. When you delete an LI element from within an HTML list the Web browser automatically renumbers for you - but you have to get the LI content on the page by typing or copying and pasting text into each LI element. When w use PHP, we can connect to a database or a stream of data from any source and present the information in a list without re-typing it. A popular way to generate a list is by using an array of information in a program to build the list (see example 1 below). An array is a broad computing concept while a list is a more specific concept. I rarely use use this list() interface in PHP so I don't want you to spend too much time on it.

Lists are very popular for certain types of processing. There is a clever programming language called LISP that works very effectively with lists as the main container for all the variables being used in computation. But, we'll only need to use generic arrays for our work in this class. The list is more a presentation concept as you might expect since we are generating HTML with our PHP code. Take a look at these three examples, note that list() exists in the PHP language, but then move on to the array information following them quickly. Example 3 has useful context when you think of nested lists in HTML pages (OL elements inside of UL elements, for example).

List Examples

Example #3 Using nested list()

Arrays

Dynamic Arrays (using the array() function)

A dynamic array is one that changes in size depending how we use it after we have created it. A list is dynamic when we add a new item to it or delete an item from it. So, it makes sense to use a dynamic array for managing lists. Look back up at the list() discussion above. We use the array() function to populate our lists. The array() function can be used to generate dynamic arrays. You might be asking yourself why you wouldn't want to use dynamic arrays all the time? There is a lot to think about in that answer, but I'll provide two simplified reasons here: First, when you create a static array and let PHP know you won't be changing it (and therefore you can't thereafter), PHP can perform some optimization work in preparing for its use - knowing it will never have to re-calculate that optimization. Its use can then be faster for the long term. Second, when you use a dynamic array, PHP has to make new room on in computer memory or in storage memory in order to store the new data you put in the array. In many applications, it is best to know you are going to run out of memory up front before going through a lot of effort to run out of memory down the road. You set up the memory once at the beginning to stablize the system and then never have to worry or slow down the system to generate it after that point in time. In terms of Web pages, we rarely use so much information as to run out of computer memory (unless our computers are running all kinds of other applications at the same time) and so I use static arrays all the time even if I waste memory by not actually putting meaninful data in all of the array I have created. Computer scientists call these kinds of decisions size versus speed trade-offs. Enough said for our needs. Just note there are lots of things you can do with arrays once you've created them.

Let's look at some simple examples of using dynamic arrays. Before we start, let me say that a very good page on the Web to give you examples of all aspects of arrays is http://www.php.net/types.array. When you can understand all these examples, you'll be well on your way to being an arrays guru. You don't need to be a guru for this class though.

Array Examples - Dynamic

	<?php

		// create a basic dynamic array with four numbers as elements in the array
		$my_numbers = array(43, 32, 56, 12);

		// insert a new fourth item in the list
		array_splice($my_numbers, 3, 0, 17);

		// add a new item to the end of the list
		array_push($my_numbers, 29);

		var_dump($my_numbers);
		echo "<br/ ><br/ >";

		for ($i=0; $i<count($my_numbers); $i++) {
			echo $my_numbers[$i];
			echo "<br/ >";
		}

		// delete the last item from an array
		array_pop($my_numbers);

		echo "<br/ ><br/ >";
		foreach ($my_numbers as $element) {
			echo $element;
			echo "<br />";
		}
	?>

array(6) { [0]=> int(43) [1]=> int(32) [2]=> int(56) [3]=> int(17) [4]=> int(12) [5]=> int(29) }

43
32
56
17
12
29


43
32
56
17
12

Static Arrays with Numeric Indices and the Array Access Operator

Array Examples - Static

<?php

    // create a basic dynamic array with four numbers as elements in the array
    	
        $my_numbers[0] = 43;
        $my_numbers[1] = 32;
        $my_numbers[2] = 56;
        $my_numbers[3] = 12;
        $my_numbers[4] = -1;
        $my_numbers[5] = -1;
        $my_numbers[6] = -1;
        
        // insert a new fourth item in the list
        
        $my_numbers[4] = $my_numbers[3];
        $my_numbers[3] = 17;
        
        // add a new item to the end of the list
	    
        $my_numbers[5] = 29;
        
        // print out the state of the array
        
        echo "<br/ ><br/ >";

        for ($i=0; $i<count($my_numbers); $i++) {
            if($my_numbers[$i] > 0) {
                echo $my_numbers[$i];
                echo "<br/ >";
            }
        }
        
        // delete the last item from an array

        $my_numbers[5] = -1;

        echo "<br/ ><br/ >";
        foreach ($my_numbers as $element) {
            if($element > 0) {
                echo $element;
                echo "<br />";
            }
        }
 ?>

Associative Arrays

Arrays have long used integer indices for member access by convention (and to be more explicit in the data access mathematics). These indices often mean nothing to those who read your code except that there is some kind of order inherent in your data. Often, even that is misleading because there is no order intended - you just had to assign one arbitrarily because arrays required one. Dynamic arrays eliminate the index when manipulating the array, but can still use the index when trying to access an array member. When you see a line of code like:

$name[56] = "Davis, Renjay"

you don't know if the array was defined in a dynamic or static manner unless you refer to code elsewhere. It doesn't matter when you refer to a data location because it works the same way for read and write access once the location in memory has been assigned a name. You can eliminate the integer index though if you have a more useful system in place to manage the array memory. You can associate other labels to your array items. When you assign these labels instead of integers, you are by definition using an associative array. Associative arrays are very useful for data processing and since the Web is used so much as a data presentation medium, associative arrays are more common on the Web than in many other programming domains (contexts). Scientific processing, which uses a lot of matrices, vectors, and numeric arrays, typically avoids associative arrays because of other conventions that give added meaning to an array's whole number index.

Associative arrays work really well with data that naturally behaves well in a relational database like MySQL (the one we will use in class). Data in databases are held in tables of records (as we will see often in this class eventually). Records give a name to each item which is then referred to as an attribute of the record. An employee record typically has an ID, name, job_position, and salary associated with the record. The word 'associated' in that last sentence is exactly the passive use of the verb 'to associate' that is related to the adjective use of the word 'associative' when referring to an array.

You can create a single employee record as an associative array:

$employee['1217'] = array("Robert","Chen","Accounting",58234.50);

and then refer to the attributes of the record by referencing the associative array by record components offset index.

For example:

$employee['1217'][0] references employee 1217's first name attribute of "Robert"

You can then add another employee record using the first one as a template:

$employee['455'] = array("Lucy","Jones","Product Development",87106.00);

The associative key does not map to a specific integer offset so the order in which new employee records is created does not effect the organization of the array for access purposes. You use a key to create an array variable, you must use the key to get the values out of the array variable.

But, you can always iterate through all the arrays that have been produced with the same variable label through a foreach loop:

foreach ($employee as $empl) {
    echo $empl[1]."<br/>";
}

accesses all the employees names and prints them out to a Web page being processed by PHP.

So, the following PHP code segment:

<?php
	$name[56] = "Davis, Renjay";
	$employee['1217'] = array("Robert","Chen","Accounting",58234.50);
	echo $employee['1217'][0]."<br/><br/>";
	$employee['455'] = array("Lucy","Jones","Product Development",87106.00);
	foreach ($employee as $empl) {
    	    echo $empl[1]."<br/>";
	}
?>

Robert

Chen
Jones

Associative Arrays and the Arrow Operator

Variables in Array Accesses

<?php
$employee = array("ID"=>array("1217", "455"), "name"=>array("Bob Chen", "Lucy Jones"), "dept"=>array("Accounting", "Product Development"), "salary"=>array(58234.50, 87106.00));
$e_count = 0;

while ($employee['name'][$e_count] != "") {
    echo $employee['name'][$e_count]."<br/>";
    $e_count++;
}
?>

Arrays of arrays

The Foreach loop

<?php
$employee = array("ID"=>array("1217", "455"), "name"=>array("Bob Chen", "Lucy Jones"), "dept"=>array("Accounting", "Product Development"), "salary"=>array(58234.50, 87106.00));
foreach ($employee['name'] as $name) {
    echo $name."<br/>";
}
?>

Introduction to Pre-Defined Functions

• All functions have a proper name with strict syntactical rules provided by the language.
• All functions are called with the use of parentheses that are placed outside of any parameter list the function allows.
• All functions have a return value that is automatically passed back to the calling code for use in that code.
• All functions have a defined signature that defines proper use in terms of data types that can be passed to the function and returned from the function.
• Functions that allow more than one variable to be passed into the function have a parameter list with parameters separated by commas.

The count() and substr() functions

• Both count and substr are valid names for a function and so we call call them by their names when we wish to use them.
• Both count() and substr() are called with the use of parentheses to tell PHP we intend to use the function and not something else called count or substr.
• Both count() and substr() have return values: count() returns an integer that is a count of the number of items in an array and substr() returns a string which is a substring of the first parameter passed in.
• Both count() and substr() have defined signatures:
  • count() requires that we pass in an array and only assign an integer-capable variable to its return value.
  • substr() requres that we pass in a string and an integer start character position and only assign a string-capable variable to its return value - but, in substr's case, we can also pass in an optional third variable: an integer length of characters that we want returned in the substring. The more flexible the function, the more likely we will be able to pass in a variable list of parameters.
• count() only takes in one parameter while substr() takes two or three. When we use substr(), we must place a comma between each parameter in the parameter list.