August 23, 03:17 pm

tutorials

articles

scripts

contact

Welcome to PHPRecipes, the starting place for PHP scripts, tutorials,

and gourmet cooking tips and recipes!

Copyright 2000 PHPRecipes. All rights reserved.

contact |

your privacy

In Fig. Figure 9.1 shows how the resulting page looks in a browser. Although I don't usually use table borders, this time I drew them out to make the three parts of the page stand out more clearly in the illustration.

Rice. 9.1. Appearance of the page built in Listing 9.8

Template optimization

In the second (in my opinion, more preferable) option, the templates are designed as functions located in a separate file. This provides additional structure to your templates. I call this file the initialization file and store other useful information in it. Since we've already looked at relatively long header and footer examples, Listings 9.10 and 9.11 have been slightly shortened to illustrate the new idea.

Listing 9.10. Optimized site template (site_init.tpl)

// File: site_init.tpl

// Purpose: PhpRecipes initialization file

$site_name = "PHPRecipes";

$site_email = " [email protected]";

$site_path = "http://localhost/phprecipes/";

function show_header($site_name) (

This is the header

function show footer()

This Is the footer

Listing 9.11. Using an initialization file

// Include initialization file

include("site_init.tpl");

// Print title

show header($site_name);

// Body content This is some body information

// Display the footer Show_footer();

Project: page generator

Although most of the websites I've created have generated the main page content based on information read from a database, there are always a few pages that remain virtually unchanged. In particular, they can display information about the development team, contact information, advertising, etc. I usually store this “static” information in a separate folder and use a PHP script to load it when a request comes in. Of course, you have a question - if this is static information, what is the PHP script for? Why not load regular HTML pages? The benefit of PHP is that you can use templates and insert static snippets as needed.

<а href = "/static.php?content=$content">Static Page Name

Let's start by creating static pages. For simplicity, I'll limit myself to three pages containing site information (Listing 9.12), advertising (Listing 9.13), and contact information (Listing 9.14).

Listing 9.12. Information about the site (about.html)

About PHPRecipes

What programmer doesn't mix all night programming with gourmet cookies. Here at PHPRecipes. hardly a night goes by without one of our coders mixing a little bit of HTML with a tasty plate of Portobello Mushrooms or even Fondue. So we decided to bring you the best of what we love most: PHP and food!

That's right, readers. Tutorials, scripts, souffles and more. 0nly at PHPRecipes.

Advertising Information

Regardless of whether they come to learn the latest PHP techniques or for brushing up on how

to bake chicken, you can bet our readers are decision makers. They are the Industry

professionals who make decisions about what their company purchases.

For advertising information, contact

">[email protected].

Listing 9.14. Contact details (contact.html)

Contact Us

Have a coding tip?

Know the perfect topping for candied yams?

Let us know! Contact the team at [email protected].

Let's move on to building the static.php page, which displays the requested static information. This file (see Listing 9.15) includes the page components of our site and the initialization file site_init.tpl.

Listing 9.15. General output of static pages (static.php)

// File: static.php

// Purpose: displaying requested static pages.

// WARNING: this assumes that the file is "site_init.tpl" and that's it

// static files are in the same directory.

// Load functions and variables include("site_init.tpl"):

// Display the header show_header($site_name);

// Output the requested content include("$content.html"):

// Display the footer show footer();

Now everything is ready to build the main scenario. Just include it in the page

<а href = "static.php?content=about">Static Page Name

Advertising Information

Contact Us

If you click on any of these links, your browser will load the corresponding static page embedded in static.php!

Results

In this chapter, you became acquainted with the primary task for which PHP was created - dynamically building web pages. The following issues were considered:

• URL processing;
• building dynamic content;
• inclusion and construction of basic templates.

The chapter ends with a page generator, a program that loads static pages into a template and makes it easy to support large numbers of static HTML pages.

The next chapter focuses on using PHP in combination with HTML forms to greatly enhance the interactivity of your site. And then - interaction with databases! You have a lot of interesting things to learn.

From previous lessons we learned that using the GET method we can pass some parameters directly to the URL. However, there is nothing stopping us from doing this without forms, just listing them in the URL.

We can pass parameters via URL. And we can get these parameters directly in the script. So what's stopping us from showing different pages to the user depending on the parameters in the URL?

Creating a dynamic page

To show different pages to the user, you need to prepare content. Let it lie in a multidimensional array:

"Creating dynamic pages", "content" => "Text of the article about dynamic pages." ], [ "title" => "How to catch a kitten", "content" => "Text of the article about kittens." ] ]; ?>

The dynamic parameter in the URL will be called id, and we will catch it in $_GET["id"] . We could add an id field to each element of the array, but then we would have to iterate through all the elements and look for the subarray with the desired id. Therefore, it is much easier to use the keys of the main array as ids.

Simply put, we take the id and try to find an article with that key in the $articles array. It looks like this:

All that remains is to sketch out the menu output and check the id for correctness. It turns out to be a real PHP router!

"Home page", "content" => "Text of the article about our site" ], [ "title" => "Creating dynamic pages", "content" => "Text of the article about dynamic pages." ], [ "title" => "How to catch a kitten", "content" => "Text of the article about kittens." ] ]; # If the id is passed, write the article to $article or null if there is no article with that id if(isset($_GET["id"])) $current_article = $articles[$_GET["id"]] ?? null; # If id is not passed, then this is the main page, we can show the page with id = 0 else $current_article = $articles; ?> $article): ?> ">

Error 404: Page not found

Now you can create dynamic sites where the number of pages depends on the number of array elements, rather than PHP files. :) If the site should have different types of pages, for example, an article and a product, you can pass the page type as the second parameter: site.ru?type=article&id=5 .

Of course, this system is not perfect. After a while you will learn how to make a normal CNC (more convenient URLs, for example site.ru/articles/5/) and store articles in a file or database.

To create a promising, expandable and effective website of any complexity, you should start with something simple. This process is not easy, it requires certain basic knowledge of PHP and MySQL, but if you consider it point by point, you can create a kind of “work plan” that will be useful when creating new sites. Let's prepare the “core” and base for the project. At first it will be a regular business card website, but then, by adding functionality, it can be turned into anything. So let's get started.

1. Preparing the database. Create the first table in the MySQL database

Create a new database, for example “mysite”. Personally, I’m used to working with UTF-8 encoding, so I’ll make a reservation right away: make sure that all text files on the site, the database itself, tables and table fields are in the same encoding.
We create a table in the new database. Let's call it “pages”. This table will store static pages of the future site and information about them. The table must contain the following fields:

• page_id - page identifier (SMALLINT, primary key, auto_increment);
• page_alias - page alias for the CNC address line (VARCHAR, 255);
• page_title - title of the page in the browser window (VARCHAR, 255);
• page_meta_d - meta description of the page for the meta description tag (VARCHAR, 255);
• page_meta_k - meta keywords for the meta keywords tag (VARCHAR, 255);
• page_h1 - page title (VARCHAR, 255);
• page_s_desc - a brief description of the material, for example, if the site materials will be in the form of a blog (TEXT);
• page_content - the main text of the page, which will be displayed in the central column of the site (TEXT);
• page_publish - contains “Y” - if the page is published, or “N” - if it is hidden (CHAR, default “Y”).

Immediately after creating the table, we insert into it the values ​​for the main page of the site. I suggest inserting the value “home” into the “page_alias” field for the main page. Meta tags correspond to the theme of the entire site. In the same way, you can create other pages, for example, “About the company” with the alias “about” and your own meta tags, or “Contacts” with the alias “contacts”, etc.

2. Create a site configuration file

In the root folder of the site, which should be empty at this stage, we create a “cfg” folder, and in it, using .htaccess, we close access with the “deny from all” directive. Create a core.php file with the following content:

// MYSQL
class MyDB
{
var $dblogin = "root"; // YOUR LOGIN TO THE DATABASE
var $dbpass = ""; // YOUR PASSWORD TO THE DATABASE
var $db = "mysite"; // NAME OF THE DATABASE FOR THE SITE
var $dbhost="localhost";

Var $link;
var $query;
var $err;
var $result;
var $data;
var $fetch;

Function connect() (
$this->link = mysql_connect($this->dbhost, $this->dblogin, $this->dbpass);
mysql_select_db($this->db);
mysql_query("SET NAMES utf8");
}

Function close() (
mysql_close($this->link);
}

Function run($query) (
$this->query = $query;
$this->result = mysql_query($this->query, $this->link);
$this->err = mysql_error();
}
function row() (
$this->data = mysql_fetch_assoc($this->result);
}
function fetch() (
while ($this->data = mysql_fetch_assoc($this->result)) (
$this->fetch = $this->data;
return $this->fetch;
}
}
function stop() (
unset($this->data);
unset($this->result);
unset($this->fetch);
unset($this->err);
unset($this->query);
}
}

This file currently contains only a simple database connection class, but in the future you can add various useful functions to it that will be accessible from anywhere in the site code. Don't forget to change the login and password for your database.

If you are working in a Windows environment, I can recommend using the . This editor has line numbering and easily converts text from one encoding to another. ATTENTION! If you work in UTF-8 encoding, convert files to UTF-8 without BOM - this will help avoid problems in the future.

3. Create index.php - the main site controller

The configuration file has been created. Now in the root folder of the site we create index.php - this will be the main script of the site, a kind of “main controller”. Contents of the index.php file:

define("INDEX", ""); // SETTING THE MAIN CONTROLLER CONSTANT

Require_once($_SERVER."/cfg/core.php"); // CONNECTING THE KERNEL

// CONNECT TO DB
$db = new MyDB();
$db->connect();

// MAIN CONTROLLER
switch ($_GET) (
case "page":
include($_SERVER."/com/page.php");
break;
default:
include($_SERVER."/com/home.php");
break;
}

Include($_SERVER."/template.php");
$db->close();

The $_GET variable will tell the main controller which site component to load when requested. Currently, our site has only two components: “page” and “main page” (in principle, you can get by with one component for displaying a regular page, but often the appearance of the site’s main page differs from regular menu item pages). The logic of the main controller is as follows: the name of the required component is extracted from the URL string (the value of the $option variable), and depending on its value, the file of the component itself is included (contained in the /com folder). The component file does all the necessary work, extracts data from the database and writes it into variables for transfer to the design template. At the very end, the site design file is connected, into which all the variables and data extracted in the components are transferred. This sounds a lot more complicated than it works.

4. Create a regular page output component

In the root of the site, create a “com” folder - component files will be stored in it. A site component, in my understanding, is a file in which data is processed for different sections of the site. For example, a regular page component retrieves the title, description and text of the material from the database and writes them into the variables $title, $meta_d, $meta_k, $content, etc. This data is then transferred to the design template (you can create your own design template for each component ) and are displayed to the user as an HTML page. For example, a catalog component that could be created in the future would do almost the same thing, but with data about products - and it has its own specifics, other fields in the table, etc. Therefore, for each functional section of the site it is worth creating a separate component. In the MVC (Model-View-Controller) scheme, the component acts as a model.

Create a file “page.php” in the “com” folder. The contents of the file are as follows:

/* PAGE COMPONENT */
$alias = $_GET;
$query = "SELECT * FROM pages WHERE page_alias="".$alias."" AND page_publish="Y" LIMIT 1";
$db->run($query);
$db->row();
// COMPONENT VARIABLES
$id = $db->data;
$alias = $db->data;
$title = $db->data;
$h1 = $db->data;
$meta_d = $db->data;
$meta_k = $db->data;
$s_desc = $db->data;
$component = $db->data;
//IF THE PAGE DOES NOT EXIST
if (!$id) (
header("HTTP/1.1 404 Not Found");
$component = "ERROR 404! This page does not exist";
}
$db->stop();

5. Create the main page output component

The main page in our database is stored under the pseudonym “home”, and so far its structure does not differ from regular site pages - it’s just an article. Nevertheless, we will create a separate component for it - for the future, so to speak.

The contents of the “home.php” component in the “com” folder are almost identical to the contents of the regular page component, with the exception of the database query string and the component name. The query string now looks like this:

$query = "SELECT * FROM wx_pages WHERE page_alias="home" LIMIT 1";

6. Create a design template for the entire site

In the root of the site we create a template.php file. In essence, this is a regular web design layout in HTML+CSS format, only with PHP variables in the right places. Insert between title tags, in the central column of the site there is an insertand so throughout the template we place the necessary variables that are declared in the components.

The root folder should also have "css" and "images" folders for design elements. In the file /css/style.css - you can customize the styles at your discretion.

7. Clean links and .htaccess file

To create clean links, I use mod_rewrite with direct instructions for the rules for each component separately, since I consider parsing the address bar using the controller itself to be unnecessary functionality. The contents of .htaccess at this stage are:

RewriteEngine On
RewriteBase /

RewriteCond %(REQUEST_FILENAME) !-d
RewriteCond %(REQUEST_FILENAME) !-f

# PROHIBITED FILES
RewriteRule .htaccess - [F]
RewriteRule template.php - [F]

# RULES mod_rewrite
RewriteRule page/(+)([\/](0,1))\.htm$ index.php?option=page&alias=$1 [L]

In the future, we will add rules for the search components, catalog, article blog, etc. There is only one point: convert links like “mysite.com/index.php?option=pages&alias=about” into a link like “mysite.com/pages/about.htm” - it looks pretty nice. Try to avoid the $_GET array in development for safety reasons and do not rely on it. It is advisable to store in it only the parameters for the main controller (the $option variable) and for the component (the $alias variable).

Also, in each site folder, “just in case,” create an empty index.html file - this is necessary so that when accessing the directory through the address bar, nothing is displayed.

Tags: php, mysql, site engine, controller, site creation, mvc

2017-01-10

Create a dynamic website using php

Hello dear visitor!

Today, from the main page, using the PHP programming language, we will create a dynamic page, which will subsequently be generated on the server with each user request.

Thus, by changing the structure of the site and filling it with similar changing pages, we will get a dynamic site, which in the future will greatly simplify its technical support and development compared to the static version.

• Why do you need a dynamic website?
• How to convert a static site to a dynamic one
• We form blocks of a dynamic site
• Converting a web page from static to dynamic
• Site source files

Why do you need a dynamic website?

Why a dynamic website is needed was discussed at the very beginning of the step-by-step instructions in the article Installing a local Denwer web server, where the need to install a local web server was explained. Therefore, we can go back and refresh this question.

Also, if you want to further consider the pros and cons of static and dynamic sites, we can advise you to read the pages of the online directory "Puzzleweb.ru" with the section Types of sites, where quite succinctly, but at the same time clearly given explanations for different site options.

screenshot 12

We can only add to this that in order to get a truly full-fledged Internet resource, it is impossible to skip this step and remain with the static site option.

Therefore, we will no longer delve into theoretical discussions of the need to create a dynamic site, but will move on to consider the question of how we will do this.

How to convert a static site to a dynamic one

As you know, the fundamental difference between a dynamic and a static site is that in a static site, ready-made web pages lie on the server and wait their turn to be sent to the user’s browser. Moreover, if the pages have even minor differences, say the difference is only in one phrase or even in one word, then these will still be separate pages.

In the dynamic version, pages are generated on the server with each user request, depending on the requested information.

Simply put, this can be compared to a construction set, where a large number of different shapes can be made from a limited number of elements. Moreover, if you make any change to one of the elements, it will be reflected in the entire structure that includes this element.

Based on this, we will make from our created main page something like a constructor, consisting of certain elements (in our case, these will be files), from which web pages will subsequently be assembled according to user requests.

To explain the actions that we will perform for this, we will use the HTML code of the main page frame obtained at one of the stages of creating a site in the article.

2. "utf-8" >

   "Description" content = "Brief description of page content" >

4. "wrapper" >

   A cap

   Rotator

   Main content

   Sidebar

As you can see from the HTML code, the container , designed to accommodate the visible part of the web page, contains the following main blocks:

• A cap;
• Rotator;
• Main content;
• Sidebar;
• Basement.

However, you need to pay attention to the fact that four of the five blocks are common, and only one “Main content” block will be different for each page.

To obtain elements of a dynamic site, we will separate the content from these blocks into separate files, which we will later include when assembling various web pages based on user requests.

Now, at this stage there will be only five of these files. But in the future, when pages or additional functionality are added to the site, new files will be connected, and so on, as needed.

This construction of the site structure will allow you in the future not to have to deal with the routine work of changing the HTML code of all pages in the event of replacing or adding any fragment common to them. In such cases, it will be enough to make changes only to a specific file, and the entire replacement procedure will be completed. As you can see, there is an advantage.

But in order to do this, we will need the PHP language, with which web pages will be able to access these selected blocks and transfer their contents to themselves.

If anyone has never had to deal with the PHP language, then it is advisable to get to know it better, since PHP is one of the most important tools for website development. This can be done by using various kinds of reference literature, which can be found in large quantities on the Russian Internet.

As an option, the already mentioned reference book “Puzzleweb.ru”, in which one of its parts is devoted to the topic of PHP. For a more in-depth study of PHP, you can also use a specialized reference book tailored specifically for this language, posted on the website "php.ru". Using the link "https://php.ru/manual/control-structures.intro.html" you can get to its "Introduction" page, from where you can easily select any section of the directory you are interested in.

But in order to now make a dynamic website and provide the ability to connect files to HTML pages, it is enough to use only one language instruction (in PHP, any script consists of a sequence of instructions). This can be one of four possible instructions for connecting files:

• include;
• require;
• include_once;
• require_once.

There is no point in describing their features here, since this is explained in detail in reference books, for example, using the link “http://www.puzzleweb.ru/php/26_inc_files.php” you can understand this well.

When creating a site, we will use the “require_once” instruction; I usually use this option, for me it is the most convenient.

Well, now that we have figured out what we will do, let’s move on to practical actions.

We form blocks of a dynamic site

In order to form blocks that will then participate in the assembly of web pages, you first need to create them. This is done in the Notepad++ text editor in the same way as we created the first site file “index.html” in the article Create a web page and host it on a local web server. Only in this case the extension should be specified not “html”, but “php”. In this case, you must definitely pay attention to the encoding in order to avoid the appearance of various kinds of incomprehensible characters on the pages in the future.

We will create the files in a separate, newly created “blocks” folder. For files that are common to all pages, we will assign names taking into account the names of the corresponding blocks. And for the “main” block we will indicate a specific name for each page of the site.

Thus, for the main page we will connect a file called “block_glavnaya” to the “main” block. For the rest: "header", "section", "aside" and "footer".

When creating files, you can also take into account that to simplify this procedure, you can copy them using the "File" menu, specifying the new file name when saving "Save As".

In general, creating files is a standard procedure, so there shouldn’t be any difficulties. In the end it should look like this.

Then we copy the contents of each block and transfer it to the appropriate file. Using "header.php" as an example, let's look at this in more detail.

1. Open the file “index.html” in the Notepad++ editor, select the desired area of ​​the “header” block and alternately click the right and left mouse buttons and copy it to the clipboard.

It should be noted that here we are copying all the contents of the block with the exception of the menu. This is because to reflect the active menu button in the tag attributes