PHP Lesson 2: Arrays

What is an array, and similarities with objects

Arrays are a wonderfully flexible concept in PHP. Some coders struggle with grasping all the concepts of them, so I decided to write a lesson about them. Although the most simple concept is quite obvious - an array is a value that contains other values - the more advanced concepts might not even be fully known to the more experienced PHP developer.

For starters, the above description of the basic concept is not even refined enough, as objects could be described in exactly the same fashion! So what's the difference between the two? Objects can contain functions and constructors/destructors, all of which arrays can not. But apart from the syntactical differences, that's about it: after all objects can be dynamically assigned new properties, arrays can be assigned new keys, objects can be -ed, so can arrays, objects can be serialized, so can arrays! It is because of these similarities that objects and arrays can be cast to one another, without the loss of data. Obviously, since arrays are functionless, once you've cast an object to an array, you cannot cast it back to the exact same class type. But your data will remain. Take a look at the following code.




It's time to introduce the different types of arrays in PHP. There are two, (actually three), types of arrays in PHP: there are indexed arrays, associative arrays, and when you mix the two you get indexed-and-associative-arrays, but this basically functions as an associative array (explaining the two, no three ;-)).

Indexed arrays

What are indexed arrays? Indexed arrays are arrays that have consecutive key values (NOTE: the terms 'key' or 'index' are interchangeable here). When you create an array without settings keys, it becomes indexed:



The above array $arr has size 4, and four values, and thus also four keys (or indices). At key (index) 0, you have value 1. At key 1, you have value 2, at key 2, you have value 4, and finally at key 3 you have value 8. Quite simple and straightforward: keys are zero-based, in other words they start at key 0, and then go up.

To add an additional value at the end of an indexed array, you have two options:



Every time you add to an array, it becomes bigger in size. With the syntax, the array size always grows by one. With the array_push function you can add more than one value at the same time:



Overwriting a value in an indexed array is very easy. You just figure out the key you wish to edit, and write:



Removing a value from an indexed array is slightly more complicated, provided you wish to keep the array indexed (There is a very easy way, but this will make the array associative automatically so we'll get there later.) There are basically three possibilities:

• you wish to remove the first element from the array
• you wish to remove the last element from the array
• you wish to remove one or more elements, or from a position in the middle of the array

Removing the first element is done using the function:



Removing the last element is done using the function:



Removing an arbitrary amount of consecutive elements from an arbitrary position in the array is slightly more complicated. If the amount of items we wish to continue is in $amount, and the position of the first of the elements is in $offset, this becomes:



Inserting an array at a different location than at the end (for this case we already covered), there are two options:

• you want to add an element at the beginning of the array
• you want to add an element at an arbitrary position

Adding an element at the beginning of an indexed array is done using the function:



Again, adding at an arbitrary position is slightly more complex. Assuming that the element you wish the new value to reside at is in $offset, shifting all other elements "to the right", you write:



Now it's time to list the features of indexed arrays:

• keys are automatically numbered
• keys always start at 0, and go up by one
• when you remove an element from an array, all values that follow it automatically get a key that is one lower, so if you have
  array( 1, 2, 4 )
  , and you remove value 2, value from shifts from index 2 to index 1 automatically
• when you insert an element anywhere but at the end, all values at the "right side" of the array automatically get a key that is one higher, so if you have
  array( 1, 2, 4 )
  and you insert value 8 at position 1, you get
  array( 1, 8, 2, 4 )
  , shifting value 2 from key 1 to key 2, and shifting value 4 from key 2 to key 3.

Associative arrays

What are associative arrays? They are arrays with arbitrary keys: the following is a valid definition of an associative array:



Keys can be specified as strings, integer values, boolean values and floating point values. Do notice though that all values that are not an integer and also not a string, are automatically converted to integer values. The above array thus is equal to the following array:



Due to this automatic conversion, I urge you to never, ever use boolean and floating point values as keys: the automatic casting to integer values may provide you with unexpected results. Stick to strings and integer values, and you're fine.

Note that any string value is a valid key, so the following is a valid array:



Adding a new value to an associative array is very easy: you simply set it's key and you're done. Check the following code:



Removing a value from an associative array is very easy, use the function:



Associative arrays have no automatic indexing, and thus the concept of "inserting at a specific location" is not really possible. When you assign to a key in an array the beforehand wasn't set, the key gets added to the back of the array, as demonstrated with adding the key 'jack' in an earlier code fragment.

Checking if a specific key is already set or not, is also easy: use the function:



However, this function has a major caveat. Check out the following code:



If I hadn't started talking about caveats, you probably would have expected Jack to be happy. However, using isset makes Jack a sad puppy, as the above code will output that . This is because unset returns for keys that have as the value. Why they did this is beyond me, but it's true. Luckily, however, there is a cure: :



The above code will not print the same statement, as returns true when the key exists: no exceptions.

Automatic (unexpected) conversion from associative to indexed and the other way around

Beware of functions that always return indexed arrays, even when the input is associative. An example of such a function is the function. It is very useful, as it quicksorts your array by value. However, much to your suprise, you might find that when the input is associative, the result array is not! This is simply a fact (and reasonably well documented on php.net). You'll just have to learn which functions mangle your keys, and which do not.

For this very reason there are multiple sort functions:

• sort
  : sorts by value, returns indexed, making associative arrays indexed
• asort
  : sorts by value, keeps indices, making indexed arrays associative
• rsort
  : sorts descending by value, returns indexed, making associative arrays indexed
• arsort
  : sorts descending by value, keeps indices, making indexed arrays associative
• ksort
  : sorts by keys, keeps indices, making indexed arrays associative
• krsort
  : sorts descending by keys, keeps indices, making indexed arrays associatve
• usort
  : sorts by value, uses user-specified comparison, returns indexed, making associatve arrays indexed
• uasort
  : sorts by value, uses user-specified comparison, keeps indices, making indexed arrays associative
• uksort
  : sorts by keys, uses user-specified comparison, keeps indices, making indexed arrays associative

There are more array functions in PHP that might change the type of your array. Some even have a property that allows you to define the behaviour in this respect (such as ). Simply remember to always read the documentation properly when you start using a new array function.

Other array functions

There are many array functions in PHP, for example:

• array_rand
  : picks random elements from input array
• array_sum
  : calculate total of all values in an array
• array_merge
  : combines multiple arrays into a single array
• array_chunk
  : chop an array up in fixed-size pieces
• array_keys
  : return all the keys in an array as an indexed array
• array_walk
  : execute a user defined function on each element in an array
• and so on, and so on... check out this page on php.net for a complete list

0 comment(s)