Zend_Cache_Core is a special frontend because it is the core of the module. It is a generic cache frontend and is extended by other classes.

	Note
	All frontends inherit from Zend_Cache_Core so that its methods and options (described below) would also be available in other frontends, therefore they won't be documented there.

These options are passed to the factory method as demonstrated in previous examples.

An example is given in the manual at the very beginning.

If you store only strings into cache (because with "automaticSerialization" option, it's possible to store some booleans), you can use a more compact construction like:

<?php  
             
// we assume you already have $cache

$id = 'myBigLoop'; // cache id of "what we want to cache"

if (!($data = $cache->load($id))) {
    // cache miss
    
    $data = '';
    for ($i = 0; $i < 10000; $i++) {
        $data = $data . $i;
    }
    
    $cache->save($data);
    
} 

// [...] do something with $data (echo it, pass it on etc.)
             
?>       

If you want to cache multiple blocks or data instances, the idea is the same:

<?php  
             
// make sure you use unique identifiers:
$id1 = 'foo';
$id2 = 'bar';

// block 1
if (!($data = $cache->load($id1))) {
    // cache missed
    
    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . $i;
    }
    
    $cache->save($data);
    
} 
echo($data);

// this isn't affected by caching
echo('NEVER CACHED! ');

// block 2
if (!($data = $cache->load($id2))) {
    // cache missed
    
    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . '!';
    }
    
    $cache->save($data);
    
} 
echo($data);

?>       

Zend_Cache_Frontend_Output is an output-capturing frontend. It utilizes output buffering in PHP to capture everything between its start() and end() methods.

This frontend doesn't have any specific options other than those of Zend_Cache_Core.

An example is given in the manual at the very beginning. Here it is with minor changes:

<?php

// if it is a cache miss, output buffering is triggered
if(!$cache->start('mypage')):

// output everything as usual
echo 'Hello world! ';
echo 'This is cached ('.time().') ';

$cache->end(); // output buffering ends
endif;

echo 'This is never cached ('.time().').';

?>       

Using this form it is fairly easy to set up output caching in your already working project with little or no code refactoring.

Zend_Cache_Frontend_Function caches the results of function calls. It has a single main method named call() which takes a function name and parameters for the call in an array.

Using the call() function is the same as using call_user_func_array() in PHP:

<?php

$cache->call('veryExpensiveFunc', $params);

# $params is an array
# for example to call (with caching) veryExpensiveFunc(1, 'foo', 'bar'), you will use
# $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar'))

?>       

Zend_Cache_Frontend_Function is smart enough to cache both the return value of the function and its internal output.

	Note
	You can pass any builtin or user defined function with the exception of array(), echo(), empty(), eval(), exit(), isset(), list(), print() and unset().

Zend_Cache_Frontend_Class is different from Zend_Cache_Frontend_Function because it allows caching of object and static method calls.

For example, to cache static calls :

<?php

class test {
   
    # Static method
    public static function foobar($param1, $param2) {
        echo "foobar_output($param1, $param2)";
        return "foobar_return($param1, $param2)";   
    }

}

// [...]
$frontendOptions = array(
    'cachedEntity' => 'test' // The name of the class
);
// [...]

# The cached call
$res = $cache->foobar('1', '2');

?>       

To cache classic method calls :

<?php

class test {
   
    private $_string = 'hello !';
      
    public function foobar2($param1, $param2) {
        echo($this->_string);
        echo "foobar2_output($param1, $param2)";
        return "foobar2_return($param1, $param2)";   
    }

}

// [...]
$frontendOptions = array(
    'cachedEntity' => new test() // An instance of the class
);
// [...]

# The cached call
$res = $cache->foobar2('1', '2');

?>       

Zend_Cache_Frontend_File is a frontend driven by the modification time of a "master file". It's really interesting for examples in configuration or templates issues.

For instance, you have an XML configuration file which is parsed by a function which returns a "config object" (like with Zend_Config). With Zend_Cache_Frontend_File, you can store the "config object" into cache (to avoid the parsing of the XML config file at each time) but with a sort of strong dependency on the "master file". So, if the XML config file is modified, the cache is immediatly invalidated.

Use of this frontend is the same than of Zend_Cache_Core. There is no need of a specific example - the only thing to do is to define the masterFile when using the factory.

Zend_Cache_Frontend_Page is like Zend_Cache_Frontend_Output but designed for a complete page. It's impossible to use Zend_Cache_Frontend_Page for caching only a single block.

On the other hand, the "cache id" is calculated automatically with $_SERVER['REQUEST_URI'] and (depending on options) $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES. More over, you have only one method to call (start()) because the end() call is fully automatic when the page is ended.

For the moment, it's not implemented but we plan to add a HTTP conditional system to save bandwith (the system will send a HTTP 304 Not Modified if the cache is hit and if the browser has already the good version).

	Note
	Zend_Cache_Frontend_Page is really "alpha stuff" and is meant to be improved further down the road.

Use of Zend_Cache_Frontend_Page is really trivial :

<?php
	           
// [...] // require, configuration and factory
	
$cache->start();
// if the cache is hit, the result is sent to the browser and the script stop here
	
// rest of the page ...
	
?>       

a more complex example which shows a way to get a centralized cache management in a bootstrap file (for using with Zend_Controller for example)

<?php

// [...] you should avoid to put too much lines before the cache section 
// [...] for example, for optimal performances, "require_once" or "Zend_Loader::loadClass" should be 
// [...] after the cache section        	

require_once 'Zend/Cache.php';

$frontendOptions = array(
   'lifeTime' => 7200,
   'debugHeader' => true, // for debuging 
   'regexps' => array(
       '^/$' => array('cache' => true),         // cache the whole IndexController         
       '^/index/' => array('cache' => true),    // cache the whole IndexController
       '^/article/' => array('cache' => false), // we don't cache the ArticleController...
       '^/article/view/' => array(              // ...but we cache the "view" action of 
           'cache' => true,                     // this ArticleController
           'cacheWithPostVariables' => true,    // and we cache even there are some variables in $_POST
           'makeIdWithPostVariables' => true,   // (but the cache will be dependent of the $_POST array)
       )
   )	  
);
$backendOptions = array(
    'cacheDir' => '/tmp/' 
);

// getting a Zend_Cache_Frontend_Page object
$cache = Zend_Cache::factory('Page', 'File', $frontendOptions, $backendOptions);

$cache->start();
// if the cache is hit, the result is sent to the browser and the script stop here

// [...] the end of the bootstrap file (these lines won't be executed if the cache is hit)
	        	
?>