Doloj procedural programming, you allow object-oriented!
Programmers - people lazy. Therefore, when business reaches job, they all over again search for any software product which to some extent satisfies their needs{requirements} for the decision of a task in view in a network. If the programmer writes something on PHP one of the first systems which he will find, will be PHP Nuke. Having played with it nekotore time, the programmer understands, that a thing, certainly, good, but too "clumsily written, hardly adapted to the problems{tasks}, distinct from a web-portal, and translation into Russian is made by the person, having no more than three glasses on great mighty.
Nevertheless, the approach to storage of a code in that kind as it is realized in PHP Nuke and it is described on a plenty of the sites, devoted PHP, it seems quite logical, accessible and priemlimym.
The general circuit of this campaign named "modular", is those: there Is a certain main script, for example index.php. This script in a certain parameter, for example, $module, accepts a name of the module which gives a browser any page. index.php looks approximately thus:
<?
include "config.php";
if (! $module ||! file_exists (" modules / $ module.inc.php ")) {
$module = "default";
}
include " modules / $ module.inc.php ";
?>
Typical "module" at such construction of a site looks so:
<?
if (! eregi ("index.php", $PHP_SELF)) {die (" Access denied ");}
$page_title = "..."; // we establish{install} a name of page
include "includes/header.php"; // we connect design
// Certain php - a code which generates the given page
include "includes/footer.php"; // we connect the rests of design
?>
Like very well, however there are the some people but:
1. In kazhom the module it is necessary to do{make} include heading - differently we can not change and other tags in the beginning of page.
2. In kazhom the module it is necessary to do{make}
if (! eregi ("index.php", $PHP_SELF)) {die (" Access denied ");}
3.
- That have not called directly, having passed various initialization of variables, connection to SUBD, include the general{common} functions, etc. in config.php. Though, actually, such interdiction is done{made} by three lines in .htaccess:
<files *.php>
deny from all
</files>
4. In each module it is necessary to do{make} include the bottom part of page - for the same reason, as item 1
5. At programming modules to have repeatedly to cause the same procedures: generation of the menu, navigation, banerov, votings, etc. Even if all these procedures will be with beautiful, legkozpominaemymi names, with a small amount of parameters, will contain all HTML-formatting inside itself all the same each time at a spelling of the module it will be necessary to write calls of all these procedures consistently:
<?
PageNavigation (module params);
PageLeftMenu (module params);
// A PHP-code generating a content
PageRelatedLinks (module params);
PageNewsLinks (module params);
PageVotes (module params);
PageBanner (module params);
?>
6. Others but, forgotten as terrible dream
Thus, the spelling of the new module begins with copying the text of the old module with the subsequent correction of the block responsible{crucial} for a content.
However there is a way to relieve from this monotonous, long and to nobody of the necessary process - for this purpose it is necessary to recollect existence OOP (object-oriented programming) and that PHP is very quite good this most OOP supports.
For the beginning we shall create a class - Web-page in which we shall describe all funcii, used at generation of our pages:
class WebPage
{
// If the name of function coincides with a classname she is considered the designer
// Speaking Russian, she is carried out at creation of object
function WebPage ($module)
{
$this-> page_title = "demo - module";
}
function PageHeader ()
{
include "includes/header.inc.php";
// In this file instead of <? = $page_title;?> it will be necessary to write <? = $this-> page_title;?>
}
function PageFooter ()
{
include "includes/footer.inc.php";
}
function PageNavigation ()
{
// A code for navigation
}
function PageLeftMenu ()
{
// A code for the menu in the left part of page
}
function PageContent ()
{
// A code generating a content
}
function PageRelatedLinks ()
{
// The code generating the links to connected sections
}
function PageNewsLinks ()
{
// A code generating the block of news
}
function PageVotes ()
{
// A code generating the block of votings
}
function PageBanner ()
{
// A code generating a banner
}
function Run ()
// kh-n Run consistently causes all necessary
// Methods of class WebPage for construction of page
{
$this-> PageNavigation ();
$this-> PageLeftMenu ();
$this-> PageContent ();
$this-> PageRelatedLinks ();
$this-> PageNewsLinks ();
$this-> PageVotes ();
$this-> PageBanner ();
}
}
?>
Now, if we should make, for example, page which differs otstandartnoj only the block of a content we can define{determine} the new class derivative from WebPage:
class CoolPage extends WebPage
{
// We redefine the designer to change a name of the module
function CoolPage ()
{
// We cause the designer of a parental class - suddenly he useful does{makes} something?;)
parent:: WebPage ();
$this-> page_title = " the Abrupt module ";
}
function PageContent ()
{
// We deduce{remove} a content
}
}
If on page news we determine other class are not necessary for us:
class CoolPageWithoutNews extends CoolPage
{
// Here we do not describe funciju CoolPageWithoutNews
// In this case PHP the designer of a parental class will automatically call
// Accordingly the name of our page will be " the abrupt module "
function PageNewsLinks ()
{
// Here it is empty, that links to news were not deduced{removed}
}
}
And so on.
Basically, if you have a plenty of classes the code of each of too can be placed them in a separate file, however it is necessary to watch{keep up} that that classes which have derivative classes, were accessible always, differently PHP cannot understand, from what file to take a code of a parental class.
Example of a file index.php which can represent itself as " the main file ":
<?
include "config.php";
include "base_classes.php";
if ($module ** file_exists ($file = " modules / $ module.inc.php ")) {
// We check, whether there is a file with "body" of a class
include $file;
}
if (! class_exists ($module)) {
// We check, that the class exists
$module = "WebPage";
}
$page=new $module; // we create object
$page-> Run (); // we start generation of page
}
?>
The note: not looking that all above mentioned code was never started, the above-stated technology, with that difference, that almost the information is in a DB, is really maintained, for example, on my site.
