Information on the utilization of functions and arrays.

1. Functions & Arrays
Henry Osborne

3. Basic Syntax
function name() { }
function hello() {
echo “Hello World!”;
}
hello();

4. Returning Values
function hello() {
return “Hello World!”;
}
$txt = hello();
echo hello();

5. Returning Values
function hello() {
echo “Hello $who”;
if ($who == “World”) {
return;
}
echo “, how are you?”;
}
hello (“World”); //Displays “Hello World”
hello (“Reader”); //Displays “Hello Reader, how are you?”

6. Returning Values
function &query($sql)
{
$result = mysql_query($sql);
return $result;
}
//The following is incorrect and will
cause PHP to emit a notice when called.
function &getHello()
{
return “Hello World”;
}
//This will also cause the warning to be
issued when called
function &test()
{
echo „This is a test‟;
}

7. Variable Scope
• Three variable scopes exist:
• Global
• Function
• Class

8. Variable Scope, cont’d
$a = “Hello World”;
function hello() {
$a = “Hello Reader”;
$b = “How are you?”;
}
hello ();
echo $a; //Will output Hello World
echo $b; //Will emit a warning

9. Variable Scope, cont’d
$a = “Hello”;
$b = “World”;
function hello() {
global $a, $b;
echo “$a $b”;
}
hello (); //Displays Hello World

10. Variable Scope, cont’d
$a = “Hello”;
$b = “World”;
function hello() {
echo $GLOBALS[„a‟].‟ „.$GLOBALS[„b‟];
}
hello (); //Displays Hello World

11. Variable-Length Argument Lists
function hello() {
if (func_num_args() > 0) {
$arg = func_get_arg(0);
echo “Hello $arg”;
} else {
echo ”Hello World”;
}
}
hello(“Reader);

12. Variable-Length Argument Lists
function countAll($arg1){
if (func_num_args() == 0) {
die(“You need to specify at least
one argument”);
} else {
$args = func_get_args();
array_shift($args);
$count = strlen($arg1);
foreach ($args as $arg) {
$count += strlen($arg);
}
}
return $count;
}
echo countAll(“apple”,”pear”, “plum”);

13. Passing Arguments by Reference
function countAll(&$count){
if (func_num_args() == 0) {
die(“You need to specify at least
one argument”);
} else {
$args = func_get_args();
array_shift($args);
$count = strlen($arg1);
foreach ($args as $arg) {
$count += strlen($arg);
}
}
}
$count = 0;
countAll($count, “apple”,”pear”, “plum”);
//count now equals 13

14. Arrays

15. Array Basics
$a = array (10, 20, 30);
$a = array (‟a‟ => 10, ‟b‟ => 20, ‟cee‟ => 30);
$a = array (5 => 1, 3 => 2, 1 => 3,);
$a = array();

16. Array Basics
$x[] = 10;
$x[‟aa‟] = 11;
echo $x[0]; // Outputs 10

17. Printing Arrays
• PHP provides two functions that can be used to output a
variable’s value recursively
• print_r()
• var_dump().

18. Enumerative vs Associative
• Arrays can be roughly divided in two categories: enumerative and
associative.
• Enumerative arrays are indexed using only numerical indexes
• Associative arrays(sometimes referred to as dictionaries) allow the
association of an arbitrary key to every element.

19. Enumerative vs Associative, cont’d
When an element is added to an array without specifying a key, PHP
automatically assigns a numeric one that is equal to the greatest numeric key
already in existence in the array, plus one:
$a = array (2 => 5);
$a[] = ‟a‟; // This will have a key of 3
$a = array (‟4‟ => 5, ‟a‟ => ‟b‟);
$a[] = 44; // This will have a key of 5

20. Array keys are case-sensitive, but type insensitive. Thus, the key ’A’
is different from the key ’a’, but the keys ’1’ and 1 are the same.
However, the conversion is only applied if a string key contains
the traditional decimal representation of a number; thus, for
example, the key ’01’ is not the same as the key 1.
NOTE WELL

21. Multi-dimensional Arrays
$array = array();
$array[] = array(‟foo‟, ‟bar‟);
$array[] = array(‟baz‟, ‟bat‟);
echo $array[0][1] . $array[1][0]; //output is barbaz

22. Unravelling Arrays
$sql = "SELECT user_first, user_last, lst_log FROM
users";
$result = mysql_query($sql);
while (list($first, $last, $last_login) =
mysql_fetch_row($result)) {
echo "$last, $first - Last Login: $last_login";
}

23. array(6) {
[0]=>
Array Operations
int(1)
[1]=>
int(2)
[2]=>
$a = array (1, 2, 3);
int(3)
$b = array (‟a‟ => 1, ‟b‟ => 2, ‟c‟ => 3);
["a"]=>
var_dump ($a + $b);
int(1)
["b"]=>
int(2)
["c"]=>
int(3)
}

24. Array Operations, cont’d
array(4) {
[0]=>
int(1)
$a = array (1, 2, 3);
[1]=>
$b = array (‟a‟ => 1, 2, 3);
int(2)
var_dump ($a + $b);
[2]=>
int(3)
["a"]=>
int(1)
}

25. Comparing Arrays
$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
$c = array (‟a‟ => 1, ‟b‟ => 2, ‟c‟ => 3);
var_dump ($a == $b); // True
var_dump ($a === $b); // False
var_dump ($a == $c); // False
var_dump ($a === $c); // False

26. Comparing Arrays, cont’d
$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
var_dump ($a != $b); // False
var_dump ($a !== $b); // True

27. Counting, Searching and Deleting Elements
$a = array (1, 2, 4);
$b = array();
$c = 10;
echo count ($a); // Outputs 3
echo count ($b); // Outputs 0
echo count ($c); // Outputs 1

28. Counting, Searching and Deleting Elements, cont’d
$a = array (‟a‟ => 1, ‟b‟ => 2);
echo isset ($a[‟a‟]); // True
echo isset ($a[‟c‟]); // False
$a = array (‟a‟ => NULL, ‟b‟ => 2);
echo isset ($a[‟a‟]); // False

29. Counting, Searching and Deleting Elements, cont’d
$a = array (‟a‟ => NULL, ‟b‟ => 2);
echo array_key_exists (‟a‟, $a); // True
$a = array (‟a‟ => NULL, ‟b‟ => 2);
echo in_array (2, $a); // True

30. Counting, Searching and Deleting Elements, cont’d
$a = array (‟a‟ => NULL, ‟b‟ => 2);
unset ($a[‟b‟]);
echo in_array ($a, 2); // False

31. Flipping and Reversing
$a = array (‟a‟, ‟b‟, ‟c‟);
array(3) {{
array(3)
["a"]=>
[0]=>
int(0)
string(1) "c"
["b"]=>
[1]=>
int(1)
string(1) "b"
["c"]=>
["x"]=>
int(2)
string(1) "a"
var_dump (array_flip ($a));
$a = array (‟x‟ => ‟a‟, 10 => ‟b‟, ‟c‟);
var_dump (array_reverse ($a));
}}

32. Array Iteration
• One of the most common operations you will perform with arrays
• PHP arrays require a set of functionality that matches their flexibility
• “normal” looping structures cannot cope with the fact that array keys do not
need to be continuous
$a = array (‟a‟ => 10, 10 => 20, ‟c‟ => 30);

33. Array Iteration: Array Pointer
$array = array(‟foo‟ => ‟bar‟, ‟baz‟, ‟bat‟ => 2);
function displayArray(&$array) {
reset($array);
while (key($array) !== null) {
echo key($array) .": " .current($array) . PHP_EOL;
next($array);
}
}

34. Array Iteration: foreach
$array = array(‟foo‟, ‟bar‟, ‟baz‟);
foreach ($array as $key => $value) {
echo "$key: $value";
}

35. array(2) {
["internal"]=>
Passive Iteration
&array(3) {
[0]=>
string(3) "RSS"
[1]=>
function setCase(&$value, &$key)
string(4) "HTML"
{
[2]=>
string(3) "XML"
$value = strtoupper($value);
}
}
["custom"]=>
$type = array(‟internal‟, ‟custom‟);
&array(2) {
$output_formats[] = array(‟rss‟, ‟html‟, ‟xml‟);
[0]=>
$output_formats[] = array(‟csv‟, ‟json‟);
string(3) "CSV"
$map = array_combine($type, $output_formats);
[1]=>
array_walk_recursive($map, ‟setCase‟);
string(4) "JSON"
}
var_dump($map);
}

36. Sorting Arrays: sort()
$array = array(‟a‟ => ‟foo‟, ‟b‟ => ‟bar‟, ‟c‟ => ‟baz‟);
sort($array);
array(3) {
[0]=>
var_dump($array);
string(3) "bar"
[1]=>
string(3) "baz"
[2]=>
string(3) "foo"
}

37. Sorting Arrays: asort()
$array = array(‟a‟ => ‟foo‟, ‟b‟ => ‟bar‟, ‟c‟ => ‟baz‟);
asort($array);
var_dump($array);
array(3) {
["b"]=>
string(3) "bar"
["c"]=>
string(3) "baz"
["a"]=>
string(3) "foo“
}

38. Sorting Arrays
SORT_REGULAR
Compare items as they appear in the array, without performing any kind of
conversion. This is the default behaviour.
SORT_NUMERIC
Convert each element to a numeric value for sorting purposes.
SORT_STRING
Compare all elements as strings.

39. Sorting Arrays: natsort()
$array = array(‟10t‟, ‟2t‟, ‟3t‟);
natsort($array);
array(3) {
[1]=>
var_dump($array);
string(2) "2t"
[2]=>
string(2) "3t"
[0]=>
string(3) "10t"
}

40. Anti-Sorting: shuffle()
$cards = array (1, 2, 3, 4);
array(4) {
[0]=>
shuffle($cards);
int(4)
var_dump($cards);
[1]=>
int(1)
[2]=>
int(2)
[3]=>
int(3)
}

41. Anti-Sorting: array_keys()
$cards = array (‟a‟ => 10, ‟b‟ => 12, ‟c‟ => 13);
$keys = array_keys ($cards);
shuffle($keys);
foreach ($keys as $v) {
echo $v . " - " . $cards[$v] . "n";
}

42. Anti-Sorting: array_rand()
$cards = array (‟a‟ => 10, ‟b‟ => 12, ‟c‟ =>array(2) { {
13);
array(3)
$keys = array_rand ($cards, 2);
["a"]=>
[0]=>
int(10)
string(1) "a"
["b"]=>
[1]=>
var_dump($keys);
int(12)
string(1) "b"
var_dump($cards);
["c"]=>
}
int(13)
}

43. Arrays as Stacks, Queues and Sets
$stack = array();
array_push($stack, ‟bar‟, ‟baz‟);
var_dump($stack);
$last_in = array_pop($stack);
var_dump($last_in, $stack);

44. Arrays as Stacks, Queues and Sets
array(2) {
[0]=>
$queue = array(‟qux‟, ‟bar‟, ‟baz‟);
string(3) "bar"
[1]=>
$first_element = array_shift($queue);
var_dump($queue);
string(3) "baz"
}
array(3) {
array_unshift($queue, ‟foo‟);
[0]=>
string(3) "foo"
var_dump($queue);
[1]=>
string(3) "bar"
[2]=>
string(3) "baz"
}

45. Set Functionality
$a = array (1, 2, 3);
$b = array (1, 3, 4);
var_dump (array_diff ($a, $b));
var_dump (array_intersect ($a, $b));

46. Functions & Arrays