CLIL-6-PHP-6. Arrays - part 1. So far we've looked at the basic variables types such as strings and integers, as

Transcription

1 Arrays - part 1 Introduction So far we've looked at the basic variables types such as strings and integers, as well as a variety of functions you can use to manipulate these data types. Beyond the basic data types are arrays and objects, which take a little bit more work in order for you to take advantage of them properly. More importantly, arrays take a solid understanding of functions before you try to use them, which is why they are separated here! As mentioned, objects are covered exclusively in their own chapter - this chapter is dedicated to the topic of arrays. In order to model our surroundings in a programming environment accurately, it is important to recognise that some types of data naturally group together - colours, for example, naturally clump together into one group. Rather than having hundreds of separate variables - one for each colour - the reality is that it makes more sense to have one variable that holds a list, or array of colours. Topics covered in this chapter are: Reading arrays Manipulating arrays Multidimensional arrays (arrays of arrays) Saving arrays 1

2 First steps array array ( [mixed...]) int count ( mixed var [, int mode]) bool print_r ( mixed expression [, bool return]) void var_dump ( mixed expression [, mixed expression [, mixed...]]) mixed var_export ( mixed expression [, bool return]) PHP has built-in support for arrays of data, and there are two ways you can create an array: using the array function, or using a special operator, [ ]. Before we look at how arrays work, there are two key things you need to understand before you continue: An array is a normal PHP variable like any others, but it works like a container - you can put other variables inside it Each variable inside an array is called an element. Each element has a key and a value, which can be any other variable. Now, consider this PHP code: $myarray = array("apples", "Oranges", "Pears"); $size = count($myarray); print_r($myarray); On line one we see the most basic way to create an array, the array() function. The array() function takes a minimum of one parameter (and a maximum of as many as you want), and returns an array containing those variables. That's right - $myarray now contains all three variables. Line two contains a new function, count(), that returns the number of elements consisting in the array passed to it 2

3 as its only parameter - in the example we pass in my $myarray, then store the number of elements (three) in $size. Note: The array() function actually allows you to have a trailing comma after the last element, eg: array("apples", "Oranges", "Pears",). This is rarely used in hand-written code, but it can make generating code much easier. Line three contains another new function, print_r(). This takes just one parameter, but it outputs detailed information about a variable, such as it is type, length, and contents. In the case of arrays, print_r() iteratively outputs all elements inside the array - it is a good way to see how arrays work. Here is the output of print_r() from the above code: Array ( [0] => Apples [1] => Oranges [2] => Pears ) As you can see, there are our three variables - Apples is at index 0 in the array (signified by "[0]=>"), Oranges is at index 1 in the array, and Pears is at index 2 in the array. Note that if you are running your scripts through a web browser as opposed to from the command-line, you may find it help to put a HTML <pre> tag before your print_r() calls, as this will format them for easier reading. Using the proper array terminology defined earlier, the 0, 1, and 2 indices are the keys of each element, the "Apples", "Oranges", and "Pears" are the values of each 3

4 element, and the key and the value considered together are the elements themselves. Note that you can provide a second parameter to print_r(), which, if set to true, will make print_r() pass its output back as its return value, and not print anything out. To achieve the same output using this method, we would need to alter the script to this: $myarray = array("apples", "Oranges", "Pears"); $size = count($myarray); $output = print_r($myarray, true); print $output; You can store whatever you like as values in an array, and you can mix values also. For example: array("foo", 1, 9.995, "bar", $somevar). You can also put arrays inside arrays, but we will be getting on to that later. There is a similar function to print_r(), which is var_dump(). It does largely the same thing, but a) prints out sizes of variables, b) does not print out non-public data in objects, and c) does not have the option to pass a second parameter to return its output. For example, altering the first script to use var_dump() rather than print_r() would give the following output: array(3) { [0]=> string(6) "Apples" [1]=> string(7) "Oranges" [2]=> string(5) "Pears" 4

5 } In there you can see var_dump() has told us that the array has three values, and also prints out the lengths of each of the strings. For teaching purposes, var_dump() is better as it shows the variable sizes, however you will probably want to use print_r() in your own work. Finally, there is the function var_export(), which is similar to both var_dump() and print_r(). The key difference with var_export(), however, is that it prints out variable information in a style that can be used as PHP code. For example, if we had use var_export() instead of print_r() in the test script, it would have output the following: array ( 0 => 'Apples', 1 => 'Oranges', 2 => 'Pears', ) Note there is an extra comma after the last element, however this is ignored by PHP and you can copy and paste that information directly into your own scripts, like this: $foo = array ( 0 => 'Apples', 1 => 'Oranges', 2 => 'Pears', ); 5

6 Associative arrays As well as choosing individual values, you can also choose your keys - in the fruits code above we just specify values, but we could have specified keys along with them, like this: $myarray = array("a"=>"apples", "b"=>"oranges", "c"=>"pears"); var_dump($myarray); This time, var_dump() will output the following: array(3) { ["a"]=> string(6) "Apples" ["b"]=> string(7) "Oranges" ["c"]=> string(5) "Pears" } As expected, our 0, 1, and 2 element keys have been replaced with a, b, and c, but we could equally have used "Foo", "Bar", and "Baz", or even variables or other arrays to act as the keys. Specifying your own keys produces what is called an associative array - you associate a specific key with a specific value. Most associative arrays use strings as keys, but do not be afraid to try more advanced things out. The one exception here is floating-point numbers: these make very poor array indexes. The problem lies in the fact that PHP converts them to integers before 6

7 they are used, which essentially rounds them down. So, the following code will create an array with just one element in: $array[1.5] = "foo"; $array[1.6] = "bar"; The first line will read 1.5 as the key, round it down to 1, then store "foo" at index 1. The second line will read 1.6 as the key, also round it down to 1, then store "bar" at index 1, overwriting "foo". If you really want to use floating-point numbers as your keys, pass them in as strings, like this: $array["1.5"] = "foo"; $array["1.6"] = "foo"; var_dump($array); That should output the following: array(2) { ["1.5"]=> string(3) "foo" ["1.6"]=> string(3) "foo" } This time the floating-point numbers have not been rounded down or converted at all, because PHP is using them as strings. The same solution applies to reading values out from an associative array with floating-point keys - you must always specify the key as a string. 7

8 The two ways of iterating through arrays void list ( mixed...) array each ( array input) If you do not specify a key, as in the first example, PHP will just assign incrementing numbers starting with 0. However, these numbers cannot be guaranteed to exist within the array in any given order, or even to exist at all - they are just key values themselves. For example, an array may have keys 0, 1, 2, 5, 3, 6, 7. That is, it can have its keys out of order or entirely missing. As a result, code like this should generally be avoided: for ($i = 0; $i < count($array); ++$i) { print $array[$i]; } However, there is a quick and easy way to accomplish the same thing: a foreach loop, which itself has two versions. The easiest way to use foreach looks like this: foreach($array as $val) { print $val; } Here the array $array is looped through and its values are extracted into $val. In this situation, the array keys are ignored completely, which usually makes most sense when they have been auto-generated (i.e. 0, 1, 2, 3, etc). The second way to use foreach does allow you to extract keys, and looks like this: foreach ($array as $key => $val) { print "$key = $val\n"; } 8

9 Another commonly used way to loop over arrays is using the list() and each() functions, like this: while (list($var, $val) = each($array)) { print "$var is $val\n"; } List() is a function that does the opposite of array() - it takes an array, and converts it into individual variables. Each() takes an array as its parameter, and returns the current key and value in that array before advancing the array cursor. "Array cursor" is the technical term for the element of an array that is currently being read. All arrays have a cursor, and you can freely move it around - it is used in the while loop above, where we need to iterate through an array. To start with, each() will return the first element, then the second element, then the third, and so on, until it finds there are no elements left, in which case it will return false and end the loop. The meaning of that first line is "get the current element in the array, and assign its key to $var and its value to $val, then advance the array cursor. There is a lot more detail on array cursors later. Generally speaking, using foreach loops is the most optimised way to loop through an array, and is also the easiest to read. In practice, however, you will find foreach loops and list()/each() loops in about equal proportions, despite the latter option being slower. The key difference between the two is that foreach automatically starts at the front of the array, whereas list()/each() does not. 9

10 The array operator There is another popular way to create and manage arrays, and it uses brackets [ ] to mean "add to array", earning it the name "the array operator". Using this functionality, you can both create arrays and add to existing arrays, so this is generally more popular - you will generally only find the array() function being used when several values are being put inside the array, as it will fit on one line. Here are some examples of the array operator in action: $array[] = "Foo"; $array[] = "Bar"; $array[] = "Baz"; var_dump($array); That should work in precisely the same as using the array() function, except it is much more flexible - we can add to the array whenever we want to. When it comes to working with non-default indices, we can just place our key inside the brackets, like this: $array["a"] = "Foo"; $array["b"] = "Bar"; $array["c"] = "Baz"; var_dump($array); 10

11 Returning arrays from functions In PHP you can return one and only one value from your user functions, but you are able to make that single value an array, thereby allowing you to return many values. This following code shows how easy it is: function dofoo() { $array["a"] = "Foo"; $array["b"] = "Bar"; $array["c"] = "Baz"; return $array; } $foo = dofoo(); Without returning an array, the only other way to pass data back to the calling script is by accepting parameters by reference and changing them inside the function. Passing arrays by reference like this is generally preferred as it is less of a hack, and also frees up your return value for some a true/false to check whether the function was successful. 11

12 Array-specific functions Although arrays are great by themselves, their real usefulness only comes out when you use special array functions to manipulate your data - this was why we had to cover functions before arrays. There are quite a few array functions all doing a variety of things, and you need not learn them all - your best bet is to give them all a try so that you at least know how they work, then get back to working on normal code. You'll soon learn what works for you best! 12

13 Chopping and changing arrays array array_diff ( array array1, array array2 [, array...]) array array_intersect ( array array1, array array2 [, array...]) array array_merge ( array array1, array array2 [, array...]) There are three key functions that handle the comparison of two arrays to create a new array, and they work in much the same way - they take a minimum of two arrays as parameters (we will call them $arr1 and $arr2), and return an array for a result. The difference is that array_diff() returns a new array containing all the values of $arr1 that do not exist in $arr2, array_intersect() returns a new array containing all the values of $arr1 that do exist in $arr2, and array_merge() just combines the two arrays. These three functions work well as a team, and allow you to construct combined arrays out of individual arrays. Here is an example with these three functions in action: $toppings1 = array("pepperoni", "Cheese", "Anchovies", "Tomatoes"); $toppings2 = array("ham", "Cheese", "Peppers"); $inttoppings = array_intersect($toppings1, $toppings2); $difftoppings = array_diff($toppings1, $toppings2); $bothtoppings = array_merge($toppings1, $toppings2); var_dump($inttoppings); var_dump($difftoppings); var_dump($bothtoppings); As you can see, there are two arrays of pizza toppings, and they both share cheese as a value. Here is what that script outputs: array(1) { [1]=> string(6) "Cheese" } 13

14 array(3) { [0]=> string(9) "Pepperoni" [2]=> string(9) "Anchovies" [3]=> string(8) "Tomatoes" } array(7) { [0]=> string(9) "Pepperoni" [1]=> string(6) "Cheese" [2]=> string(9) "Anchovies" [3]=> string(8) "Tomatoes" [4]=> string(3) "Ham" [5]=> string(6) "Cheese" [6]=> string(7) "Peppers" } Array_intersect(), if you recall, returns an array listing all values in array parameter one that are also in array parameter two, so this call in our example will put just one element, cheese, into $inttoppings. The call to array_diff() will place into $difftoppings all the values from $toppings1 that aren't in $toppings2, namely pepperoni, anchovies, and tomatoes. Finally we have a call to array_merge(), which results in seven elements being placed into $bothtoppings: pepperoni, cheese, anchovies, tomatoes, peppers, ham, and cheese. As you can see, "cheese" is in there twice, so what you really need now is a way to strip out duplicate values. Note: The + operator in PHP is overloaded so that you can use it to merge arrays, eg $array3 = $array1 + $array2, but will ignore any key clashes, and so is quite confusing to use unless you have unique keys. 14

15 Stripping out duplicate values array array_unique ( array input) Consider if the $toppings2 array had been declared like this: $toppings2 = array("peppers", "Ham", "Cheese", "Peppers"); In this situation, there'd be two Peppers elements in there, in which case we would want to strip out the duplicate Peppers before running the merges and intersects. This is done by using array_unique(), which takes an array as its parameter and returns the same array with its duplicate values removed, like this: $toppings2 = array_unique($toppings2); Try the example code again, this time removing the duplicate Cheese values from $bothtoppings. 15

16 Filtering your array through a function array array_filter ( array input [, callback function]) The final array function in this group is array_filter(), which is a very powerful function that allows you to filter elements through a function you specify. If the function returns true, the item makes it into the array that is returned, otherwise it is not. Consider this script: function endswithy($value) { return (substr($value, -1) == 'y'); } $people = array("johnny", "Timmy", "Bobby", "Sam", "Tammy", "Danny", "Joe"); $withy = array_filter($people, "endswithy"); var_dump($withy); In this script we have an array of people, most of which have a name ending with "y". However, several do not, and for one reason or another we want to have a list of people whose names ends in "y", so array_filter() is used. The function endswithy() will return true if the last letter of each array value ends with a y, otherwise false. By passing that as the second parameter to array_filter(), it will be called once for every array element, passing in the value of the element as the parameter to endswithy(), where it is checked for a "y" at the end. 16

17 Converting an array to individual variables int extract ( array source [, int extract_type [, string prefix]]) Extract() is a very popular function that converts elements in an array into variables in their own right. Extract takes a minimum of one parameter, an array, and returns the number of elements extracted. This is best explained using code, so here goes: $Wales = 'Swansea'; $capitalcities['england'] = 'London'; $capitalcities['scotland'] = 'Edinburgh'; $capitalcities['wales'] = 'Cardiff'; extract($capitalcities); print $Wales; After calling extract, the "England", "Scotland", and "Wales" keys become variables in their own right ($England, $Scotland, and $Wales), with their values set to "London", "Edinburgh", and "Cardiff" respectively. By default, extract() will overwrite any existing variables, meaning that $Wales's original value of "Swansea" will be overwritten with "Cardiff". This behaviour can be altered using the second parameter, and averted using the third parameter. Parameter two takes a special constant value that allows you to decide how values will be treated if there is an existing variable, and parameter three allows you to prefix each extract variable with a special string. Here are the possible values of the second parameter: EXTR_OVERWRITE On collision, overwrite the existing variable EXTR_SKIP On collision, do not overwrite the existing variable 17

18 EXTR_PREFIX_SAME On collision, prefix the variable name with the prefix specified by parameter three EXTR_PREFIX_ALL Prefix all variables with the prefix specified by parameter three, whether or not there is a collision EXTR_PREFIX_INVALID Only use the prefix specified by parameter three when variables names would otherwise be illegal (e.g. "$9") EXTR_IF_EXISTS Only set variables if they already exist EXTR_PREFIX_IF_EXISTS Only create prefixed variables if non-prefixed version already exists EXTR_REFS Extract variables as references The last option, EXTR_REFS, can either be used on its own or in combination with others using the bitwise OR operator. Here are some examples based upon the $capitalcities array from the previous example: $Wales = 'Swansea'; extract($capitalcities, EXTR_SKIP); print $Wales; print $Scotland; extract($capitalcities, EXTR_PREFIX_SAME, "country"); print $Wales; print $country_england; extract($capitalcities, EXTR_PREFIX_ALL, "country"); On line one we pre-set $Wales to be a value so that you can clearly see how the second parameter works. On line two we call extract() using two parameters, with EXTR_SKIP as parameter two so that our $Wales will not be overwritten. However, as you will be able to see if you run the script, $England and $Scotland were set. On line five we use EXTR_PREFIX_SAME, which will extract variables and use the third parameter as a prefix if it finds any collisions. As we set $Wales ourselves 18

19 and our previous call to extract() created $England and $Scotland, all our variables will need to be prefixed. As you can see on line six, $Wales is still set to "Swansea", and on line seven we have our prefixed variable $country_england. Note that PHP places an underscore _ after your prefix to make the variable easy to read. Finally we call extract() with EXTR_PREFIX_ALL, which will unconditionally create variables with prefixes, overwriting $country_england, etc. Note that EXTR_OVERWRITE is rarely if ever used, because it is the same as using extract() without second or third parameters. 19

20 Checking whether an element exists bool in_array ( mixed needle, array haystack [, bool strict]) The in_array() function does precisely what you might think - if you pass it a value and an array it will return true if the value is in the array, otherwise false. This following example show it in action: $needle = "Sam"; $haystack = array("johnny", "Timmy", "Bobby", "Sam", "Tammy", "Danny", "Joe"); if (in_array($needle, $haystack)) { print "$needle is in the array!\n"; } else { print "$needle is not in the array\n"; } In_array() has an optional boolean third parameter (set to false by default) that defines whether you want to use strict checking or not. If parameter three is set to true, PHP will only return true if the value is in the array and it is of the same type - that is, if they are identical in the same way as the === operator (three equals signs). This is not used very often, but it is important that you are at least aware of its existence. 20