php|nightly

array_merge()

php|nightly — Sat, 06 Mar 2010 05:00:01 +0000

Combine the values of two or more arrays into a new array. Values will be appended onto the end with numeric keys being re-indexed as it goes. Should a duplicate non-numeric key be found, the previous value is overwritten.

You might think of this as adding arrays together, which is fine, but you can actually use + with arrays. More about that after a few examples.

$a1 = array('a',
            'b',
            'c',
            'd',
            'e');
 
$a2 = array('p',
            'o',
            'i',
            'u');
 
$arr = array_merge($a1, $a2);
/*
array (
  0 => 'a',
  1 => 'b',
  2 => 'c',
  3 => 'd',
  4 => 'e',
  5 => 'p',
  6 => 'o',
  7 => 'i',
  8 => 'u'
)
*/
 
$a1 = array('a',
            'b',
            'this' => 'c',
            'd',
            'e');
 
$a2 = array('p',
            'that' => 'o',
            'i',
            'u');
 
$arr = array_merge($a1, $a2);
/*
array (
  0 => 'a',
  1 => 'b',
  'this' => 'c',
  2 => 'd',
  3 => 'e',
  4 => 'p',
  'that' => 'o',
  5 => 'i',
  6 => 'u'
)
*/
 
// even the first array is re-indexed
// 'this' value is overwritten
$a1 = array(5 => 'a',
            'b',
            'this' => 'c',
            'd',
            'e');
 
$a2 = array(17 => 'p',
            'this' => 'o',
            'i',
            'u');
 
$arr = array_merge($a1, $a2);
/*
array (
  0 => 'a',
  1 => 'b',
  'this' => 'o',
  2 => 'd',
  3 => 'e',
  4 => 'p',
  5 => 'i',
  6 => 'u'
)
*/
 
// if only one array is given, it is just re-indexed
$arr = array_merge($a1);
/*
array (
  0 => 'a',
  1 => 'b',
  'this' => 'c',
  2 => 'd',
  3 => 'e'
)
*/

Remember, this function will accept more than two arrays.

$a1 = range(3, 7);
$a2 = range('A', 'D');
$a3 = array(2001 => 'oddity');
$a4 = range('i', 'k');
 
$arr = array_merge($a1, $a2, $a3, $a4);
/*
array (
  0 => 3,
  1 => 4,
  2 => 5,
  3 => 6,
  4 => 7,
  5 => 'A',
  6 => 'B',
  7 => 'C',
  8 => 'D',
  9 => 'oddity',
  10 => 'i',
  11 => 'j',
  12 => 'k'
)
*/

Using + to merge arrays together acts differently. The keys are not re-indexed, and values are not overwritten. For duplicate keys (even numeric ones) the previous value stands and the other is ignored.

$a1 = array('a', 'b');
$a2 = array('A', 'B', 'C', 'D');
$a3 = array('m' => 13,
            'n' => 14);
$a4 = array(17 => 'Q',
            18 => 'R');
 
$arr = $a1 + $a2 + $a3 + $a4;
/*
array (
  0 => 'a',
  1 => 'b',
  2 => 'C',
  3 => 'D',
  'm' => 13,
  'n' => 14,
  17 => 'Q',
  18 => 'R'
)
*/

See the manual entry for array_merge()
Originally posted 2009-03-06

array_combine()

php|nightly — Fri, 05 Mar 2010 05:00:01 +0000

“You’ve got your values with my keys!”
“You’ve got your keys with my values!”
Mmmm…

Use the values of one array as the keys, and the values of another array as the values, and get a brand new array from the combination.

The stipulations are:

The two arrays must have the same number of elements
The keys will be converted to string if necessary
Keys of an integer in string format will become a numeric key
Values will be overwritten on duplicate keys

As you’ll see here, the keys of your original arrays do not matter. Only the values are combined to create the new array.

$a1 = array('one' => 1,
            'two' => 2,
            'three' => 300,
            'four' => 'the',
            'five' => 'end');
 
$a2 = array('a' => 'apple',
            'b' => 'banana',
            'c' => 'carrot',
            'd' => 'dandelion',
            'e' => 'eggplant');
 
$arr = array_combine($a1, $a2);
/*
array (
  1 => 'apple',
  2 => 'banana',
  300 => 'carrot',
  'the' => 'dandelion',
  'end' => 'eggplant'
)
*/

An example of overwriting duplicate keys. Note that the resulting array has only four elements.

$a1 = array('one' => 1,
            'two' => 2,
            'three' => 300,
            'four' => 'the',
            'five' => 300);
 
$a2 = array('a' => 'apple',
            'b' => 'banana',
            'c' => 'carrot',
            'd' => 'dandelion',
            'e' => 'eggplant');
 
$arr = array_combine($a1, $a2);
/*
array (
  1 => 'apple',
  2 => 'banana',
  300 => 'eggplant',
  'the' => 'dandelion'
)
*/

For the keys, false will become the empty string, true will become one (1), integers in quotes will become numeric (even negative), floats will become strings.

$a1 = array('a',
            false,
            0,
            -4,
            '-6',
            true,
            'two words',
            '@#$',
            '4.5',
            3.5);
 
$a2 = array(1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            0);
 
$arr = array_combine($a1, $a2);
/*
array (
  'a' => 1,
  '' => 2,
  0 => 3,
  -4 => 4,
  -6 => 5,
  1 => 6,
  'two words' => 7,
  '@#$' => 8,
  '4.5' => 9,
  '3.5' => 0
)
*/

See the manual entry for array_combine()
Originally posted 2009-03-05

array_fill_keys()

php|nightly — Thu, 04 Mar 2010 05:00:01 +0000

This function acts similar to array_fill() but is different in that you specify the keys to use instead of simply creating a numerically keyed array.

Since you are suppling the keys, you do not need to tell it how many elements to make (it will use all of the keys) and you do not need to tell it where to start; just give it the list of keys and the value to use for each one and off it goes.

As an example, here’s how those two functions can produce the same output.

$arr1 = array_fill(5, 17, 'Q'); // start with key of 5, make 17 elements
$arr2 = array_fill_keys(range(5, 22), 'Q'); // for keys, use an array of 5-22 (has 17 elements)

$keys = array('first',
              'another',
              42,
              'this_one');
$arr = array_fill_keys($keys, 'X');
/*
array (
  'first' => 'X',
  'another' => 'X',
  42 => 'X',
  'this_one' => 'X'
)
*/

In your array of keys to use, a string which is an integer value will be converted to that integer value (even negative numbers). Boolean false will become an empty string, true will become integer one (1). Duplicate keys will be ignored.

$keys = array('first',
              'another',
              0,
              false,
              true,
              '87',
              '-4',
              1,
              '42.5',
              'this_one');
$arr = array_fill_keys($keys, 'X');
/*
array (
  'first' => 'X',
  'another' => 'X',
  0 => 'X',
  '' => 'X',
  1 => 'X',
  87 => 'X',
  -4 => 'X',
  '42.5' => 'X',
  'this_one' => 'X'
)
*/

See the manual entry for array_fill_keys()
Originally posted 2009-03-04

array_fill()

php|nightly — Wed, 03 Mar 2010 05:00:01 +0000

This function will create an array and initialize the elements with the value of your choosing. The resulting array will be numerically indexed.

You specify the starting index, the number of elements the array will contain, and the value to be used for each of those elements.

This can be useful for initializing an array before merging other data with it so that each key will have a value associated with it instead of ending up with “holes” in the array by having some not being set.

$arr = array_fill(4, 3, 'monkey');
/*
array (
  4 => 'monkey',
  5 => 'monkey',
  6 => 'monkey'
)
*/
 
$arr = array_fill(0, 5, 17);
/*
array (
  0 => 17,
  1 => 17,
  2 => 17,
  3 => 17,
  4 => 17
)
*/

The value may be any type that could be placed in an array.

$arr = array_fill(8, 3, false);
/*
array (
  8 => false,
  9 => false,
  10 => false
)
*/
 
$val = array('apple', 'banana');
$arr = array_fill(3, 2, $val);
/*
array (
  3 => 
  array (
    0 => 'apple',
    1 => 'banana'
  ),
  4 => 
  array (
    0 => 'apple',
    1 => 'banana'
  )
)
*/
 
// a quick way to set up a multidimensional "grid" array
$arr = array_fill(0, 5, array_fill(0, 5, 'Q')); // a 5x5 array with each element initialized to Q

The second parameter will be converted to an integer (decimals are truncated). If it is less than one, however, a warning will be given and false is returned. Keep in mind again how types are converted to integers.

If the first parameter is negative, the first element will have that negative key, but the second element will step to zero, then one, etc. This is the normal functionality of arrays.

$arr = array_fill(0, '2x', 'monkey');
/*
array (
  0 => 'monkey',
  1 => 'monkey'
)
*/
 
$arr = array_fill(-17, 4, 'X');
/*
array (
  -17 => 'X',
  0 => 'X',
  1 => 'X',
  2 => 'X'
)
*/

See the manual entry for array_fill()
Originally posted 2009-03-03

range()

php|nightly — Tue, 02 Mar 2010 05:00:01 +0000

Instantly create an array full of values in a range of your choice. For example, all the numbers five through twenty, or the letters B through N, or maybe just the odd numbers zero through fifty.

You specify the starting point, the ending point, and optionally the step (defaults to one). If the start is greater than the end, the array will be filled “backwards”.

Only the first character of the strings will be used when creating a range of characters. Any other characters of the string will be ignored.

$arr = range(1, 8);    // array(1, 2, 3, 4, 5, 6, 7, 8)
$arr = range(8, 1);    // array(8, 7, 6, 5, 4, 3, 2, 1)
$arr = range(1, 8, 2); // array(1, 3, 5, 7)
$arr = range(1, 8, 5); // array(1, 6)
 
$arr = range('q', 'y');    // array('q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y')
$arr = range('q', 'm');    // array('q', 'p', 'o', 'n', 'm')
$arr = range('q', 'y', 2); // array('q', 's', 'u', 'w', 'y')
$arr = range('q', 'y', 5); // array('q', 'v')
 
// this function appears to take the
// absolute value of the step parameter
$arr = range(1, 8, -2); // array(1, 3, 5, 7)

Take care mixing integers and strings. The string will first be converted to a numeric value. Also, the step need not be a whole number. However, if the step is not a whole number, any strings used will be converted to numeric.

If the string is converted to a numeric value, the “only the first character” rule is out. That rule is applied after any conversion.

$arr = range('1', '8'); // array(1, 2, 3, 4, 5, 6, 7, 8)
$arr = range(2, 'x');   // array(2, 1, 0)
$arr = range(2, '5x');  // array(2, 3, 4, 5)
 
$arr = range(2, 4, .5);      // array(2, 2.5, 3, 3.5, 4)
$arr = range(3.14, 5.2, .3); // array(3.14, 3.44, 3.74, 4.04, 4.34, 4.64, 4.94, 5.24)
$arr = range('a', 'g', .5);  // array(0);
 
$arr = range('28', '33'); // array(28, 29, 30, 31, 32, 33)

$nums = range(1, 69);
shuffle($nums);
echo "Your winning lottery numbers are:
{$nums[0]} {$nums[1]} {$nums[2]} {$nums[3]} {$nums[4]} {$nums[5]}";

Originally posted 2009-03-02

PHPClasses

php|nightly — Mon, 01 Mar 2010 05:00:01 +0000

PHPClasses.org is a resource for object oriented PHP code. The site itself is full of advertisements and can be difficult to navigate, but with over 2300 authors contributing over 4400 files, it can be a great place to find ready-to-go code or maybe just some inspiration.

It’s all community based. Anyone can contribute, though there is a review process. It’s a good way to get your code seen and get your name out if that’s what you’re after. Some people have elected to be notified on each new approved contribution. You could have thousands of people looking at and possibly using your code!

Not all classes at the site will be available for you to use, however. It depends on the license attached. At the time of this writing, here are the licenses listed on the contribution page.

Artistic License
BSD License
GNU Free Documentation License (FDL)
GNU General Public License (GPL)
GNU Lesser General Public License (LGPL)
MIT/X Consortium License
Python License
Q Public License (QPL)
Free For Educational Use
Free For Non-Commercial Use
Free To Use But Restricted
Freely Distributable
Freeware
Proprietary License
Proprietary License with Source
Public Domain
Shareware
The PHP License
Other (custom)

So, if you’re planning to piece together some commercial software, make sure the license allows for that.

Are there similar resources out there? Which are your favorites? Let us know in the comments here.

Originally posted 2009-02-28

array_keys()

php|nightly — Sat, 27 Feb 2010 15:24:01 +0000

Give this function an array and you’ll get back an array, the values of which will be the keys of the original array.

As a bonus, you can request to get only the keys which correspond to a certain value. Specify the value (a single value only, though it may be of any type) in the second parameter. Set the third parameter to true if you want to be strict in searching against type. (see the entry on == vs. ===)

$arr = array('elephant',
             'a' => 'apple',
             'b' => 'banana',
             'c' => 'carrot',
             'fly',
             array('z' => 'zucchini',
                   'y' => 'yarrow',
                   'platypus'),
             'gnat');
 
$new_arr1 = array_keys($arr);
/*
array (
  0 => 0,
  1 => 'a',
  2 => 'b',
  3 => 'c',
  4 => 1,
  5 => 2,
  6 => 3
)
*/
 
$new_arr2 = array_keys($arr, 'banana');
/*
array (
  0 => 'b'
)
*/
 
$search = array('banana',
                'elephant',
                'gnat');
$new_arr3 = array_keys($arr, $search);
/*
array ()
*/
 
// Search must be a single value. In this case it was looking for
// a value matching that array which does not exist.
// Compare the above with the following.
 
$search = array('z' => 'zucchini',
                'y' => 'yarrow',
                'platypus');
$new_arr4 = array_keys($arr, $search);
/*
array (
  0 => 2
)
*/

When using the search feature, be careful of types. That’s what the third parameter is for. Set it to true to match the value and type.

Here you’ll see an example of returning multiple keys, followed by examples of searching through different types.

$arr1 = array('pumpkin',
              'acorn',
              'spaghetti',
              'butternut',
              'acorn');
$new_arr1 = array_keys($arr1, 'acorn');
/*
array (
  0 => 1,
  1 => 4
)
*/
 
$arr2 = array(17,
             255,
             0,
             'apple',
             false,
             '0');
 
$new_arr2 = array_keys($arr2, 0);
/*
array (
  0 => 2,
  1 => 3,
  2 => 4,
  3 => 5
)
*/
 
$new_arr3 = array_keys($arr2, false);
/*
array (
  0 => 2,
  1 => 4,
  2 => 5
)
*/
 
$new_arr4 = array_keys($arr2, 0, true);
/*
array (
  0 => 2
)
*/

See the manual entry for array_keys()
Originally posted 2009-02-27

array_values()

php|nightly — Fri, 26 Feb 2010 05:00:37 +0000

This function will take an array and give you back an array with all the same values but re-indexed numerically, starting at zero. Think of it somewhat as straightening a deck of cards. All the cards are still there but now they’re all presented in a nice, neat stack.

The keys of your input array will not be used. Any nested arrays will not be re-indexed, however. Those keys will remain.

The array you pass to this function will not be altered. A new array is created and returned to you.

$arr = array('elephant',
             'a' => 'apple',
             'b' => 'banana',
             'c' => 'carrot',
             'fly',
             array('z' => 'zucchini',
                   'y' => 'yarrow',
                   'platypus'),
             'gnat');
$new_arr = array_values($arr);
/*
array (
  0 => 'elephant',
  1 => 'apple',
  2 => 'banana',
  3 => 'carrot',
  4 => 'fly',
  5 => array (
         'z' => 'zucchini',
         'y' => 'yarrow',
          0  => 'platypus',
       ),
  6 => 'gnat'
)
*/

See the manual entry for array_values()
Originally posted 2009-02-26

The Optional Closing Tag

php|nightly — Thu, 25 Feb 2010 14:09:50 +0000

You know that a block of PHP code begins with and anything outside of that will be sent as output. What you may or may not know is that the closing tag is optional at the end of a file.

So should you include this closing tag in your PHP files? That question was put out to the PHP community and here are the latest results:

Arguments For NO

Sure, the language is full of conveniences but what good is that bit of information? Leaving off the final closing PHP tag could have saved many hours of confusion for a number of people.

Have you ever came upon a “headers already sent” message and had no idea why? This comes up constantly in forums and lists and the solution is almost always to remove any whitespace before . This whitespace issue is the number one (possibly only) reason to argue the possition of leaving off the final closing tag.

Unintended whitespace sent as output can lead not only to issues with sending headers, but also could introduce errors in other types of output such as XML or images.

Here’s an example of how this whitespace can be introduced into a file. Line numbers are included in these examples.

--index.php--
1  
2  include 'inc.php';
3  header("Location: http://phpnightly.com");
4  exit;
5  ?>
 
--inc.php--
1  
2  // some code here, maybe a hit counter
3  // this file isn't meant to output anything
4  ?>
5
6

Running index.php will produce something like

Warning: Cannot modify header information - headers already sent by (output started at \public_html\inc.php:6) in \public_html\index.php on line 3

The closing tag can have a single new line after it without causing any problems. But a new line, space, tab, anything after that will be sent as output and can cause that warning message.

Arguments For YES

Why then, given this information that it could ruin a script, would you want to use it?

It’s a clean and definite finish to the script
Leaving it off is just lazy. You should be sure there isn’t whitespace there
Every tag, brace, parenthesis, etc. needs a partner

The manual states that it is optional. The Zend Framework coding standard (and others) says that it must be left off.

If you really aren’t concerned about the whitespace issue, it pretty much comes down to personal preference. Or whatever the boss says, of course.

Personally, I’ve come to prefer leaving it out. Potential issues are avoided and I don’t see a benefit to having it in there if there’s no output at the end.

Originally posted 2009-02-25

parse_str()

php|nightly — Wed, 24 Feb 2010 05:00:41 +0000

Deconstructs a URL query string parsing out the variable/value pairs. The array named as the second parameter will hold all the info. If the second parameter is not present, the variables will be put into the current scope (see extract).

This function is the counterpart of http_build_query().

I advise you to always include the second parameter to avoid overwriting data and to ensure you always know where your data originated from.

$a = 'monkey';
$str = 'a=zebra&b=yak&c=Xavier&0=litmus&1=test&d=whale';
parse_str($str);
/*
Equivalent to doing the following:
$a = 'zebra';
$b = 'yak';
$c = 'Xavier';
$0 = 'litmus';
$1 = 'test';
$d = 'whale';
 
An error would be thrown if you tried to create the variables $0 and $1
but no error would occur parse_str, though you wouldn't be able to
retrieve the values of $0 or $1 here.
 
$a would now hold the value "zebra".
*/
 
$str = 'a=zebra&b=yak&c=Xavier&0=litmus&1=test&d=whale';
parse_str($str, $arr);
/*
$arr is now:
array (
  'a' => 'zebra',
  'b' => 'yak',
  'c' => 'Xavier',
  0   => 'litmus',
  1   => 'test',
  'd' => 'whale'
)
 
Here, you could be able to access all values such as $arr[0] and $arr[1].
*/

See the manual entry for parse_str()
Originally posted 2009-02-24