Php > Algorithms sample source codes

New functions for PHP3. For those that know Perl, you will recognize

New functions for PHP3. For those that know Perl, you will recognize
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!<br>\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!<br>\n"; 
      return; 
    } 
    if (!$element){ 
      print "Must specify array element!<br>\n"; 
      return; 
    } 
    if (count($data) < $element){ 
      $num = count($data); 
      print "Array only has $num elements!<br>\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!<br>\n"; 
      return; 
    } 
    if (!$range){ 
      print "No range specified!<br>\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!<br>\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); 

  } 

##


?>