PHP: Array Functions - Manual

I need to take an element from the Array and change its position within the Array by moving the rest of the elements as required.
This is the function that does it. The first parameter is the working Array. The second is the position of the element to move and the third is the position where to move the element.
The function returns the modified Array.
<?php
function array_move_elem($array, $from, $to) {
    if ($from == $to) { return $array; }
    $c = count($array);
    if (($c > $from) and ($c > $to)) {
        if ($from < $to) {
            $f = $array[$from];
            for ($i = $from; $i < $to; $i++) {
                $array[$i] = $array[$i+1];
            }
            $array[$to] = $f;
        } else {
            $f = $array[$from];
            for ($i = $from; $i > $to; $i--) {
                $array[$i] = $array[$i-1];
            }
            $array[$to] = $f;
        }

}
    return $array;
}

?>
Examples:
<?php
$array = array('Cero','Uno','Dos','Tres','Cuatro','Cinco','Seis','Siete','Ocho','Nueve','Diez');
$array = array_move_elem($array, 3, 5); // Move element in position 3 to position 5...
print_r($array);

$array = array_move_elem($array, 5, 3); // Move element in position 5 to position 3, leaving array as it was... ;)
print_r($array);

?>
Return:
<?php
Array ( [0] => Cero [1] => Uno [2] => Dos [3] => Cuatro [4] => Cinco [5] => Tres [6] => Seis [7] => Siete [8] => Ocho [9] => Nueve [10] => Diez )
Array ( [0] => Cero [1] => Uno [2] => Dos [3] => Tres [4] => Cuatro [5] => Cinco [6] => Seis [7] => Siete [8] => Ocho [9] => Nueve [10] => Diez )
?>

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;
}
?>

Updated code of 'indioeuropeo' with option to input string-based keys.

INPUT:
array(4) {
  ["a"]=>
  string(5) "Apple"
  ["b"]=>
  string(6) "Banana"
  ["c"]=>
  string(3) "Cat"
  ["d"]=>
  string(3) "Dog"
}

OUTPUT:
array(4) {
  ["a"]=>
  string(5) "Apple"
  ["d"]=>
  string(3) "Dog"
  ["b"]=>
  string(6) "Banana"
  ["c"]=>
  string(3) "Cat"
}

FUNCTION:
<?php
function array_move_elem($array, $from, $to){
// return if non-numeric couldn't be found or from=to
    if(!is_numeric($from)){
        if(array_search($from, array_keys($array))!==FALSE){
            $from = array_search($from, array_keys($array));
        }else{
            return $array;
        }
    }
    $array_numeric_keys = array();
    foreach($array as $k => $v){
        $array_numeric_keys[] = $k;
    }
    if ($from == $to) { return $array; }
    $c = count($array_numeric_keys);
    if (($c > $from) and ($c > $to)) {
        if ($from < $to) {
            $f = $array_numeric_keys[$from];
            for ($i = $from; $i < $to; $i++) {
                $array_numeric_keys[$i] = $array_numeric_keys[$i+1];
            }
            $array_numeric_keys[$to] = $f;
        } else {
            $f = $array_numeric_keys[$from];
            for ($i = $from; $i > $to; $i--) {
                $array_numeric_keys[$i] = $array_numeric_keys[$i-1];
            }
            $array_numeric_keys[$to] = $f;
        }

}
    $array_new = array();
    foreach($array_numeric_keys as $v){
        $array_new[$v] = $array[$v];
    }
    return $array_new;
}
?>

Short function for making a recursive array copy while cloning objects on the way.

<?php
function arrayCopy( array $array ) {
        $result = array();
        foreach( $array as $key => $val ) {
            if( is_array( $val ) ) {
                $result[$key] = arrayCopy( $val );
            } elseif ( is_object( $val ) ) {
                $result[$key] = clone $val;
            } else {
                $result[$key] = $val;
            }
        }
        return $result;
}
?>

I was looking for an array aggregation function here and ended up writing this one.

Note: This implementation assumes that none of the fields you're aggregating on contain The '@' symbol.

<?php
  function array_group_by($flds, $arr) {
    $groups = array();
    foreach ($arr as $rec) {
      $keys = array_map(function($f) use($rec) { return $rec[$f]; }, $flds);
      $k = implode('@', $keys);
      if (isset($groups[$k])) {
        $groups[$k][] = $rec;
      } else {
        $groups[$k] = array($rec);
      }
    }
    return $groups;
  }

?>

If you need to flattern two-dismensional array with single values assoc subarrays, you could use this function:

<?php
function arrayFlatten($array) {
        $flattern = array();
        foreach ($array as $key => $value){
            $new_key = array_keys($value);
            $flattern[] = $value[$new_key[0]];
        }
        return $flattern;
}
?>

While PHP has well over three-score array functions, array_rotate is strangely missing as of PHP 5.3. Searching online offered several solutions, but the ones I found have defects such as inefficiently looping through the array or ignoring keys.

The following array_rotate() function uses array_merge and array_shift to reliably rotate an array forwards or backwards, preserving keys. If you know you can trust your $array to be an array and $shift to be between 0 and the length of your array, you can skip the function definition and use just the return expression in your code.

<?php
function array_rotate($array, $shift) {
    if(!is_array($array) || !is_numeric($shift)) {
        if(!is_array($array)) error_log(__FUNCTION__.' expects first argument to be array; '.gettype($array).' received.');
        if(!is_numeric($shift)) error_log(__FUNCTION__.' expects second argument to be numeric; '.gettype($shift)." `$shift` received.");
        return $array;
    }
    $shift %= count($array); //we won't try to shift more than one array length
    if($shift < 0) $shift += count($array);//handle negative shifts as positive
    return array_merge(array_slice($array, $shift, NULL, true), array_slice($array, 0, $shift, true));
}
?>
A few simple tests:
<?php
$array=array("foo"=>1,"bar"=>2,"baz"=>3,4,5);

print_r(array_rotate($array, 2));
print_r(array_rotate($array, -2));
print_r(array_rotate($array, count($array)));
print_r(array_rotate($array, "4"));
print_r(array_rotate($array, -9));
?>

/*to change an index without rewriting the whole table and leave at the same place.
*/
<?php
function change_index(&$tableau, $old_key, $new_key) {
    $changed = FALSE;
    $temp = 0;
    foreach ($tableau as $key => $value) {
        switch ($changed) {
            case FALSE :
                //creates the new key and deletes the old
                if ($key == $old_key) {
                    $tableau[$new_key] = $tableau[$old_key];
                    unset($tableau[$old_key]);
                    $changed = TRUE;
                }
                break;

case TRUE :
                //moves following keys
                if ($key != $new_key){
                $temp= $tableau[$key];
                unset($tableau[$key]);
                $tableau[$key] = $temp;
                break;
                }
                else {$changed = FALSE;} //stop
        }
    }
    array_values($tableau); //free_memory
}

//Result :
$tableau = array(1, 2 , 3, 4,5, 6, 7, 8, 9, 10);
$res = print_r($tableau, TRUE);
$longueur = strlen($res) -1;
echo "Old array :\n" . substr($res, 8, $longueur) . "\n" ;

change_index ($tableau, 2, 'number 2');
$res = print_r($tableau, TRUE);
$longueur = strlen($res) -10;
echo "New array :\n" . substr($res, 8, $longueur) . "\n" ;

/*
Old array :
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
)

New array :
    [0] => 1
    [1] => 2
    [numéro 2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
*/
?>

Function to pretty print arrays and objects. Detects object recursion and allows setting a maximum depth. Based on arraytostring and u_print_r from the print_r function notes. Should be called like so:

<?php
egvaluetostring($value)   //no max depth, or
egvaluetostring($value, $max_depth)   //max depth set

function egvaluetostring($value, $max_depth, $key = NULL, $depth = 0, $refChain = array()) {
  if($depth > 0)
    $tab = str_repeat("\t", $depth);
  $text .= $tab . ($key !== NULL ? $key . " => " : "");

if (is_array($value) || is_object($value)) {
    $recursion = FALSE;
    if (is_object($value)) {
      foreach ($refChain as $refVal) {
        if ($refVal === $value) {
          $recursion = TRUE;
          break;
        }
      }
      array_push($refChain, $value);
    }

$text .= (is_array($value) ? "array" : "object") . " ( ";

if ($recursion) {
      $text .= "*RECURSION* ";
    }
    elseif (isset($max_depth) && $depth >= $max_depth) {
      $text .= "*MAX DEPTH REACHED* ";
    }
    else {
      if (!empty($value)) {
        $text .= "\n";
        foreach ($value as $child_key => $child_value) {
          $text .= egvaluetostring($child_value, $max_depth, (is_array($value) ? "[" : "") . $child_key . (is_array($value) ? "]" : ""), $depth+1, $refChain) . ",\n";
        }
        $text .= "\n" . $tab;
      }
    }

$text .= ")";

if (is_object($value)) {
      array_pop($refChain);
    }
  }
  else {
    $text .= "$value";
  }

return $text;
}
?>