HomePHP Page 3 - Web Development With PHP FastTemplate
Proofing The Pudding - PHP
Typically, most PHP-based Web sites use scripts which containintermingled PHP and HTML code. While this speeds up development, it alsohas a downside: an interface designer cannot modify page layouts or HTMLtemplates without the assistance of an experienced PHP developer. Well,there's a solution to the problem - and you'll be surprised to hear thatit's been around for quite a while. Say hello to PHP FastTemplate.
Next, we need to tell FastTemplate about the template, assign values to the variables, and put the two together. Here's the script:
<?
// mypage.php - generate output using FastTemplate
// include class file
include("class.FastTemplate.php3");
// instantiate new object
$obj = new FastTemplate(".");
// assign names for template files
// "index" now references the template "./mypage.tpl"
$obj->define(array("index" => "mypage.tpl"));
// assign values to FT variables within the template
// this may also be set up as an associative array of key-value pairs
$obj->assign("FNAME", "John");
$obj->assign("LNAME", "Doe");
$obj->assign("AGE", "36");
$obj->assign("TEL", "(12)-34-567 8912");
$obj->assign("EMAIL_ADDRESS", "jdoe@anonymous.com");
// parse template "index" and store in handler "result"
$obj->parse(result, "index");
// print contents of handler "result"
$obj->FastPrint(result);
?>
A quick explanation is in order here.
1. The first step when using
the FastTemplate class is to create a new FastTemplate object, and tell it the location of the template files.
<?
include("class.FastTemplate.php3");
$obj = new FastTemplate(".");
?>
In this case, there's only one template and it's in the current
directory.
2. Next, the define() method is used to assign names to the templates you plan to use through the script - these names are defined in an associative array, and will be used throughout the remainder of the script to refer to the respective template files. In this case, I've used the name "index" to refer to the template "mypage.tpl".
3. Once FastTemplate knows which templates to use, and has names by which
it can refer to them, the next step is to assign values to the variables in the templates. As you can see from "mypage.tpl" above, it contains five variables - the assign() method is used to assign values to these variables
Variables may also be assign()ed values via an associative array
containing key-value pairs - you'll see that technique in the next example.
4. With the variables assigned values, it's time to put the two together. This is accomplished via FastTemplate's parse() method, which is easily the most important method in the object collection.
The parse() method accepts two arguments - a variable name, and a template name. In this example, the variable is called RESULT, and the template is named "index" (which references the template "mypage.tpl").
<?
$obj->parse(result, "index");
?>
In English, the line of code above means "read the template referenced by
the name "index", assign values to the variables found within it, and then assign the result, complete with substituted values, to the variable "result"." Whew!
5. At this point, the variable "result" contains the final page output - all that remains is to print it to the browser.
<?
$obj->FastPrint(result);
?>
The FastPrint() function prints the result of the last parse() function
call - or you can specify the name of the variable to be printed, as above.
Here's what it looks like:
Since the HTML interface is in a separate template file, it's easy for designers with no programming experience to radically alter the interface without affecting the program code...so long as they remember to replace the placeholders when they're done. As an illustration, here's a completely reworked version of "mypage.tpl"
/ 9 
