a lot of these.All but one deal with array handling. Sorting, splicing, etc
OK, I finally got around to putting these all together. I was
originally creating a class to handle arrays, but functions
are easier to remember and call.
#################### ADD-INS FOR PHP3 #######################
#
# These functions should look familiar to anyone that knows
# Perl. I use them all the time so I made these rather than
# have to code them over and over. There are also some
# functions that do not relate to Perl.
#
# Function list:
#
# Chomp
# Shift
# Unshift
# Pop
# Push
# Splice
# Sort unique
# Truncate array
# Get array range
################### Chomp function #####################
#
# Removes trailing line breaks from a given string
# If 'int' is specified it removes int line breaks
# which is much faster than calling chomp several
# times.
#
function chomp(&$string, $int = 1){
if (!$string || $int < 1){ return; }
for ($x = 0; $x < $int; $x++){
if (ereg("\n$",$string,$ref)){
$string = ereg_replace("\n$","",$string);
}else{
return;
}
}
unset($x);
unset($int);
}
#
################## Shift function ######################
#
# Shifts array from left to right. This will shift off the
# zeroeth (first) element from the array and move all other
# elements to their new positions, shifted 1 space left.
#
function shift(&$array){
if (!is_array($array) || !is_string($variable)){ return; }
$variable = $array[0];
for ($x = 1; $x < count($array); $x++){
$temp[count($temp)] = $array[$x];
}
$array = $temp;
unset($temp);
return $variable;
}
#
################### Unshift function #####################
#
# This is the reverse of the shift function in that it will
# add $variable to the front of $array. The number of
# elements in the new array is returned.
#
function unshift(&$array,$variable){
if (!is_array($array)){ return; }
if (!is_array($variable)){
$temp = $array;
unset($array);
$array[0] = $variable;
for ($x = 0; $x < count($temp); $x++){
$array[count($array)] = $temp[$x];
}
unset($temp);
unset($x);
}elseif(is_array($variable)){
$temp = $array;
unset($array);
for ($x = 0; $x < count($variable); $x++){
$array[count($array)] = $variable[$x];
}
for ($x = 0; $x < count($temp); $x++){
$array[count($array)] = $temp[$x];
}
unset($temp);
unset($x);
}
return count($array);
}
#
#########################################################
################### Pop function #########################
#
# 'Pops' off and returns the last element of $array. By
# doing so, the size of $array is reduced by 1.
#
function pop(&$array){
if (!is_array($array)){ return; }
$variable = $array[count($array)-1];
unset($array[count($array)-1]);
return $variable;
}
#
##########################################################
#################### Push function #######################
#
# 'Pushes' $variable onto $array where $variable becomes
# the last element in $array. If $variable is an array
# then all elements of $variable are added to $array and
# $array will increase in size equal to the number of
# elements that were in $variable. The new size of $array
# is returned from this function.
#
function push(&$array,$variable){
if (!is_array($array)){ return; }
if (!is_array($variable)){
$array[count($array)] = $variable;
}elseif (is_array($variable)){
for ($x = 0; $x < count($variable); $x++){
$array[count($array)] = $variable[$x];
}
}
unset($x);
return count($array);
}
#
################### Splice function #####################
#
# This function lets you add elements to the beginning,
# middle, or end of an array. You can replace portions
# of an array with other arrays, or elements. If any
# variables were replaced in $array they are returned.
#
function splice(&$array,$skip,$length,$variable){
if (!is_array($array) || $length == 0){ return; }
$replaced = array();
if ($skip < 0){
if (!is_array($variable)){
$array[count($array)] = $variable;
}elseif (is_array($variable)){
for ($x = 0; $x < count($variable); $x++){
$array[count($array)] = $variable[$x];
}
}
return $replaced;
}
for ($x = 0; $x < count($array); $x++){
if ($x >= $skip){
if (!is_array($variable)){
if ($length > 1){
/* Disabled splicing of arrays since I can't figure how
to do it right now. Will have to look at this later.
The splicing of single variables still works fine.
for ($y = $skip; $y < ($length+$skip); $y++){
if ($y < count($array)){
$replaced[count($replaced)] = $array[$y];
}
}
$array[$skip] = $variable;
break;
*/
}else{
$replaced[count($replaced)] = $array[$x];
$array[$x] = $variable;
break;
}
}elseif (is_array($variable)){
for ($y = $skip; $y <= $length; $y++){
$replaced[count($replaced)] = $array[$y];
$array[$y] = $array[($skip+$length)];
}
for ($y = (count($array)-$length); $y < count($array); $y++){
unset($array[$y]);
}
$temp = $array;
unset($array);
for ($y = ($skip-1); $y >= 0; $y--){
$array[$y] = $temp[$y];
}
for ($y = $skip; $y < count($variable); $y++){
$array[count($array)] = $variable[$y];
}
for ($y = $skip; $y < count($temp); $y++){
$array[count($array)] = $temp[$y];
}
}
}
}
return $replaced;
}
#
################### Sort unique functions ##########################
#
# Sorts an array into unique elements. If there are arrays
# within the top level array, only the second level arrays
# are sorted. Any arrays beyond the second level are not sorted.
# if $type is specified as 'nocase' then all elements are
# sorted case-insensitive.
#
function sort_unique(&$data, $type = ""){
if (!is_array($data)){
settype($data,"array");
}
if (count($data) < 1){
print "Array is empty!
\n";
return;
}
if (isset($temp)){ unset($temp); }
$count = 0;
for ($x = 0; $x < count($data); $x++){
if (is_array($data[$x])){
sort_unique_sub(&$data[$x], $type);
$count++;
}
}
if ($count == 0){
sort_unique_sub(&$data, $type);
}
}
function sort_unique_sub ($data, $type = ""){
if (isset($temp)){ unset($temp); }
if ($type == "nocase"){
for ($x = 0; $x < count($data); $x++){
$data[$x] = strtolower($data[$x]);
}
}
sort($data);
for ($x = 0; $x < count($data); $x++){
if ($data[$x] != $data[$x+1]){
$temp[sizeof($temp)] = $data[$x];
}
}
unset ($data);
for ($x = 0; $x < count($temp); $x++){
$data[$x] = $temp[$x];
}
}
#
################ Truncate array function #########################
#
# This function will remove all elements from the specified
# element to the end of array.
#
function truncate_array(&$data, $element){
if (!is_array($data)){
settype($data,"array");
}
if (count($data) < 1){
print "Array is empty!
\n";
return;
}
if (!$element){
print "Must specify array element!
\n";
return;
}
if (count($data) < $element){
$num = count($data);
print "Array only has $num elements!
\n";
return;
}
for ($x = count($data); $x >= 1; $x--){
if ($x >= $element){
unset($data[$x-1]);
}
}
}
############### Get array range function #######################
#
# This function will take an array and a range of elements. It
# then alters the array so that only the range of elements
# specified exist in the array.
#
function get_array_range(&$data, $range = ""){
if (!is_array($data)){
settype($data,"array");
}
if (count($data) < 1){
print "Array is empty!
\n";
return;
}
if (!$range){
print "No range specified!
\n";
return;
}
list($start,$end) = split("-",$range);
if ($start > $end){
$temp = $start;
$start = $end;
$end = $temp;
}
if ($end > count($data)){
$num = count($data);
print "Array only has $num elements!
\n";
return;
}
if (isset($temp)){ unset($temp); }
for ($x = 1; $x <= count($data); $x++){
if ($x >= $start && $x <= $end){
$temp[sizeof($temp)] = $data[$x-1];
}
}
unset($data);
$data = $temp;
unset($temp);
}
##
?>