php.ComLanka.com PHP Tutorial ,PHP source code, PHP online example

Algorithms Arrays Passwords Uncategorized
Commerce Uncategorized
Databases Abstraction Layers Informix LDAP MS SQL MySQL ODBC PostgreSQL Uncategorized
Date & Time Calculators Conversion Translation Uncategorized
Discussion Chat Forums Guestbooks Polls Uncategorized
Email Validation Uncategorized
External Uncategorized
Files and Directories Uncategorized
Games Uncategorized
Graphics 3-D Graphs Resizing Thumbnails Uncategorized
HTML Forms Menus & Navigation Source Viewers Tables Templates Uncategorized
HTTP Authentication Cookies File Uploading Uncategorized
I18N Uncategorized
Math Uncategorized
Miscellaneous Uncategorized
Searching and Trees Uncategorized
Security Uncategorized
Text Uncategorized
Utilities Calendars Counters Link Checkers Weather Uncategorized
XML Uncategorized

php sample source codes
In this simple function you send two arrays and it gives you an array with the operation A-B, elements on A that are not included on B. function RestaDeArrays($vectorA,$vectorB) { $cantA=count($vectorA); $cantB=count($vectorB); $No_saca=0; for($i=0;$i<$cantA;$i++) { for($j=0;$j<$cantB;$j++) { if($vectorA[$i]==$vectorB[$j]) $No_saca=1; } if($No_saca==0) $nuevo_array[]=$vectorA[$i]; else $No_saca=0; } return $nuevo_array; }
This is a really simple function that allows one to display array data in a more readable way than with the standard print_r function <? /* Function coded by Stephan Pirson contact: saibot@hesperia-mud.org */ function print_a( $TheArray ) { // Note: the function is recursive echo "<table border=1>\n"; $Keys = array_keys( $TheArray ); foreach( $Keys as $OneKey ) { echo "<tr>\n"; echo "<td bgcolor='#727450'>"; echo "<B>" . $OneKey . "</B>"; echo "</td>\n"; echo "<td bgcolor='#C4C2A6'>"; if ( is_array($TheArray[$OneKey]) ) print_a($TheArray[$OneKey]); else echo $TheArray[$OneKey]; echo "</td>\n"; echo "</tr>\n"; } echo "</table>\n"; } ?>
Function for sorting associative arrays by one or more keys. Similar to "ORDER BY" in an SQL query. <?php /* I use it for sorting the rows of MYSQL_ASSOC-results without the need to query the database again... it helps when you have slow querys whose result only needs to be sorted again. First transfer the result into an array like this: while($row = mysql_fetch_array($result, MYSQL_ASSOC)) $DB_Array[] = $row; Syntax: aasort($assoc_array, array("+first_key", "-second_key", etc..)); Example: aasort($db_array, array("+ID", "-AGE", "+NAME")); Where the "+" in front of the keys stands for "ASC" and "-" for "DESC". This sorts the array first ascending by "ID", then descending by "AGE" and finally ascending by "NAME". Note: the function does no error handling... so make sure all keys exist in the array and they have a + or - as the first character. To keep the $DB_Array between pages use sessions. To use the function with other arrays, they must have the following format: $array[1] = array("key" => "value", "key" => "value", etc..); $array[2] = array("key" => "value", "key" => "value", etc..); $array[4] = array("key" => "value", "key" => "value", etc..); etc. */ function aasort(&$array, $args) { foreach($args as $arg) { $order_field = substr($arg, 1, strlen($arg)); foreach($array as $array_row) { $sort_array[$order_field][] = $array_row[$order_field]; } $sort_rule .= '$sort_array['.$order_field.'], '.($arg[0] == "+" ? SORT_ASC : SORT_DESC).','; } eval ("array_multisort($sort_rule".' &$array);'); } ?>
similar to <b>print_r()</b>, beside highlighting and syntax - that allows you simply copy and paste printed array into your php code. <?php function _aprint($arr, $tab = 1) // similar to print_r() { if( !is_array($arr) ) return " <span style=\"color:#336699\">".ucfirst(gettype($arr))."</span> "._slashes($arr); $space = str_repeat("\t", $tab); $out = " <span style=\"color:#336699\">array(</span>\n"; end($arr); $end = key($arr); if( count($arr) == 0 ) return "<span style=\"color:#336699\">array()</span>"; foreach( $arr as $key=>$val ){ if( $key == $end ) $colon = ''; else $colon = ','; if( !is_numeric($key) ) $key = "<span style=\"color:#993366\">'".str_replace( array("\\","'"), array("\\\\","\'"), htmlspecialchars($key) )."'</span>"; if( is_array($val) ) $val = _aprint($val, ($tab+1)); else if( !is_numeric($val) ) $val = "<span style=\"color:#993366\">'".str_replace( array("\\","'"), array("\\\\","\'"), htmlspecialchars($val) )."'</span>"; $out .= "$space$key => $val$colon\n"; } if( $tab == 1 ) return "$out$space<span style=\"color:#336699\">)</span>;"; else return "$out$space<span style=\"color:#336699\">)</span>"; } function aprint( $arr, $prefix=''){ if( ltrim($prefix) != '' ) $prefix = '<span style="color:#336699">'.$prefix.'</span> ='; echo "\n\n<table style=\"width:100%; margin:1px; background:#F0F2F4; border:1px solid #D8DDE6;\"><tbody><tr><td><pre style=\"color:#000000;\">$prefix"._aprint($arr)."</pre></td></tr></tbody></table>\n\n"; // overflow:auto; } ?>
an enhanced version of array_merge - only adds on unique elements. Only works for simple (i.e. not associative) arrays function array_expand($base = 0, $extra = 0) { // Take two one-dimensional array, step through the first looking for // each element of the second. If any of the elements in the second // array are not in the first, append them. Kind of an extended version // of PHP4's array_merge() function if (!is_array($base)) return false; $ext_arr = (is_array($extra)) ? $extra : array($extra); for ($i = 0; $i < sizeof($ext_arr); $i++) { if (!in_array($ext_arr[$i], $base)) $base[] = $ext_arr[$i]; } return $base; }
with the function array filter one gets the value of any array as input and with the help of a callback for more functional editing and gets back a modified array. <?PHP function un_zahl($wert) { return ($wert % 2 == 1);} function a_zahl($wert) { return ($wert % 2 == 0); } $array1 = array ("a"=>1,"b"=>2,"c"=>3,"d"=>5); $array2 = array (1, 2, 3, 4, 5, 6); $werte1 = array_filter($array1, "un_zahl"); echo "non-straight values:<br>"; while(list($key, $val) = each($werte1)){ echo $val . "<br>"; } echo "straight values: <br>"; $werte2 = array_filter($array2, "a_zahl"); while(list($key, $val) = each($werte2)){ echo $val . "<br>"; } ?>
this function return array B from array A by N interval Since i element <?php function filter_by_interval($a,$i,$interval) { $count = count($a); for( $i = $i - 1; $i < $count; $i++ ) { $ar[] = $a[$i]; $i+=$interval; } return $ar; } ?>
uses some html to beautify the output of the print_r function for arrays function aprint ($array){ print "\n<pre>"; print_r ($array); print "\n</pre>"; }
This is a recursive function group that takes an array name and a valuename for that array and turns it into string that can be handed to eval() /* THIS WRAPS ARRAYTOSTRINGRECURSIVE, THIS WAY MORE START VALUES CAN BE ADDED WITHOUT CHANGING THE CALLS TO THE FUNCTION */ function arraytostring($var, $varname){ if(!is_array($var) || strlen($varname) < 1): return false; endif; return arraytostringrecursive($var, $varname, true, false); } function arraytostringrecursive($var, $varname, $firsttime, $lasttime){ /* ONLY THE FIRST TIME THROUGH GETS THE $ FOR THE NAME */ if($firsttime): $string = "\$".$varname." = array ("; else: $string = $varname." => array ("; endif; /* WATCH THE DEPTH SO A "," CAN BE PLACED AT THE CORRECT POINTS */ $depth = sizeof($var); /* GO THROUGH EACH ASPECT OF THE ARRAY */ foreach($var as $dim => $value){ /* BRING THE DEPTH DOWN ONE, WHEN IT IS NOT ZERO IT GETS A COMMA */ $depth--; /* IF THE VALUE IS AN ARRAY RECURSE */ if(is_array($value)): /* IF THIS IS THE LAST ELEMENT IN THE ARRAY DO NOT PLACE A COMMA ON THE END */ if($depth == 0): $lasttime = true; endif; $string .= arraytostringrecursive($value, $dim, false, $lasttime); else: $string .= "\"".$dim."\" => "; if(is_numeric($value)): $string .= $value; else: $string .= "'".$value."'"; endif; if($depth > 0): $string .= ", "; endif; endif; }
Find the dimensions of every array. Returns an integer representing the dimensions of the given array. //better pass by reference, cause this is special for passing long and complex arrays function array_dims(&$array){ $dims=0; if(is_array($array)){ $dims=1; $i=0; foreach($array as $value){ if(is_array($value)){ if($dims<2){ $dims=2; } $rDims[++$i]=array_dims($value); } } if($dims==2){ $maxDims=max($rDims)-1; if($maxDims>=1){ $dims+=$maxDims; } } } return $dims; }
With this function you can set up an array of defaults that should always be set, and then add those defaults to another array. his /** * Sets every value from $extra that is not present in $base. * * This means that the first array is expanded by every key/value pair * in $extra, *if* there is no such key in $base already. In other words, * if you see $extra as a set of default values, the result will be those * default values, overwritten by stuff from $base, plus any extra data * in $base. * * @param array $base Array to fill up (add defaults to). * @param array $extra The array with the extra (default) data. * @return array $base with values from $extra added. */ function array_fillup($base, $extra) { if (!is_array($base) || !is_array($extra)) return false; foreach($extra as $k => $v) { if(!isset($base[$k])) { $base[$k] = $v; } elseif(is_array($base[$k])) { $base[$k] = array_fillup($base[$k], $v); } } return $base; }
Works on a like idea as array_merge(), but instead of concatenating arrays, it takes two related indexed arrays and creates one associative array. /* Name: array_merge_assoc Author: Markus Diersbock Details: Takes two related indexed arrays and combines them into one associative array. Notes: If $keyarray is NOT greater or equal to $valuearray the function will error unless the optional $force=TRUE. Revisions: 2003/12/13 - Created 2004/01/14 - Added code for unequal arrays */ function array_merge_assoc($keyarray, $valuearray, $force=FALSE){ $i=0; if ((count($keyarray) >= count($valuearray)) || $force==TRUE) { foreach($keyarray as $element){ $aryreturn[$element]=$valuearray[$i++]; } } else { return 'Arrays are not of equal size'; } return $aryreturn; }
Description: array array_rm_dupes(array array, [boolean is_sorted]) array_rm_dupes() removes duplicate values from an array. It takes input array and returns a new array without duplicate values. array_rm_dupes() sorts the input array in case if is_sorted flag is "false" (default). Two elements are considered equal if and only if (string) $elem1 === (string) $elem2 NOTE THAT UNLIKE THE STANDARD array_unique() FUNCTION KEYS ARE PRESERVED! <? /************************************************************************* * array_rm_dupes routine v.1.00 * Language: PHP4 * Author: Vadim Bodrov (falkoris@hotmail.com) * Date: 2 April 2002 * * Description: * array array_rm_dupes(array array, [boolean is_sorted]) * * array_rm_dupes() removes duplicate values from an array. It takes * input array and returns a new array without duplicate values. * array_rm_dupes() sorts the input array in case if is_sorted flag is * "false" (default). Two elements are considered equal if and only if * (string) $elem1 === (string) $elem2 * * NOTE THAT UNLIKE THE STANDARD array_unique() FUNCTION KEYS ARE * PRESERVED! *************************************************************************/ function array_rm_dupes($arg_array, $is_sorted = false) { if (!$is_sorted) sort($arg_array); if (count($arg_array) > 1) { $res = array($last = $arg_array[0]); for ($i = 1; $i < count($arg_array); $i++) { if (!((string) $arg_array[$i] === (string) $last)) { array_push($res, $arg_array[$i]); $last = $arg_array[$i]; } } return $res; } else return $arg_array; } ?>
array_unique function & ar_Unique($array) { for ( $i = 0; $i < count ($array); $i++ ) { for ( $j = 0; $j < count ($array); $j++ ) { if($array[$i] == $array[$j]) { $a[$j] = $array[$i]; break; } } } return $a; }
Runs through an array, assigns variables based on key name. Ability to append or prepend text to newly created variables. Useful for adapting current applications that depend on register_globals to work without it. function assignFromArray($array, $prepend="", $append="") { foreach ($array as $key => $value) { global ${$prepend . $key . $append}; ${$prepend . $key . $append} = $array[$key]; } }
This function will return an array "compressed", meaning that it will change its numeric keys in order to make it a gapless list. For Example, when the input is an array having 2, 3, 7, and 197 as keys, those keys will be respectively changed to 2, 3, 4 and 5. //######################################################################## //# *Compress array with numeric keys* //# array array_compress (array $array) //# //# This function will return $array "compressed", meaning that it //# will change its numeric keys in order to make it a gapless list. //# For Example, when the input is an array having 2, 3, 7, and 197 //# as keys, those keys will be respectively changed to 2, 3, 4 and 5. //# String keys (even if it is a string consisting of a number) will //# be returned unchanged. The input array may have any base (lowest key), //# which will be kept. //# //# Feel free to erase this header and and any other comments you wish. //######################################################################## function array_compress ($array) { //if passed variable isn't an array, it returns false if (!is_array($array)) return false; //sorts the array physically by key, so the foreach will //get the pairs in ascending key order ksort($array); //this is where the thing is done foreach ($array as $key => $value){ //makes sure it gets only the numeric keys if (is_long($key)) { //$expected is the key that should appear after //the last parsed key. If this key isn't equal to //expected, we make one that is. if (isset($expected) and $expected != $key) { $array[$expected++] = $array[$key]; unset($array[$key]); } else { $expected = $key + 1; } } } return $array; }
it first browse through the array and than print it out also in an array function.very useful when one is working with MYSQL <? $array = array("PHP",1,"PHPList",1,"openIT"); $number = array_count_values($array); while(list($key, $val) = each($number)) { echo $key . " - " . $val . "<br>";} ?>
Easily set up weighted distributions, useful for ad serving, load balancing, scheduling etc. # users "user"=>weight, "user"=>weight ... $users = array("manager"=>1,"peon"=>4, "middlemngr"=>3, "sales"=>3, "other peon"=>4); asort($users); ############################################################################################################ function distrib($arr){ $weight_total = array_sum($arr); $vals = array_values($arr); // loop through and figure out the percentage for each user. while ( list($key, $val) = each($arr) ){ $curr = $val; //$percent = (($curr * 100) / $total); // percentage of highest.. $percent = (($curr / $weight_total) * 100); // this is for % of sum(total) $percent_int = floor($percent); $percent_float = number_format($percent, 1); // now set up our return array.. "user"=>percentage, "user"=>percentage ... $ret[$key] = $percent_float; }//wend // send it back return $ret; }// end function ############################################################################################################ // this function spits back a placement for a user.. // theoretically this should have an even distribution based on our distribution list. // dist_arr = output from distrib() function determine_placement($dist_arr, $rndval=""){ if ($rndval == "") { $rndval = mt_rand(0,100); } //set a rnd val $running = 0; // private $running default while (list($key, $val) = each ($dist_arr)){ $running += $val; if ($rndval < $running) { return $key; } }//wend return false; }//end function ############################################################################################################ // just to test the output function test_output($dist_arr){ while (list($key, $val) = each ($dist_arr)){ echo "<td width=\"$val%\">$key ($val%)</td>\n"; }//wend }//end function $gen_distrib = distrib($users); ?> <table width=100% border=1 cellpadding=0 cellspacing=0> <tr> <? test_output(distrib($users)); ?> </tr> </table> <? $placement = array(); //declare it $phpGa = new PhpGa(5); for ($a=0;$a<1000;$a++){ $tmp = determine_placement($gen_distrib); if (in_array($tmp, array_keys($placement))){ $placement[$tmp]++; }else{ $placement[$tmp] = 1; // first count }// }//rof asort($placement); ?> <table width=100% border=1 cellpadding=0 cellspacing=0> <tr> <? test_output(distrib($placement)); ?> </tr> </table>
Dumps out an array suitable for re-creating using eval() <?php //Note that this dumps an array out in a form suitable to be //used with eval() to recreate the array! function arrayDump(&$array, $col=0){ if (is_array($array)){ echo "array(\n"; $i = 0; $count = count($array); while($i < $count && list($key, $val) = each($array)){ echo $key, ' ==> '; arrayDump($val, $col+1); $i++; if ($i < $count){ echo ','; } echo "\n"; } echo ")\n"; } else{ echo $array; } } for ($i = 0; $i < 5; $i++){ for ($j = $i; $j < 4; $j++){ for ($k = $j; $k < 3; $k++){ $data[$i][$j][$k] = $i * $j + $k; } } } echo "<PRE>"; arrayDump($data); echo "</PRE>"; ?>
Remoeves empty values of array... function rm_empty_value($array) { $x = 0; foreach ($array as $key => $value) { if($value) { $array_temp[$x] = $value; } $x++; } return $array_temp; }
Duplicates the functionality of PHP 4's array_rand function in PHP 3. Handy for people who have not yet been able to convince their sysadmins to upgrade to PHP 4, or for those who need a starting point to create a function similar to array_rand. function fake_array_rand ($array, $num_req = 1) { # Ensure that $num_req has a sane value $num_req > 0 or $num_req = 1; $count = count ($array); for ($n=0; $n < $num_req; ++$n) { # Help keep the number generator random :) $randval and usleep ("0.$randval"); # Seed the random number generator # Generate a random number srand ((double) microtime() * 10000000); $randval = rand(); # Use the random value to 'pick' an entry from the array # Count the number of times that the entry is picked ++$index[$randval % $count]; } # Loop through the array for ($n = 0; $n < $count; ++$n, next ($array)) { # When we get to an entry that has been picked # Put the entry into an array for output # Don't forget to decrease the counter while ($index[$n]) { $out[] = key ($array); --$index[$n]; } } # Return a string if only on random key was asked for # otherwise return an array return ($num_req == 1) ? $out[0] : $out ; } /* DESCRIPTION ============================================================ fake_array_rand: Duplicates the functionality of PHP 4's array_rand function in PHP 3. Handy for people who have not yet been able to convince their sysadmins to upgrade to PHP 4, or for those who need a starting point to create a function similar to array_rand. ============================================================ CREDITS ============================================================ Author: J. A. Greant ( zak@nucleus.com ) Version 1: September 1, 2000 ============================================================ NOTICES ============================================================ If you: Modify this code and want to share your changes :) Find a bug Have other questions or comments Please write: Zak Greant (zak@nucleus.com) ============================================================ USAGE EXAMPLES ============================================================ # pick a random entry from an array print $array[ fake_array_rand($array) ]; # grab 3 random array keys $rand_keys = fake_array_rand ($array, 3); ============================================================ COPYRIGHT ============================================================ Copyright (c) 2000 J. A. Greant ( zak@nucleus.com ) All rights reserved. This function is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This function is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this function; if not, write to the: Free Software Foundation, Inc. 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA http://www.gnu.org/ ============================================================ */
This code will take an array and form another array containing unique values. This can then be shuffled with the randomize array routine. $source = "array~values~with~repeated~array~bits~with~separators"; $f = array(); $uniq = array(); $f = split("~",$source); for ($x=0;$x<count($f);$x++){ #loop through array $dup = "true"; for ($y=0;$y<count($uniq);$y++){ if ($f[$x] == $uniq[$y]){ # check for duplicates $dup = "false"; } } if ($dup == "true"){ $uniq[] = $f[$x]; # add unique value to array } } # $uniq now only contains unique values.
This takes a full name and converts it into an array. It drops the middle initial, if present, to render the first and last name. <?php $name = preg_split("/[\s]+/", "$FullName"); if (empty($name[2])) // If there's no third name present, //we'll assume we've received // only the first and last name { $FirstName= ("$name[0]"); $LastName= stripslashes("$name[1]"); // stripslashes because //we love the Irish } else // If there is a third name present, // we'll assume the 2nd position is the // middle initial, which we'll drop for the form entry. { $FirstName= ("$name[0]"); // Allow multiple name entries // so Jay L. De La Cruz, Jr. doesn't // feel slighted. $LastName= stripslashes(("$name[2]" . " " . "$name[3]" . " " . "$name[4]" . " " . "$name[5]")); } ?>
Use this simple functino to duplicate the array_diff() or array_diff_assoc() functionality in PHP with arrays of your own objects. This should, in theory, work with any data type. serialize() could maybe even be used to make this obsolete, but who knows... //Difference function for arrays of objects (like array_diff()). function objArrayDiff($base = array(), $b = array()) { for($ctr1 = 0; $ctr1 < count($base); ++$ctr1) { foreach($b as $key1 => $value1) { if($base[$ctr1] == $value1) { unset($b[$key1]); }//End if }//End foreach }//End for return $b; }//End function objArrayDiff($base = array(), $b = array())
This may save someone 5 minutes. A little function that generates an array of unique random integers. function randarray ($max) { srand((double) microtime() * 1000000); $count =0; $currentnum=0; $randomnumbers= array(); while ($count<$max) { $currentnum=rand (0,$max); if (!in_array($currentnum,$randomnumbers)) { $randomnumbers[$count]=$currentnum; $count++; } } return $randomnumbers; }
This function will randomize an array (by Richard Lynch) //Use &$array to avoid stack explosion. //PHP4 probably needs something slightly different //since it has true references & counting. function shuffle(&$array){ //Assumes array is 0-based integer keys //Initialize the random number generator once, and only once, //Even if we call shuffle function twice in one script. if (!isset($randinit)){ srand((double) microtime() * 1000000); static $randinit = 1; } //Start at the end and work our way forward, //always swapping a randomly selected item //with the current 'last' one. $last = count($array); while ($last > 1){ //Earlier versions of PHP had different args for rand(). $random = rand(0, $last); //Swap the randomly selected element with the last element. $temp = $array[$random]; $array[$random] = $array[$last]; $array[$last] = $temp; //Move 'forward' in array $last--; } return 1; }
Removes Empty Values Of Array :) function rm_empty_values($array) { $x = 0; foreach ($array as $key => $value) { if(($value) || ($value == "0")) { $array_temp[$x] = $value; $x++; } } return $array_temp; }
This is a function that reverses an array. For users that only have PHP 3.0 available. function Reverter($a) { $temp = array(); $_asize = sizeof($a); for($i = 0; $i < $_asize; $i++) { $temp[$i] = $a[$_asize-$i-1]; } return $temp; }
In this simple function you send two arrays and a number x if x is 1 the function will return A+B ( reunion ) and if x it is not 1 will return A%B ( crossing ) <?php /* Code by Serban Nicolae @2004 orfeu@as.ro In this simple function you send two arrays and a number x if x is 1 the function will return A+B ( reunion ) and if x is 2 will return A%B ( crossing ) */ function oper_arrays($a ,$b, $x=1) { $ct1=count($a); $ct2=count($b); if ($x==1) { $c=$a; for ($i=0 ; $i<$ct2 ; $i++) { $boo=0; for ($j=0 ; $j<$ct1 ; $j++) if ($b[$i]==$a[$j]) $boo=1; if ($boo==0) $c[]=$b[$i]; } return $c; } else { for ($i=0 ; $i<$ct1 ; $i++) { $boo=0; for ($j=0 ; $j<$ct2 ; $j++) if ($a[$i]==$b[$j]) $boo=1; if ($boo==1) $c[]=$a[$i]; } return $c; } } ?>
esay - isert/add elements to any position of your array(s) - delete elements from your array(s) - move elements within your array(s) - replace elements from your array(s) ... the array, 'dynamically' grows or shrinks to whatever we tweak it <? ################################################################### ## ## Array tweaker class ## by Holger Bahr, Waldorf GmbH ## ## ... for unique sounding electronic music gear visit us at: ## http://www.waldorf-music.de ## ## you can use this class if you want to ## ## - delete elements of your arrays ## - insert elements to your arrays ## - move an element of your arrays to another position ## - replace an element of your array ## ## You can delete this stupid header if you use the class ## in your software. When you add some functionality or ## something, please drop me a line to hb@waldorf-gmbh.de ## ################################################################### class tweak_array { var $error_l = '<p><b>Warning:</b> Check your input parameters in your call to <i><b>'; var $error_r = '</b></i></p>'; function insert($array = '', $position = '' , $elements= '') { if ($position == '' || $array == '' || $elements == '' || $position < 1 || $position > count($array)+1) { echo $this->error_l."insert".$this->error_r; } else { $left = array_slice ($array, 0, $position-1); $right = array_slice ($array, $position-1); $insert = explode ('\,', $elements); $array = array_merge ($left, $insert, $right); unset($left, $right, $insert); } unset ($position, $elements); return $array; } function delete($array = '', $from = '', $to='') { if ($to == '') $to = $from; if ($array == '' || $from == '' || $to > count($array) || $to < 1 || $from > count($array)) { echo $this->error_l."delete".$this->error_r; } elseif ($to < $from) { echo '<p><b>Warning:</b> you provided wrong parameter relationship to <b><i>delete</i></b></p>'; } else { $left = array_slice ($array, 0, $from-1); $right = array_slice ($array, $to); $array = array_merge ($left, $right); unset ($left, $right); } unset ($from, $to); return $array; } function move($array = '', $from = '', $to = '') { if ($array == ''|| $from == ''|| $to == '' || $to > count($array) || $to < 1 || $from > count($array) || $from < 1) { echo $this->error_l."move".$this->error_r; } else { $hopper = $array[$from-1]; $array = $this->delete($array, $from); $array = $this->insert($array, $to, $hopper); } unset ($hopper, $from, $to); return $array; } function replace($array = '', $position = '', $new_element = ' ') { if ($array == '' || $position == '' || $position > count($array) || $position < 1) { echo $this->error_l."replace".$this->error_r; } else { $array = $this->insert($array, $position, $new_element); $array = $this->delete($array, $position+count(explode('\,', $new_element))); } unset ($position, $new_element); return $array; } } ################################################################################### ## ## Never forget the "\," when inserting multiple things into an existing single ## element and use implode() with the same separator "\," when you drop the ## whole content of an other array, into a single element (see Example). ## ## NEVER forget that an array starts with [0] and we say that 0 is the 1ST element. ## ################################################################################### ?>
This code will allow you to use two-dimensional arrays with forms in PHP 3 <? while (list($key, $value) = each ($foo)){ $keys = explode('__', $key); $realfoo[$keys[0]][$keys[1]] = $value; } ?>
This works because im using it. Took me 3 hours to figure out but its done. Enjoy. $old = $YourArrayName; $new = array(); $counter = 0; $new[$counter] = XXXXX; for($i=0;$i<count($old);$i++){ $write = true; for ($j=0;$j<count($new); $j++) { if ($old[$i] == $new[$j]) { $write = false; } } if ($write == true) { $new[$counter] = $old[$i]; $counter++; } } for ($i=0;$i<count($new);$i++) { if ($new[$i] != XXXXX) { //If nothing was done then remove the default element. echo $new[$i] . "<BR>"; } }