Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Function Reference : Array Functions

Array Functions

Introduction

These functions allow you to interact with and manipulate arrays in various ways. Arrays are essential for storing, managing, and operating on sets of variables.

Simple and multi-dimensional arrays are supported, and may be either user created or created by another function. There are specific database handling functions for populating arrays from database queries, and several functions return arrays.

Please see the Arrays section of the manual for a detailed explanation of how arrays are implemented and used in PHP. See also Array operators for other ways how to manipulate the arrays.

Requirements

No external libraries are needed to build this extension.

Installation

There is no installation needed to use these functions; they are part of the PHP core.

Runtime Configuration

This extension has no configuration directives defined in php.ini.

Resource Types

This extension has no resource types defined.

Predefined Constants

The constants below are always available as part of the PHP core.

CASE_LOWER (integer)
CASE_LOWER is used with array_change_key_case() and is used to convert array keys to lower case. This is also the default case for array_change_key_case().
CASE_UPPER (integer)
CASE_UPPER is used with array_change_key_case() and is used to convert array keys to upper case.

Sorting order flags:

SORT_ASC (integer)
SORT_ASC is used with array_multisort() to sort in ascending order.
SORT_DESC (integer)
SORT_DESC is used with array_multisort() to sort in descending order.

Sorting type flags: used by various sort functions

SORT_REGULAR (integer)
SORT_REGULAR is used to compare items normally.
SORT_NUMERIC (integer)
SORT_NUMERIC is used to compare items numerically.
SORT_STRING (integer)
SORT_STRING is used to compare items as strings.
SORT_LOCALE_STRING (integer)
SORT_LOCALE_STRING is used to compare items as strings, based on the current locale. Added in PHP 4.4.0 and 5.0.2.
COUNT_NORMAL (integer)
COUNT_RECURSIVE (integer)
EXTR_OVERWRITE (integer)
EXTR_SKIP (integer)
EXTR_PREFIX_SAME (integer)
EXTR_PREFIX_ALL (integer)
EXTR_PREFIX_INVALID (integer)
EXTR_PREFIX_IF_EXISTS (integer)
EXTR_IF_EXISTS (integer)
EXTR_REFS (integer)

See Also

See also is_array(), explode(), implode(), split(), preg_split(), and unset().

Table of Contents

array_change_key_case — Changes all keys in an array
array_chunk — Split an array into chunks
array_combine — Creates an array by using one array for keys and another for its values
array_count_values — Counts all the values of an array
array_diff_assoc — Computes the difference of arrays with additional index check
array_diff_key — Computes the difference of arrays using keys for comparison
array_diff_uassoc — Computes the difference of arrays with additional index check which is performed by a user supplied callback function
array_diff_ukey — Computes the difference of arrays using a callback function on the keys for comparison
array_diff — Computes the difference of arrays
array_fill_keys — Fill an array with values, specifying keys
array_fill — Fill an array with values
array_filter — Filters elements of an array using a callback function
array_flip — Exchanges all keys with their associated values in an array
array_intersect_assoc — Computes the intersection of arrays with additional index check
array_intersect_key — Computes the intersection of arrays using keys for comparison
array_intersect_uassoc — Computes the intersection of arrays with additional index check, compares indexes by a callback function
array_intersect_ukey — Computes the intersection of arrays using a callback function on the keys for comparison
array_intersect — Computes the intersection of arrays
array_key_exists — Checks if the given key or index exists in the array
array_keys — Return all the keys of an array
array_map — Applies the callback to the elements of the given arrays
array_merge_recursive — Merge two or more arrays recursively
array_merge — Merge one or more arrays
array_multisort — Sort multiple or multi-dimensional arrays
array_pad — Pad array to the specified length with a value
array_pop — Pop the element off the end of array
array_product — Calculate the product of values in an array
array_push — Push one or more elements onto the end of array
array_rand — Pick one or more random entries out of an array
array_reduce — Iteratively reduce the array to a single value using a callback function
array_reverse — Return an array with elements in reverse order
array_search — Searches the array for a given value and returns the corresponding key if successful
array_shift — Shift an element off the beginning of array
array_slice — Extract a slice of the array
array_splice — Remove a portion of the array and replace it with something else
array_sum — Calculate the sum of values in an array
array_udiff_assoc — Computes the difference of arrays with additional index check, compares data by a callback function
array_udiff_uassoc — Computes the difference of arrays with additional index check, compares data and indexes by a callback function
array_udiff — Computes the difference of arrays by using a callback function for data comparison
array_uintersect_assoc — Computes the intersection of arrays with additional index check, compares data by a callback function
array_uintersect_uassoc — Computes the intersection of arrays with additional index check, compares data and indexes by a callback functions
array_uintersect — Computes the intersection of arrays, compares data by a callback function
array_unique — Removes duplicate values from an array
array_unshift — Prepend one or more elements to the beginning of an array
array_values — Return all the values of an array
array_walk_recursive — Apply a user function recursively to every member of an array
array_walk — Apply a user function to every member of an array
array — Create an array
arsort — Sort an array in reverse order and maintain index association
asort — Sort an array and maintain index association
compact — Create array containing variables and their values
count — Count elements in an array, or properties in an object
current — Return the current element in an array
each — Return the current key and value pair from an array and advance the array cursor
end — Set the internal pointer of an array to its last element
extract — Import variables into the current symbol table from an array
in_array — Checks if a value exists in an array
key — Fetch a key from an associative array
krsort — Sort an array by key in reverse order
ksort — Sort an array by key
list — Assign variables as if they were an array
natcasesort — Sort an array using a case insensitive "natural order" algorithm
natsort — Sort an array using a "natural order" algorithm
next — Advance the internal array pointer of an array
pos — Alias of current()
prev — Rewind the internal array pointer
range — Create an array containing a range of elements
reset — Set the internal pointer of an array to its first element
rsort — Sort an array in reverse order
shuffle — Shuffle an array
sizeof — Alias of count()
sort — Sort an array
uasort — Sort an array with a user-defined comparison function and maintain index association
uksort — Sort an array by keys using a user-defined comparison function
usort — Sort an array by values using a user-defined comparison function

Code Examples / Notes » ref.array

sebastian
xxellisxx at gmail dot com:
see implode(), it does exactly what you want, but quicker.
$array = array();
$string = implode( '', $array );

administrador ensaimada sphoera punt com
With this simple function you can convert a (partial) bidimensional array into a XHTML table structure:
<?php
$table = array();
$table[1][1] = "first";
$table[2][1] = "second";
$table[5][3] = "odd one";
$table[1][2] = "third";
echo matrix2table($table);
function matrix2table($arr,$tbattrs = "width='100%' border='1'", $clattrs="align='center'"){
$maxX = $maxY = 1;
for ($x=0;$x<100;$x++){
for ($y=0;$y<100;$y++){
if ($arr[$x][$y]!=""){
if ($maxX < $x) $maxX = $x;
if ($maxY < $y) $maxY = $y;
}
}
}
$retval = "<table $tbattrs>\n";
for ($x=1;$x<=$maxX;$x++){
$retval.=" <tr>\n";
for ($y=1;$y<=$maxY;$y++){
   $retval.= (isset($arr[$x][$y]))
?"  <td $clattrs>".$arr[$x][$y]."</td>\n"
:"  <td $clattrs>&nbsp;</td>\n";
}
$retval.=" </tr>\n";
}
return $retval."</table>\n";
}
?>
more scripts at http://www.sphoera.com

psbrogna
Why is a deep copy function needed to move a sub array? I've just used the equality operator as in the code below.
<?php
$a= array(
   'a'=>'apple',
   'b'=>'banana',
   'c'=>'cherry',
   'subArray'=>array(
     'A'=>'APPLE',
     'B'=>'BANANA',
     'C'=>'CHERRY'
   )
 );
$a['copiedArray']= $a['subArray']; unset($a['subArray']);
var_dump($a);
?>
The above outputs the $a array with copiedArray being present and subArray gone. (php version: 4.4.0).

shufty
when using Nimja's function, it was removing values that equaled 0, the following function counters this
<?php
function cleanArray($array) {
   foreach ($array as $key => $value) {
       if ($value == "") unset($array[$key]);
   }
   return $array;
}
?>

james churchman
very simple tip.. if you want an array's keys.. but not the values in it then this will do the trick
$keys_only_array = array_flip(array_keys($origional_array_with_keys_and_values));
james

mark lindeman
Very simple solution for changing the key of an associative array, of course it will fail in a lot of scenarios, but will do the trick in simple arrays:
<?php
function replace_key(&$input, $from_key, $to_key)
{
$input = unserialize(str_replace(':"'.$from_key.'";', ':"'.$to_key.'";',serialize($input)));
}
$array =array("a"=>1, "B"=>2, "c"=>3);
replace_key($array, "B", "b");
print_r($array);
?>
Output:
Array
(
   [a] => 1
   [b] => 2
   [c] => 3
)

za
Updated functions for moving element between associative arrays using a numeric index.
Sample:
$a=array("04"=>"alpha",4=>"bravo","c"=>"charlie","d"=>"delta");
$b=array_move($a,4,2);
Move element "bravo" after "delta" keeping keys.
Old function probably goes wrong moving "alpha": caused by array_search that match numeric index 4 with "04" (string).
Follow:
<?php
// array functions - 20/07/2006 12.28
if(!defined("ARRAY_FUNCS")) {
// Swap 2 elements in array preserving keys.
function array_swap(&$array,$key1,$key2) {
$v1=$array[$key1];
$v2=$array[$key2];
$out=array();
foreach($array as $i=>$v) {
if($i===$key1) {
$i=$key2;
$v=$v2;
} else if($i===$key2) {
$i=$key1;
$v=$v1;
}
$out[$i]=$v;
}
return $out;
}

//  Get a key position in array
function array_kpos(&$array,$key) {
$x=0;
foreach($array as $i=>$v) {
if($key===$i) return $x;
$x++;
}
return false;
}

// Return key by position
function array_kbypos(&$array,$pos) {
$x=0;
foreach($array as $i=>$v) {
if($pos==$x++) return $i;
}
return false;
}
// Move an element inside an array preserving keys
// $relpos should be like -1, +2...
function array_move(&$array,$key,$relpos) {
if(!$relpos) return false;
$from=array_kpos($array,$key);
if($from===false) return false;
$to=$from+$relpos+($relpos>0?1:0);
$len=count($array);
if($to>=$len) {
$val=$array[$key];
unset($array[$key]);
$array[$key]=$val;
} else {
if($to<0) $to=0;
$new=array();
$x=0;
foreach($array as  $i=>$v) {
if($x++==$to) $new[$key]=$array[$key];
if($i!==$key) $new[$i]=$v;
}
$array=$new;
}
return $array;
}
define("ARRAY_FUNCS",true);
}
?>

31-jan-2004 09:29
To remove an element from an array use unset(). Example:
unset($bar['mushroomsoup']);

aidan
To convert an array to a HTML table, see:
http://aidanlister.com/repos/v/function.array2table.php
PEAR also provides a simular package with many more features,
http://pear.php.net/package/Var_Dump

mo dot longman
to 2g4wx3:
i think better way for this is using JSON, if you have such module in your PHP. See json.org.
to convert JS array to JSON string: arr.toJSONString();
to convert JSON string to PHP array: json_decode($jsonString);
You can also stringify objects, numbers, etc.

phpnet_spam
Thought this might save someone a few hours. :)  Feedback welcome, of course!  Public domain, yadda yadda.
function assocSort(&$array,$key) {
   if (!is_array($array) || count($array) == 0) return true;
   $assocSortCompare  = '$a = $a["'.$key.'"]; $b = $b["'.$key.'"];';
   if (is_numeric($array[0][$key])) {
     $assocSortCompare.= ' return ($a == $b) ? 0 : (($a < $b) ? -1 : 1);';
   } else {
     $assocSortCompare.= ' return strcmp($a,$b);';
   }
   $assocSortCompare = create_function('$a,$b',$assocSortCompare);
   return usort($array,$assocSortCompare);
}

nick
This little function will move an array element up or down. Unlike the similar function in a previous comment this will work for associative arrays too.
Because it uses current to traverse the array it will fail if a value is false (or 0). It could probably be rewritten to use each() but I couldn't work it out.
<?php
function array_move_element($array, $value, $direction = 'up') {

$temp = array();

if(end($array) == $value && $direction == 'down') {
return $array;
}
if(reset($array) == $value && $direction == 'up') {
return $array;
}
while ($array_value = current($array)) {

$this_key = key($array);
if ($array_value == $value) {
if($direction == 'down') {
$next_value = next($array);
$temp[key($array)] = $next_value;
$temp[$this_key] = $array_value;
} else {
$prev_value = prev($array);
$prev_key = key($array);
unset($temp[$prev_key]);
$temp[$this_key] = $array_value;
$temp[$prev_key] = $prev_value;
next($array);
next($array);
}
continue;
} else {
$temp[$this_key] = $array_value;
}
next($array);
}
return $temp;

}
?>

frando
This is a super-hard array conversion function.
It only returns TRUE if the two arrays are completely identical, that means that they have the same keys, and the values of all keys are exactly the same (compared with ===).
<?php
function array_same($a1, $a2) {
 if (!is_array($a1) || !is_array($a2))
   return false;
 
 $keys = array_merge(array_keys($a1), array_keys($a2));
 
 foreach ($keys as $k) {
   if (!isset($a2[$k]) || !isset($a1[$k]))
     return false;
     
   if (is_array($a1[$k]) || is_array($a2[$k])) {
     if (!array_same($a1[$k], $a2[$k]))
       return false;
   }
   else {
     if (! ($a1[$k] === $a2[$k]))
       return false;
   }
 }
 
 return true;
}
?>

phamphong_tn
This is a code remove an other row of array
<?php
//$mang is an array, $id is index of row in array
function remove($mang,$id)
{
$flag = false;
$count = count($mang);
$i = 0;
while ($flag!=true && $i<$count) {
if ($i==$id) {
unset($mang[$i]);
$flag = true;
$index = $i;
}
else {
if ($temp) {
array_push($temp,$mang[$i]);
}
else
{
$temp = array($mang[$i]);
}
}
$i++;
}
if ($flag) {
while ($index<$count)
{
if ($temp) {
array_push($temp,$mang[$index+1]);
}
else
{
$temp = array($mang[$index+1]);
}
$index++;
}
}
array_pop($temp);
return $temp;
}
$arr = array(array("id"=>"1","name"=>"b"),array("id"=>"2","name"=>"d"));
array_push($arr,array("id"=>"3","name"=>"f"));
array_push($arr,array("id"=>4,"name"=>"g"));
$arr = remove($arr,2);
echo "<pre>";
print_r($arr);
?>

alessandronunes
The Ninmja sugestion plus multidiomensional array search (recursive):
function cleanArray($array) {
  foreach ($array as $index => $value) {
if(is_array($array[$index])) $array[$index] = cleanArray($array[$index]);
if (empty($value)) unset($array[$index]);
  }
  return $array;
}

ryan1_00
The following will take a query result and create a dynamic table for it. Using the Key() function to get the table headers and the current() function for the actual values.
$result = mysql_query($qry) or die ("<center> ERROR: ".mysql_error()."</center>");
 
  $x = 0;
  echo "<table border=\"1\" align=\"center\">";  
  while($row = mysql_fetch_assoc($result))
{
if ($x == 0) // so that table headers are only created on the first pass
{
$col = (count($row)); // counts number of elements in the array
  $x=1;
echo "<tr>";
for ($y=0; $y<$col; $y++)
{
echo "<th>";
echo key($row); // gets the names of the fields
echo "</th>";
next($row);
}
echo "</tr>";
}
reset($row);
echo "<tr>";
for ($y=0; $y<$col; $y++)
{
echo "<td valign=\"top\" align=\"left\">";
echo current($row);
echo"</td>";
next($row);
}
echo "</tr>";
}  // end of while loop

zspencer
The array system is sadly lacking a "set" function... I needed one that would set the pointer to the key that I specified.
So I wrote my own.
<?
$array=array();
$array['a']='lala';
$array['b']='blabla';
$array['c']='nono';
set($array, 'b');
echo current($array);
// outputs blabla
function set(&$array, $key)
{
reset($array);
while($current=key($array))
{
if($current==$key)
{
return true;
}
next($array);
}
return false;

}
?>

xxellisxx
Super simple way of converting an array to a string.
function array_to_string($array)
{
 foreach ($array as $index => $val)
  {
   $val2 .=$val;
  }
 return $val2;
}

admin \x40 uostas.net
simple function to remove element from array
saving index sequence
<?php
function array_remval($val,&$arr){
 $i=array_search($val,$arr);
 if($i===false)return false;
 $arr=array_merge(array_slice($arr, 0,$i), array_slice($arr, $i+1));
 return true;
}
?>
example:
<?php
$input=Array('a','b','c','d','e');
array_remval('d',$input);
//result:
//Array('a','b','c','e');
?>

daenders
Several people here have posted functions for converting arrays to strings, but nobody posted a sister function that would convert it back.  Also, their data is not URL safe.  These functions are URL safe, hide the data by MIME encoding it, and are much shorter.  Enjoy.  :-)
<?php
// Converts an array to a string that is safe to pass via a URL
function array_to_string($array) {
   $retval = '';
   foreach ($array as $index => $value) {
       $retval .= urlencode(base64_encode($index)) . '|' . urlencode(base64_encode($value)) . '||';
   }
   return urlencode(substr($retval, 0, -2));
}
   
// Converts a string created by array_to_string() back into an array.
function string_to_array($string) {
   $retval = array();
   $string = urldecode($string);
   $tmp_array = explode('||', $string);
   foreach ($tmp_array as $tmp_val) {
       list($index, $value) = explode('|', $tmp_val);
       $retval[base64_decode(urldecode($index))] = base64_decode(urldecode($value));
   }  
   return $retval;
}
// Example:
$array1 = array('index1' => 'val1', 'index2' => 'val2', 'index3' => 'val3');
echo '<pre>'; print_r($array1); echo '</pre>';
$string = array_to_string($array1);
echo '$string: '.$string.'<br />';
$array2 = string_to_array($string);
echo '<pre>'; print_r($array2); echo '</pre>';
?>

michael
Reply to array_cartesian_product of skopek at mediatac dot com, 13-Oct-2004 12:44:
Your function does not work in my configuration (WinXP, apache 2.0, php 4.3.11).
This part of code:
...
} else { //if next returns false, then reset and go on with previuos array...
 reset($arrays[$j]);
}
...
cause infinite loop.
Replacing to
...
} elseif (isset($arrays[$j])) {
 reset($arrays[$j]);
}
...
works good.
My complete working function (additionaly strings as keys are allowed):
<?php
function array_cartesian_product($arrays)
{
$result = array();
$arrays = array_values($arrays);
$sizeIn = sizeof($arrays);
$size = $sizeIn > 0 ? 1 : 0;
foreach ($arrays as $array)
$size = $size * sizeof($array);
for ($i = 0; $i < $size; $i ++)
{
$result[$i] = array();
for ($j = 0; $j < $sizeIn; $j ++)
array_push($result[$i], current($arrays[$j]));
for ($j = ($sizeIn -1); $j >= 0; $j --)
{
if (next($arrays[$j]))
break;
elseif (isset ($arrays[$j]))
reset($arrays[$j]);
}
}
return $result;
}
?>

r2rien
Regarding the string to array (parse_array) function posted by Kevin Law(thanks) and urlencoded by vinaur(thanks) ,
The function will not work correctly if you use integer values as keys.
Thus I exchanged array_merge with a simple combined operator.
For example dealing with 4digit year strings as keys; parse_array(2006:abc,B:bcd) will produce
=> with array_merge:
<?php //...
$result = array_merge($result, parse_line2array(substr($line,$comma_pos+1)));
//...
$result = array_merge($result, parse_line2array($line));
//... ?>
Array (
   [0] => abc
   [B] => bcd
)
=> with combined operator:
<?php //...
$result += parse_line2array(substr($line,$comma_pos+1));
//...
$result += parse_line2array($line);
//... ?>
Array
(
   [2006] => abc
   [B] => bcd
)

ob
Regarding the function of spam at madhermit dot net from January 9th 2006:
That function only preserves the deepest keys and values.
If you try to flatten an array with that function where the deepest instance of keys might be the same where as keys in the "key-path" are different, values will be overwritten.
So here is a function that preserves the whole key-path and the keys of the flattened array will be string keys consisting of the key-path separated by $Separator.
<?php
// flatten multidimensional array to one dimension
// preserves keys by generating a key for the flattened array which consists of the
// key-path of the multidimensional array separated by $Separator
// usage: array ArrayFlatten( array Array [, string Separator] )
function ArrayFlatten($Array,$Separator="_",$FlattenedKey='') {
 $FlattenedArray=Array();
 foreach($Array as $Key => $Value) {
   if(is_Array($Value))
     $FlattenedArray=Array_merge($FlattenedArray,
                                 ArrayFlatten($Value,$Separator,
                                              (strlen($FlattenedKey)>0
                                               ?$FlattenedKey.$Separator
                                               :"").$Key)
                                              );
   else
     $FlattenedArray[$FlattenedKey.$Separator.$Key]=$Value;
 }
 return $FlattenedArray;
}
?>

vinaur
Regarding the array to string (parse_line) and string to array (parse_array) functions posted below by Kevin Law.
The functions will not work correctly if the array being parsed contains values that include commas and possibly parentheses.
To solve this problem I added urlencode and urldecode functions and the result looks like this:
<?php
function parse_line($array){
$line = "";
foreach($array AS $key => $value){
if(is_array($value)){
$value = "(". parse_line($value) . ")";
}
else
{
$value = urlencode($value);
}
$line = $line . "," . urlencode($key) . ":" . $value . "";            
}
$line = substr($line, 1);
return $line;
}
function parse_array($line){
  $q_pos = strpos($line, ":");
  $name = urldecode(substr($line,0,$q_pos));
  $line = trim(substr($line,$q_pos+1));
  $open_backet_pos = strpos($line, "(");
  if($open_backet_pos===false || $open_backet_pos>0){
      $comma_pos = strpos($line, ",");
      if($comma_pos===false){
          $result[$name] = urldecode($line);
          $line = "";
      }else{
          $result[$name] = urldecode(substr($line,0,$comma_pos));
          $result = array_merge($result, parse_array(substr($line,$comma_pos+1)));
          $line = "";
      }
  }else if ($open_backet_pos==0){
      $line = substr($line,1);
      $num_backet = 1;
      $line_char_array = str_split($line);
      for($index = 0; count($line_char_array); $index++){
          if($line_char_array[$index] == '('){
              $num_backet++;
          }else if ($line_char_array[$index] == ')'){
              $num_backet--;
          }
          if($num_backet == 0){
              break;
          }
      }
      $sub_line = substr($line,0,$index);
      $result[$name] = parse_array($sub_line);
      $line = substr($line,$index+2);
  }
  if(strlen($line)!=0){
      $result = array_merge($result, parse_array($line));
  }
  return $result;
}
?>

ob
Regarding my own posting 2 postings down about the function ArrayDepth() to find the maximum depth of a multidimensional array:
A number of functions for counting array dimensions have been posted. And I tried using them. Yet, if at all they only return the depth of the first branch of the array. They can not handle arrays where a later path holds a more dimension than the first.
My version will check all paths down the array and return the maximum depth. That's why I posted it.

hayley watson
Regarding cyberchrist at futura dot net's function. It makes an unnecessary array_merge(); the elements of $b that are merged with those of $a are immediately removed again by the array_diff(). The "limiting to known values" is entirely unnecessary, in other words: arrays already only contain "known values".
Also, the description and function only address the issue of whether $a is a subset of $b, not whether it is a proper subset. For $a to be a proper subset of $b, it must also be the case that $b is not a subset of $a.
Taking those points into account (and a personal aesthetic dislike of "if(test) return true; else return false;" gives:
<?php
function is_subset($a, $b)
{
return count(array_diff($a,$b))==0;
}
function is_proper_subset($a, $b)
{
return is_subset($a, $b) && !is_subset($b, $a);
}
?>

padraig
Re removing blank elements from arrays, this is even more concise:
<?php
$arraytest = array_diff($arraytest, array(""));
?>

kthejoker - google mail
re jeremyquintion:
your solution is array_merge(), which will reindex a numeric array.
So if you have
$array[0] = "something";
$array[1] = "something else";
$array[2] = "yet another";
unset($array[1]);
array_merge($array);
the result is
$array[0] = "something";
$array[1] = "yet another";
and then you can use a for loop accordingly. Obviously this isn't ideal if you want to maintain key association.

php_spam {at erif dot org
public domain, yadda yadda. :)
This function takes a flatfile-like array (like the results of a joined query) and normalizes it based on whichever parameters you like.
<?php
 function hashByFields($things,$fields) {
   $retval=null;
   $count = count($fields);
   foreach ($things as $thing) {
     $fwibble =& $retval;
     for ($j=0;$j<$count;$j++) {
       $val = $thing[$fields[$j]];
       if ($j == $count - 1) {
         $fwibble[$val] = $thing;
       } else if (!isset($fwibble[$val])) {
         $fwibble[$val] = Array();
       }
       $fwibble =& $fwibble[$val];
     }
   }
   return $retval;
 }
?>

php_spam
Public domain, yadda yadda.  This is an extension of the assocSort below, patched up a bit.  Feedback would be wonderful.
<?php
 function assocMultiSort(&$array,$keys,$directions=true) {
   if (!is_array($array) || count($array) == 0) return true;
   if (!is_array($keys)) { $keys = Array($keys); }
   //we want "current" instead of necessarily the "zeroth" element; there may not be a zeroth element
   $test = current($array);
   $assocSortCompare = '';
   for ($i=0,$count=count($keys);$i<$count;$i++) {
     $key = $keys[$i];
     if (is_array($directions)) {
       $direction = $directions[$i];
     } else {
       $direction = $directions;
     }
     if ($i > 0) $assocSortCompare .= 'if ($retval != 0) return $retval; ';
     $assocSortCompare .= '$ax = $a["'.$key.'"]; $bx = $b["'.$key.'"];';
     //TODO -- if it's "blank", search up the list until we find something not blank
     if (is_numeric($test[$key]) || ($test[$key] == ((int)$test[$key]))) {
       if ($direction) {
         $assocSortCompare.= ' $retval = ($ax == $bx) ? 0 : (($ax < $bx) ? -1 : 1);';
       } else {
         $assocSortCompare.= ' $retval = ($ax == $bx) ? 0 : (($ax < $bx) ? 1 : -1);';
       }
     } else {
       if ($direction) {
         $assocSortCompare.= ' $retval = strcmp($ax,$bx);';
       } else {
         $assocSortCompare.= ' $retval = strcmp($bx,$ax);';
       }
     }
   }
   $assocSortCompare.= ' return $retval;';
   $assocSortCompare = create_function('$a,$b',$assocSortCompare);
   $retval = usort($array,$assocSortCompare);
   return $retval;
 }
?>

tvscoundrel
phamphong_tn's function to remove an element from an array seems a bit complicated for something that is actually quite simple.
Here's another way to remove an element from an array:
<?php
//the function
function removeArrayElement(&$arr, $index){
if(isset($arr[$index])){
array_splice($arr, $index, 1);
}
}
//testing the function
$test = array("zero", "one", "two", "three");
echo "<pre>";
print_r($test);
echo "</pre>";
$this->removeArrayElement($test, 2);
echo "<pre>";
print_r($test);
echo "</pre>";
?>
output:
Array
(
   [0] => zero
   [1] => one
   [2] => two
   [3] => three
)
Array
(
   [0] => zero
   [1] => one
   [2] => three
)
To remove an element from an associative array is even simpler:
unset($arr[$index]);

sneskid
notice
<?php
$v = array();
$v['0'] = 's';
$v[0] = 'i';
echo $v['0'];
echo $v[0];
$v['.1'] = 's';
$v[.1] = 'i';
echo $v['.1'];
echo $v[.1];
$v['0.1'] = 's';
$v[0.1] = 'i';
echo $v['0.1'];
echo $v[0.1];
// output: iisi
foreach($v as $key => $val) echo $v[$key] . ' : ' . $val . "\r\n";
// output: iisi
?>
This means foreach preserves the key data type, it also means arrays distinguish between float numbers and float like  strings, unlike integers

rune
Notice that keys are considered equal if they are "=="-equal. That is:
<?
$a = array();
$a[1] = 'this is the first value';
$a[true] = 'this value overrides the first value';
$a['1'] = 'so does this one';
?>

eddypearson
Little function to remove blank values from an array (will not reorder indexes however):
function CleanA($arr) {
while ($count < count($arr)) {
if ($arr[$count] == "") {
unset($arr[$count]);
}
$count++;
}
return $arr;
}

cyberchrist
Lately, dealing with databases, I've been finding myself needing to know if one array, $a, is a proper subset of $b.
Mathematically, this is asking (in set theory) [excuse the use of u and n instead of proper Unicode):

( A u B ) n ( ~ B )
What this does is it first limits to known values, then looks for anything outside of B but in the union of A and B (which would be those things in A which are not also in B).
If any value exists in this set, then A is NOT a proper subset of B, because a value exists in A but not in B.  For A to be a proper subset, all values in A must be in B.
I'm sure this could easily be done any number of ways but this seems to work for me.  It's not got a lot of error detection such as sterilizing inputs or checking input types.
// bool array_subset( array, array )
// Returns true if $a is a proper subset of $b, returns false otherwise.
function array_subset( $a, $b )
{
   if( count( array_diff( array_merge($a,$b), $b)) == 0 )
       return true;
   else
       return false;
}

dieter peeters
in response to: Domenic Denicola
I reworked your function a bit and thought i just as well could post it.
Below is the cleaner version, just cut and paste ;) The third parameter is of little use to the coder, unless javascript declaration of variables changes at some point in the future - who knows.
Only minor point is the added parameter which probably gets copied every recursive call with an empty value, though i don't know the exact ways how php handles recursion internally. Most of the time php is pretty smart when optimizing code and an empty string shouldn't take much memory anyway :)
<?php
function phpArrayToJsArray($name,$array,$prePend='var ')
{
   if (is_array($array)) { // Array recursion
       $result = $name.' = new Array();'."\n";
       foreach ($array as $key => $value) {
          $result .= phpArrayToJsArray($name.'["'.$key.'"]',$value,'');
       }
   } else {  // Base case of recursion
       $result = $name.' = "'.$array.'";'."\n";
   }
   return $prePend.$result;
}
?>

ben
In reference to the cleanArray function below, note that it checks the value using the empty() function and removes it. This will also remove the integer value 0 and the string "0" among other possibly unexpected things. Check the manual entry for empty().

sergio
In a pratical problem, I was involved in a system of queries giving the behaviour of all combinations of some parameters. How to write those queries?
The problem was to generate automatically every possible combination of those parameters. I didn't find a function and I wrote it.
(Naturally, a different way could be to build a binary sequence, but I find this function more compact and useful).
So, consider an array of objects and suppose to need all possibile combinations of those objects. Here is the function, that could be useful for some folk.
Enjoy.
<?php
function combinations($elements) {
        if (is_array($elements)) {
           /*
           I want to generate an array of combinations, i.e. an array whose elements are arrays
           composed by the elements of the starting object, combined in all possible ways.
           The empty array must be an element of the target array.
           */
           $combinations=array(array()); # don't forget the empty arrangement!
           /*
           Built the target array, the algorithm is to repeat the operations below for each object of the starting array:
           - take the object from the starting array;
           - generate all arrays given by the target array elements merged with the current object;
           - add every new combination to the target array (the array of arrays);
           - add the current object (as a vector) to the target array, as a combination of one element.
           */
           foreach ($elements as $element) {
                   $new_combinations=array(); # temporary array, see below
                   foreach ($combinations as $combination) {
                           $new_combination=array_merge($combination,(array)$element);
                           # I cannot merge directly with the main array ($combinations) because I'm in the foreach cycle
                           # I use a temporary array
                           array_push($new_combinations,$new_combination);
                           }
                   $combinations=array_merge($combinations,$new_combinations);
                   }
           return $combinations;
           } else {
           return false;
           }
        }
?>
To test the function:
<?php
$elements=array('bitter','sour','salty','sweet');
print_r(combinations($elements));
?>
The exemple was suggested in 6th century BC.
See why on: http://en.wikipedia.org/wiki/Combinatorics#Overview_and_history

wmakend
if you want to sort array like this one
$aInt = array('1','2','3','4');
and you to have somethings like this
1 --- 2
1 --- 3
1 --- 4
2 --- 3
2 --- 4
3 --- 4
you can do this like with
$NumInt = count($aInt);
for($j=0; $j<=$NumInt-1; $j++){        
       $first = $aInt[$j];
           for ($i=1; $i<=$NumInt-1-$j; $i++) {
               echo $first." --- ".$aInt[$i+$j]."
";
           }      
}

sean
I wrote this function to parse arrays so they work with SQL strings if you need to use the MySQL "IN()" function.
function format_sql_array($array)
{
$SQLstring = "";
foreach($array as $item)
 {
$SQLstring .= "'$item',";
 }
$SQLstring = rtrim($SQLstring, ",");
$SQLstring = str_replace("'',", "", $SQLstring);
return $SQLstring;
}
Example:
$my_array = array("red", "blue", "green");
$sql_array = format_sql_array($my_array);
//$sql_array is now "'red','blue','green'"
Sample SQL:
$SQL = "SELECT FROM colors_table WHERE color IN($sql_array)";

g4wx3
I needed a function to convert a php array into a javascript array.
No problem i found it on "the net".
But the function i found wasn't good enough, instead of return a string with javascript-array it echoed directly everything.
I wanted to write the string to a file, when calling the function out of my function libary.
Secondly, there where minor "bugs" in the script, when you're original array contained characters like line breaks(\r\n,..), or quotes('), it would hack up the javascript array
Sow, i changed the function and fixed the bug.
<?php
//SUPER COOL : http://www.communitymx.com/content/article.cfm?page=3&cid=7CD16
//Checkout:  REVERSE: http://www.hscripts.com/tutorials/php/jsArrayToPHP.php
//Convert a PHP array to a JavaScript one (rev. 4)
//Changlog by g4wx3: echo replaced by $output, added function output
function output($string) //make javascript ready
{
$string = str_replace( array( '\\' , '\'' ), array('\\\\', '\\\'') , $string); //-> for javascript array
$string = str_replace(  array("\r\n", "\r", "\n") , '
' , $string); //nl2br
return $string;
}
function arrayToJS4($array, $baseName ) {
//Write out the initial array definition
//v4 echo ($baseName . " = new Array(); \r\n ");
$output = $baseName . " = new Array(); \r\n ";
//Reset the array loop pointer
reset ($array);
//Use list() and each() to loop over each key/value
//pair of the array
while (list($key, $value) = each($array)) {
if (is_numeric($key)) {
//A numeric key, so output as usual
$outKey = "[" . $key . "]";
} else {
//A string key, so output as a string
$outKey = "['" . $key . "']";
}
     
if (is_array($value)) {
//The value is another array, so simply call
//another instance of this function to handle it
$output .= arrayToJS4($value, $baseName . $outKey);
} else {
//Output the key declaration
//v4 echo ($baseName . $outKey . " = ");      
$output .= $baseName . $outKey . " = ";

//Now output the value
if (is_string($value)) {
//Output as a string, as we did before      
//v4 echo ("'" . output($value) . "'; \r\n ");
$output .= "'" . output($value) . "'; \r\n ";
} else if ($value === false) {
//Explicitly output false
//v4 echo ("false; \r\n");
$output .= "false; \r\n";
} else if ($value === NULL) {
//Explicitly output null
//v4 echo ("null; \r\n");
$output .= "null; \r\n";
} else if ($value === true) {
//Explicitly output true
//v4 echo ("true; \r\n");
$output .= "true; \r\n";
} else {
//Output the value directly otherwise
//v4 echo ($value . "; \r\n");
$output .= $value . "; \r\n";
}
}
}
return $output;
}
?>
You can use this for printing $_GET array, for example

stalker
I had some problems while selecting sub-arrays from multi-dimensional arrays (like the SQL-WHERE clause), so i wrote the following function:
<?php
function selectMultiArray($__multiarray,$__key,$__value) {
 foreach($__multiarray as $multipart) {
   if($multipart[$__key] == $__value) {
     $__return[] = $multipart;
   }
 }
 if(empty($__return)) {
   return FALSE;
 }
 return $__return;
}
?>
hope someones finding this helpful. If you have better was for getting to this, please answer.
greets,
St4Lk3R

djspy187
I had an issue with arrays and copying them by reference as follows.
// Loop on the list and insert default values
foreach ($navigation as &$item)
{
$children = &$item['children']};
foreach ($children as &$child)
{
// Do stuff
}
}
This would give me error message
Fatal error: Cannot create references to/from string offsets nor overloaded objects in /var/www/dev/kh_system/navigation.php on line 103
Even though $item['children'] is an array.
The workaround is to do a for ($i =0;$i < count($Item);$i++) and to then access the children like this
$navigation[$i]['children']

colin
I couldn't get the previous set pointer functions working for whatever reason so I modifed. I trigger errors if needed but obviously you can do whatever
// setPointer - Sets the pointer to the provided $key in provided $array
final private function setPointer(&$array, $set_key) {

// Check if $array is an array
if (!is_array($array)) {
trigger_error('$array must be an array', E_USER_ERROR);
}

// Check if $key is in $array
if (!array_key_exists($set_key, $array)) {
trigger_error('$set_key must exist in $array', E_USER_ERROR);
}
// Set array pointer to first element
reset($array);

// Cycle through array
while ($set_key != key($array)) {

// Advance the pointer
next($array);
}
}
Try with:
$array = array();
$array[0] = 'zero';
$array[1] = 'one';
$array[2] = 'two';
$array[3] = 'three';
// Set the pointer
setPointer($array, 1);
// Display elements
echo current($array); // Outputs 'one'
echo next($array); // Outputs 'two'

m227 a poczta.onet.pl
How to count dimensions in multi-array? (corrected)
previous version didn't work when called more than one time.
($dimcount was preserved from previous call)
This is the way I corrected this:
function countdim($array)
 {
   if (is_array(reset($array)))  
     $return = countdim(reset($array)) + 1;
   else
     $return = 1;
 
   return $return;
 }
This function will return int number of array dimensions.

vladson
Hope someone find it useful..
<?php
/*
Function: eratosthenes
Usage: array eratosthenes ( int max_value )
Description:
Sieve of Eratosthenes is a simple, ancient algorithm
for finding all prime numbers up to a specified integer.
It was created by Eratosthenes, an ancient Greek mathematician.
*/
function eratosthenes($max) {
$sieve = array_fill(2, ($max-1), false);
while ($key = array_search(false, $sieve)) {
$sieve[$key] = true;
for ($i=$key*$key; $i<=$max; $i+=$key) {
if (array_key_exists($i, $sieve)) {
unset($sieve[$i]);
}
}
}
return array_keys($sieve);
}
?>

peanutpad
heres a function from http://www.linksback.org  Feedback welcome, of course!  Public domain, yadda yadda.
function mySort(&$array,$key) {
   if (!is_array($array) || count($array) == 0) return true;
   $assocSortCompare  = '$a = $a["'.$key.'"]; $b = $b["'.$key.'"];';
   if (is_numeric($array[0][$key])) {
     $assocSortCompare.= ' return ($a == $b) ? 0 : (($a < $b) ? -1 : 1);';
   } else {
     $assocSortCompare.= ' return strcmp($a,$b);';
   }
   $assocSortCompare = create_function('$a,$b',$assocSortCompare);
   return usort($array,$assocSortCompare);
}

designatevoid
Here's an improvement to the array_to_string and string_to_array functions posted by daenders AT yahoo DOT com above.
They now handle NULL values correctly.
<?php
// Converts an array to a string that is safe to pass via a URL
function array_to_string($array) {
$retval = '';
$null_value = "^^^";
foreach ($array as $index => $value) {
if (!$value)
$value = $null_value;
$retval .= urlencode(base64_encode($index)) . '|' . urlencode(base64_encode($value)) . '||';
}
return urlencode(substr($retval, 0, -2));
}
 
// Converts a string created by array_to_string() back into an array.
function string_to_array($string) {
$retval = array();
$string = urldecode($string);
$tmp_array = explode('||', $string);
$null_value = urlencode(base64_encode("^^^"));
foreach ($tmp_array as $tmp_val) {
list($index, $value) = explode('|', $tmp_val);
$decoded_index = base64_decode(urldecode($index));
if($value != $null_value)
$retval[$decoded_index] = base64_decode(urldecode($value));
else
$retval[$decoded_index] = NULL;
}
return $retval;
}
?>

atomo64
Here's a simple way to convert an array to a string and vice-versa.
Note that it does NOT support string keys,
for more information take a look at what it does:
<?php
class OptionAsArray
{
function make_the_arr($value)
{
$newValue=array();
$vals=explode('&',$value);
foreach($vals as $v)
{
if($v{0}=='@')
$newValue[]=$this->make_the_arr(
urldecode(substr($v,1)));
else
$newValue[]=urldecode($v);
}
if(empty($newValue))
return false;
else
return $newValue;
}
function make_the_value($arr)
{
$newValue=array();
foreach($arr as $value)
{
if(is_array($value))
$newValue[]='@'.urlencode(
implode('&',$this->make_the_value($value)));
else
$newValue[]=urlencode($value);
}
if(empty($newValue))
return false;
else
return $newValue;
}
}
?>

pedja
Here is the function that cleans array of empty records. It goes recursive through multidimensional array and erases any item that has empty value or is empty array.
This actually works on any variable type, not just arrays.
<?php
function clean_item ($p_value) {
if (is_array ($p_value)) {
if ( count ($p_value) == 0) {
$p_value = null;
} else {
foreach ($p_value as $m_key => $m_value) {
$p_value[$m_key] = clean_item ($m_value);
if (empty ($p_value[$m_key])) unset ($p_value[$m_key]);
}
}
} else {
if (empty ($p_value)) {
$p_value = null;
}
}
return $p_value;
}
?>
Example:
<?php
$m_array['aaa'] = 'bbb';
$m_array['ccc'] = '';
$m_array['ddd'] = Array();
$m_array['eee']['fff'] = Array();
$m_array['eee']['ggg'] = '';
$m_array['eee']['hhh'] = 'iii';
$m_array['eee']['j']['a'] = 'gh';
$m_array['eee']['j']['b'] = '';
$m_array['eee']['j']['c'] = 'rty';
$m_array['eee']['j']['d'] = Array();
$m_array['eee']['j']['e'][1] = 'r';
$m_array['eee']['j']['e'][2] = 'y';
$m_array['eee']['j']['e'][1] = '';
$m_array['eee']['j']['e'][4] = Array();
$m_array['eee']['j']['e'][5] = '';
$m_clean = $seo->clean_item ($m_array);
print_r ($m_array);
print_r ($m_clean);
?>
Variable $m_clean contains:
Array
(
   [aaa] => bbb
   [eee] => Array
       (
           [hhh] => iii
           [j] => Array
               (
                   [a] => gh
                   [c] => rty
                   [e] => Array
                       (
                           [2] => y
                       )
               )
       )
)
?>

ob
Here is a function to find out the maximum depth of a multidimensional array.
<?php
// return depth of given array
// if Array is a string ArrayDepth() will return 0
// usage: int ArrayDepth(array Array)
function ArrayDepth($Array,$DepthCount=-1,$DepthArray=array()) {
 $DepthCount++;
 if (is_array($Array))
   foreach ($Array as $Key => $Value)
     $DepthArray[]=ArrayDepth($Value,$DepthCount);
 else
   return $DepthCount;
 foreach($DepthArray as $Value)
   $Depth=$Value>$Depth?$Value:$Depth;
 return $Depth;
}
?>

spam
Here is a function that recursively flattens an multidimensional array while maintaining keys. Hopefully it is useful to someone..
Example Input:
Array
(
   [name] => John Doe
   [email] => johndoe@earthlink.net
   [addresses] => Array
       (
           [1] => Array
               (
                   [address] => 555 Somewhere
                   [city] => Podunk
                   [state] => CA
                   [zip] => 90120
               )
           [2] => Array
               (
                   [address] => 333 Someother Place
                   [city] => Podunk
                   [state] => CA
                   [zip] => 91103
               )
       )
)
Example output:
Array
(
   [name] => John Doe
   [email] => johndoe@earthlink.net
   [address1] => 555 Somewhere
   [city1] => Podunk
   [state1] => CA
   [zip1] => 90120
   [address2] => 333 Someother Place
   [city2] => Podunk
   [state2] => CA
   [zip2] => 91103
)
<?
function flattenArray($array,$keyname='')
{
   $tmp = array();
   foreach($array as $key => $value)
   {
       if(is_array($value))
           $tmp = array_merge($tmp,flattenArray($value,$key));
       else
           $tmp[$key.$keyname] = $value;
   }
   return $tmp;
}
?>

nicolai bloch
Here are two functions for checking if an array contains numeric or string indexes only.
Hope someone else will find them useful.
<?php
//Check for numeric array
function isNumeric($ar) {
 $keys = array_keys($ar);
 natsort($keys); //String keys will be last
 return is_int(array_pop($keys));
}
//Check for associative array
function isAssoc($ar) {
 $keys = array_keys($ar);
 natsort($keys); //Numeric keys will be first
 return is_string(array_shift($keys));
}
?>

ob
Here are two functions Array2String() and String2Array() based on functions posted below by daenders AT yahoo DOT com.
An improvement handling NULL values correctly was posted by designatevoid at gmail dot com.
My version also solves the NULL-value-problem plus keeps support of multidimensional arrays.
<?php
// convert a multidimensional array to url save and encoded string
// usage: string Array2String( array Array )
function Array2String($Array) {
 $Return='';
 $NullValue="^^^";
 foreach ($Array as $Key => $Value) {
   if(is_array($Value))
     $ReturnValue='^^array^'.Array2String($Value);
   else
     $ReturnValue=(strlen($Value)>0)?$Value:$NullValue;
   $Return.=urlencode(base64_encode($Key)) . '|' . urlencode(base64_encode($ReturnValue)).'||';
 }
 return urlencode(substr($Return,0,-2));
}
?>
<?php
// convert a string generated with Array2String() back to the original (multidimensional) array
// usage: array String2Array ( string String)
function String2Array($String) {
 $Return=array();
 $String=urldecode($String);
 $TempArray=explode('||',$String);
 $NullValue=urlencode(base64_encode("^^^"));
 foreach ($TempArray as $TempValue) {
   list($Key,$Value)=explode('|',$TempValue);
   $DecodedKey=base64_decode(urldecode($Key));
   if($Value!=$NullValue) {
     $ReturnValue=base64_decode(urldecode($Value));
     if(substr($ReturnValue,0,8)=='^^array^')
       $ReturnValue=String2Array(substr($ReturnValue,8));
     $Return[$DecodedKey]=$ReturnValue;
    }
   else
     $Return[$DecodedKey]=NULL;
 }
 return $Return;
}
?>

elkabong
Hello all! I've just been working on a system to automatically manage virtualhosts on an Apache box and I needed to duplicate some multidimensional arrays containing references to other multidimensional array some of which also contained references. These big arrays are defaults which need to be overwritten on a per-virtualhost basis, so copying references into the virtualhost arrays was not an option (as the defults would get corrupted).
After hours of banging me head on the wall, this is what I've come up with:
<?PHP # Tested on PHP Version 5.0.4
# Recursively set $copy[$x] to the actual values of $array[$x]
function array_deep_copy (&$array, &$copy) {
if(!is_array($copy)) $copy = array();
foreach($array as $k => $v) {
if(is_array($v)) {
array_deep_copy($v,$copy[$k]);
} else {
$copy[$k] = $v;
}
}
}
# To call it do this:
$my_lovely_reference_free_array = array();
array_deep_copy($my_array_full_of_references, $my_lovely_reference_free_array);
# Now you can modify all of $my_lovely_reference_free_array without
# worrying about $my_array_full_of_references!
?>
NOTE: Don't use this on self-referencing arrays! I haven't tried it yet but I'm guessing an infinate loop will occur...
I hope someone finds this useful, I'm only a beginner so if there's any fatal flaws or improvements please let me know!

piotr dot galas+phpnet
Function which converts array to string but not serialize it.
function arraytostring($array)
{
$text.="array(";
$count=count($array);
foreach ($array as $key=>$value)
{
$x++;
if (is_array($value))
{
if(substr($text,-1,1)==')') $text .= ',';
$text.='"'.$key.'"'."=>".arraytostring($value);
continue;
}
$text.="\"$key\"=>\"$value\"";
if ($count!=$x) $text.=",";
}
$text.=")";
if(substr($text, -4, 4)=='),),')$text.='))';
return $text;
}

christian
function array_flatten(&$a,$pref='',$sep='_') {
       $ret=array();
       foreach ($a as $i => $j)
       {
           if (is_array($j)) {
               $ret=array_merge($ret, array_flatten($j, $pref . ( strlen($pref) != 0 ? $sep : '' ) . $i ) );
           }
           else
           {
               $ret[$pref. $sep . $i] = $j;
           }
       }
       return $ret;
   }

q1712
for your intrest:
the values of the constans used are (all integer):
CASE_LOWER = 0
CASE_UPPER = 1
SORT_ASC = 4
SORT_DESC = 3
SORT_REGULAR = 0
SORT_NUMERIC = 1
SORT_STRING = 2
SORT_LOCALE_STRING = 5
COUNT_NORMAL = 0
COUNT_RECURSIVE = 1
EXTR_OVERWRITE = 0
EXTR_SKIP = 1
EXTR_PREFIX_SAME = 2
EXTR_PREFIX_ALL = 3
EXTR_PREFIX_INVALID = 4
EXTR_PREFIX_IF_EXISTS = 5
EXTR_IF_EXISTS = 6
EXTR_REFS = 256

simone dot carletti
Ever wanted to obtain a subset of an associative array from a list of parameters (stored into a non-associative array)?
Give this a try:
<?php
$params = array("name" => "Simone", "gender" => "M", "city" => "Macerata", "phone" => 123);
$fields = array("name", "city");
echo "<pre>";
print_r($params);
print_r($fields);
print_r(subArr($params, $fields));
function subArr($assocArrHaystack, $arrFields)
{
$arrSub = array();
foreach ($assocArrHaystack as $key => $value) {
if (in_array($key, $arrFields)) {
$arrSub[$key] = $value;
}
}
return $arrSub;
}
?>
And the output is:
Array
(
   [name] => Simone
   [gender] => M
   [city] => Macerata
   [phone] => 123
)
Array
(
   [0] => name
   [1] => city
)
Array
(
   [name] => Simone
   [city] => Macerata
)
Enjoy!
Simone

webdev
Bugs happen, but how can people post functions that WON'T EVEN COMPILE!  I truly detest finding a cool code snippet or function and then having to debug them. Sorry for the rant, but I have experienced this scenario a number of times.  TEST YOUR CODE, THEN POST!
Here is a revised and corrected previously posted function ArrayDepth, which had 3 bugs and yes, would not compile.
function ArrayDepth($Array,$DepthCount=-1) {
// Find maximum depth of an array
// Usage: int ArrayDepth( array $array )
// returns integer with max depth
// if Array is a string or an empty array it will return 0
 $DepthArray=array(0);
 $DepthCount++;
 $Depth = 0;
 if (is_array($Array))
   foreach ($Array as $Key => $Value) {
     $DepthArray[]=ArrayDepth($Value,$DepthCount);
}
 else
   return $DepthCount;
 return max($DepthCount,max($DepthArray));
}

msajko
array_to_string and sister function string_to_array with multi dimensional array support.
// Converts an array to a string that is safe to pass via a URL
function array_to_string($array) {
  $retval = '';
  $null_value = "^^^";
  foreach ($array as $index => $val) {
  if(gettype($val)=='array') $value='^^array^'.array_to_string($val); else $value=$val;
      if (!$value)
          $value = $null_value;
      $retval .= urlencode(base64_encode($index)) . '|' . urlencode(base64_encode($value)) . '||';
  }
  return urlencode(substr($retval, 0, -2));
}

// Converts a string created by array_to_string() back into an array.
function string_to_array($string) {
  $retval = array();
  $string = urldecode($string);
  $tmp_array = explode('||', $string);
  $null_value = urlencode(base64_encode("^^^"));
  foreach ($tmp_array as $tmp_val) {
      list($index, $value) = explode('|', $tmp_val);
      $decoded_index = base64_decode(urldecode($index));
      if($value != $null_value){
          $val= base64_decode(urldecode($value));
  if(substr($val,0,8)=='^^array^') $val=string_to_array(substr($val,8));
  $retval[$decoded_index]=$val;
 }
      else
          $retval[$decoded_index] = NULL;
  }
  return $retval;
}

domenic denicola
Another JavaScript conversion, this time to objects instead of arrays. They can be accessed the same way, but are declared much shorter, so it saves some download time for your users:
<?
function PhpArrayToJsObject($array, $objName)
{
return 'var ' . $objName . ' = ' . PhpArrayToJsObject_Recurse($array) . ";\n";
}
function PhpArrayToJsObject_Recurse($array)
{
// Base case of recursion: when the passed value is not a PHP array, just output it (in quotes).
if(! is_array($array) )
{
// Handle null specially: otherwise it becomes "".
if ($array === null)
{
return 'null';
}

return '"' . $array . '"';
}

// Open this JS object.
$retVal = "{";
// Output all key/value pairs as "$key" : $value
// * Output a JS object (using recursion), if $value is a PHP array.
// * Output the value in quotes, if $value is not an array (see above).
$first = true;
foreach($array as $key => $value)
{
// Add a comma before all but the first pair.
if (! $first )
{
$retVal .= ', ';
}
$first = false;

// Quote $key if it's a string.
if (is_string($key) )
{
$key = '"' . $key . '"';
}

$retVal .= $key . ' : ' . PhpArrayToJsObject_Recurse($value);
}
// Close and return the JS object.
return $retVal . "}";
}
?>
Difference from previous function: null values are no longer "" in the object, they are JavaScript null.
So for example:
<?
$theArray = array("A" => array("a", "b", "c" => array("x")), "B" => "y");
echo PhpArrayToJsObject($theArray, "myArray");
?>
Gives:
var myArray = {"A" : {0 : "a", 1 : "b", "c" : {0 : "x"}}, "B" : "y"};
You can still access them just like arrays, with myArray["A"][0] or myArray["A"]["c"][0] or whatever. Just shrinks your pages.

elkabong
An improvement to the array_deep_copy function I posted ages ago which takes a 'snapshot' of an array, making copies of all actual values referenced... Now it is possible to prevent it traversing the tree forever when an array references itself. You can set the default $maxdepth to anything you like, you should never call this function with the $depth specified!
<?php
/* Make a complete deep copy of an array replacing
references with deep copies until a certain depth is reached
($maxdepth) whereupon references are copied as-is...  */
function array_deep_copy (&$array, &$copy, $maxdepth=50, $depth=0) {
if($depth > $maxdepth) { $copy = $array; return; }
if(!is_array($copy)) $copy = array();
foreach($array as $k => &$v) {
if(is_array($v)) { array_deep_copy($v,$copy[$k],$maxdepth,++$depth);
} else {
$copy[$k] = $v;
}
}
}
# call it like this:
array_deep_copy($array_to_be_copied,$deep_copy_of_array,$maxdepth);
?>
Hope someone finds it useful!

nimja
A very clean and efficient function to remove empty values from an Array.
<?php
function cleanArray($array) {
foreach ($array as $index => $value) {
if (empty($value)) unset($array[$index]);
}
return $array;
}
?>

hannes dot dahlberg
A small function to get the median of an array filled with numbers
function median($array)
{
sort($array);
return ($array[ceil((count($array) / 2)) - 1] + $array[floor((count($array) / 2))]) / 2;
}

info
A slight modification in the arraytostring function, posted below. This function lists an array the same way you would define it in PHP.
<?PHP
function arraytostring($array, $depth = 0)
{
  if($depth > 0)
     $tab = implode('', array_fill(0, $depth, "\t"));
  $text.="array(\n";
  $count=count($array);
  foreach ($array as $key=>$value)
  {
      $x++;
      if (is_array($value))
      {
          if(substr($text,-1,1)==')')    $text .= ',';
          $text.=$tab."\t".'"'.$key.'"'." => ".arraytostring($value, $depth+1);
          continue;
      }
      $text.=$tab."\t"."\"$key\" => \"$value\"";
      if ($count!=$x) $text.=",\n";
  }
  $text.="\n".$tab.")\n";
  if(substr($text, -4, 4)=='),),')$text.='))';
  return $text;
}
?>

madness
A little function I like to use instead of the classic one, it lets me choose a better format an is overall more versatile:
<?
function get_image_size($filename, &$imageinfo){
$rawdata=getimagesize($filename, $imageinfo);
$refineddata=$rawdata;
if ($rawdata){
$refineddata=$rawdata;
$refineddata['width']=$rawdata[0];
$refineddata['height']=$rawdata[1];
$refineddata['type']=$rawdata[2];
$refineddata['attribute']=" ".$rawdata[3];
$refineddata[4]=$rawdata['mime'];
}
return $refineddata;
}
?>
Notice I also added the extra space in the attribute field, becuase I usually use it like this:
<?
echo "<img src=\\"foo.jpg\\"".$imgdata[attribute]." alt=\\"foo\\" />";
?>
This way if the attribute happens to be a null or empty value the tag doesn't contain double spaces.

filip
a better array_key_set function:
function array_key_set(&$array, $key=0) {
if(is_array($array)) {
if(!array_key_exists($array, $key)) {
return false;
}
reset($array);
while($current = key($array)) {
if($current == $key) {
return true;
}
next($array);
}
}
return false;
}

jeremyquinton
//using the foreach loop of php instead of a normal
//for loop with the sizeof operator after unset is used.
$values = array();
array_push($values,"lion");
array_push($values,"elephant");
array_push($values,"cheetah");
array_push($values,"wildebeest");
unset($values[2]);
//normal for loop thinks array size is three
//when sizoef function is used in conjunction
//the for loop.
for($i = 0;$i < sizeof($values); $i++) {
    echo "animals " . $values[$i]. "\n";
}
//prints
animals lion
animals elephant
animals
echo "\n";
//foreach prints the three values left properly
foreach($values as $animals) {
    echo "animal " . $animals. "\n";
}
//prints
animal lion
animal elephant
animal wildebeest
//simple but valid

dkrysiak
// note: my previous post have one small error in call to array_key_exists() - posting again - please remove this comment and that note :-)
<?php
/* Another version of subArr() function by simone dot carletti at unimc dot it: */
//{{{ array_select()
/**
* Choose array element with given keys
*
* @param Array $arr
* @param Array $keys Keys/indexes of elements to choose
* @return Array Array with elements being references to the elements od original array with chosen indexes.
*/
function &array_select($arr, $keys)
{
$res = array();
foreach ($keys as $key) {
if (array_key_exists($key, $arr)) {
$res[$key] =& $arr[$key];
}
}
return $res;
} // end: array_select() }}}
/*
In my opinion it should be faster than subArr().
Another difference from subArr() is that elements of returned array are references to the same variables as elements of original array (this can be easily changed)
*/
?>

g dot bell
/*
function to give array of ranks. Handles ties.
input $arr is zero based array to be ranked
$order is the sorting order
'asc' (default) ranks smallest as 1
'desc' ranks largest as 1
output zero based array of ranks.
Ties (repeated values) given equal (integer) values
*/
function array_rank($arr,$order='asc') {
// $direction parameter
foreach($arr as $being_ranked) {
$t1 = $t2 = 0;
if ($order == 'asc') {
foreach ($arr as $checking) {
if ($checking > $being_ranked) continue;
if ($checking < $being_ranked) {
$t1++;
} else {
$t2++; // equal so increment tie counter
}
}
} elseif ($order == 'desc') {
foreach ($arr as $checking) {
if ($checking < $being_ranked) continue;
if ($checking > $being_ranked) {
$t1++;
} else {
$t2++; // equal so increment tie counter
}
}
}
$ranks[] = floor($t1 + ($t2 + 1) / 2);
}
return $ranks;
}

jonathan
/**
* Flattens a multimentional array.
*
* Takes a multi-dimentional array as input and returns a flattened
* array as output. Implemented using a non-recursive algorithm.
* Example:
* <code>
* $in = array('John', 'Jim', array('Jane', 'Jasmine'), 'Jake');
* $out = array_flatten($in);
* // $out = array('John', 'Jim', 'Jane', 'Jasmine', 'Jake');
* </code>
*
* @author Jonathan Sharp <jonathan@sharpmedia.net>
* @var array
* @returns array
*/
function array_flatten($array)
{
while (($v = array_shift($array)) !== null) {
if (is_array($v)) {
$array = array_merge($v, $array);
} else {
$tmp[] = $v;
}
}

return $tmp;
}

aflavio
/**
* Remove a value from a array
* @param string $val
* @param array $arr
* @return array $array_remval
*/
function array_remval($val, &$arr)
{
 $array_remval = $arr;
 for($x=0;$x<count($array_remval)-1;$x++)
 {
 $i=array_search($val,$array_remval);
 if($i===false)return false;
 $array_remval=array_merge(array_slice($array_remval, 0,$i), array_slice($array_remval, $i+1));
 }
 return $array_remval;
}
$stack = array("orange", "banana", "apple", "raspberry", "apple");
output $stack = array("orange", "banana", "raspberry");

rajaratnam thavakumar--thava16
<?php
/*
This will return the N possible future dates acording to your selections of parameters
mydates_array([Which Week in a Month],[Which Day in a Week],[No of Dates have to return])
Eg:- Every 2nd Sunday mydates_array(2,0,10)
$Dateid---> Sunday - 0 , Monday - 1 , Tuesday - 2, Wednesday - 3,
Thursday - 4 , Friday - 5 , Saturday - 6
$weekid---> * can not be greater than 6
* if weekID is equal 6 it will return the Last Day of the weeek.
* Eg:-mydates_array(6,1,10);
* it will Returns 10 Last Mondays
* Please note weekid 5 is not availble in all months.mydates_array will not returns $no_returns that you want.
* Eg:-mydates_array(5,1,10);
* it will Returns 5th Monday
$no_returns--> No of dates that you want
By: Rajaratnam Thavakumar(thava16@hotmail.com)
*/
function mydates_array($weekid,$Dateid,$no_returns){
 if($weekid<=6){
$todayweek = date("D");
$myarr=array("Sun","Mon","Tue","Wed","Thu","Fri","Sat");
for($k=0;$k<=6;$k++){
if ($todayweek==$myarr[$k]){
if($k==0){
$currentdate=0;
}else{
$currentdate=$k;
}
 }
}
//get Dateid ----------------
   if($Dateid==0){
$Newmyday=date("d")-$currentdate;
}else if ($Dateid==1){
$Newmyday=date("d")-($currentdate-1);
}else if ($Dateid==2){
$Newmyday=date("d")-($currentdate-2);
}else if ($Dateid==3){
$Newmyday=date("d")-($currentdate-3);
}else if ($Dateid==4){
$Newmyday=date("d")-($currentdate-4);
}else if ($Dateid==5){
$Newmyday=date("d")-($currentdate-5);
}else if ($Dateid==6){
$Newmyday=date("d")-($currentdate-6);
}
$thisweekId=$weekid;
$count=0;
$column=0;
$myval=$no_returns*5;
for($i=1; $i<=$myval; $i++){
$week1a = mktime(0, 0, 0,  date("m"), $Newmyday,  date("Y"));
$week123=strftime("%Y-%m-%d", $week1a);
$Newmyday=$Newmyday+7;
list ($iyear, $imonth, $idate) = split ('[-.-]', $week123);  
  //Insert Dates into Array
 if( $idate<10){
 $idate=trim(str_replace('0','',$idate));
 }
$myweekno=ceil(($idate + date("w",mktime(0,0,0,$imonth,0,$iyear)))/7);
 $row=$myweekno-1;
  $Mymonth[$i]=$imonth;
  if ($i>1){
if ($Mymonth[$i-1]!=$Mymonth[$i]){
 $column=$column+1;
}
}
$EveDates[$row][$column]=$week123;
}
$count=0;
for ( $column = 0; $column < $no_returns; $column++ ){  //--for1-----
$mynewcount=0;  
for($row = 0; $row < 6; $row++){ //--for2-----
if($EveDates[$row][$column]!="" && $thisweekId!=6){
  list ($iyear1, $imonth1, $idate1) = split ('[-.-]', $EveDates[$row][$column]);
  $myweekno=ceil(($idate1 + date("w",mktime(0,0,0,$imonth1,0,$iyear1)))/7);
if($myweekno==$thisweekId+1){
$week_n1= mktime(0, 0, 0, date("m"), date("d"),  date("Y"));
$week_m1=strftime("%Y-%m-%d", $week_n1);
if($count < $no_returns && $EveDates[$row][$column] >= $week_m1){
  $mydates_array[$count]=$EveDates[$row][$column];
}
$count=$count+1;
}
}
else{
 $mycount=0;
 if ($row==5 && $thisweekId==6){
 for($e=5; $e>=0; $e--){
  if($EveDates[$e][$column]!=""){
  break;
  }
 }
$week_n1= mktime(0, 0, 0, date("m"), date("d"),  date("Y"));
$week_m1=strftime("%Y-%m-%d", $week_n1);
if($mycount<$no_returns && $EveDates[$e][$column] >= $week_m1){
$mydates_array[$count]=$EveDates[$e][$column];
}
$mycount=$mycount+1;
$count=$count+1;  
 }
}
}  //--End of for2-----
} //--End of for1-----
 return $mydates_array;
}else{
echo('WeekID Cant be  more than six!');
}}
?>
<select name="eventDate" style="border:1 solid #000066" >
<? // Return 10 Every 2nd Monday dates
$myarray=mydates_array(6,5,10);
for ($i=0;$i<count($myarray);$i++){
list ($iyear, $imonth, $idate) = split ('[-.-]', $myarray[$i]);
$week1a = mktime(0, 0, 0,$imonth, $idate,  $iyear);
$week= strftime("%A %d %B %Y", $week1a);
?>
<option  value="<?=$myarray[$i]?>"><?=$week?></option>
<? }?>
</select>

g8z
<?php
/**
filter_by_occurrence scans an array, and depending on the $exclusive parameter, includes or excludes elements occuring at least $min_occurences times, and at most $max_occurances times.
parameters:
$data_set = the array to work on
$min_occurrences = the minimum number of occurrences
$max_occurrences = the maximum number of occurrences (zero for unlimited)
$exclusive = if true, will return only results that do not occur within the specified bounds
Courtesy of the $5 Script Achive: http://www.tufat.com
**/
function filter_by_occurrence ($data_set, $min_occurrences, $max_occurrences = 0, $exclusive = false) {
$results = array();
// iterate through unique elements
foreach (array_unique($data_set) as $value) {
// count how many times element is in the array
$count = 0;
foreach ($data_set as $element) {
if ($element == $value)
$count++;
}
// check if meets min_occurences
$is_in_range = false;
if ($count >= $min_occurrences) {
// check if meets max_occurrences (unless max_occurences is 0)
if ( $count <= $max_occurrences || $max_occurrences == 0)
$is_in_range = true;
}
// add item to array if appropriate
if ($is_in_range && !$exclusive)
array_push($results, $value);
if (!$is_in_range && $exclusive)
array_push($results, $value);
}
// return results
return $results;
}
// EXAMPLE:
$test_data = array('pizza', 'ham', 'pizza', 'pizza', 'ham', 'fish', 'fish', 'fish', 'fish', 'dinosaur');
foreach (filter_by_occurrence( $test_data, 3, 0, false ) as $value)
{
print $value . ' occurs at least 3 times. <br />';
}
?>

kazuyoshi tlacaelel
<?php
/**
* converts a multidimensional array to a flat array
*
* trying to keep the original names of the keys
* if repeated keys are found a hash will be added to the
* keys trying to keep as much as possible of the original
* key context
*
* september 30 2007
*
* PHP version 5
*
* @license         GPL
*
*/
$array = array ( 0 => array ( 0 => 1, 1 => 2, 2 => array ( 0 => 3, 1 => 4, 2 =>
array ( 0 => 5, 1 => 6, 2 => array ( 0 => 7, 1 => 8,),),), 3 => array (
   0 => array ( 0 => 9, 1 => 10, 2 => array ( 0 => 11, 1 => 12,
   2 => array ( 0 => 13, 1 => 14, 2 => array ( 0 => 15, 1 => 16,),),),),
   1 => array ( 0 => 17, 1 => 18,),),), 1 => array ( 0 => 19, 1 => 20,),
   2 => array ( 0 => array ( 0 => 21, 1 => 22, 2 => array ( 0 => 23, 1 => 24,
   2 => array ( 0 => 25, 1 => 26, 2 => array ( 0 => 27, 1 => 28,),),),),
   1 => array ( 0 => 29, 1 => 30,),),);
/**
* transforms a multidimensional array to a flat array
*
* the parameter is referenced
* so no returning value is needed
* @param array $array the multidimensional array to flat
* @return void
*/
function array_flatten(&$array)
{
   function has_arrays($array)
   {
       foreach ($array as $item) {
           if (is_array($item)) {
               return true;
           }
       }
       return false;
   }
   function copy_array(&$array, $array_key)
   {
       $array2 = $array[$array_key];
       unset($array[$array_key]);
       foreach ($array2 as $subkey => $subvalue) {
           if (array_key_exists($subkey, $array)) {
               $array[generate_unique_key($subkey)] = $subvalue;
           } else {
               $array[$subkey] = $subvalue;
           }
       }
   }
   function generate_unique_key($key)
   {
       if (strlen($key)>8) {
           $key = $key[0] . $key[1] . $key[2];
       }
       $id = $key . '_';
       $uid = uniqid();
       $len = strlen($uid);
       $max = (9 - strlen($key));
       for ($c = $len; ; $c --) {
           $id .= $uid[$c];
           if ($c == ($len - $max)) {
               break;
           }
       }
       return $id;
   }
   function get_array_indexes($array)
   {
       $ret_array = array();
       foreach ($array as $key => $value) {
           if (is_array($value)) {
               $ret_array[] = $key;
           }
       }
       return $ret_array;
   }
   while(has_arrays($array)) {
       foreach (get_array_indexes($array) as $key) {
           copy_array($array, $key);
       }
   }
}
   array_flatten($array);
   array_multisort($array);
   var_export($array);
   /**
    *  OUTPUT
    *
    *  array (
    *    0 => 1,
    *    '1_403767b6' => 2,
    *    '0_793767b6' => 3,
    *    '1_8a3767b6' => 4,
    *    '0_454767b6' => 5,
    *    '1_564767b6' => 6,
    *    '0_035767b6' => 7,
    *    '1_345767b6' => 8,
    *    '0_e74767b6' => 9,
    *    '1_f84767b6' => 10,
    *    '0_855767b6' => 11,
    *    '1_a65767b6' => 12,
    *    '0_4e5767b6' => 13,
    *    '1_6f5767b6' => 14,
    *    '0_566767b6' => 15,
    *    '1_876767b6' => 16,
    *    '0_5b4767b6' => 17,
    *    '1_6c4767b6' => 18,
    *    '0_d43767b6' => 19,
    *    1 => 20,
    *    '0_4e3767b6' => 21,
    *    '1_5f3767b6' => 22,
    *    '0_ad4767b6' => 23,
    *    '1_ce4767b6' => 24,
    *    '0_485767b6' => 25,
    *    '1_695767b6' => 26,
    *    '0_116767b6' => 27,
    *    '1_426767b6' => 28,
    *    '0_814767b6' => 29,
    *    '1_924767b6' => 30,
    *  )
    */
?>

sid dot pasquale
<?php
/* This function allow you to transform a multidimensional array
  in a simple monodimensional array.
  Usage: array_walk($oldarray, 'flatten_array', &$newarray);
  For example, this code below shows to you:
Array
(
   [1] => Array
       (
           [0] => 1
           [1] => 2
       )

   [2] => Array
       (
           [0] => 3
           [1] => 4
       )

)

Array
(
   [0] => 1
   [1] => 2
   [2] => 3
   [3] => 4
)
*/
function flatten_array($value, $key, &$array) {
if (!is_array($value))
array_push($array,$value);
else
array_walk($value, 'flatten_array', &$array);

}

$oldarray = array(
1 => array(1,2),
2 => array(3,4)
);
$newarray = array();
array_walk($oldarray, 'flatten_array', &$newarray);
echo "<pre>";
print_r($oldarray);
print_r($newarray);
echo "</pre>";
?>

za
<?php
// Swap 2 elements in array preserving keys.
function array_swap(&$array,$key1,$key2) {
$v1=$array[$key1];
$v2=$array[$key2];
$out=array();
foreach($array as $i=>$v) {
if($i==$key1) {
$i=$key2;
$v=$v2;
} else if($i==$key2) {
$i=$key1;
$v=$v1;
}
$out[$i]=$v;
}
return $out;
}
// Move an element inside an array preserving keys.
function array_move(&$array,$key,$position) {
$from=array_search($key,array_keys($array));
$to=$from+$position;
$tot=count($array);
if($position>0) $to++;
if($to<0) $to=0;
else if($to>=$tot) $to=$tot-1;
$n=0;
$out=array();
foreach($array as $i=>$v) {
if($n==$to) $out[$key]=$array[$key];
if($n++==$from) continue;
$out[$i]=$v;
}
return $out;
}
?>

kroczu
<?
//A little function to convert array to simle xml:
function array_xml($array, $num_prefix = "num_")
{
   if(!is_array($array)) // text
   {
       return $array;
   }
   else
   {
       foreach($array as $key=>$val) // subnode
       {
           $key = (is_numeric($key)? $num_prefix.$key : $key);
           $return.="<".$key.">".array_xml($val, $num_prefix)."</".$key.">";
       }
   }
   return $return;
}
//example:
$array[0][0]                    = 1;
$array[0]['test']               = "test";
$array['test1']['test2']        = "test";
$array['test'][0]               = "test";
$array['test'][1]['test_x']     = $array;
print_r($array);
print"<xml>";
print array_xml($array);
print"</xml>";
/*
print_r($array) previev:
Array
(
   [0] => Array
       (
           [0] => 1
           [test] => test
       )
   [test1] => Array
       (
           [test2] => test
       )
   [test] => Array
       (
           [0] => test
           [1] => Array
               (
                   [test_x] => Array
                       (
                           [0] => Array
                               (
                                   [0] => 1
                                   [test] => test
                               )
                           [test1] => Array
                               (
                                   [test2] => test
                               )
                           [test] => Array
                               (
                                   [0] => test
                               )
                       )
               )
       )
)
result xml in firefox preview:
-<xml>
- <num_0>
<num_0>1</num_0>
<test>test</test>
</num_0>
- <test1>
<test2>test</test2>
</test1>
- <test>
<num_0>test</num_0>
- <num_1>
- <test_x>
- <num_0>
<num_0>1</num_0>
<test>test</test>
</num_0>
- <test1>
<test2>test</test2>
</test1>
- <test>
<num_0>test</num_0>
</test>
</test_x>
</num_1>
</test>
</xml>
*/
?>

Change Language


Follow Navioo On Twitter
.NET Functions
Apache-specific Functions
Alternative PHP Cache
Advanced PHP debugger
Array Functions
Aspell functions [deprecated]
BBCode Functions
BCMath Arbitrary Precision Mathematics Functions
PHP bytecode Compiler
Bzip2 Compression Functions
Calendar Functions
CCVS API Functions [deprecated]
Class/Object Functions
Classkit Functions
ClibPDF Functions [deprecated]
COM and .Net (Windows)
Crack Functions
Character Type Functions
CURL
Cybercash Payment Functions
Credit Mutuel CyberMUT functions
Cyrus IMAP administration Functions
Date and Time Functions
DB++ Functions
Database (dbm-style) Abstraction Layer Functions
dBase Functions
DBM Functions [deprecated]
dbx Functions
Direct IO Functions
Directory Functions
DOM Functions
DOM XML Functions
enchant Functions
Error Handling and Logging Functions
Exif Functions
Expect Functions
File Alteration Monitor Functions
Forms Data Format Functions
Fileinfo Functions
filePro Functions
Filesystem Functions
Filter Functions
Firebird/InterBase Functions
Firebird/Interbase Functions (PDO_FIREBIRD)
FriBiDi Functions
FrontBase Functions
FTP Functions
Function Handling Functions
GeoIP Functions
Gettext Functions
GMP Functions
gnupg Functions
Net_Gopher
Haru PDF Functions
hash Functions
HTTP
Hyperwave Functions
Hyperwave API Functions
i18n Functions
IBM Functions (PDO_IBM)
IBM DB2
iconv Functions
ID3 Functions
IIS Administration Functions
Image Functions
Imagick Image Library
IMAP
Informix Functions
Informix Functions (PDO_INFORMIX)
Ingres II Functions
IRC Gateway Functions
PHP / Java Integration
JSON Functions
KADM5
LDAP Functions
libxml Functions
Lotus Notes Functions
LZF Functions
Mail Functions
Mailparse Functions
Mathematical Functions
MaxDB PHP Extension
MCAL Functions
Mcrypt Encryption Functions
MCVE (Monetra) Payment Functions
Memcache Functions
Mhash Functions
Mimetype Functions
Ming functions for Flash
Miscellaneous Functions
mnoGoSearch Functions
Microsoft SQL Server Functions
Microsoft SQL Server and Sybase Functions (PDO_DBLIB)
Mohawk Software Session Handler Functions
mSQL Functions
Multibyte String Functions
muscat Functions
MySQL Functions
MySQL Functions (PDO_MYSQL)
MySQL Improved Extension
Ncurses Terminal Screen Control Functions
Network Functions
Newt Functions
NSAPI-specific Functions
Object Aggregation/Composition Functions
Object property and method call overloading
Oracle Functions
ODBC Functions (Unified)
ODBC and DB2 Functions (PDO_ODBC)
oggvorbis
OpenAL Audio Bindings
OpenSSL Functions
Oracle Functions [deprecated]
Oracle Functions (PDO_OCI)
Output Control Functions
Ovrimos SQL Functions
Paradox File Access
Parsekit Functions
Process Control Functions
Regular Expression Functions (Perl-Compatible)
PDF Functions
PDO Functions
Phar archive stream and classes
PHP Options&Information
POSIX Functions
Regular Expression Functions (POSIX Extended)
PostgreSQL Functions
PostgreSQL Functions (PDO_PGSQL)
Printer Functions
Program Execution Functions
PostScript document creation
Pspell Functions
qtdom Functions
Radius
Rar Functions
GNU Readline
GNU Recode Functions
RPM Header Reading Functions
runkit Functions
SAM - Simple Asynchronous Messaging
Satellite CORBA client extension [deprecated]
SCA Functions
SDO Functions
SDO XML Data Access Service Functions
SDO Relational Data Access Service Functions
Semaphore
SESAM Database Functions
PostgreSQL Session Save Handler
Session Handling Functions
Shared Memory Functions
SimpleXML functions
SNMP Functions
SOAP Functions
Socket Functions
Standard PHP Library (SPL) Functions
SQLite Functions
SQLite Functions (PDO_SQLITE)
Secure Shell2 Functions
Statistics Functions
Stream Functions
String Functions
Subversion Functions
Shockwave Flash Functions
Swish Functions
Sybase Functions
TCP Wrappers Functions
Tidy Functions
Tokenizer Functions
Unicode Functions
URL Functions
Variable Handling Functions
Verisign Payflow Pro Functions
vpopmail Functions
W32api Functions
WDDX Functions
win32ps Functions
win32service Functions
xattr Functions
xdiff Functions
XML Parser Functions
XML-RPC Functions
XMLReader functions
XMLWriter Functions
XSL functions
XSLT Functions
YAZ Functions
YP/NIS Functions
Zip File Functions
Zlib Compression Functions
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker