Non-Recursive Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

$tree=array('folder/');
$folders_to_do = array('folder/');
$current_folder = '';
while(!empty($folders_to_do)){
	$key_of_current_folder = key($folders_to_do);
	$current_folder = $folders_to_do[$key_of_current_folder];
	$folder = scandir($current_folder);
	foreach($folder as $item){
		if(is_dir($current_folder.$item) and $item != '.' and $item != '..'){
			$folders_to_do[] = $current_folder.$item.'/';
			$tree[] = $current_folder.$item.'/';
		}
		if(is_file($current_folder.$item))
			$tree[] = $current_folder.$item;
	}
	unset($folders_to_do[$key_of_current_folder]);
}
sort($tree);

The way it works is very simple. It runs only on 2 loops (while & foreach), 1 array (folders_to_do) and 1 string variable (current_folder) to control what we are scanning. The outer loop will always loop it self as long as it has something to scan, that means if the to-do array is not empty it will loop again. Now inside the while loop we have the regular scandir() function and foreach loop. in the foreach loop when a file is found it is added to the main tree array but if a folder is found then it is not only added to the tree array but is also added to the to-do list. Since the to-do list has something new to scan, the while loop will not brake. At the end when there is no more directories to scan the tree array will contain every folder and file found in the initial directory passed. All that is left to do is to sort the array and you get a neat list of each files and folders of a passed directory.

Recursive:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$tree2 = recursive('folder/');
function recursive($current_folder){
	static $tree = array();
 
	$folder = scandir($current_folder);
	foreach($folder as $item){
		if(is_dir($current_folder.$item) and $item != '.' and $item != '..'){
			$tree[] = $current_folder.$item.'/';
			recursive($current_folder.$item.'/');
		}
		if(is_file($current_folder.$item))
			$tree[] = $current_folder.$item;
	}
	return $tree;
}

This method is also straight forward. It uses a static array inside the function to hold the tree, optionally you can keep passing the tree as an argument if you do not wish to use a static array or if you simple going to use the function multiple times on the same script. The function it self takes in only 1 string variable which is the folder it is going to process. The foreach loop does same thing basically; if it is a file it only adds to the tree array and if it is a folder it adds to the tree array and calls the function with the folder path as teh argument. The recursion concept is no different then any other. It was only simplified ridiculously.

Result Array:

Array
(
    [0] => folder/
    [1] => folder/another folder/
    [2] => folder/another folder/bar file
    [3] => folder/another folder/dddddd/
    [4] => folder/another folder/dddddd/lost track/
    [5] => folder/another folder/dddddd/lost track/last file
    [6] => folder/another folder/hhh/
    [7] => folder/another omg folder/
    [8] => folder/codeigniter omg/
    [9] => folder/codeigniter omg/index.php
...

Both of those codes will produce exactly the same thing but using different amount of memory. Above you can see a steddy array with each folder and file name with full paths.

Performance:
AS I said earlier I had about 360 files and folder combined for testing.

The time in milliseconds took to execute was the same on average of those methods. I refreshed many times and it was always either same or one or the other had few more milliseconds.

The memory usage for the non recursive was 82,512 and for the recursive method it was 116,112. I used the memory_get_usage() function to find those numbers. For each method I took memory usage before the code and after the code. So the results are (after_code – before_code) for first and second methods, just to clarify so no one has questions to how I have come to my conclusion.

82,512 / 116,112 = 0.71 ratio!

All testing was done here: http://www.sandbox.doc776.org/recursion/script.php

For those that do not know what CodeIgniter is, it is a very small but powerful MVC based PHP framework for developing web applications. And for those who not sure what CodeLighter is, it is mini version of CodeIgniter, it follows the same syntax in general but the actual framework is minimized to the core.

Some nice things of CodeIgniter is that it has a separate documentation and lots of useful helpers and functions. This is a full framework so everything in it is separated from each part for the code like routes, hooks, core classes and so on.

CodeLighter has every core class like dispatcher controller loader and such placed in one single file. If you are the type that likes simplicity then this is good for you. Even thought it is in one file it is all very well commented and there is no need for documentation separately. It is very easy to go through the code and understand what each thing does and makes it easy to edit to your likes. CodeLighter of course supports the full MVC but more compact on the configuration end. Separate models, helpers, views and controllers. the whole code it self has only 5 directories and 3 files. One is the index that starts the code the actual CodeLighter core classes and MySQL class, everything else is for you to make.

I tried using both of those frameworks to try them out. The first thing to look at is the page render time. I had both frameworks installed on same server and had them only connect to the database and that is it. The render time of each page has a huge difference. CodeIgniter scored on average of 0.07 seconds at all times and CodeLighter Scored 0.005 seconds on average. The difference in loading times is all there and at the end before choosing what you want to use think about what you need it for. The CodeIgniter woulb be good for something heavy that has lots of pages and lots of features. CodeLighter would still be fine but would be better for smaller websites. It is like, what is the point of using a framework if it actually slower then the original code.

Notes:
CodeIgniter is good for beginners that wish to learn MVC structure. Which stands for Module View Controller.
CodeLighter is good for those who are going in depth and wish to know the full mechanics and use a more plain and dynamic MVC framework.

Method 1: (best way)

1
2
3
4
5
6
7
8
9
10
11

// get_file_extension ( string [the file name] , boolean [lower case] )
function get_file_extension($str,$low = true){
	$i = strrpos($str,'.');
	if (!$i)
		return '';
	$l = strlen($str) - $i;
	$ext = substr($str,$i+1,$l);
	if($low == true)
	$ext = strtolower($ext);
	return $ext;
}

Method 2:

1
2
3
4
5
6
7
8
9
10

// get_file_extension ( string [the file name] , boolean [lower case] )
function get_file_extension($str,$low = true){
	$ar = explode('.',$str);
	if(empty($ar))
		return '';
	$ar = array_reverse($ar);
	if($low == true)
	$ext = strtolower($ar[0]);
	return $ext;
}

Both functions produce the same output but one uses the string functions and the other uses array function. If you think about it, to manipulate and create arrays take more memory then manipulating regular text. (internally arrays are created using those same string manipulation methods) So method one is better because it uses most simple way to get what you need.

Straight forward stuff…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function makecode($chars = 6)
{
	for($i=0; $i<=($chars-1); $i++)
	{
		$r0 = rand(0,1);
		$r1 = rand(0,2); // frequency of lower case
		if($r0==0)
			$r .= chr(rand(ord('A'),ord('Z')));
		elseif($r0==1)
			$r .= rand(0,9);
		if($r1==0)
			$r = strtolower($r);
	}
	return $r;
}

$r0 controls if the next digit is a number or a letter
$1 controls if teh letter will be upper or lower. Set it to 0 if you want it to always be lower or change the range to what ever suits you.
Also a number maybe passed to the function to change how many digits in the code to make.

Method 1: Very simple straight forward stuff. Can be customized to different sizes with different limits.

1
2
3
4
5
6
7
8

function convert_size($num)
{
    if ($num >= 1073741824) $num = round($num / 1073741824 * 100) / 100 .' gb';
    else if ($num >= 1048576) $num = round($num / 1048576 * 100) / 100 .' mb';
    else if ($num >= 1024) $num = round($num / 1024 * 100) / 100 .' kb';
    else $num .= ' b';
    return $num;
}

Method 2: (best way) More advance using a loop to count size depth. Very small and compact all the way to YB. Unlike method 1 it runs by a single constant.

1
2
3
4
5
6
7
8
9
10

function convert_size($size){
  $i=0;
  $iec = array(" B", " KB", " MB", " GB", " TB", " PB", " EB", " ZB", " YB");
  while (($size/1024)>1)
  {
   $size=round($size/1024,2);
   $i++;
  }
  return substr($size,0,strpos($size,'.')+4).$iec[$i];
}

As you see if you wish to have a large range conversion using the first method then you will have lots of IF statements unlike method two. Iif you are using method one you have more simple flexibility to have different off-sets for sizes.

Method two uses a single while loop to take the size to its lowest by every 1024 and each time it loops it reduces a single multiple of 1024 and counts how many times it reduces it, and at the end shows the corresponding unit size from the array using that count. The array must have the unit sizes in correct order. Good thing about this is if you give it a number that is like 7^20 (that’s 20 zeroes), then it still works just fine as long as the array has that many unit sizes.

Method 1:
Place this at the very begin of your PHP code:

1

define('STARTING_MICROTIME', get_microtime());

Depending on how you like to organize your code have those functions some where, they are pretty straight forward:

1
2
3
4
5
6
7
8
9

function execution_time()
{
    return sprintf("%01.4f", get_microtime() - STARTING_MICROTIME);
}
function get_microtime()
{
    $time = explode(' ', microtime());
    return doubleval($time[0]) + $time[1];
}

And finally just use the execution_time() function to show the total time elapsed since the script started.

Method 2:
Place this at very beginning of your code.

1

define('PAGE_LOAD_START', microtime(true));

And this where you want to display the render time.

1

<?php echo round((microtime(true) - PAGE_LOAD_START), 4); ?>

This way is easier IMO. Using constants is not necessary, it just avoids problems in namespaces if your code is OOP like.

This class can be used to manipulate images stored in files or in a MySQL database. It can read images from files and store them in a MySQL database table, and vice-versa. The class can also convert images between GIF, JPEG and PNG formats, as well resize the images to create thumbnails.

Documentation:
Coming Soon…

imagethumb(image resource, max width, max height, fill to make square)
1 – (GD image resource) Straight forward teh image resource loaded by GD library.
2 – (int) maximum width of thumbnail
3 – (int) maximum width of thumbnail
4 – (true/false) make thumbnail square

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

function imagethumb($old_im, $limit_w = 100, $limit_h = 100, $fill = false)
{
	//get original dimensions
	$old_w = imagesx($old_im);
	$old_h = imagesy($old_im);
 
	//first resize by width if overflow else set old to new
	if($old_w > $limit_w)
	{
		//get reduction percent
		$reduce_percent = ($limit_w / $old_w) * 100;
		//set new w and h
		$new_w = ($old_w / 100) * $reduce_percent;
		$new_h = ($old_h / 100) * $reduce_percent;
	}
	else
	{
		//set as the old dimensions
		$new_w = $old_w;
		$new_h = $old_h;
	}
 
	//second resize by height if still overflows
	if($new_h > $limit_h)
	{
		//get reduction percent
		$reduce_percent = ($limit_h / $new_h) * 100;
		//set new w and h
		$new_w = ($new_w / 100) * $reduce_percent;
		$new_h = ($new_h / 100) * $reduce_percent;
	}
 
	if($fill == true)
	{
		//height offset picture, to keep centered
		if($new_h < $limit_h)
			$h_offset = floor(($limit_h - $new_h)/2);
		else
			$h_offset = 0;
 
		//width offset picture, to keep centered
		if($new_w < $limit_w)
			$w_offset = floor(($limit_w - $new_w)/2);
		else
			$w_offset = 0;
 
		//make new image and copy to it
		$new_im = imagecreatetruecolor($limit_w, $limit_h);
	}
	else
		$new_im = imagecreatetruecolor($new_w, $new_h);
 
	imagecopyresampled($new_im, $old_im, $w_offset, $h_offset, 0, 0, $new_w, $new_h, $old_w, $old_h);
 
	return $new_im;
}

Step one, get those values:
total_items
items_per_page
current_page

Step two, calculate total pages:
total_pages = ( total_items / items_per_page )

Step three, calculate limit offset for database query:
start_item = current_page * items_per_page
end_item = if on last page then ( total_pages – start_item ) else ( items_per_page ) “asuming your database works like mysql”

Be mindful that arrays and databases start from 0 not from 1.

And from there just make your PHP code and add on nifty features of your own.

Check out my previous guide for a nice pagination script with demo.

For this script you would need to ahve PHP5. If you on PHP4 then you got to use fopen, fget, fput and fclose, classic style. You would also need to be able to modify your php ini variables with ini_set().

The other script that you will need to put at the source from where you copying is basically scandir() and echo all the files will full path with a separator like
or anything that is uncommon.

//depends on what si teh biggest fiel that would be copied
ini_set("memory_limit","256M");
 
//you can let it run for hours on end till its copied
ini_set("max_execution_time","60000");
 
//list of files to be copied from source website, get them here
$files = explode('<br>',file_get_contents('http:///source.website.com/list.php'));
 
/*on the listing i just printed each file with a new line tag at end, so the last line 
also got the tag, when exploded results in the last slot of the array to be empty*/
//remove that last empty value in the array
array_pop($files);
 
//total files to be copied
$total = count($maps);
 
//copied count
$cop = 0;
 
//you can stop this script and re run it again, so you get files that already exist on new location
//previously copied count
$ext = 0;
 
//start teh big loop
foreach($files as $k => $m) {
 
//display that we starting to copy this
 echo 'Copying '.($k+1).'/'.$total.' '.$m.' ... ';
 flush();
 
//if its not copied previously
	if(!is_file('path/to/new/place/here/'.$m)){
 
//get the file from source or show that we cant
	$f = @file_get_contents('http://source.website.com/'.$m) or er();
 
//if get works fire away
if($f) {
//put it on our server now
		if(file_put_contents('path/to/new/place/here/'.$m, $f)) {
 
//show that we done copying
			echo 'Done!<br>';
			$cop++;
			flush();
 
//wait haf a second or 1 second not to flame your source website
			usleep(500000);//500000 = 0.5 seconds / 1000000 = seconds
			}else echo 'Cannot put file.<br>';
		}else echo 'Cannot get file.<br>';
	}
	else
	{
		//show if already exists
echo 'Already exists.<br>';
		$ext++;
 
	}
 
}
//litle info
echo 'Copied '.$cop.' and '.$ext.' existed of '.$total.'. Failed: '.($total - $ext - $cop);

The flush() just shows current generated content to use.

Note:
I have noticed that if you pass URLs that have spaces in them, it will return as error also. I tried encoding teh URL and same thing happand. My solutioin: I used a curl version of file_get_content(). Here is the script, it will not return error on URLs with spaces:

function curl_get_file_contents($URL)
    {
        $c = curl_init();
        curl_setopt($c, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt($c, CURLOPT_URL, $URL);
        $contents = curl_exec($c);
        curl_close($c);
        if ($contents) return $contents;
            else return FALSE;
    }

The mini script that generates the list of files to copy on the source end of this deal is easy if you only copying folder by folder.

$dir = @opendir("copy/this/");
while (($file = readdir($dir)) !== false)
{
	if($file != "." && $file != "..")
	{ echo $file."<br>"; }
}

There is no limit to how much you can automate the procedure. Remember that.

Output from when I was using it:

Copying 6868/8593 6a8f9cbcaa6e54ad6032250c359bd233.png ... Done!
Copying 6869/8593 2997daad502d72d34ddb1e68499ebe08.png ... Done!
Copying 6870/8593 382c4d6be6670d61d2cc3c074f1a15bb.png ... Done!
Copying 6871/8593 72790f18f902f42d35a648cc32f69571.png ... Done!
Copying 6872/8593 66f037fb5bfb7aed444617dfcd071e95.png ... Done!
Copying 6873/8593 96544d7d415904d2b5443738713f5ab1.png ... Done!

Yeah I was copying directly one folder, my resources (don’t ask why there is 8000 of them, that’s just half of it). It finished it in around 2 hours. I just left the page on and minimized it as i was doing some other work. If you accidentally stop it, just refresh it. It will skip thought all the existing files in seconds and continue copying the rest. Saves you time relay, unlike with big back up and upload scripts here the only error that can happen if you are requesting too fast and it will skip that file, to fix that just refresh the page to get all those skipped ones, fast and easy.