php|nightly

asort()

php|nightly — Wed, 10 Mar 2010 04:00:01 +0000

Sort an array by its values from lowest to highest just like sort(). Only true or false is returned (success or failure). This function alters the input array itself.

The difference between this and sort() is that asort() keeps the keys intact. This is useful for associative arrays, but it keeps the numeric keys as well as string keys.

To sort from highest to lowest, see arsort() which works the same as this function.

Optional flags can be used as the second parameter. SORT_REGULAR is the default.

SORT_REGULAR	Compare items normally (don’t change types)
SORT_NUMERIC	Compare items numerically
SORT_STRING	Compare items as strings
SORT_LOCALE_STRING	Compare items as strings, based on the current locale.

If the values are of mixed types, you may not get the result you expect in some cases.

$arr = array('eggplant',
             'banana',
             'apple',
             'dandelion',
             'carrot');
asort($arr);
/*
array (
  2 => 'apple',
  1 => 'banana',
  4 => 'carrot',
  3 => 'dandelion',
  0 => 'eggplant'
)
*/
 
$arr = array('test' => 'eggplant',
             'banana',
             'sample' => 'apple',
             17 => 'dandelion',
             'carrot');
asort($arr);
/*
array (
  'sample' => 'apple',
  0 => 'banana',
  18 => 'carrot',
  17 => 'dandelion',
  'test' => 'eggplant'
)
*/
 
$arr = array('25',
             43,
             8004,
             3,
             '8004',
             0,
             -52);
asort($arr);
/*
array (
  6 => -52,
  5 => 0,
  3 => 3,
  0 => '25',
  1 => 43,
  4 => '8004',
  2 => 8004
)
*/
 
$arr = array('25',
             43,
             8004,
             3,
             '8004',
             0,
             -52);
asort($arr, SORT_STRING);
/*
array (
  6 => -52,
  5 => 0,
  0 => '25',
  3 => 3,
  1 => 43,
  2 => 8004,
  4 => '8004'
)
*/

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

sort()

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

Sort an array by its values from lowest to highest. All of the keys are lost as it is re-indexed as a numerically indexed array. Only true or false is returned (success or failure). This function alters the input array itself.

To sort from highest to lowest, see rsort() which works the same as this function.

Optional flags can be used as the second parameter. SORT_REGULAR is the default.

SORT_REGULAR	Compare items normally (don’t change types)
SORT_NUMERIC	Compare items numerically
SORT_STRING	Compare items as strings
SORT_LOCALE_STRING	Compare items as strings, based on the current locale.

If the values are of mixed types, you may not get the result you expect in some cases.

$arr = array('eggplant',
             'banana',
             'apple',
             'dandelion',
             'carrot');
sort($arr);
/*
array (
  0 => 'apple',
  1 => 'banana',
  2 => 'carrot',
  3 => 'dandelion',
  4 => 'eggplant'
)
*/
 
$arr = array('test' => 'eggplant',
             'banana',
             'sample' => 'apple',
             17 => 'dandelion',
             'carrot');
sort($arr);
/*
array (
  0 => 'apple',
  1 => 'banana',
  2 => 'carrot',
  3 => 'dandelion',
  4 => 'eggplant'
)
*/
 
$arr = array('25',
             43,
             8004,
             3,
             '8004',
             0,
             -52);
sort($arr);
/*
array (
  0 => -52,
  1 => 0,
  2 => 3,
  3 => '25',
  4 => 43,
  5 => '8004',
  6 => 8004
)
*/
 
$arr = array('25',
             43,
             8004,
             3,
             '8004',
             0,
             -52);
sort($arr, SORT_STRING);
/*
array (
  0 => -52,
  1 => 0,
  2 => '25',
  3 => 3,
  4 => 43,
  5 => 8004,
  6 => '8004'
)
*/

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

array_sum()

php|nightly — Mon, 08 Mar 2010 20:32:01 +0000

This function will add up the values of an array. Values will be converted to integer or float for calculation only. The array will remain unchanged.

Nested arrays will be ignored regardless of their values. Consider them zero to this function.

$arr = array(2,
             4,
             6,
             '5');
 
$sum = array_sum($arr); // 17
 
 
$arr = array(2,
             4,
             6,
             '5',
             true);
 
$sum = array_sum($arr); // 18
 
 
$arr = array(2,
             4,
             3.7,
             -82);
 
$sum = array_sum($arr); // -72.3
 
 
$x = array(15,
           23);
$y = '12Monkeys';
$arr = array(2,
             4,
             $x,
             $y);
 
$sum = array_sum($arr); // 18

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

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