Well, now that everyone knows what to do and not do with sessions, we can try to improve performance a little more.
The rule is to determine how sessions will be used in the application and then choose a better handler than the default one : files.

SQLite : fast read / slow write

SQLite for handling sessions is used to improve significantly read accesses. On the other hand, write processing will be slown and time-consuming.
In fact, instead of using one file per session like the default “files” handler, all of them will be stored in a single file, which is a database. So any write action will lock the file resulting in other access tries to be put in a queue.

Balance the pros and the cons, if the application need huge write accesses don’t use SQLite to manage sessions. But, if writes are limited SQLite is really appropriate.

Moreover, it’s quick and simple to setup.
Install SQLite on the server if it is not already done :

apt-get install php5-sqlite

Then just tell PHP, in the php.ini file, to use SQLiteas the session handler and the file path where to store them :

session.save_handler = sqlite
session.save_path = "/path/sessions.db"

You don’t even need to worry if the file exists or not, it will be automatically created. The first session_start() query will initiate the database with a table which contains 3 columns “sess_id”, “value” and “updated”.
Remember to restart your web server to apply the modifications.

Memcached : fast but RAM consuming

For people who doesn’t know about Memcached, it’s a distributed memory object caching system. Just visit the official website to learn more : http://memcached.org/. In a few words, Memcached allows to store data in memory.

Disk I/O are one of the slowest elements in applications workflow. So, if frequently used data are put in RAM, a lot of disk reads and writes will be saved. This can be applied to your application common data and to users sessions as well.

The installation is very simple, in most case rely on the package manager of the host OS is sufficient.
For example, in a debian based system :

apt-get install memcached
apt-get install php5-memcache

Then, if no specific configuration has to be done in the Memcached configuration file, just change the session save handler in the php.ini :

session.save_handler = memcache
session.save_path = "tcp://127.0.0.1:11211"

Restart Apache (or nginx, lighttpd, etc.) and that’s it. Now the session processing will be really fast.

But, even if using Memcached for handling sessions has good pros, there are also cons.
In fact, session data are now saved into the server RAM. That means that the storage limit is equal to the available memory on the web server. And the more RAM is used to save session data the less is available for web applications execution. So be careful in what is stored in sessions, that’s where the best practices become handful. Moreover, data stored in RAM will not survive in a power outage or reboot.

To go further, a single dedicated Memcached server can be shared between several application servers. For example, if you want to do load balancing with multiple web servers, they can use the same Memcached server to cache data. Just change the IP address in the php.ini configuration file with the cache server one and you’re done.

Other leads

Instead of using Memcached, you can set up a RAMDisk to store sessions in RAM without changing the default files handler. But this solution requires some adminsys skills.

Another possibility is to use the shared memory module of PHP. I have never tried this method and didn’t manage to find a good tutorial to implement it. So if anyone has ever done this, please leave a comment

Ever faced the problem of needing to loop through an array but it has non-consecutive numeric keys ?
There are some easy ways to reassign array keys from 0 onwards.

Supposing that I have an array with numeric keys as below :

$array = array(
    'zero',
    'one',
    'two',
    'three',
    'four',
    'five'
);

print_r($array);

/*
Output :

Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => three
    [4] => four
    [5] => five
)
*/

For some reasons I unset one of the array elements :

unset($array[2]);

print_r($array);

/*
Output :

Array
(
    [0] => zero
    [1] => one
    [3] => three
    [4] => four
    [5] => five
)
*/

Keys ordering is now broken.
But it’s really simple to reorder them. No need to do kind of tricky foreach() loop, just use array_values() PHP built-in function :

$array = array_values($array);

print_r($array);

/*
Output :

Array
(
    [0] => zero
    [1] => one
    [2] => three
    [3] => four
    [4] => five
)
*/

Ta-da

To go a little further, the first or last element of an array can be removed without breaking keys order.
It can be done very easily by using array_shift() and array_pop() functions :

$array = array(
    'zero',
    'one',
    'two',
    'three',
    'four',
    'five'
);
print_r($array);

/*
Array
(
    [0] => zero
    [1] => one
    [2] => two
    [3] => three
    [4] => four
    [5] => five
)
*/

array_shift($array);
print_r($array);

/*
Array
(
    [0] => one
    [1] => two
    [2] => three
    [3] => four
    [4] => five
)
*/

array_pop($array);
print_r($array);

/*
Array
(
    [0] => one
    [1] => two
    [2] => three
    [3] => four
)
*/

Hope it helps

Moreover, it provides a large set of ready-to-use and useful classes, abstract classes and interfaces. This ressources collection composes the SPL : Standard PHP Library. Among those, array overloading classes, iterators and additional exceptions may be found.

This post don’t cover all the SPL features but offer a good overview of the powerful iterators to enrich your own classes.

Yet, if you are curious, you may list all the classes and interfaces contained in the SPL with the two following functions :

// Display the SPL classes
var_dump(spl_classes());

// Display the declared interfaces
var_dump(get_declared_interfaces());

What is an iterator ?

Ok, let’s start by giving a definition of what an iterator is. I have picked up and summerized the one from Wikipedia :

In computer programming, an iterator is an object that enables a programmer to traverse a container. [...] Note that an iterator performs traversal and also gives access to data elements in a container, but does not perform iteration [...]. An iterator is behaviorally similar to a database cursor.

In PHP, generally, the container is an array or an object which provides methods to be traversed. Then, it may be loop through by a foreach structure.

The basics

As you surely know, the foreach structure allows to iterate over arrays :

$arr = array('one' => 1, 'two' => 2, 'three' => 3);

foreach ($arr as $key => $value){
    echo 'the key "', $key, '" is set to "', $value, '".', "\n";
}

/* Output :
the key "one" is set to "1".
the key "two" is set to "2".
the key "three" is set to "3".
*/

But what does happen exactly when the foreach loop is starting ?

If you read the documentation, you will learn that when foreach starts :

• PHP performs a reset on the specified array to put its internal pointer on the first element
• then check if the pointer position in the array is valid
• reads the key, value pair at that position
• assigns the values to the $key and $value variables
• then the pointer is advanced by one
• if the position is still valid, the loop will continue so on

You may reproduce this behavior by using these following array iterative functions : reset(), array_key_exists(), key(), current(), next().

$arr = array('one' => 1, 'two' => 2, 'three' => 3);

reset($arr);
while (array_key_exists(key($arr), $arr) === true){
    echo 'the key "', key($arr), '" is set to "', current($arr), '".', "\n";
    next($arr);
}

/* Output :
the key "one" is set to "1".
the key "two" is set to "2".
the key "three" is set to "3".
*/

In PHP 4, foreach worked only on arrays, but with PHP 5 it is possible to iterate objects.

The Traversable abstract interface

In fact, PHP is able to iterate on any object that implements the Traversable interface. Yet, all classes implement this interface by default.
So, you may use any object in foreach, it will loop through its public properties :

class MyClass
{
    public $public1 = 'public value 1';
    public $public2 = 'public value 2';
    public $public3 = 'public value 3';

    protected $protected = 'protected value';

    private $private = 'private value';
}

$Class = new MyClass();

foreach ($Class as $key => $value){
    echo $key, ' => ', $value, "\n";
}

/* Output :
public1 => public value 1
public2 => public value 2
public3 => public value 3
*/

Nevertheless, as Traversable is an abstract interface, it cannot be implemented alone. It is just use as an internal engine interface. Either Iterator or IteratorAggregate have to be used instead.

The Iterator and IteratorAggregate interfaces

To personalize the way an object is traversed, you can implement the Iterator interface. This one force the class which implements it to define five specific methods : rewind, valid, key, next.

Remember the while syntax above in the “Basics” part ?
The foreach statement will use the Iterator interface methods as well to iterate the object :

class AnIterator implements Iterator
{
    private $_list = array(
        'one',
        'two',
        'three'
    );
    private $_key = 0;

    public function __construct()
    {
        $this->_key = 0;
    }

    public function rewind()
    {
        $this->_key = 0;
    }

    public function valid()
    {
        return array_key_exists($this->_key, $this->_list);
    }

    public function key()
    {
        return $this->_key;
    }

    public function current()
    {
        return $this->_list[$this->_key];
    }

    public function next()
    {
        ++$this->_key;
    }

}

$Iterator = new AnIterator();
foreach ($Iterator as $key => $value){
    echo $key, ' => ', $value, "\n";
}

/* Output :
0 => one
1 => two
2 => three
*/

The official documentation have a good example to see when each method is called during the foreach statement : See Example #2 Basic usage.

Now, if you don’t want to put the Iterator methods inside your class, you may implement IteratorAggregate instead. Then, the class just need to define a getIterator() method that must return an iterator which will be used by foreach :

class MyClass implements IteratorAggregate
{
    private $_list = array();

    public function addElement($mixed)
    {
        $this->_list[] = $mixed;
    }

    public function getIterator()
    {
        return new ArrayIterator($this->_list);
    }
}

$Class = new MyClass();
$Class->addElement('one');
$Class->addElement('two');
$Class->addElement('three');

foreach ($Class as $key => $value){
    echo $key, ' => ', $value, "\n";
}

/* Output :
0 => one
1 => two
2 => three
*/

The foreach statement automatically calls the getIterator() method of the $Class object to check how to iterate it.
Instead of returning an ArrayIterator, you may make your own iterator, as seen above with the AnIterator class, an return it.

Make a class countable with the Countable interface

As arrays, it is useful to be able to know the size of iterable objects. That’s where the Countable interface takes place. It allows to define a count() method to your class that will be used by the count() or sizeof() function :

class MyClass implements IteratorAggregate, Countable
{
    private $_list = array();

    public function addElement($mixed)
    {
        $this->_list[] = $mixed;
    }

    public function getIterator()
    {
        return new ArrayIterator($this->_list);
    }

    public function count()
    {
         return sizeof($this->_list);
    }
}

$Class = new MyClass();
$Class->addElement('one');
$Class->addElement('two');
$Class->addElement('three');

if (sizeof($Class) > 1){
    foreach ($Class as $key => $value){
        echo $key, ' => ', $value, "\n";
    }
}

/* Output :
0 => one
1 => two
2 => three
*/

Dummy iterator example

Now that you know how to make iterable and coutable objects, let’s see an example. This one is just for fun, don’t implement it as it in one of your application…

The following abstract class just easily allow to count and traverse all rows contained in a database table. I have taken table names from a classic WordPress database :

abstract class SimpleSqlTableIterator implements IteratorAggregate, Countable
{
    protected static $_Dao;

    protected $_tableName;
    protected $_tableRows = array();

    static public function setDao(PDO $Dao)
    {
        static::$_Dao = $Dao;
    }

    public function getIterator()
    {
        if (sizeof($this->_tableRows) < 1){
            $this->_getData();
        }

        return new ArrayIterator($this->_tableRows);
    }

    public function count()
    {
        if (sizeof($this->_tableRows) < 1){
            $this->_getData();
        }

        return sizeof($this->_tableRows);

    }

    protected function _getData()
    {
        $Stmt = static::$_Dao->query("SELECT * FROM {$this->_tableName}");
        $this->_tableRows = $Stmt->fetchAll(PDO::FETCH_ASSOC);
    }
}

class UserTable extends SimpleSqlTableIterator
{
    protected $_tableName = 'wp_users';
}

class PostTable extends SimpleSqlTableIterator
{
    protected $_tableName = 'wp_posts';
}

$Db = new PDO (
    'mysql:host=localhost;dbname=your_wp_db',
    'your_user',
    'youor_passwd'
);
SimpleSqlTableIterator::setDao($Db);

$Users = new UserTable();

var_dump(sizeof($Users));

foreach ($Users as $user){
    var_dump($user);
}

$Posts = new PostTable();

var_dump(sizeof($Posts));

foreach ($Posts as $post){
    var_dump($post);
}

Next Time

In a future entry, we will see other useful iterators such as SeekableIterator, FilterIterator, LimitIterator…

Your quest is over, I have what you need : the cal_days_in_month() function from the Calendar PHP extension. This function can work with different calendars : gregorian, julian, jewish… Then just specified a month of a particular year and it will return the number of days :

$days = cal_days_in_month(CAL_GREGORIAN, 2, 2024);
echo $days; // output : 29

$days = cal_days_in_month(CAL_GREGORIAN, date('n'), date('Y'));
echo $days; // output : 30

To list the available calendars, you may use cal_info() :

print_r(cal_info());

See “sources” links for more informations

To help you keep your applications safe, since its 5.2 version, PHP provides the Filter extension which supplies a couple of handy functions to validate and sanitize data.
The two main functions are filter_var and filter_input. The first simply filters a specified variable with the given filter whereas the second is able to directly target an external variable (such as a $_POST or $_GET key) and to return it, possibly after having filtered it.
Both come with the same list of filters allowing you to validate or sanitize data.

In this first part we’re going to overview the validate filters. The sanitize ones will be exposed in a second part post.

Validate basic values

So, how it works ?
PHP has defined a list of constants which contain the ID (an integer) of all the available filters. Then, just specified the value to validate and the filter ID to the filter_var() function and you’re done.

It’s important to understand that filters don’t act like the PHP is_*() functions. They don’t check the type of the specified value but return the value itself or false if this one is not validate.
Plus, they come with some extra features that are very useful.

Validate an integer

For example, integer values may be validated with the constant FILTER_VALIDATE_INT :

$var = 1;
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : int(1)

$var = '1024';
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : int(1024)

$var = 'abc';
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : bool(false)

$var = '42x';
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : bool(false)

Octal and hexadecimal value may also be checked :

$var = 0755;
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : int(493)

$var = 0xFF;
$result = filter_var($var, FILTER_VALIDATE_INT);
var_dump($result); // output : int(255)

After defining two simple options, you may also be more restrictive and specified an allowed range of values :

$var = 5;
$result = filter_var(
    $var,
    FILTER_VALIDATE_INT,
    array(
    	'options' => array(
    	    'min_range' => 1,
    	    'max_range' => 10
        )
    )
);
var_dump($result); // output : int(5)

$var = 0x1E;
$result = filter_var(
    $var,
    FILTER_VALIDATE_INT,
    array(
    	'options' => array(
    	    'min_range' => 1,
    	    'max_range' => 100
        )
    )
);
var_dump($result); // output : int(30)

Validate a float

Float numbers have also their validator, FILTER_VALIDATE_FLOAT :

$var = 3.14;
$result = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($result); // output : float(3.14)

$var = '3.14';
$result = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($result); // output : foat(3.14)

$var = '10';
$result = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($result); // output : float(10)

$var = 'Not a float';
$result = filter_var($var, FILTER_VALIDATE_FLOAT);
var_dump($result); // output : bool(false)

The decimal separator may be defined with an option :

$options = array('decimal' => ',');
$var = '3,14';
$result = filter_var(
    $var,
    FILTER_VALIDATE_FLOAT,
    array(array('options' => $options))
);
var_dump($result); // output : float(3.14)

Validate a boolean

The FILTER_VALIDATE_BOOLEAN allows to check not only a boolean but more generaly a truthy or falsy value.

$boolean = filter_var($var, FILTER_VALIDATE_BOOLEAN);

The code above will return true if $var has one of the following value :

• true
• 1
• ’1′
• ‘yes’
• ‘on’
• ‘true’

Any others value will result in a false, unless you specify the FILTER_NULL_ON_FAILURE flag in a third argument :

$boolean = filter_var($var, FILTER_VALIDATE_BOOLEAN, array('flags' => FILTER_NULL_ON_FAILURE));

// The following works too
$boolean = filter_var($var, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);

Then false will be return if $var is equal to :

• false
• NULL
• 0
• ’0′
• ‘false’
• ‘off’
• ”

Otherwise NULL will be return.

Validate more complex values

The three following validators will make you save some times by avoiding the use of complex regexp to validate URL, email and IP addresses.

Validate an URL

Don’t misunderstand, this validator doesn’t check if an URL exsits or not, it just validates the syntax of the value :

$var = 'http://domain.tld';
$result = filter_var($var, FILTER_VALIDATE_URL);
var_dump($result); // output : string(17) "http://domain.tld"

$var = 'http://domain';
$result = filter_var($var, FILTER_VALIDATE_URL);
var_dump($result); // output : string(13) "http://domain"

$var = 'http:domain';
$result = filter_var($var, FILTER_VALIDATE_URL);
var_dump($result); // output : bool(false)

If you want to force the URL to have a path or a query string, you may add some flags :

$var = 'http://domain.tld';
$result = filter_var($var, FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED);
var_dump($result); // output : bool(false)

$var = 'http://domain.tld/';
$result = filter_var($var, FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED);
var_dump($result); // output : string(18) "http://domain.tld/"

$var = 'http://domain.tld/path/';
$result = filter_var($var, FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED);
var_dump($result); // output : string(23) "http://domain.tld/path/"

$var = 'http://domain.tld/?id=1';
$result = filter_var($var, FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED);
var_dump($result); // output : string(23) "http://domain.tld/?id=1"

Validate an email

As the URL validator, FILTER_VALIDATE_EMAIL allow to check an email address without using a single regexp :

$var = 'email@domain.tld';
$result = filter_var($var, FILTER_VALIDATE_EMAIL);
var_dump($result); // output : string(16) "email@domain.tld"

$var = 'email@domain';
$result = filter_var($var, FILTER_VALIDATE_EMAIL);
var_dump($result); // output : bool(false)

Validate an IP address

FILTER_VALIDATE_IP is also very handy, allowing you to validate IPv4, IPv6 addresses and check if they are not in a private range :

$var = '10.10.1.127';
$result = filter_var($var, FILTER_VALIDATE_IP);
var_dump($result); // output : string(11) "10.10.1.127"

$var = '2001:0db8:0000:85a3:0000:0000:ac1f:8001';
$result = filter_var($var, FILTER_VALIDATE_IP);
var_dump($result); // output : string(39) "2001:0db8:0000:85a3:0000:0000:ac1f:8001"

$var = '2001:0db8:0000:85a3:0000:0000:ac1f:8001';
$result = filter_var($var, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4);
var_dump($result); // output : bool(false)

$var = '192.168.0.2';
$result = filter_var($var, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE);
var_dump($result); // output : bool(false)

Validate inputs with filter_input()

Idealy, your application should never work directly with $_GET, $_POST or $_COOKIE array. The only lines of code that may contain them should be those that do the filtering.
So, let’s see how to use the validate filters to directly interact with input data.

Suppose you have built a newsletter system on your website. Then, you have made an HTML form with a text field allowing your visitors to subscribe by keying their email address. When an email address is submitted, your script has to check that it is valid before store it in the database.
If you use to do something like the following :

if (preg_match('\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b', $_POST['email']) > 0) {
    $some_sql_query = "INSERT INTO newsletter (email) VALUES (' {$_POST['email']}')";
    $result = mysql_query($some_sql_query);
    // ...
}

It’s a bad practice, you should never rely on super global variable. This way you avoid configuration differences and PHP evolution problems. Moreover, the use of an regexp to validate the email address isn’t really safe, unless you are absolutely sure of what it does and that it respects the syntax defined in RFC 5322…

A better practice would be to use PHP built-in filter :

$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
if ($email !== false && $email !== NULL){
    $some_sql_query = "INSERT INTO newsletter (email) VALUES ('$email')";
    // Do what you want
}

Much simple, isn’t it ?

Go further

For more informations, examples and functions read the official documentation :

• Validate filters list
• Filter flags list
• Filter funcions list

Happy reading

$str = 'Hello World!';
$char = $str{4};

echo $char; // output : o

So, you may iterate on string characters to build an array :

$str = 'Hello World!';
$n = strlen($str);
$arr = array();
for ($i = 0; $i < $n; $i++){
    $arr[$i] = $str{$i};
}

But, it’s by far not the easiest way to convert a string into an array
PHP has already a built-in function to do the job : str_split.

$str = 'Hello World!';
$arr = str_split($str);

print_r($arr);
/*
Array
(
    [0] => H
    [1] => e
    [2] => l
    [3] => l
    [4] => o
    [5] =>
    [6] => W
    [7] => o
    [8] => r
    [9] => l
    [10] => d
    [11] => !
)
*/

Plus, str_split has another cool feature : if the optional second parameter is specified, the returned array will be broken down into chunks with each the length you have chosen.

$str = 'Hello World!';
$arr = str_split($str, 2);

print_r($arr);
/*
Array
(
    [0] => He
    [1] => ll
    [2] => o
    [3] => Wo
    [4] => rl
    [5] => d!
)
*/

Now, let’s make an example with a very simple string to hexadecimal representation function :

function str_to_hex($str)
{
    $n = strlen($str);
    $str = str_split($str);
    for ($i = 0; $i < $n; $i++){
        $str[$i] = dechex(ord($str[$i]));
    }
    return implode($str);
}

echo str_to_hex('Hello'); // output : 48656c6c6f

The reverse :

function hex_to_str($str)
{
    $str = str_split($str, 2);
    $n = sizeof($str);
    for ($i = 0; $i < $n; $i++){
         $str[$i] = chr(hexdec($str[$i]));
    }
    return implode($str);
}

echo hex_to_str('48656c6c6f'); // output : Hello

Enjoy

The following guidelines suppose that PHP is configured to use the default session save handler files and uses cookies to send tokens. Other handlers will be seen in the second part.

Session, what is it for ?

In a few words, the session is used to keep track of a visitor and store data about it across requests to your server. A token is sent to the visitor in a cookie and the user will return it at each of its requests. Then the session allows you to register data to be preserved.

From here, you are able to store the user id for example, which may be used to retrieve its related data through some SQL queries. Also, you may store its access rights, names, last visited URL, shopping cart etc… Everything that helps defining its application environnement and avoid unneedful SQL queries.

What you shouldn’t do

As seen above, the session must be used to store data concerning an authenticated user.
You should not use it as a data cache or store template part in it.

For example, HTML elements such as navigation menu or footer, is surely not specific to an user, so if you store these pieces of code in sessions, the contents will be duplicated in each session file…
As well, if you store SQL queries results in the session, this will increase significantly their file size and degrading performance. Moreover, retrieve query results from a session is not necessarily faster than calling the database.

Even if, at first sight, the session setup is not the most expensive part of a HTML page generation, it’s useful to work on it to avoid big performance hits.
The most you keep your session files small and less numerous, the most your website will be fast.

If you want to make data caching there are several dedicated solutions available such as APC or Memcached, so don’t use the session for this task.

Optimization

Now that you know how to properly use sessions, we can start to optimize our PHP configuration and code

First, keep in mind that when a session is started in your script, PHP :

• tries to read the token contained in the cookie
• opens or creates a file on-disk
• locks it, so you can write in it
• reads its contents
• puts the data in the global array $_SESSION
• sets caching headers
• returns a cookie to the client
• etc…

All these actions are just a summary of what PHP does, I don’t know the exact internal mechanisms…
But they set out one thing, the setup of a session have a cost in terms of performance.
So you should always keep the control of the session initialization.

For that purpose, the php flag session.auto_start in your php.ini must be set to 0. Otherwise, a session will be mount at the begining of each request for each user and even when it’s not necessarily. If a visitor has no need to be logged, why setting a session for him ?
I admit that for 1 or 2 visitors per day it’s surely not significant but what if your website must handle thousands visits at the same time ?

You have to determine where and when a session has to be set up. Then you may start it explicitly with :

$boolean = session_start();

At that point, the session is running. That means its file is locked to prevent concurrent writes and only your current script may make operations on it. Other access tries will be denied, resulting in your other scripts to stall, waiting for the session file to be available.
So, if you don’t need to save data into the session, close it as soon as possible. Then data you set in the $_SESSION array is written in the storage and all of the global $_SESSION array contents are still avalaible in read-only mode :

session_start();

$_SESSION['foo'] = 'This will be stored in the session';
session_write_close();

echo $_SESSION['foo'];

// Other data that has been stored before the current script
// are still available in read mode
echo $_SESSION['bar'];

Voilà !

Applying these few best practices is a good start to not slow your web applications when implementing session support.

In the second part of this serie, we will see how to increase even more performance by using others session handler instead of files.

$filename = '/path/to/your/file.php';
$ext = substr($filename, strrpos($filename, '.') + 1);

echo $ext; // display : php

Stop reinventing the wheel, there’s a simple PHP function to get informations from a file path, among them the file extension.
The pathinfo function parses and returns in an array :

• the directory name
• the file name
• the extension
• the file name without the extension

To get only the file extension you can pass a second argument like the following :

$filename = '/path/to/your/file.php';
$ext = pathinfo($filename, PATHINFO_EXTENSION);

echo $ext; // display : php

And you’re done
See the official documentation for more information about the pathinfo function.

PHP Chunk intends to bring you quick tips, code snippets and best practices in PHP coding. It is aimed at beginner developers and more experimented coders as well.
Visit my about page to learn more about me and this blog.

Hope you will learn some good stuff.
Happy reading

<?php
echo 'Hello World!';
?>