See also is_array(), explode(), implode(), split(), preg_split(), and unset().
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;
}
?>
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));
?>
Big arrays use a lot of memory possibly resulting in memory limit errors. You can reduce memory usage on your script by destroying them as soon as you´re done with them. I was able to get over a few megabytes of memory by simply destroying some variables I didn´t use anymore.
You can view the memory usage/gain by using the funcion memory_get_usage(). Hope this helps!
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;
}
?>
Arrays are good, but inapplicable when dealing with huge amounts of data.
I'm working on rewriting some array functions to operate with plain Iterators - map, reduce, walk, flip et cetera are already there.
In addition I'm going to implement simulation of comprehensions (generators) in PHP (http://en.wikipedia.org/wiki/List_comprehension).
See the source code, examples and documentation at http://code.google.com/p/php-iterator-utils/
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.
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;
}
?>
/*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
*/
?>
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;
}
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;
}
?>
A usefull function that returns a flat array.
I use it in a template system. Let the user pass a multidimensional array. Convert it using my function. Then use
<?php
$array = flatten($array,'','{$','}','->');
echo str_replace(array_keys($array),array_values($array),$template)
/**
* Flattens out an multidimension array
* Using the last parameters you can define the new key based on the old path.
* @param array $array A multidimension array
* @param string $prefix Internal perfix parameter - leave empty.
* @param string $start_string What string should start the final array key?
* @param string $end_string What string should end the final array key?
* @param string $seperator The string that should seperate the piecies in final array key path
* @return array Returns the flat array
*/
function flatten($array, $start_string= '{$',$end_string= '}',$seperator='->',$prefix="") {
$return = array();
foreach($array as $key=>$value) {
if (is_array($value)) {
$return = array_merge($return, Parser_method_replace::flatten($value, $prefix.$key.$seperator,$start_string,$end_string,$seperator));
} else
$return [$start_string.$prefix.$key.$end_string] = $value;
}
return $return;
}
}
?>
Example:
$template = 'My string with replacement {$test->subkey}';
{$test->subkey} will get replaced with $array['test']['subkey']
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';
?>
