Eventually I came across file_get_contents to do the job. Since this also needs allow_url_fopen to be on, my post on fetching page content with cURL came to mind.

This does the same thing without restrictions on privacy and is available on most current setups.

Fetching Raw Data with get_page_content

We start off with our get_page_content method from the last post, which we use to collect page data. We’re looking to collect the raw data of an image, and here I’ve used the Google logo as an example.

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

function get_page_content($url)
{
  $resource = curl_init();
 
  curl_setopt($resource, CURLOPT_URL, $url);
  curl_setopt($resource, CURLOPT_HEADER, false);
  curl_setopt($resource, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($resource, CURLOPT_CONNECTTIMEOUT, 30);
 
  $content = curl_exec($resource);
 
  curl_close($resource);
 
  return $content;
}
 
$content = get_page_content('http://www.google.co.uk/intl/en_com/images/srpr/logo1w.png');
 
$fp = fopen('logo.png', 'w');
fwrite($fp, $content);
fclose($fp);

The use of get_page_content is the same as in the last post.

For the last three lines we use a few functions for creating a new file.

The first line creates a handle to a file (which doesn’t have to exist), which here we’ve called “logo.png”. This is where our image will be copied to. The “w” parameter tells the script we are opening the file for it to be directly written to, and we save the resource into $fp.

The second line writes the content that we collected earlier into our image. The raw data will make it display properly since it’s being saved as an image file.

Calling fclose on the resource closes the handle to it and frees up memory.

Mimicking the PHP Copy

Now the script will work fine if you use it as-is, but for a more robust way of handling file copying we’re going to create a wrapper around it to be called similarly to the copy function.

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

function copy_file($source, $destination)
{
  $resource = curl_init();
 
  curl_setopt($resource, CURLOPT_URL, $source);
  curl_setopt($resource, CURLOPT_HEADER, false);
  curl_setopt($resource, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($resource, CURLOPT_CONNECTTIMEOUT, 30);
 
  $content = curl_exec($resource);
 
  curl_close($resource);
 
  $fp = fopen($destination, 'w');
  fwrite($fp, $content);
  fclose($fp);
}

Here we have a new function with a $source and $destination parameter, identical to copy.

Handling Failed Requests

To add even further similarity to the allow_url_fopen method I’ll add in some boolean return values.

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

function copy_the_file($source, $destination)
{
  $resource = curl_init();
 
  curl_setopt($resource, CURLOPT_URL, $source);
  curl_setopt($resource, CURLOPT_HEADER, false);
  curl_setopt($resource, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($resource, CURLOPT_CONNECTTIMEOUT, 30);
 
  $content = curl_exec($resource);
 
  curl_close($resource);
 
  if($content != '')
  {
    $fp = fopen($destination, 'w');
    $fw = fwrite($fp, $content);
    fclose($fp);
 
    if($fw != false)
    {
      return true;
    }
  }
 
  return false;
}

So now if there is no content in the external file or the new file can’t be written to your server, the function will return false.

You can add to this with some cURL error checking and a handler on fopen, but it depends how robust it would need to be on your own website.

The great thing is, this script doesn’t just work with images. Just change the destination file to anything else with a change of extension and it’ll work exactly the same.

Here I will discuss the use and methods of randomisation in PHP with data from a MySQL database.

Collecting the Data

First we need to grab our database rows.

For this we uses a simple SELECT statement, where in this example is taken from a “users” table with two fields “ID” and “name”.

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

$db = MySQLi(DB_HOST, DB_USER, DB_PASS, DB_NAME);
 
$query = "SELECT `ID`, `name` FROM `users` ORDER BY `ID` ASC";
 
$results = $db->query($query);
 
$rows = array();
 
while($r = $results->fetch_assoc())
{
  $rows[] = $r;
}
 
echo '<ol>';
 
foreach($rows as $row)
{
  echo '<li>'.$row['ID'].' = '.$row['name'].'</li>';
}
 
echo '</ol>';

This will print out all of the data from our database into an ordered list, arranged by ID from 1 upwards.

Randomise with PHP

To then take this data and shuffle its values, we can then take the conveniently named shuffle method in PHP and apply it to our $rows array.

Add this code to the above script at line 13. It takes the data and again prints it out into an ordered list, this time with a randomised data set.

13

shuffle($rows);

Using the MySQL Query

Now, since here we are already using a MySQL query, we can utilise the RAND() method by adding it to our $query string.

This should be used as an alternative to the PHP shuffle method, so as such should not include the above line with shuffle in it (unless you want to randomise it twice – but it won’t make your data any more unique).

Replace your query string with this, on line 3.

3

$query = "SELECT `ID`, `name` FROM `users` ORDER BY RAND()";

Notice it’s only the last part (ORDER BY...) that changes.

This code – or at least the idea – can be applied to, and is useful for, all programming languages. The syntax will vary between them but fundamentally the results will be the same.

Making a Facebook app? Why not award the user with a random item when they log in once a day, or show a rearranged list of their friends if it’s otherwise too large to show on a page.

Own a blog? Apply this to your homepage and show some old posts. It will also get their page rankings higher if they are being re-indexed by search engines. It’s like fresh content!

It will also help your visitors find posts they never knew they were looking for. ‘Cos we’re all just browsing after all

In PHP, all you do is include the class in your document and construct it with a Twitter username (with some options for extra tweaking).

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

<?php
class UserTweets
{
  var $username = '';
  var $page_content = '';
  var $encoded_content = array();
  var $results = array();
  var $user_info = array();
  var $result_count = 0;
  var $connected = false;
 
  function __construct($username, $options = array())
  {
    $this->username = $username;
 
    $request_options = array(
      'since_id', 'max_id', 'count', 'page'
    );
 
    $option_set = array();
    $option_string = 'screen_name='.urlencode($username);
 
    if(!empty($options))
    {
      foreach($request_options as $req)
      {
        if(isset($options[$req]))
        {
          $option_set[$req] = $options[$req];
          $option_string .= '&'.$req.'='.urlencode($options[$req]);
        }
      }
    }
 
    $url = 'http://api.twitter.com/1/statuses/user_timeline.json?'.$option_string;
 
    $connection = @curl_init();
 
    if($connection)
    {
      curl_setopt($connection, CURLOPT_URL, $url);
      curl_setopt($connection, CURLOPT_HEADER, false);
      curl_setopt($connection, CURLOPT_RETURNTRANSFER, true);
      curl_setopt($connection, CURLOPT_CONNECTTIMEOUT, 30);
 
      $this->page_content = curl_exec($connection);
 
      curl_close($connection);
 
      $this->connected = true;
    }
    else
    {
      $connection = @file_get_contents($url);
 
      if($connection)
      {
        $this->page_content = $connection;
 
        $this->connected = true;
      }
    }
 
    if($this->connected)
    {
      $this->results = json_decode($this->page_content, true);
      $this->result_count = count($this->results);
      if($this->result_count > 0)
      {
        $this->user_info = $this->results[0]['user'];
        foreach($this->results as &$result)
        {
          unset($result['user']);
        }
      }
    }
  }
}
?>

Usage

To fetch a user’s tweets with default settings (simple method).

1

$tweets = new UserTweets('_bigSteve');

Setting options with names and values as defined in the Twitter API Wiki. This example returns 5 results posted on or before the update with ID of 12402600172.

1
2
3
4
5
6

$options = array(
  'max_id' => 12402600172,
  'count' => 5
);
 
$tweets = new UserTweets('_bigSteve', $options);

Displaying tweets in an ordered list.

1
2
3
4
5
6
7
8
9
10

if($tweets->result_count > 0)
{
  echo '<h1>Tweets</h1>';
  echo '<ol>';
  foreach($tweets->results as $tweet)
  {
    echo '<li>'.$tweet['text'].'</li>';
  }
  echo '</ol>';
}

…And user info. This data is stripped out of the results array and added into its own named user_info to reduce bloat.

1
2
3
4
5
6
7
8
9
10

if($tweets->result_count > 0)
{
  echo '<h1>User Info</h1>';
  echo '<ol>';
  foreach($tweets->user_info as $name => $info)
  {
    echo '<li>'.$name.' => '.$info.'</li>';
  }
  echo '</ol>';
}

This script will work on server setups with either the cURL library or allow_url_fopen turned on, taking preference over the faster and more secure cURL. If none are in use, most of the object properties will be empty (like results and page_content) and it will handle itself properly without printing errors to the page.

Hope this class will make it a bit easier for developers to start using the great Twitter API in their own mashups.

Comments are welcome as always.

Have fun

http://example.com/page.php#content

The “content” part of this URL however never gets passed to PHP since it is only used client-side. However, with a little bit of help from JavaScript we can do exactly that.

JavaScript can be used to grab all of the URL data since it runs client-side, which makes it ideal. In the below example we collect the URL, check for the hash tag, and refresh the page replacing the fragment anchor data with a PHP parameter.

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

<script type="text/javascript">
var parts = location.href.split('#');
if(parts.length > 1)
{
    var params = parts[0].split('?');
    var mark = '?';
    if(params.length > 1)
    {
        mark = '&';
    }
    location.href = parts[0] + mark + 'fragment=' + parts[1];
}
</script>

Line 2: If the URL has a fragment anchor, this will contain more than one element.
Lines 5-10: Quick check for any existing PHP parameters, adding an ampersand (&) instead if true.
Line 11: Combine the URL data and redirect.

We will then be sent to a page like this:

http://example.com/page.php?fragment=content

A quick check in PHP then prints the parameter to the page.

1
2
3
4
5
6

<?php
if(isset($_GET['fragment']))
{
    echo $_GET['fragment'];
}
?>

Add this just below the JavaScript content from earlier.

For examples of this script being used in large websites, look for any Facebook URLs that have a “#!” in them, and paste that into another tab (try Photo pages). You will then notice that the browser redirects you to a page with a nicer URL but with the same content as you had before.

This is a very neat little trick that is particularly useful in photo galleries with JavaScript support, but has uses for a wide range of projects that control most of their page data client-side.

The script handles sessions within a database to allow it to be more secure and analytically useful. It’s derived from an article by Richard Willars who I owe a lot to for the basis of this script. Anything that I don’t cover will be available on his website.

Here is the script:

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

/*
  Session class by Stephen McIntyre
  http://stephenmcintyre.net
*/
class Session
{
  private $id = '';
  private $alive = true;
  private $dbc = NULL;
 
  function __construct()
  {
    session_set_save_handler(
      array(&$this, 'open'),
      array(&$this, 'close'),
      array(&$this, 'read'),
      array(&$this, 'write'),
      array(&$this, 'destroy'),
      array(&$this, 'clean'));
 
    session_start();
  }
 
  function __destruct()
  {
    if($this->alive)
    {
      session_write_close();
      $this->alive = false;
    }
  }
 
  function delete()
  {
    if(ini_get('session.use_cookies'))
    {
      $params = session_get_cookie_params();
      setcookie(session_name(), '', time() - 42000,
        $params['path'], $params['domain'],
        $params['secure'], $params['httponly']
      );
    }
 
    session_destroy();
 
    $this->alive = false;
  }
 
  private function open()
  {    
    $this->dbc = new MYSQLi(DB_HOST, DB_USERNAME, DB_PASSWORD, DB_NAME)
      OR die('Could not connect to database.');
 
    return true;
  }
 
  private function close()
  {
    return $this->dbc->close();
  }
 
  private function read($sid)
  {
    $this->id = $sid;
 
    $q = "SELECT `data` FROM `sessions` WHERE `id` = '".$this->dbc->real_escape_string($sid)."' LIMIT 1";
    $r = $this->dbc->query($q);
 
    if($r->num_rows == 1)
    {
      $fields = $r->fetch_assoc();
 
      return $fields['data'];
    }
    else
    {
      return '';
    }
  }
 
  private function write($sid, $data)
  {
    $q = "REPLACE INTO `sessions` (`id`, `data`) VALUES ('".$this->dbc->real_escape_string($sid)."', '".$this->dbc->real_escape_string($data)."')";
    $this->dbc->query($q);
 
    return $this->dbc->affected_rows;
  }
 
  private function destroy($sid)
  {
    $q = "DELETE FROM `sessions` WHERE `id` = '".$this->dbc->real_escape_string($sid)."'"; 
    $this->dbc->query($q);
 
    $_SESSION = array();
 
    return $this->dbc->affected_rows;
  }
 
  private function clean($expire)
  {
    $q = "DELETE FROM `sessions` WHERE DATE_ADD(`sesh_last_accessed`, INTERVAL ".(int) $expire." SECOND) < NOW()"; 
    $this->dbc->query($q);
 
    return $this->dbc->affected_rows;
  }
}

Before you try to use the class you have to set up your database. I have used exactly the same database setup as Richard here, but can easily be expanded into using user IDs and shopping carts as I mentioned before.

1
2
3
4
5
6

CREATE TABLE `sessions` (
  `id` char(32) NOT NULL,
  `data` longtext NOT NULL,
  `last_accessed` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

If you use phpMyAdmin it’s as simple as adding a database as you normally would and pasting the above into the SQL query box.

For the class to connect to the database, you also need to create some definitions in PHP.

1
2
3
4

define('DB_USERNAME', 'root');
define('DB_PASSWORD', '');
define('DB_NAME', 'penguin');
define('DB_HOST', 'localhost');

This should be placed at the top of your PHP file, replacing the appropriate fields with your own database information.

That’s it set up. All you have to do now is call it in one line.

1

$session = new Session();

And set our session data with the $_SESSION variable as usual.

1
2

$session = new Session();
$_SESSION['user_id'] = 1;

The user ID above will then be stored inside the “data” field in your database, in a serialised format that the class will be able to parse.

Since it’s handled from a class, the variable will also call session_write_close(); by itself when the page ends, so no need to call this yourself. If you want to end it early though, you can always call the destructor manually.

1
2
3

$session = new Session();
// ... extra code ...
$session->__destruct();

The session can also be deleted (like when logging out) and to do this we just call the delete method.

1
2
3

$session = new Session();
// ... extra code ...
$session->delete();

So there you have it, a simple session handling class you can use for any web project.

Also, if you do use this in your applications, please be kind enough to leave the extra header text at the top.

Thanks

However, this forum post seems to be the only official documentation on what is a very interesting data feed, so it is with this reason that I decided to create this beginner’s tutorial on how to use it.

Since Kongregate is a website that hosts Flash games, this data would primarily be used to collect data into such games – like showing user badges embedded into a Flash dashboard. In this tutorial, I will take a different approach and show you how to collect that data in PHP and build your own activity stream.

All Badges Feed

Located at http://www.kongregate.com/badges.json

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

{
  "description": "Collect 100 squiggles and pwn 10 spiders",
  "users_count": 285194,
  "name": "Running Start",
  "games": [
    {
      "url": "http://www.kongregate.com/games/DrNeroCF/fancy-pants-adventure-world-2",
      "title": "Fancy Pants Adventure: World 2"
    }
  ],
  "icon_url": "http://cdn2.kongregate.com/badge_icons/0000/0367/world2easy.png?1242937128",
  "created_at": "2008/01/24 20:26:15 -0800",
  "points": 5,
  "difficulty": "easy",
  "id": 184
}

This is an example of an item from the list of game badges in the feed. It contains more than enough information to help make your own application. Each element is labeled so that you can index and call each item when you need to. Further down I’ll show you how to sort out the data in PHP.

User Badges Feed

Can be found at http://www.kongregate.com/accounts/USERNAME/badges.json, replacing USERNAME with your account login name.

1
2
3
4

{
  "badge_id": 184,
  "created_at": "2008/06/23 06:20:42 -0700"
}

A much simpler looking JSON string. A user’s badge feed only contains a list of badge IDs and the date and time that the user achieved them. All other data can be found on the global badge feed above, we just match up the IDs.

Grabbing the Data

Last week I showed you how to fetch page content using PHP. We can reuse the get_page_content method here to collect our information from Kongregate. Be sure to add this method above all other code in your PHP file, before adding the content from the box below.

1
2
3
4
5
6
7
8
9

$all_badges_content = get_page_content(
  "http://www.kongregate.com/badges.json");
 
$all_badges = json_decode($all_badges_content, true);
 
$user_badges_content = get_page_content(
  "http://www.kongregate.com/accounts/USERNAME/badges.json");
 
$user_badges = json_decode($user_badges_content, true);

This sets up two arrays ($all_badges and $user_badges) that we can use to loop through and match IDs.

Displaying the Content

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

echo '<ol>';
foreach($user_badges as $badge)
{
  foreach($all_badges as $i => $global)
  {
    if($badge['badge_id'] == $global['id'])
    {
      echo
        '<li>'.
          '<a href="' . $global['games'][0]['url'] . '">'.
            htmlspecialchars( $global['name'], ENT_COMPAT, 'UTF-8' ) . ' Badge'.
          '</a>'.
          '<span>'.
            ' : ' . htmlspecialchars( $global['description'], ENT_COMPAT, 'UTF-8' ).
          '</span>'.
        '</li>';
        unset($badge[$i]);
        break;
    }
  }
}
echo '</ol>';

For each user badge in the $user_badges array we loop through our global badges to find a match and print an output of badge, link, and description to the page.

The break and unset in this code is useful for reducing memory usage on the script.

The break exits the current loop when the badges have been matched – since we won’t need to keep looking once we have found what we are looking for.

The unset removes the item from our list of all badges completely, since once it has been found once we won’t ever need to match it again since we can only have one of each badge.

Finishing Up

For a full copy-paste version of the code, feel free to skip to the end of this article, or view a demo page of this script.

Note: the demo page is a rendered example of the end result and does not update. For markup purposes only.

Also note that reading the JSON data directly from the server in this way is not recommended. For better use of this data, please store and manage the information within your own database setup.

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

<?php
function get_page_content($url){
  $resource = curl_init();
 
  curl_setopt($resource, CURLOPT_URL, $url);
  curl_setopt($resource, CURLOPT_HEADER, false);
  curl_setopt($resource, CURLOPT_RETURNTRANSFER, true);
 
  $content = curl_exec($resource);
 
  curl_close($resource);
 
  return $content;
}
 
$all_badges_content = get_page_content(
  "http://www.kongregate.com/badges.json");
 
$all_badges = json_decode($all_badges_content, true);
 
$user_badges_content = get_page_content(
  "http://www.kongregate.com/accounts/USERNAME/badges.json");
 
$user_badges = json_decode($user_badges_content, true);
 
echo '<ol>';
 
foreach($user_badges as $badge)
{
  foreach($all_badges as $i => $global)
  {
    if($badge['badge_id'] == $global['id'])
    {
      echo
        '<li>'.
          '<a href="' . $global['games'][0]['url'] . '">'.
            htmlspecialchars( $global['name'], ENT_COMPAT, 'UTF-8' ) . ' Badge'.
          '</a>'.
          '<span>'.
            ' : ' . htmlspecialchars( $global['description'], ENT_COMPAT, 'UTF-8' ).
          '</span>'.
        '</li>';
        unset($badge[$i]);
        break;
    }
  }
}
echo '</ol>';
?>

Their data output is most commonly formatted in RSS (for feed readers), and JSON (a lighter form than XML used a lot for AJAX). In this post I’ll show you how to use the cURL library to collect data from any public web page.

First, I’ve set up a function that will take in the URL you want to use as a parameter and returns the content of the page. This will make it easier later on, particularly if you want to call more than one page in a single script (like feeding Twitter and Facebook status updates into one stream).

Making a Connection

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

function get_page_content($url){
  $resource = curl_init();
 
  curl_setopt($resource, CURLOPT_URL, $url);
  curl_setopt($resource, CURLOPT_HEADER, false);
  curl_setopt($resource, CURLOPT_RETURNTRANSFER, true);
 
  $content = curl_exec($resource);
 
  curl_close($resource);
 
  return $content;
}

Line 2: Initialises a cURL connection so we can start using it.

Line 4: Sets the URL.
Line 5: Sets headers to false, so that we don’t collect extra header data that we won’t use.
Line 6: Sets the return transfer to true. Without setting this, the script will output the content directly to the page, which we don’t want.

Line 8: Execute the connection using the options from lines 4-6 and store it into a holding variable. If we hadn’t set our return transfer to true, this would return empty.

Lines 10-12: Close connection to the URL and return the holding variable.

So, for example, we can collect JSON formatted data from a user’s latest Twitter updates:

Decoding the Data

1
2
3
4

$twitter_content = get_page_content(
  "http://api.twitter.com/1/statuses/user_timeline.json?screen_name=_bigSteve");
 
$tweets = json_decode($twitter_content, true);

Where json_decode with its second parameter as true puts our data into an associative array.

We can then display this data as we usually would, looping through the elements:

Displaying the Text

1
2
3
4
5
6
7
8
9
10
11

echo "<ol>";
 
foreach($tweets as $tweet){
 
  echo "<li>".
    htmlspecialchars($tweet['text'], ENT_COMPAT, 'UTF-8').
    "</li>\n";
 
}
 
echo "</ol>";

The htmlspecialchars method in there is very useful for escaping special characters into their HTML entities, so should be used here since we are sending output to the web page.

After the text we want to output, I’ve found the other two parameters to be useful in most cases. You can change these if you get some strange characters.

So when you run the script on your own website, it will display an ordered list of Twitter updates onto the page. You can take the info above and convert it to use data from other APIs, using the get_page_content method we created in particular.

If you’re looking to parse XML documents like RSS feeds, then SimpleXML is a great library for that. When given the option though, it’s almost always best to go with JSON, so have a poke around for it in the API docs before you set off.

Bad practice

One way I’ve seen it done before is like this:

$query = mysql_query( "SELECT * FROM `users`" );
while( $row = mysql_fetch_assoc( $query ) ){
    $dob = strtotime( $row['dob'] );
    $joined = strtotime( $row['joined'] );
    if( $dob >= 0 ){
        $array[$joined] = $row;
    }
}
krsort( $array, SORT_NUMERIC );
array_slice( $array, 10 );
foreach( $array as $item ){
    echo 'Name: ' . $item['name'] . '';
    echo 'Join Date: ' . $item['joined'] . '';
    echo 'Date of Birth: ' . $item['dob'] . '';
    echo '';
}

Good practice

The alternative uses some SQL techniques to do all of that data sorting within the database query.

$dob_limit = date( 'c', 0 );
$query = mysql_query( "SELECT `name`,`joined`,`dob` FROM `users` WHERE `dob` >= $dob_limit ORDER BY `joined` DESC LIMIT 10" );
while( $item = mysql_fetch_assoc( $query ) ){
    echo 'Name: ' . $item['name'] . '';
    echo 'Join Date: ' . $item['joined'] . '';
    echo 'Date of Birth: ' . $item['dob'] . '';
    echo '';
}

As you can see, the latter script should look far simpler, is easier to write, and works much quicker and efficiently.

Note also that in the second script the fields after the SELECT statement have been specified rather than leaving a wild-card asterisk (*). The asterisk returns all data in the row that the SQL statement found a match in, and the more data we have in a row the more data could become redundant as we extract it.

For example, consider that the users table had extra fields containing first name, surname, website URL, small personal biography, home town, favourite film, favourite food, and so on. For each row you extract, all seven of those become unused pieces of data in the memory on your server and possibly even the computers of your users. Multiply that seven by each row in your database, then by how many times the query will be called, and things start to add up pretty quickly.

The point is then that if you start with a clear idea on what you actually need in order to use your script, you can be specific in what data you need to collect from your database. Doing so decreases your page load times and lowers your bandwidth, usually with dramatic results.

If like me you hadn’t heard about PHP until this point where you are looking to add in other scripts to your web pages, then now is a very good time to learn about PHP includes.

1

<?php include( 'header.html' ); ?>

One thing to note before I begin is that if you’re ever told to use a frame or iframe tag for this kind of thing, don’t. There’s plenty of articles on why this is, but the main reasons I don’t use them is that it doesn’t play nicely with the other scripts on the page (like JavaScript and CSS) and are a pain for error checking in web development.

PHP displays the page as if it had been generated from a single HTML script, and this after all is what we’re looking for.

Using a PHP include is as simple as pasting in the code before the jump. All you do is replace the ‘header.html’ with a relative path to the file you want added in.

1
2
3
4
5

<?php
include( 'header.html' );
include( 'path/to/menu.html' );
include( '../footer.php' );
?>

Just remember to enclose them in the standard <?php and ?> tags. Oh yeah, and you have to save whatever files that use them with a ‘.php’ extension instead of ‘.html’ so that it can read those special tags and run the code inside them.

File: index.php

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

<div id="container">
 
<?php
include( 'header.html' );
include( 'path/to/menu.html' );
?>
 
<p>
  Some dummy content text goes here to fill space.
</p>
 
<?php include( '../footer.php' ); ?>
 
</div>

File: header.html

1
2
3

<h1>My First PHP Page</h1>
 
<h2>Hello World</h2>

File: menu.html

1
2
3
4
5
6

<ul>
  <li><a href="#">Home</a></li>
  <li><a href="#">About</a></li>
  <li><a href="#">Gallery</a></li>
  <li><a href="#">Contact</a></li>
</ul>

File: footer.php

1
2
3
4
5
6
7
8

<p>
  <em>
    Generated on 
    <?php
    echo date( 'jS M Y \a\t g:i a' );
    ?>
  </em>
</p>

In ‘footer.php’, date is a PHP method like include that generates a string of text from the time that you run it. The fancy letters in the brackets just make it return the right information you want it to.

The echo part takes the info from date() and writes it to the screen, so your end result is something like this:

Generated on 13th Feb 2009 at 23:31

See it in action by viewing the full page.

Further reading

As you can see, when used wisely PHP includes can be very useful and efficient for your web development and helps organise all your files. Other methods you can use are require, include_once, and require_once.

1
2
3
4
5

<?php
require( 'header.html' );
include_once( 'path/to/menu.html' );
require_once( '../footer.php' );
?>

include: Searches for the file in brackets. If found, adds data into script, otherwise ignores and continues.

require: Similar to include, but if no file is found exits the script and displays an error. Useful for adding in files necessary to how your script will run.

include_once and require_once: Will only add data in once. If there are multiple calls of these methods to the same file in one script, only the first call will be used. Useful for things like PHP classes.

These are used and written in almost exactly the same way as the include examples. At the time you need to consider using one of these, you will be able to tell from the list above which one will best suit your project.