 SELFHTML actuel Articles spécialisés Programmation |
|
 |
Christian Seiler |
|
|
 | |
| Adresse électronique: |  christian.seiler@selfhtml.org |
| Homepage-URL: |  http://www.christian-seiler.de/ |
Il s'agit ici d'un article traduit de l'allemand par la rédaction de SELFHTML actuel. Veuillez poser vos questions relatives à cet article uniquement à son auteur, prenant compte que celui-ci ne maîtrise peut-être pas la langue française!
 |
On peut lire aujourd'hui sur de nombreuses pages le texte suivant:
Actuellement 42 visiteurs sont connectés. |
Ce texte indique le nombre de visiteurs qui naviguent en ce moment sur la page Web. Cet article a pour but de montrer comment réaliser un tel affichage et quels problèmes peuvent alors survenir.
Il faut bien entendu pour ce genre d'affichage qu'une technique côté serveur soit disponible. Dans cet article du code en exemple est mentionné en Perl et en PHP. Ce code peut être naturellement aussi bien être transposé sur d'autres techniques côté serveur comme par exemple d'autres langages de programmation tels que Python ou Ruby ainsi que pour des environnements tels que Microsofts Active Server Pages.
Au cas où vous ne vous intéresseriez que superficiellement au sujet et que vous voudriez ignorer les problèmes en vous limitant à la réalisation d'un tel affichage, il vous suffit de ne lire que la Première possibilité et d'effectuer le téléchargement.
| |
La réalisation d'un affichage du nombre de visiteurs qui se trouvent actuellement sur la page est moins évidente qu'il n'y paraît au premier abord. Les pages Web sont transmises par le protocole HTTP. La transmission par HTTP se d´roule de la façon suivante: Dans un premier temps le navigateur établit la connexion au serveur. Ensuite le navigateur transmet au serveur le nom de la ressource qu'il veut connaître. Le serveur lui livre alors la ressource (ou un message d'erreur). Suite à quoi la connection au serveur est à nouveau interrompue. Ce processus est mis en lumière par le diagramme suivant:
Ètant donné que la liaison est interrompue, le serveur Web ne peut plus connaître si l'utilisateur se trouve toujours sur la page ou non. Quand l'utilisateur ferme la fenêtre de son navigateur, entre quelque chose dans la ligne d'adresse ou bien quitte la page en activant un lien, il est impossible pour le serveur de la page d'origine de capter cet événement.
Il y a une possibilité en HTTP de maintenir la liaison au serveur. Pour ce faire, l'établissement de la connexion qui nécessite du temps ne doit pas être exécuté plusieurs fois quand par exemple des images de la page Web doivent être chargées ensuite. Cette propriété s'appelle Connection: keep-alive.
Quoiqu'il en soit, dans un cas de figure classique cette connexion est interrompue aussitôt, dès que les éléments d'une page Web ont été chargés.
De plus, toutes les demandes transmises au serveur par cette connexion sont indépendantes l'une de l'autre. HTTP n'offre aucune possibilité d'affecter ces demandes à un utilisateur. Connection: keep-alive est donc pas une solution à ce problème.
| |
Une possibilité de contourner ce problème serait une limite de temps. Ce qu'on appelle une adresse IP est affectée lors de la connexion à chaque ordinateur avec lequel un visiteur se connecte à Internet. Cette adresse IP est également connue du serveur. Quand une requête arrive alors d'une adresse IP, cette adresse IP ainsi que la date et l'heure sont enregistrées dans une liste. Si l'adresse IP existe déjà dans la liste, l'enregistrement existant est écrasé. Ce qui revient à utiliser l'adresse IP comme critère d'identification du visiteur.
Avant que les requêtes n'arrivent, la liste est vide. Cependant dès que la première requête arrive d'une adresse IP, la liste prend cet aspect:
|
Dès qu'une autre requête arrive d'une autre adresse IP, la liste prend cet aspect:
|
Une nouvelle requête vient alors de la première adresse IP. La liste donnerait alors
|
Si le nombre de visiteurs connectés doit être affiché, tous les enregistrements de la liste plus anciens qu'une période déterminée -par exemple quinze minutes- sont alors filtrés. Le nombre des enregistrements restants donne alors une approximation du nombre de visiteurs connectés.
C'est la fonction en PHP qui sera mentionnée ici, la fonction en Perl pouvant être consultée dans le téléchargement disponible dans cet article. En premier lieu une fonction est nécessaire pour ajouter à la liste le visiteur actuel:
compte_visiteurs:// compte le visiteur actuel
function compte_visiteurs ($ident) {
// Cherche la liste
$liste = cherche_liste_visiteurs ();
// ajoute le critère d'identification actuel avec la date et l'heure
$liste[$ident] = time ();
// écrit la liste
ecrit_liste_visiteurs ($liste);
}
|
Cette fonction cherche d'abord la liste complète de tous les visiteurs. Pour ce faire elle appelle la fonction cherche_liste_visiteurs. Cette liste représente un tableau associatif. Comme clé est utilisé le critère d'identification de chacun des utilisateurs et comme valeur la date et l'heure de l'accès sous forme de date au format UNIX (ici c'est l'adresse IP qui servira de critère d'identification). Cette structure est particulièrement commode étant donné qu'il ne faut plus se soucier si un enregistrement existe ou non. Le critère d'identification actuel qui est transmis grâce au paramètre ident ainsi que la date et l'heure actuelle sont ajoutés à la liste. Enfin la liste est sauvegardée avec la fonction ecrit_liste_visiteurs.
cherche_liste_visiteurs:// cherche la liste dans un fichier
function cherche_liste_visiteurs () {
// importe la configuration
global $configuration_visiteurs_en_ligne;
// lit le fichier
$lignes = file ($configuration_visiteurs_en_ligne['fichier']);
// erreur?
if (!is_array ($lignes)) {
return array ();
}
$resultat = array ();
// parcourt les lignes
foreach ($lignes as $ligne) {
// sépare le critère d'identification de la date et l'heure
list ($ident, $heure) = explode ('|', $ligne, 2);
// sauter quand le critère d'identification est vide
if (empty ($ident)) {
continue;
}
// si l'heure est trop ancienne
if ($heure < time() - $configuration_visiteurs_en_ligne['limite_temps']) {
// sauter
continue;
}
// ajoute au résultat
$resultat[$ident] = (int)$heure;
}
return $resultat;
}
|
Cette fonction importe dans un premier temps la configuration. Y sont mentionnés le nom du fichier et une limite de temps. Vous trouverez ci-dessous plus de détails concernant la configuration. Le fichier est lu grâce à la fonction file. Celle-ci retourne toutes les lignes sous forme de tableau. Au cas où une erreur est rencontrée, à savoir si la fontion ne retourne aucun tableau, c'est une liste vide qui est retournée.
C'est maintenant que la liste de résultat est initialisée. Après quoi chaque ligne est examinée dans une boucle foreach. Le fichier avec la liste pourrait se présenter sous la forme typique suivante:
127.0.0.1|1054378620 192.168.100.2|1054381432 |
Dans ce fichier l'adresse IP est séparée de la date et de l'heure par le signe |. C'est également d'après ce signe que la séparation s'effectue à l'appel de explode dans la fonction cherche_liste_visiteurs. Au cas où l'adresse IP est vide et donc que la ligne est vide, l'enregistrement est ignoré. Au cas où la date et l'heure sont trop anciennes, il en va de même. Sinon l'adresse IP et la date et l'heure sont affectées à la variable $resultat. La transformation explicite en nombre est necessaire étant donné que la fonction file lit également le signe de passage à la ligne. Ce qui ne serait pas très joli lors de la sauvegarde car dans le cas contraire de nombreuses lignes vides seraient générées. Enfin la liste des résultats est retournée.
ecrit_liste_visiteurs:// sauvegarde la liste
function ecrit_liste_visiteurs ($liste) {
// importe la configuration
global $configuration_visiteurs_en_ligne;
$resultat = '';
// parcourt la liste
foreach ($liste as $ident => $heure) {
$resultat .= "$ident|$heure\n";
}
// ouvre fichier
$fichier = fopen ($configuration_visiteurs_en_ligne['fichier'], 'w');
// erreur?
if (!is_resource ($fichier)) {
return false;
}
// écrit le résultat
$cnt = fwrite ($fichier, $resultat);
// erreur?
if ($cnt === false) {
fclose ($fichier);
return false;
}
// ferme le fichier
fclose ($fichier);
// c'est terminé
return true;
}
|
Quant à cette fonction, elle sauvegarde à nouveau la liste des visiteurs. Tout d'abord la configuration est à nouveau importée. Puis la liste est parcourue et chaque enregistrement est ajouté à une chaîne de caractères $resultat. Le contenu de la chaîne de caractères se présente finalement de telle façon qu'il peut être lu par la fonction cherche_liste_visiteurs. Le fichier est maintenant ouvert en écriture avec fopen. En cas d'erreur, la fonction est interrompue. La chaîne de caractères du résultat est maintenant écrite dans le fichier grâce à fwrite. Le fichier est alors fermé et la fonction annonce si elle a été exécutée avec succès.
comptage_visiteurs:// retourne le nombre de visiteurs
function comptage_visiteurs () {
return count (cherche_liste_visiteurs ());
}
|
Cette fonction retourne le nombre de visiteurs qui se trouvent avtuellement sur la page. Elle cherche simplement la liste des visiteurs et compte le nombre d'enregistrements.
// Configuration $configuration_visiteurs_en_ligne = array ( // fichier dans lequel il faut sauvegarder 'fichier' => 'visiteurs_en_ligne.txt', // délai de peremption pour un enregistrement 'limite_temps' => 300 // 5 minutes ); |
C'est avec ceci que les fonctions sont configurées. Cette variable globale est importée par les différentes fonctions et leur indique comment se comporter. La mention fichier détermine le nom du fichier dans lequel la liste doit être sauvegardée. Les mentions de chemin relatives ou absolues sont possibles. La mention limite_temps indique la durée pendant laquelle une adresse IP doit rester mémorisée. Cette mention est exprimée en secondes.
<?php
// intégration du fichier de comptage des visiteurs connectés
require 'visiteurs_en_ligne.php';
// compter ce visiteur
compte_visiteurs ($_SERVER['REMOTE_ADDR']);
?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Titre de la page</title>
</head>
<body>
<?php $nombre_visiteurs = comptage_visiteurs(); ?>
<p>Actuellement
<?php if ($nombre_visiteurs == 1) { ?>
est connecté
<?php } else { ?>
sont connectés
<?php } ?>
<?php echo $nombre_visiteurs ?> visiteurs sur cette page.</p>
</body>
</html>
|
Avant toute sortie du script, le visiteur doit être compté. Cela se fait en appelant la fonction compte_visiteurs avec l'adresse IP actuelle. L'adresse IP du client figure dans $_SERVER['REMOTE_ADDR']. Cela doit se faire dans chaque document HTML de la page Web, même si la page elle même ne présente pas l'affichage du décompte. Pour chaque page présentant ce décompte, il faut en plus chercher le nombre des visiteurs avec comptage_visiteurs pour ensuite le sortir. La construction avec if dans l'exemple n'a été ajoutée que pour respecter la grammaire française, les parties importantes sont mises en valeur.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
use UserOnline;
visiteurs_en_ligne::comptage_visiteurs ($ENV{'REMOTE_ADDR'});
print "Content-Type: text/html\n\n";
|
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); use UserOnline; my $nombre = visiteurs_en_ligne::comptage_visiteurs (); print "Content-Type: text/html\n\n"; print $nombre; |
Dans le téléchargement se trouve un module Perl UserOnline.pm.
Ce module Perl propose les mêmes fonctions qui sont également proposées en PHP ci-dessus. De plus le module Perl intègre ces fonctions dans un paquet. Le premier script se contente de compter les visiteurs, le deuxième script sort le nombre de visiteurs. La configuration du module Perl s'effectue dans le fichier module proprement-dit, exactement comme la configuration des fonctions PHP.
<!--#include virtual="/cgi-bin/countuser.pl"--> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Titre de la page</title> </head> <body> <p>Il y a en ce moment <!--#include virtual="/cgi-bin/useronline.pl"--> visiteurs connectés.</p> </body> </html> |
Les deux scripts Perl ci-dessus sont maintenant incorporés grâce aux SSI. Le fichier countuser.pl doit être incorporé dans toutes les pages, le fichier useronline.pl uniquement dans les pages sur lesquelles un affichage du nombre de visiteurs est nécessaire. Vous trouverez d'autres remarques sur les SSI dans SELFHTML à l'adresse 
Server Side Includes en HTML.
Au cas où la page est constituée partiellement ou en totalité de scripts Perl, il est possible d'incorporer directement le module Perl plutôt que d'utiliser les SSI.
Pour ne pas dépasser le cadre de cet article, les mécanismes de verrouillage de fichier n'ont pas eté incorporés ici. Ils le sont cependant dans le téléchargement. Il est recommandé d'employer les fichiers du téléchargement plutôt que les fonctions décrites ici.
Pour les pages recevant un grand nombre de visiteurs, la méthode consistant à sauvegarder les informations dans des fichiers n'est pas appropriée. Trop de ressources sont tout simplement nécessaires pour lire complètement le fichier, traiter les données et sauvegarder à nouveau le fichier. Pour les pages au trafic de visiteurs important, il est conseillé d'utiliser la solution de la base de données protégée. Une telle solution dépasserait cependant largement le cadre de cet article, c'est pourquoi aucune solution de ce genre n'est proposée ici.
| |
La première proposition de solution présente cependant différents défauts majeurs:
Pour contourner ces inconvénients, deux autres propositions de solution sont proposées dans cet article. Ces deux autres propositions de solutions sont construites sur la base de la première proposition et peuvent être combinées. Chacune de ces deux propositions visent en fait un inconvénient déterminé.
| |
Cette proposition doit éliminer l'inconvénient de l'identification du visiteur. Comme il a été dit, l'adresse IP est un critère d'identification visiblement mauvais. Après que le problème d'identifier le visiteur clairement durant plusieurs requêtes d'applications Web n'est pas limité uniquement à de tels affichages, il existe déjà une solution à ce problème: les sessions.
Au premier appel d'une page par un navigateur un numéro univoque est créé. Ce numéro univoque est un nombre aléatoire afin que les numéros de session d'autres utilisateurs ne puissent être trouvés. Le plus souvent, ce numéro est envoyé au navigateur sous forme de témoin de connexion (Cookie). Cela a pour effet qu'à chaque nouvelle requête le navigateur enverra ce numéro sous forme de témoin de connexion au serveur. Le serveur peut identifier le visiteur sans équivoque au vu de ce numéro. Il est également possible que ce nombre soit transmis par paramètre de l'URL. Ceci est rendu nécessaire quand le visiteur a désactivé les témoins de connexion. Chaque lien dans la page doit alors être pourvu en plus de ce numéro.
La plupart du temps, des informations sont affectées aux numéros de session sur le serveur. Ce qui est avant tout pratique pour les ouvertures de sessions (login) - il ne faut ouvrir la session qu'une fois et le nom de l'utilisateur est mémorisé avec ce numéro de session. Les sessions se périment automatiquement au bout d'un certain temps. Sinon quelqu'un pourrait essayer de essayer de trouver le numéro de session d'un utilisateur inscrit. En outre, de l'espace est ainsi épargné sur le serveur - il y a en effet 2 puissance 128 possibilités différentes pour un numéro de session typique. Si pour chaque numéro de session existant, les données étaient conservées, l'espace de sauvegarde sur le serveur serait dilapidé en peu de temps.
Le problème avec les sessions: Dès qu'un navigateur contacte le serveur sans avoir de numéro, une nouvelle session est créée. Ainsi il est possible à un seul utilisateur de créer par mégarde énormément de sessions. De la sorte les sessions peuvent être un critère encore plus mauvais que les adresses IP pour l'identification du nombre de visiteurs.
Quand une page cependant propose une identification (login), il est pourtant possible d'afficher alors les visiteurs enregistrés, qui sont connectés à cet instant précis. On utilise alors comme critère univoque non plus l'adresse IP, mais le nom de l'utilisateur. Sinon on procède exatement comme dans la première proposition de solution. Naturellement, on ne peut compter ainsi que les visiteurs enregistrés. Toutefois on peut ainsi identifier exactement les différents utilisateurs en palliant le premier défaut de la première proposition de solution.
La fonction dans le premier exemple est écrite de façon très générale. C'est pourquoi elle peut être utilisée tout simplement avec un autre critère d'identification. Les applications Web avec sessions sont programmées de telle sorte que le code d'initialisation de la session et d'autres données se trouvent dans un fichier central. Si ce fichier s'appelle header.inc.php et que le nom de l'utilisateur se trouve dans $_SESSION['username'], le nouveau fichier header.inc.php pourrait prendre cet aspect:
<?php
// certaines choses sont initialisées ici
// comme par exemple la session:
session_start ();
// d'autres choses sont exécutées ici...
// incorporation du fichier pour compter les visiteurs connectés
require 'visiteurs_en_ligne.php';
// compter ce visiteur s'il est connecté
if (!empty ($_SESSION['username'])) {
compte_visiteurs ($_SESSION['username']);
}
?>
|
Le début du fichier ne diffère pas. L'affichage est incorporé exactement comme dans le premier exemple. Le fichier visiteurs_en_ligne.php qui met les fonctions à disposition est tout simplement incorporé, puis, dans la mesure où l'utilisateur est connecté, celui-ci est compté . La condition pour vérifier si l'utilisateur est connecté ou non s'exprime ici sous la forme: Est-ce que la variabe de session avec le nom de l'utilisateur est vide ou non? Cette condition peut bien sûr également s'exprimer différemment suivant les applications.
Il est aussi possible, c'est le cas dans de nombreux babillards électroniques (bulletin Boards), non seulement afficher le nombre d'utilisateurs actuellement connectés mais également leurs noms. Pour ce faire, le code d'affichage devrait être ainsi modifié:
<?php $visiteur = cherche_liste_visiteurs(); $nombre_visiteurs = count ($visiteur); ?>
<p>Actuellement
<?php if ($nombre_visiteurs == 1) { ?>
est connecté
<?php } else { ?>
sont connectés
<?php } ?>
<?php echo $nombre_visiteurs ?> visiteurs:
<?php echo implode (', ', array_keys ($visiteur)); ?></p>
|
Dans un premier temps la fonction prend ici la liste des visiteurs. Ensuite le nombre de visiteurs est recherché puis sorti. Étant donné que les noms de visiteurs servent de clés pour le tableau, toutes les clés doivent d'abord être extraites grâce à array_keys. Cette liste avec les clés (qui représente en fait la liste des noms des utilisateurs) est ensuite tranformée en chaîne de caractères séparés par des virgules grâce à implode pour être par la suite sortie.
Les modifications au code Perl existant pour le comptage des différents utilisateurs peuvent être faites de façon analogue à celles intervenues sur le code PHP, il faut simplement transmettre comme critère d'identification le nom d'utilisateur disponible de toute façon dans le script.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
use UserOnline;
my %liste = visiteurs_en_ligne::cherche_liste_visiteurs ();
my @utilisateur = keys %liste;
my $nombre = @utilisateur;
print "Content-Type: text/html\n\n";
print "Actuellement il y a $nombre visiteurs en ligne: ";
print join (', ', @utilisateur);
|
Ce code Perl est lui aussi analogue au code PHP. Comme les visiteurs peuvent s'identifier par des sessions, il est peu probable que les pages soient établies par les SSI. C'est la raison pour laquelle ce code ne doit servir que de modèle pour le code à incorporer ensuite dans des scripts existants.
| |
La seconde possibilité de solution présente ágalement quelques défauts majeurs:
| |
Cette proposition de solution vise à éliminer le problème de la durée de navigation sur la page Web. Dans le principe, il faut que le serveur soit recontacté à intervalles réguliers, pour savoir qu'un visiteur est encore en ligne. Cet intervalle doit naturellement être inférieur à la limite de temps fixée après laquelle un enregistrement dans la liste est périmé.
On pourrait avec JavaScript faire charger à intervalles réguliers certaines petites images invisibles. Ce qui aurait pour conséquence de recontacter régulièrement le serveur. Quoiqu'il en soit, JavaScript est désactivé chez certains utilisateurs ce qui rend ainsi cette méthode inutilisable. Recharger la page ou l'actualiser peut aussi être éliminé étant donné les gros désagréments pour l'utilisateur.
L'unique solution viable pour un contact régulier semble être alors un cadre (frame) invisible sans quadrillage: la page proprement-dite est chargée dans un cadre qui occupe toute la fenêtre, l'autre cadre ayant une taille nulle. Dans l'autre cadre est chargée une page sans contenu aussi petite que possible et qui se recharge régulièrement. Ainsi le serveur sera également contacté à intervalles réguliers.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Titre de la page</title>
</head>
<frameset rows="100%,0%" frameborder="0" framespacing="0" border="0">
<frame src="page_proprement_dite.html" name="page" noresize>
<frame src="comptage_visiteurs_en_ligne.php" name="cadre_vide" noresize>
<noframes>
<p>Cette page Web peut également être consultée <a href="page_proprement_dite.html">sans cadres</a>.</p>
</noframes>
</frameset>
</html>
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <meta http-equiv="Refresh" content="270; URL=comptage_visiteurs_en_ligne.php"> <title>Titre de la page</title> </head> <body> <?php // Incorporation du fichier pour le comptage des visiteurs en ligne require 'visiteurs_en_ligne.php'; // prendre en compte ce visiteur compte_visiteurs ($_SERVER['REMOTE_ADDR']); ?> </body> </html> |
Le jeu de cadres est appelé à la place de la page d'accueil proprement-dite. La page d'accueil peut maintenant être atteinte sous page_proprement_dite.html. Celle-ci est également incorporée dans le jeu de cadres. De plus une page comptage_visiteurs_en_ligne.php est incorporée. Cette page se recharge par une mention Meta Refresh. Dans la partie PHP, c'est d'abord le fichier pour le comptage des visiteurs de la première proposition de solution qui est incorporé, suite à quoi la fonction pour le comptage des visiteurs est appelée. Aucune sortie n'a lieu.
Au cas où un moteur de recherche trouve une sous-page, le jeu de cadres doit être rechargé. Pour que cela intervienne automatiquement, JavaScript est inévitablement nécessaire. Afin cependant que la page appelée précédemment apparaisse à nouveau après le chargement du jeu de cadres (et non pas la page d'accueil), il existe des solutions toutes prêtes dans les articles spécialisés 
JavaScript et PHP ainsi que Perl.
| |
La troisième proposition de solution présente également différents inconvénients:
| |
La réalisation d'un affichage du nombre de visiteurs actuellement connectés n'est pas possible. Il est possible grâce à différents procédés d'effectuer une grossière estimation de ce chiffre. Cependant, plus le nombre de visiteurs accédant simultanément à une page est élevé, plus l'affichage sera imprécis. L'affichage ne sera exact qu'en l'absence de tout visiteur sur la page.
Si vous décidez malgré tout de mettre un tel affichage sur votre page, vous pouvez alors utiliser les scripts publiés ici. Les fichiers visiteurs_en_ligne.php et UserOnline.pm sont disponibles au téléchargement, l'incorporation dans sa propre page peut s'inspirer des exemples donnés dans cet article.
Remarque: Sous Windows 95, Windows 98 et Windows Millenium Edition il n' est pas possible, d'installer des verrouillages de fichiers. Cela vaut aussi bien pour PHP que pour Perl. La variante Perl de la fonction flock
entraîne un message d'erreur. C'est pourquoi il vous faut mettre en commentaire ou effacer les lignes qui contiennent cette fonction, si vous avez l'un de ces systèmes d'exploitation. Avec d'autres systèmes d'exploitation y compris Windows NT 4.0, Windows 2000, Windows XP et Linux, par contre, les verrouillages de fichiers sont possibles. Étant donné que dans la normale, les serveurs ne tournent qu'avec des systèmes d'exploitation qui gèrent les verrouillages de fichier, j'ai utilisé les verrouillages de fichiers. La variante PHP n'est pas concernée étant donné que la version PHP ne renvoie que false.
|
|
| SELFHTML actuel Articles spécialisés Programmation |
