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.

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;
}

Basic Pagination

For total pages, get total amount of rows in your list and divide it by how many rows you want per page and then ceil() the outcome for a nice rounded answer. The names of variables should be straight forward.

//get our data from a database
$total_rows = mysql_num_rows(mysql_query("select null from `table`"));
 
//find total pages
$total_pages = ceil($total_rows / 20);

Ceil() rounds the number up in case it is 4.5 so that means the last page will have maybe 10 rows of items left of the 20 per page.

Now you are all set. Get the current page that the user is viewing or set it to 1 by default.

//if empty, set to 1 if not use what is available
$current_page = (empty($_GET['page'])) ? 1 : trim($_GET['page']);
$current_page--; //zero is number! read farther...

Now you are all set to contract the navigation and the listing.

One more thing you should watch out for is the offset, since in arrays and databases it starts from 0 and the human interface should always start from 1. The code will fully be done in the favor of stating at 0 so there is less complication; it is up to you basicaly if you understand how it works.

Navigation

Best for navigation is to make it as a function, that way you can easily stick it in multiple places by just calling it, and it also makes your code more clean.

//make the function, it will need total pages and current page to work properly
function pagination_nav($total_pages, $current_page) {
 
	//set the empty var, so then we can just add to it like $nav .= 'something'
	$nav = '';
 
	//(optional) this will display a [Prev] button that will flip one page backwards, if already on first page it will show a null link instead.
	if($current_page > 1) //if we can go back wards show link
		$nav .= '<a href="listing.php?page='.($current_page - 1).'">[Prev]</a>';
	else //if not show null link or delete this whole line all togeather
		$nav .= '<a href="#">[Prev]</a>';
 
	//the main part of the nav
	//loop throught all the posible pages from 1 too total ammount
	for($i = 1; $i &lt;= $total_pages; $i++ )
	{
		if($current_page == $i) //if on current page display null link or none at all or make it more fency
			$nav .= '<a href="#">[-'.$i.'-]</a>';
		else //if not on the current page then display it as a regular link to that page
			$nav .= '<a href="listing.php?page='.$i.'">['.$i.']</a>';
	}
 
	//(optional) this will display a [Next] button that will flip one page forward, if already on last page it will show a null link instead.
	if($current_page &lt; $total_pages)
		$nav .= '<a href="listing.php?page='.($current_page + 1).'">[Next]</a>';
	else //if not show null link or delete this whole line all togeather
		$nav .= '<a href="#">[Next]</a>';
 
	//give back the goodness
	return $nav;
 
}
 
//to use it
echo apps_page_nav($total_pages, $current_page + 1);
//notice we have +1, that's because the function is doing this for the human interface, but total pages does not aply to the rule here as it is not used directly with data array or database.

The whole process is straight forward, the optional buttons can be manipulated and you can add a button to skip to last page and to first page also.

Listing

This part is more simple then the rest. Now we have some useful variable set and navigation out of the way. Do a quic validation that the current page selected is in between zero or total pages amount or equal to zero or total.

//validate the page number is with in range
if($pageID >= 0 && $pageID <= $total_pages) {
 
	//calculate the rows offset
	//the start will be the page number * number of rows per page
	$limit_start = $current_page * 20;
	// * here there is a special case for the last page calculation.
	//If on last page then (total rows - the starting rows) else its 20 per page
	$limit_end = ($current_page == $total_pages) ? ($total_rows - $limit_start) : 20;

* For the last page: If there is only like 5 items on the last page then the $limit_end cannot be 20, it will have to be 4. With mysql query it does not matter but in some cases it will matter a lot, if you get data from array for instance. Different databases may have a different syntax for limiting the results.

//get rows of items for that specific page, notice the 'limit'
$result = mysql_query("select * from `table` limit {$limit_start}, {$limit_end} ");

All straight forward. Different databases may have a slightly different syntax. Here if we are on page 1 then it will be limit 0, 20. (the second # is actualy teh ammount of rows starting from the first #) Straight forward.

Displaying

Nothing complicated, you may want to use a table for displaying or a list I will just spit out the results with a <br /> at the end of each line.

//You can use for loop or while loop, with for loop you can make every other row diff color easily.
while($row = mysql_fetch_assoc($result)) {
	echo '.$row['id'].' '.$row['field2'].' '.$row['field3'].'<br />';
}

That concluded the basics of pagination.

Ordering and Sorting

Sorting the results is easiest using your database. For mysql you can add “order by `field` asc” before giving the limit. To keep pagination and order variables in the URL you will need to add the current ordering to each URL that is generated by the pagination function. Also for the order by option links that you may add you will need to keep the current page teh user is on in the URL so it does not reset to 1.

Ajax / JavaScript

Using JavaScript to make a server side paginating server side table is easy. All you need is a good JavaScript that allows you to load content into a DIV element of the HTML and you are set to go. make a main page like index.html and make pages.php. Index.html will have the actual JavaScript and the DIV element. The pages.php will be the actual pagination and ordering script that will point all links to the JavaScript that will load the content in the DIV. That is server side ordering and pagination, the index stays intact while you can list thought any page and so on.

Ups and downs: Well so much for people who’s browsers cannot use JavaScript but that’s a very small fraction. Will save bandwidth, you only show them what they need. If you use server side you make less stress on the user but if you let the client’s browser do all the work it will put more stress on them (thought around 1000 results wont matter much depending on the size).

There is an example given at the bottom of the tutorial.

Examples:

I have went through this very carefully so that any beginner at PHP may understand this, or so I hope. Remember php.net is your friend.

Simple Pagination: [demo] [source]

Preview Frame:

So here is a basic good directory structure of the website:

/
/include/pages
/include/libraries
/images

This in my point of view is a really simple organized and safe way to create a website that can have a massive amount of pages and easy indexed. Included folder is where we store all our libraries, layouts, our custom functions, classes and pages. And the images folder speaks for it self. The slash at front means root of the website.

It may look good but I can still make it more better. Even thought people will not be able to access those folders we can make it shorter to save some time ans space, even thought its just few bytes of data. Shorten the “include” to “inc” and “images” to “img” for a start. There is no point having a big word like “libraries” because we can make a mistake in the spelling when writing scripts that deal with files in that folder.

So here is what we have now:

/
/inc/pages
/inc/lib
/img

Now it looks and feels very simple.

There are 4 major php pages that we need to create first:

• index.php
  - the page that loads configuration and all our things in the lib/ folder we made and finally the content page that the user wants to see like home or a list of something
• config.php
  - place to hold critical configurations like folder names and database user name and password
• layout.php
  -how our site will look, much better to have a layout in one place rather then writing in every single display page (the beauty of PHP)
• home.php
  - the default page that is shown if no page was selected

Here is what the structure should look like now:

/
/config.php
/index.php
/inc/pages
/inc/pages/home.php
/inc/lib
/inc/lib/layout.php
/img

Now lets get into more detail of those pages.

config.php

You must have a one place where you can put the critical information. This information is basically passwords and folder names. You can store the folder names in a database but the root things like the password for is best be stored here. This is not required but is best for flexibility.

For instance it is much easier to use $dbpass $dbname $dbuser for entering you main database because if you were to change a database name or pass word all you need to do is edit the config.php where you declared those 3 variables. if you got the pass and the name written in every page then its more of a security risk and you will be in pain updating every page where you connected to the database.

Same goes for folders. Make an array for folder places so then if for some reason you want to change the whole folder or select a new version of files you can just edit this variable instead of updating each page of your site.

Make sure that this page must be included to operate, I talk more about this for the index page. Very important.

index.php

Instead of having lots of pages in the root fo our website like index.php as a home page and gallery.php for the gallery and so on we will have just one single page “index.php”. And instead of writing our home page in it we make this our page server, it listens what page clients wants and it loads them. This means that this page will have the highest load.

Basic code:

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

<php
//Set variable that this is the index of the site.
define('THEINDEX',TRUE);
 
//Load configuration file.
require('config.php');
 
//Array of website required files.
$required_files = array(
'layout.php' //Page layout
);
 
//Include website required files from array or die.
foreach($required_files as $file)
if (@is_file($di['lib'].$file))
require_once($di['lib'].$file);
else
die('Required File Not Found: '.$file);
 
//Page request handle.
if (@is_file($di['pages'].trim($_GET['page']).'.php'))
require_once($di['pages'].trim($_GET['page']).'.php');
else
require_once($di['pages'].'home.php');
?>

Define some complex variable for security measures. This is how it works, this variable is defines only in this page and it better be something big just in case. Basically every other PHP page on your site at the top of the whole code will have one if statement that checks to see if this was defined. Since this is only defined in the index then pages included by the index will be able to see this variables and pass the if statement true. If the included page at work does not see this variable set then we can simple use die() or redirect the user to the home page. This is just one of the simple ways to prevent code execution, there is also lots of other ways. This is not necessary but works for me.

Require the configuration. (config.php) – Writing the PHP script we will first call the configuration file (config.php) that holds all critical data.

Require the your library scripts. (ex: layout.php) – Then knowing all the folder names that we got from the config.php we can include all of the libraries.

The page selection is done by passing URL variables. So if this is the URL “www.example.com/index.php?page=home” then there is one variable by the name of “page” that has a value of “home” (aside the variables set by the server). Simple right (those who know all this probably falling asleep, but I take newbies into consideration). Choosing what variable name you will use for passing the page name is important because it must be the same for every link that you will write in your website. if you got like 30 pages of dense code then its a pain modifying the variable name. Usually this name will have to be something simple like ‘p’ for page or ‘a’ for action. Lets assume we will use “page” as the variable name to keep things simple. So now its basically things we will pass in the page variable will be just the name of the pages that are located in the /inc/pages folder. So if we want the home.php we will use “home” not the whole thing. The ending is unnecessary. Concluding that first we add .php to the value in the “page” variable and check if that page exist in the /inc/pages folder and if it does then load it. If it does not exist then load our default page “home.php”.

layout.php

This is where we store the HTML header and the fotter of the website. Now this may seem very simple and limited but it is not. This is just a mere start. A lot of modifications can be done.

Basic example code:

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

<?php
class Layout {
 
function top() {
echo '<html><head><title>Example</title></head><body>';
}
 
function foot() {
echo '</body></html>';
}
 
}
?>

There you have it, a simple page. This means you will not have to create all teh headers and stuff in each page you make, instead you can just use Layout::top(); to show the top part. This is not limited so your your imagination to how far you can modify this and make it more advance.

home.php

Our simple default page that will be shown if no page is selected or page that was selected is not found.

Example code:

1
2
3
4
5
6

<?php
//Cheking for constants defined in index to prevent direct page usage.
if (!defined('ININDEX')) die('no peeking');
 
echo 'Hello World!';
?>

The first chunk is what I talked about when creating the index.php. This little piece of code will check to see if that constant was defined. If the constant does not exist it will stop working the rest of script and display “no peeking” as the code says.

You can download all those pages already constructed and at their correct place here. I have also added tiny bit of things to the code and a 1 bar layout.

DOWNLOAD