Cameron Laird

PHP does not support processing streams. Regardless, and contrary to the opinion of most PHP developers I have spoken to, PHP applications can multitask. Let's start by finding out what "multitasking" and "threading" mean for PHP programming.

Diversity of parallelism

First, we put aside the cases that lie outside the mainstream of the main theme. PHP has a complex relationship with multitasking or concurrency. On the upper level PHP is constantly involved in multitasking - standard PHP installations on the server (like the Apache module) are used in a multitasking way. That is, multiple client applications (web browsers) can request the same PHP page at the same time, and the web server will return it to everyone more or less at the same time.

One web page does not block transmission of another, although they can interfere slightly with each other when dealing with limited resources such as server memory or network bandwidth. In this way, system requirement concurrency may well be tolerated by PHP-based solutions. In terms of implementation, PHP holds the Web server responsible for concurrency.

Client-side parallelism called Ajax has also caught the attention of developers in the past few years. While the meaning of Ajax has become somewhat obscure, one aspect of this technology is that the browser can perform computations at the same time and remain sensitive to user actions such as menu selections. It really is kind of multitasking. PHP coded Ajax does this, but without any special PHP involvement; Ajax frameworks for other languages ​​work the same way.

A third example of concurrency that only scratches the surface of PHP is PHP / TK. PHP / TK is a PHP extension that provides portable Graphical User Interface (GUI) bindings to the PHP core. PHP / TK allows you to create desktop GUI applications written in PHP. Its event-driven aspects simulate a form of concurrency that is easy to learn and less error prone than working with threads. Again, concurrency is "inherited" from a complementary technology rather than a fundamental PHP functionality.

There have been several experiments to add threading support to PHP itself. As far as I know, none have been successful. However, the event-driven Ajax and PHP / TK frameworks show that events can even better express concurrency for PHP than threads can. PHP V5 proves it.

PHP V5 offers stream_select ()

In standard PHP V4 and earlier, all the work of a PHP application must be done sequentially. If the program needs to retrieve the price of an item from two commercial sites, for example, it asks for the first price, waits for a response, asks for the second price, and waits again.

What if a program could perform multiple tasks at the same time? It would be completed in only a fraction of the time required for consistent work.

First example

The new stream_select function, along with several of its friends, provides this capability. Consider the following example:

0) ($ s = stream_socket_client ("phaseit.net:80", $ errno, $ errstr, $ timeout, STREAM_CLIENT_ASYNC_CONNECT / STREAM_CLIENT_CONNECT); if ($ s) ($ sockets [$ id ++] = $ s; $ http_message = " GET / demonstration / delay? Delay = ". $ Delay." HTTP / 1.0 \ r \ nHost: phaseit.net \ r \ n \ r \ n "; fwrite ($ s, $ http_message);) else (echo" Stream ". $ id." failed to open correctly. ";) $ delay - = 3;) while (count ($ sockets)) ($ read = $ sockets; stream_select ($ read, $ w = null, $ e = null , $ timeout); if (count ($ read)) (/ * stream_select usually shuffles $ read, so we have to figure out which socket it is reading from. * / foreach ($ read as $ r) ($ id = array_search ($ r, $ sockets); $ data = fread ($ r, $ convenient_read_block); / * A socket can be read either because it has data to read OR because it is in an EOF state. * / if (strlen ($ data) = = 0) (echo "Stream". $ Id. "Closes at". Date ("h: i: s"). ". \ N"; fclose ($ r); unset ($ sockets [$ id]); ) else ($ result [$ id]. = $ data;))) else (/ * Ty maut means that * all * threads did not wait for a response. * / echo "Time-out! \ n"; break; ))?>

If you run this program, you will see information similar to the following:

Program starts at 02:38:50. Stream 4 closes at 02:38:53. Stream 3 closes at 02:38:56. Stream 2 closes at 02:38:59. Stream 1 closes at 02:39:02. Stream 0 closes at 02:39:05.

It is important to understand what is happening here. On the high level the first program makes several HTTP requests and receives pages that the Web server sends to it. While a real application would probably request several different Web servers (possibly google.com, yahoo.com, ask.com, etc.), this example passes all requests to our corporate server on Phaseit.net just for the sake of reducing complexity.

The requested Web pages return results after the variable delay shown below. If the program were to execute requests sequentially, it would take about 15 + 12 + 9 + 6 + 3 (45) seconds to complete. As shown in Listing 2, it actually takes 15 seconds to complete. Triple productivity is a great result.

This is made possible by stream_select - new function in PHP V5. Requests are initiated the usual way- opening several stream_socket_clients and writing a GET to each of them, which corresponds to http://phaseit.net/demonstration/delay?delay=$DELAY. When you request this URL in your browser, you should see:

Although the particular implementation in Listing 3 is for UNIX®, almost all of the scripts in this article apply equally well to PHP installations on Windows® (especially post-Windows 98) or UNIX. In particular, you can work with Listing 1 on any operating system. Linux® and Mac OS X are flavors of UNIX, and all of the code here will work on both systems.

Latency server requests are made in the following order:

delay = 15 delay = 12 delay = 9 delay = 6 delay = 3

The goal of stream_select is to get results as quickly as possible. In this case, the order of the delays is the opposite of the order in which the requests were made. After 3 seconds, the first page is ready to read. This part of the program is normal PHP code - in this case, with fread. Just like in another PHP program, reading could be done with fgets.

Processing continues in the same way. The program blocks at stream_select until the data is ready. Crucial is that it starts reading as soon as any connection has data, in any order. This is how the program implements multitasking or parallel processing of the results of multiple queries.

Note that there is no additional CPU load on the host computer. It is not uncommon for network programs to execute fread in this way soon to use 100% of the CPU. This is not the case here, since stream_select has the desired properties and responds immediately as soon as any read is possible, but it also minimally loads the CPU in standby mode between reads.

What you need to know about stream_select ()

This event-based programming is not trivial. Although Listing 1 has been reduced to the essentials, any coding based on callbacks or coordination (which is necessary in multitasking applications) will be less familiar than a simple procedural sequence. In this case, the biggest difficulty lies in the $ read array. Please note that this is a link; stream_select returns important information by modifying the contents of $ read. Just as pointers have a reputation for being a constant source of bugs in C, references seem to be the most difficult part of PHP for programmers.

This query technique can be used from any number of external Web sites, ensuring that the program receives each result as quickly as possible without waiting for other requests. In fact, this technique works correctly with any TCP / IP connection, not just the Web (port 80), that is, in principle, you can control the extraction of LDAP data, SMTP transmission, SOAP requests, etc.

But that's not all. PHP V5 handles various connections as "streams" rather than simple sockets. The PHP Client URL Library (CURL) supports HTTPS certificates, outbound FTP uploads, cookies, and more (CURL allows PHP applications to use different protocols to connect to servers). Since CURL provides a stream interface, the connection is transparent from the program's point of view. The next section explains how stream_select multiplexes even local computation.

There are a few caveats with stream_select. This function is not documented, so it is not covered even in new PHP books. Several of the code examples available on the Web just don't work or are not understandable. The second and third arguments to stream_select, which control the write and exception channels corresponding to the read channels in Listing 1, should almost always be null. With a few exceptions, the selection of these channels is a mistake. If you are not experienced enough, use only well-described options.

In addition, stream_select appears to be buggy due to at least, in PHP V5.1.2. Most significantly, the return value of a function cannot be trusted. Although I haven't debugged the implementation yet, my experience has shown that it is safe to test count ($ read) as in Listing 1, but that does not apply to the return value of stream_select itself, despite the official documentation.

PHP Local Concurrency

The example and most of the discussion above focused on how to manage multiple remote resources at the same time and get results as they appear, rather than waiting for each one to be processed in the order of the original request. This is undoubtedly an important application of PHP concurrency. Sometimes real applications can be accelerated tenfold or more.

What if the slowdown occurs closer? Is there a way to speed up getting results in PHP when processing locally? There are several. They are perhaps even less well known than the socket-oriented approach in Listing 1. There are several reasons for this, including:

• For the most part, PHP pages are fast enough. Better performance could be an advantage, but not enough to justify the investment in new code.
• Using PHP in Web pages can make partial code speedups irrelevant. Redistributing computation to get intermediate results faster is irrelevant when the only criterion is the speed of delivery of the Web page as a whole.
• Few local bottlenecks are controlled by PHP. Users may complain that retrieving information about account takes 8 seconds, but it may be limiting the processing of the database or some other resources external to PHP. Even if you reduce the PHP processing time to zero, it will still take more than 7 seconds to just search.
• Even fewer constraints lend themselves to parallel processing. Let's pretend that specific page calculates the recommended price for the listed common stock, and the calculations are complex and take many seconds. The computation can be sequential in nature. There is no obvious way to distribute it for "collaboration".
• Few PHP programmers understand PHP's potential for parallel processing. When talking about the possibility of parallelization, most of the programmers I met simply quoted the phrase "PHP does not work with threads" and returned to their established computation model.

Sometimes you can do better. Suppose a PHP page needs to compute two stock prices, perhaps compare them, and the host computer being used is multiprocessor. In this case, we can almost double the performance by assigning two separate, long-running computations to different processors.

In the world of PHP computing, such examples are rare. However, since I have not found an exact description anywhere else, I want to give an example of such acceleration here.

array ("pipe", "r"), 1 => array ("pipe", "w"), 2 => array ("file", $ error_log, "w")); $ cmd = "sleep". $ delay. "; echo" Finished with delay of ". $ delay." "."; $ handles [$ id] = proc_open ($ cmd, $ descriptorspec, $ pipes); $ streams [$ id] = $ pipes; $ all_pipes [$ id] = $ pipes; $ delay - = 2; ) while (count ($ streams)) ($ read = $ streams; stream_select ($ read, $ w = null, $ e = null, $ timeout); foreach ($ read as $ r) ($ id = array_search ($ r, $ streams); echo stream_get_contents ($ all_pipes [$ id]); if (feof ($ r)) (fclose ($ all_pipes [$ id]); fclose ($ all_pipes [$ id]); $ return_value = proc_close ($ handles [$ id]); unset ($ streams [$ id]);)))?>

This program will display the following information:

Program starts at 10:28:41. Finished with delay of 1. Finished with delay of 3.

The idea is that PHP started two independent subprocesses, received data from the first, and then from the second, although the latter started earlier. If the host computer is multiprocessor and operating system correctly configured, it takes care of assigning different subprograms to different processors. This is one way to take advantage of PHP's multiprocessing machines.

Summary

PHP supports multitasking. PHP does not support stream processing in the way other programming languages ​​such as Java or C ++ do, but the examples above have shown that PHP has a higher potential for speeding up than most people realize.

So, friends, if you have reached this lesson, then you managed to either install local server, or buy a hosting that can work with PHP. Congratulations - this is a big step!

I will say briefly about PHP - this programming language is used all over the world and on it you can create sites of all levels of complexity, from business card sites to large portals. I think it is no longer a secret for many that the largest social networks facebook.com(from scratch to php) and vk.com(php engine) were written in PHP. So we draw conclusions and start work!)

How the code works

PHP Code processed on the server side... That is, there is no ready page. For example, the code instructs to collect data on how many users are registered on this moment on the site. Site visitor clicks on a link All users... He wants to get dynamic data, that is, those that are constantly changing. After the counting on the server is finished, the data will come from the server in the form of the generated HTML-code of the page with the number of users. As a result, after clicking a request on the link, the user receives the page. If you view the code of the resulting page, you can see only HTML, and the PHP code will not be available for viewing. Roughly speaking, PHP is an instruction to the server on how and from which blocks to make a page.

What does PHP code look like and where to insert it?

PHP code can be embedded directly into HTML. PHP code is embedded in HTML pages using angle brackets and a question mark , however, you can limit yourself to parentheses with question marks ... You will only need to change the file extension, for example, from .html on the .php

PHP Code(file index.php)

echo "Hello world!";
?>

Demonstration Download sources
The result of the code will be the output of plain text Hello World!... Ask why write php code to display plain text? Echo statement, which we will talk about a little later, is needed not just for displaying text. More often, echo is used to display the result of the work of some function that calculated or took data from the database (What is a Database?). That is, for dynamic data display.

The echo statement in PHP

As you already understood, the operator echo needed to output data. We take the content (in our case, only the text so far) in quotes, and at the end we put a semicolon ; this marks the end of the operator's work.

In programming, when creating the first page, it is customary to use the phrase Hello, World!- that is Hello World! This is what we use. We will not use html in the example, as it is not necessary.

PHP Code

echo "Hello World!";
?>
The program will output Hello World!.
In the very first example, we inserted a small php code into the html. Now, on the contrary, let's inject html elements into the php code.

PHP Code

echo " ";
echo " ";
echo " ";
echo "";
echo " ";
echo "

Hello World!

";
echo "";
?>
As a result, we get an empty page with a title Hello World!

PHP print statement

Unlike the echo statement, print outputs data including spaces and hyphenation. Has some limitations - you can use only one argument, echo several. Lasts longer than echo. In what follows, we will use this operator when writing functions.

print "Hello World!
The second line of text "; // the result will be displayed in two lines
?>
The text will be displayed as it is written.

Output statement - PHP heredoc syntax

As you have already noticed, displaying a page by constantly using the echo operator is ugly and unreadable. Therefore, to output large parts html code and there is another output statement using the heredoc syntax. It also displays the data in the same form in which it was (spaces and hyphens).

echo<<

Example

An example of outputting a large amount of text using html

The second paragraph of the same voluminous text.

HERE;
?>

Lesson memo

PHP code can:

1. not contain any html element. The page and text will still be displayed. html is needed for nice content markup.

2. be both included in the html-code and contain it inside their own output statements (echo, print, etc.). The main thing is not to forget the design

3. pages with php-code must have the appropriate extension: .php .phtml

From the next lessons, we will cover the basics of creating sites in php, in which you will see all the advantages of using this language!

Thank you for your attention!

Have a nice day, everyone. This is the first article in the PHP series for beginners. This will be an unusual series of articles, there will not be echo "Hello World", there will be hardcore from the life of PHP programmers with a little bit of "homework" to consolidate the material.

I'll start with sessions - this is one of the most important components that you will have to work with. Not understanding the principles of his work - twist business. So in order to avoid problems, I will try to tell you about all the possible nuances.

But first, in order to understand why we need a session, let's turn to the origins - to the HTTP protocol.

HTTP Protocol

The HTTP protocol is the HyperText Transfer Protocol - ie. in fact, it is a text protocol, and it will not be difficult to understand it.

Initially, it was assumed that only HTML will be transmitted via this protocol, from the place and the name, but now what they do not send （_ ㅅ _） = ^. ^ =

In order not to beat around the bush, let me give you an example of communication over the HTTP protocol, here is the request how your browser sends it when you request the page http://example.com:

GET / HTTP / 1.1 Host: example.com Accept: text / html ... empty string ...

And here's an example of an answer:

HTTP / 1.1 200 OK Content-Length: 1983 Content-Type: text / html; charset = utf-8 ... ...

These are very simplified examples, but here you can see what the HTTP request and response consist of:

1. start line- for a request contains the method and path of the requested page, for a response - the protocol version and response code
2. headlines- have the format key-value separated by a colon, each new header is written on a new line
3. message body- HTML directly or data is separated from headers by two line breaks, may be absent, as in the given request

So, it seems, they figured out the protocol - it is simple, it has been leading its history since 1992, so you cannot call it ideal, but what it is - sent a request - get an answer, and that's it, the server and the client are no longer connected in any way. But such a scenario is by no means the only possible one, we can have authorization, the server must somehow understand that this request came from a specific user, i.e. client and server must communicate within a certain session. And yes, they came up with the following mechanism for this:

1. when authorizing a user, the server generates and remembers a unique key - the session identifier, and informs the browser
2. the browser stores this key, and with each subsequent request, it sends it

To implement this mechanism, (cookies, cookies) were created - simple text files on your computer, one file for each domain (although some browsers are more advanced and use a SQLite database for storing), while the browser imposes a limit on the number of records and the size of the stored data (for most browsers it is 4096 bytes, see RFC 2109 from 1997)

Those. if you steal a cookie from your browser, will it be possible to go to your facebook page on your behalf? Do not be alarmed, this cannot be done, at least with facebook, and then I will teach you how you can protect yourself from this type of attack on your users.

Let's now see how our request-response will change, whether there is an authorization:

POST / login / HTTP / 1.1 Host: example.com Accept: text / html login = Username & password = Userpass

Our method has changed to POST, and in the body of the request, the username and password are transmitted (if you use GET method, then the query string will contain the username and password, and may be saved on some intermediate proxy servers, which is very bad).

HTTP / 1.1 200 OK Content-Type: text / html; charset = utf-8 Set-Cookie: KEY = VerySecretUniqueKey ... ...

The server response will contain the Set-Cookie: KEY = VerySecretUniqueKey header, which will force the browser to save this data to cookies, and the next time the server is accessed, they will be sent and recognized by the server:

GET / HTTP / 1.1 Host: example.com Accept: text / html Cookie: KEY = VerySecretUniqueKey ... empty string ...

As you can see, the headers sent by the browser (Request Headers) and the server (Response Headers) are different, although there are general headers for both requests and responses (General Headers).

The server recognized our user by the cookies sent, and will further provide him with access to personal information... So, well, sort of sorted out with sessions and HTTP, now you can return to PHP and its features.

PHP and session

I hope you already have PHP installed on your computer, since further I will give examples, and they will need to be run

PHP was created to match the HTTP protocol - i.e. its main task is to respond to an HTTP request and "die" freeing memory and resources. Therefore, the session mechanism works in PHP not in automatic mode, but manually, and you need to know what to call, and in what order.

First of all, you need to "start" the session - for this we will use the session_start () function, create a file session.start.php with the following content:

Session_start ();

And now - we update the page, and we see that the browser is sending this cookie to the server, you can try to refresh the page a couple of times, the result will be identical:

In total, we have - theory coincided with practice, and that's just fine.

The next step is to save an arbitrary value to the session, for this, PHP uses the $ _SESSION super-global variable, we will save current time- for this we call the date () function:

Session_start (); $ _SESSION ["time"] = date ("H: i: s"); echo $ _SESSION ["time"];

We update the page and see the server time, update it again - and the time has been updated. Let's now do so that set time did not change on every page refresh:

Session_start (); if (! isset ($ _ SESSION ["time"])) ($ _SESSION ["time"] = date ("H: i: s");) echo $ _SESSION ["time"];

We update - the time does not change, what is needed. But at the same time, we remember that PHP is dying, which means it stores this session somewhere, and we will find this place ...

All the secret becomes clear

By default, PHP stores the session in files - the session.save_handler directive is responsible for this. Look for the path where files are saved in the session.save_path directive, or use the session_save_path () function to get the required path.

In your configuration, the path to the files may not be specified, then the session files will be stored in temporary files on your system - call the sys_get_temp_dir () function and find out where this hidden place is.

So, we go along this path and find your session file (I have this file sess_dap83arr6r3b56e0q7t5i0qf91), open it in text editor:

Time | s: 8: "16:19:51";

As you can see, this is our time, this is the tricky format in which our session is stored, but we can make edits, change the time, or we can simply enter any line, why not:

Time | s: 13: "\ m / (@ [email protected]) \ m / ";

To convert this string into an array, you need to use the session_decode () function, for the reverse conversion - session_encode () - this is called serialization, but only in PHP for sessions - it is special, although you can use standard PHP serialization - write it in the configuration directive session .serialize_handler php_serialize value and you will be happy, and $ _SESSION can be used without restrictions - now you can use numbers and Special symbols| and! in the name (for all 10+ years of work, I never had to :)

Exercise
Write your own function, similar in functionality to session_decode (), here is a test set of data for the session (you do not need knowledge of regular expressions to solve), take the text for conversion from the file of your current session:

$ _SESSION ["integer var"] = 123; $ _SESSION ["float var"] = 1.23; $ _SESSION ["octal var"] = 0x123; $ _SESSION ["string var"] = "Hello world"; $ _SESSION ["array var"] = ["one", "two",]; $ object = new stdClass (); $ object-> foo = "bar"; $ object-> arr = ["hello", "world"]; $ _SESSION ["object var"] = $ object; $ _SESSION ["integer again"] = 42;

So, what have we not tried yet? That's right - to steal cookies, let's launch another browser and add the same cookies to it. I wrote you a simple javascript for this, copy it into the browser console and run it, just do not forget to change the session identifier to your own:

Javascript: (function () (document.cookie = "PHPSESSID = dap83arr6r3b56e0q7t5i0qf91; path = /;"; window.location.reload ();)) ()

Now you have both browsers looking at the same session. I mentioned above that I will talk about protection methods, consider the simplest way - we will bind the session to the browser, more precisely, to how the browser appears to the server - we will remember the User-Agent and check it every time:

Session_start (); if (! isset ($ _ SESSION ["time"])) ($ _SESSION ["ua"] = $ _SERVER ["HTTP_USER_AGENT"]; $ _SESSION ["time"] = date ("H: i: s"); ) if ($ _SESSION ["ua"]! = $ _SERVER ["HTTP_USER_AGENT"]) (die ("Wrong browser");) echo $ _SESSION ["time"];

This is harder to fake, but it's still possible, add here saving and checking $ _SERVER ["REMOTE_ADDR"] and $ _SERVER ["HTTP_X_FORWARDED_FOR"], and it will more or less look like protection from intruders encroaching on our "cookies".

Keyword in the previous paragraph it seems, in real projects, cookies have long been running over the HTTPS protocol, so no one can steal them without physical access to your computer or smartphone

Exercise
Add a check for the user's IP to the code, if the check fails, delete the compromised session.

Step by step

And now I will explain step by step the algorithm of how a session works in PHP, using the example of the following code (default settings):

Session_start (); $ _SESSION ["id"] = 42;

1. after calling session_start () PHP looks for the session identifier in the cookie by the name specified in session.name - this is PHPSESSID
2. if there is no identifier, then it is created (see session_id ()), and creates empty file session along the path session.save_path with the name sess_ (session_id ()), headers will be added to the server response to set the cookie (session_name ()) = (session_id ())
3. if the identifier is present, then we are looking for the session file in the session.save_path folder:
   • not found - create an empty file named sess _ ($ _ COOKIE) (the identifier can contain only characters from ranges a-z, A-Z, 0-9, comma and minus sign)
   • find, read the file and unpack the data (see session_decode ()) into the super-global variable $ _SESSION
4. when the script has finished its work, then all data from $ _SESSION is packed using session_encode () into a file along the path session.save_path named sess_ (session_id ())

Exercise
Set in your browser an arbitrary value for the cookie named PHPSESSID, let it be 1234567890, refresh the page, check that you have created new file sess_1234567890

Is there life without cookies?

PHP can work with a session even if cookies are disabled in the browser, but then all URLs on the site will contain a parameter with the identifier of your session, and yes - this still needs to be configured, but do you need it? I didn't have to use it, but if I really want to, I'll just tell you where to dig:

And if you need to store the session in the database?

To store the session in the database, you need to change the session storage and tell PHP how to use it; for this purpose, the SessionHandlerInterface interface and the session_set_save_handler function have been created.

Separately, I note that you do not need to write your own session handlers for redis and memcache - when you install these extensions, the corresponding handlers go along with them, so RTFM is our everything. Well, yes, the handler must be specified before calling session_start ();)

Exercise
Implement SessionHandlerInterface to store MySQL session, test if it works.
This is an asterisk assignment for those who are already familiar with databases.

When does a session die?

An interesting question, you can ask it to seasoned developers - when does PHP delete expired session files? The answer is in the official manual, but not explicitly - so remember:

The garbage collection can be launched when the session_start () function is called, the probability of launching depends on two directives session.gc_probability and session.gc_divisor, the first acts as a dividend, the second as a divisor, and by default these values ​​are 1 and 100, i.e. e. the probability that the collector will be launched and the session files will be deleted is approximately 1%.

Exercise
Change the value of the session.gc_divisor directive so that the garbage collector starts every time, check that this is what happens.

The most trivial mistake

An error with more than half a million results in Google search results:

Cannot send session cookie - headers already sent by
Cannot send session cache limiter - headers already sent

To get one, create a file session.error.php with the following content:

Echo str_pad ("", ini_get ("output_buffering")); session_start ();

In the second line, there is a strange "magic" - this is a trick with an output buffer, I will talk about it in one of the next articles, for now, consider it only as a line of 4096 characters long, in this case, these are all spaces

Run, after deleting the cookie, and you will get the above errors, although the error text is different, but the essence is the same - the train has left - the server has already sent the page content to the browser, and it is too late to send headers, this will not work, and the cherished session identifier has not appeared in the cookies. If you stumbled upon this error, look for the place where the text is displayed
ahead of time, it could be a space before charactersin one of the included files, and okay, if it's a space, there may be some unprintable character like a BOM, so be careful, and this infection will not touch you (well,… homeric laughter).

Exercise
To test this knowledge, I want you to implement your own session mechanism and make the above code work:

Require_once "include / sess.php"; sess_start (); if (isset ($ _ SESS ["id"])) (echo $ _SESS ["id"];) else ($ _SESS ["id"] = 42;)

To accomplish this, you need the register_shutdown_function () function.

Finally

In this article, you are given six tasks, and they not only concern working with sessions, but also introduce you to MySQL and the functions of working with strings. To master this material - you don't need a separate article, the manual on the links given will be enough - no one will read it for you. Go for it!

P.S. If you learned something new from the article - thank the author - share the article in social networks;)

If you are new to PHP, there are some definitions you need to know.
First of all, PHP is a programming language and it is used to write commands (scripts) addressed to the server. To put it even simpler, using PHP we can communicate with the server.
PHP commands are easy to embed in HTML pages. This property is an important advantage. PHP language before languages ​​like Perl and C.

PHP syntax

PHP script code starts after opening tag... The text between these two tags is read by a program on the server, and the result is output to an HTML document. Let's take an example:

include ("sidebar.htm");
?>

If we need to insert something into the html code of the page, we must use the include command. Next, we indicate the file address, and the line ends, as in CSS;

Insert HTML code into site pages

As a rule, sidebars ( sidebar) and basement ( footer) remain unchanged on all pages of the site. Hence the codes

and

.....

can be placed in separate htm pages "sidebar.htm" and "footer.htm" and inserted into site pages using the include command. If, at the same time, the main content is transferred to a separate file -

.....

, then the code of our page will look like:

include ("sidebar.htm");
include ("content.htm");
include ("footer.htm");
?>

sidebar.htm content

Likewise with the content.htm and footer.htm files.

With this generation of pages, you just need to make changes to one file "sidebar.htm" to change all the pages of the site. This is very convenient if your site consists of hundreds or thousands of pages.

PHP on your computer

For you to be able to work with PHP scripts and view the results of execution in a browser, you need to install a working web server with PHP on your local computer.
Denver is best suited for such tasks. (the official site provides everything you need is free) The installation kit includes - Apache, php and MySQL. In other words, a fully functional server for hosting sites will be located on your computer.

In order for the PHP code to work in HTML pages, you need to open the file .htaccess in any text editor and write the following:

AddHandler application / x-httpd-php .html

This entry allows PHP execution scripts in HTML pages.

Or change the file extension. html on the. php

PHP features

PHP is capable of more than just rendering HTML. PHP's capabilities include generating images, PDFs and even Flash movies (using libswf and Ming) generated on the fly. PHP is also capable of serving any text data such as XHTML and other XML files. PHP is able to automatically generate such files and save them to file system your server instead of serving it to the client, thus organizing a server-side dynamic content cache.

One of the significant advantages of PHP is its support for a wide range of databases. In short, PHP has a lot to offer you! More details about the benefits of PHP can be found at www.php.su.

February 1, 2015

When starting to write programs for the web, many novice programmers encounter this error. They view the browser-server system as a normal application. Interactive. I pressed the button - the system reacted. I drew it with the mouse - it reacted. All information that is available to the client is also available to the program, the program is in memory all the time.
So, in web programming this is not true!.
At the moment when the user sees the page in front of him and begins to perform some actions with it, PHP has already exited! And the user interacts not with the PHP script, but with his HTML page, which he received in the browser. In most cases, the result of a PHP script is plain text. HTML page text. Which is given to the browser and displayed as normal HTML. You can see for yourself by writing in the script
"Hey, Vasya!" ; ?> ;
And then by viewing the source text of the resulting page in a browser. There are no PHP tags there! Only
Hey, Vasya!
Because PHP is executed on the server!

The server and the browser communicate by sending requests to each other using a special protocol - HTTP. Only the browser can initiate the connection. It sends a request to the server to show such and such a file. The server sends the file to the client.
This is the only way it happens. The client requested - the server gave it away. And immediately forgot about the client. From here it becomes clear the answer to the question of whether it is possible to know exactly how many users are on the site now. It is forbidden. because there is not a single one "on the site". They connect, request a page, and disconnect. Do not have a permanent connection to the server, as, for example, Kwaku players. You can only find out approximately by recording the time of each connection and selecting records for a certain period of time.

An example of communication between the browser and the server:
The user clicks on the link, the browser sends a request to the server and waits for a response:
Browser -> PHP
PHP executes the script, sends the result to the browser and exits:
PHP -> browser
The browser displays the page, "scanning" it for links that need to be requested from the server (tags ,