La tâche côté serveur consiste généralement à effectuer des opérations logiques en fonction de la demande du client et à renvoyer le résultat. Cette réponse est généralement au format XML (le côté serveur doit donc utiliser le DOM de PHP pour créer une réponse XML)
1. PHP utilise DOM pour créer une réponse XML, qui est analysée par le JS du client puis affichée sur la page (donc ; vous devez maîtriser l'API DOM de PHP)
En fait, il existe deux manières de générer du XML en PHP :
Utiliser l'API DOM (Méthode 1)
L'autre consiste à faire écho directement au contenu XML (Méthode 2) ;
Voir exemple :
Page HTML (contient trois fonctions de déclenchement JS : onmouseover, onmouseout, onclick ; déclenchent respectivement leurs propres fonctions)
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//en">
<html>
<tête>
<title> Serveur PHP Ajax </title>
<script type="text/javascript" src="js.js"></script>
</tête>
<corps>
<span onmouseover="PHPechoXML()" onmouseout="PHPDOMXML()">Mots par défaut</span>
<div id="show"></div>
diviser<input type="text" id="firstNumber"/>par
<input type="text" id="secondNumber"/>
<input type="button" value="Envoyer" onclick="CSparameter()"/>
<div id="result"></div>
</corps>
</html>
Page JS (définissez respectivement trois fonctions de déclenchement JS : PHPechoXML, PHPDOMXML et CSparameter)
Il existe des fonctions de création d'objets XMLHttpRequest et des fonctions respectives de traitement des réponses du serveur.
///////1. Créer un objet XMLHttpRequest
var xmlHttp = createXmlHttpRequestObject();
fonction createXmlHttpRequestObject()
...{
var xmlHttp;
essayez
...{
// essaie de créer un objet XMLHttpRequest
xmlHttp = nouveau XMLHttpRequest();
}
attraper(e)
...{
// suppose IE6 ou version antérieure
var XmlHttpVersions = nouveau tableau('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
pour (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
essayer
...{
// essaie de créer un objet XMLHttpRequest
xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
}
attraper (e) ...{}
}
}
si (!xmlHttp)
alert("Erreur lors de la création de l'objet XMLHttpRequest.");
autre
retourner xmlHttp ;
}
///////2. Fonction de réponse à un événement JavaScript (déclencheur onmouseover)
// lit un fichier sur le serveur
fonction PHPichoXML()
...{
// ne continue que si xmlHttp n'est pas nul
si(xmlHttp)
...{
// essaie de se connecter au serveur
essayer
...{
//lance la lecture d'un fichier depuis le serveur
//Envoyer une requête asynchrone au fichier PHPechoXML.php côté serveur
xmlHttp.open("GET", "PHPechoXML.php", true);
xmlHttp.onreadystatechange = handleRequestStateChange ;
xmlHttp.send(null);
}
// affiche l'erreur en cas d'échec
attraper (e)
...{
alert("Impossible de se connecter au serveur : " + e.toString());
}
}
}
///////3. Fonction de réponse à un événement JavaScript (déclencheur onmouseout)
fonctionPHPDOMXML()
...{
// ne continue que si xmlHttp n'est pas nul
si(xmlHttp)
...{
// essaie de se connecter au serveur
essayer
...{
//lance la lecture d'un fichier depuis le serveur
//Envoyer une requête asynchrone au fichier PHPDOMXML.php côté serveur
xmlHttp.open("GET", "PHPDOMXML.php", true);
xmlHttp.onreadystatechange = handleRequestStateChange ;
xmlHttp.send(null);
}
// affiche l'erreur en cas d'échec
attraper (e)
...{
alert("Impossible de se connecter au serveur : " + e.toString());
}
}
}
// gère la réponse reçue du serveur, fonction de rappel d'état côté serveur
fonction handleRequestStateChange()
...{
si (xmlHttp.readyState == 4)
...{
// continue uniquement si le statut HTTP est "OK"
si (xmlHttp.status == 200)
...{
essayer
...{
// lit le message du serveur
var xmlResponse = xmlHttp.responseXML;
//Capturez les erreurs potentielles dans IE et Opera
si(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Structure XML invalide : "+xmlHttp.responseText);
}
// Capturer les erreurs potentielles dans FireFox
var rootNodeName=xmlResponse.documentElement.nodeName;
si(rootNodeName=="parsererror")
...{
throw("Structure XML invalide : "+xmlHttp.responseText);
}
//Récupérez la réponse XML du serveur, analysez-la et affichez-la sur la page Web
//obtient l'élément de document XML
xmlRoot = xmlResponse.documentElement ;
// obtient des tableaux avec des titres de livres et des ISBN
cityArray=xmlRoot.getElementsByTagName("ville");
//générer une sortie HTML
varhtml = "";
// parcourt les tableaux et crée une structure HTML
pour (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// obtient une référence à l'élément <div> sur la page
myDiv = document.getElementById("show");
// affiche la sortie HTML
myDiv.innerHTML = "Le serveur dit : <br />" + html ;
}
attraper(e)
...{
//afficher un message d'erreur
alert("Erreur de lecture de la réponse : " + e.toString());
}
}
autre
...{
//afficher le message d'état
alert("Un problème est survenu lors de la récupération des données : " +
xmlHttp.statusText);
}
}
}
///////4. Fonction de réponse à un événement JavaScript (déclencheur onclick)
fonction CSparamètre()
...{
// ne continue que si xmlHttp n'est pas nul
si(xmlHttp)
...{
// essaie de se connecter au serveur
essayer
...{
//Récupère la valeur sous la forme
var firstNumber=document.getElementById("firstNumber").value;
var secondNumber=document.getElementById("secondNumber").value;
//Défini comme paramètre pour faire une requête asynchrone à CSparameter.php côté serveur
var param="firstNumber="+firstNumber+"&secondNumber="+secondNumber;
// lance la lecture d'un fichier depuis le serveur
xmlHttp.open("GET", "CSparameter.php?"+param, true);
xmlHttp.onreadystatechange = handleRequestStateChangePara ;
xmlHttp.send(null);
}
// affiche l'erreur en cas d'échec
attraper (e)
...{
alert("Impossible de se connecter au serveur : " + e.toString());
}
}
}
//Fonction de rappel de changement d'état du serveur (le serveur accepte les paramètres du client et renvoie une réponse XML après calcul logique. Le client analyse le XML et renvoie les mises à jour de la page)
// gère la réponse reçue du serveur
fonction handleRequestStateChangePara()
...{
si (xmlHttp.readyState == 4)
...{
// continue uniquement si le statut HTTP est "OK"
si (xmlHttp.status == 200)
...{
essayer
...{
// lit le message du serveur
var xmlResponse = xmlHttp.responseXML;
// Capturez les erreurs potentielles dans IE et Opera
si(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Structure XML invalide : "+xmlHttp.responseText);
}
// Capturer les erreurs potentielles dans FireFox
var rootNodeName=xmlResponse.documentElement.nodeName;
si(rootNodeName=="parsererror")
...{
throw("Structure XML invalide : "+xmlHttp.responseText);
}
//obtenir l'élément de document XML
xmlRoot = xmlResponse.documentElement ;
cityArray=xmlRoot.getElementsByTagName("result");
//générer une sortie HTML
varhtml = "";
// parcourt les tableaux et crée une structure HTML
pour (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// obtient une référence à l'élément <div> sur la page
myDiv = document.getElementById("result");
// affiche la sortie HTML
myDiv.innerHTML = "Le serveur dit : <br />" + html ;
}
attraper(e)
...{
//afficher un message d'erreur
alert("Erreur de lecture de la réponse : " + e.toString());
}
}
autre
...{
//afficher le message d'état
alert("Un problème est survenu lors de la récupération des données : " +
xmlHttp.statusText);
}
}
}
Script PHP côté serveur (responsable d'accepter les requêtes asynchrones du Client, d'y répondre et de les renvoyer au Client au format XML)
PHEchoXML.php (la première méthode permettant à PHP de générer une réponse XML, echo génère du contenu XML)
<?php
//La première méthode permettant à PHP côté serveur de générer des fichiers XML consiste à faire écho directement au XML.
header('Content-Type : texte/xml');
//générer un en-tête XML
echo '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
echo '<villes>';
$cityArray=array('Paris','Londres','NewYork','Pékin','Tokoy');
foreach ($cityArray comme $city)
{
echo '<ville>'.$ville.'</ville>';
}
echo '</cities>';
?>
PHPDOMXML.php (La deuxième méthode permettant à PHP de générer une réponse XML, en utilisant l'API DOM de PHP pour générer une réponse au format XML)
<?php
header('Content-Type : texte/xml');
$cityArray=array('Shanghai','Pékin','Shanxi','Shandong');
//Créer un document XML
$dom=nouveau DOMDocument();
// Balise la plus externe
$citiesTag=$dom->createElement('villes');
$dom->appendChild($citiesTag);
//Le Tag à l'intérieur peut être généré par boucle
foreach ($cityArray comme $city)
{
$cityTag=$dom->createElement('city');
$cityName=$dom->createTextNode($city);
$cityTag->appendChild($cityName);
$citiesTag->appendChild($cityTag);
}
//Enregistre la structure XML sous forme de chaîne et affiche-la
$xmlString=$dom->saveXML();
echo $xmlString;
?>
2. Transfert de paramètres entre côté client et côté serveur :
Il peut y avoir un formulaire dans la page Web côté client, afin que les paramètres puissent être transmis à la <méthode GET ou POST, variable ou XML> côté serveur, et que le côté serveur génère une réponse XML qui répond aux exigences basées sur les paramètres transmis (interaction des paramètres côté client et côté serveur implémentés)
Voir exemple :
Comme dans 1, le script côté PHP pour le passage des paramètres est le suivant CSparameter.php (accepte les paramètres de la requête asynchrone du formulaire client, effectue un traitement logique et génère une réponse XML à renvoyer au client) <?php
//Personnaliser la fonction de gestion des erreurs côté serveur
require_once('error_handler.php');
header('Content-Type: text/xml');
//Accepter les paramètres de la requête asynchrone du client
$firstNumber=$_GET['firstNumber'];
$secondNumber=$_GET['secondNumber'];
//Effectuer des calculs logiques
$result=$firstNumber/$secondNumber;
//Générer une réponse au format XML et la renvoyer au Client
$dom=nouveau DOMDocument();
$resultsTag=$dom->createElement('results');
$dom->appendChild($resultsTag);
$resultTag=$dom->createElement('result');
$resultText=$dom->createTextNode($result);
$resultTag->appendChild($resultText);
$resultsTag->appendChild($resultTag);
$xmlString=$dom->saveXML();
echo $xmlString
?>
3. Gestion des exceptions d'erreurs côté PHP (les erreurs ou exceptions mentionnées ici font référence à des erreurs logiques) :
a) Par défaut, PHP ne lèvera pas d'exception lorsqu'une erreur ou une exception se produit (en effet, les display_errors par défaut dans php.ini sont désactivés et l'erreur sera enregistrée dans l'enregistrement du journal des erreurs Apache). écrit Difficile à déboguer. <Il est souvent difficile de localiser les erreurs affichées par le navigateur>
b) Mais si display_errors est activé, l'erreur sera affichée, mais le message d'erreur sera peu convivial.
http://www.downcodes.com/
c) Vous pouvez écrire votre propre fonction de gestion des exceptions d'erreur PHP (il n'est pas nécessaire que display_errors soit activé) pour afficher les erreurs de manière évidente pour un débogage facile ;
Habituellement, vous écrivez votre propre fonction de gestion des exceptions comme suit :
Afficher l'exception d'erreur côté serveur définie en lançant la fonction error_handler.php (peut être facilement réutilisée dans les programmes PHP)
<?php
//définit une fonction de gestionnaire d'erreurs définie par l'utilisateur, méthode de gestion des exceptions d'erreurs définie par l'utilisateur
set_error_handler('error_handler', E_ALL);
fonction error_handler ($errNo,$errStr,$errFile,$errLine)
{
//Si le tampon de sortie n'est pas vide, videz-le
si(ob_get_length()) ob_clean();
//Définir une sortie personnalisée
$error_message='ERRNO : '.$errNo.chr(10).'TEXTE : '.$errStr.chr(10).'LOCATION : '.$errFile.', Line'.$errLine;
echo $message_erreur;
sortie;
}
?>
4. Accès côté serveur à la base de données <Utiliser MySQL pour accéder aux données afin d'obtenir une véritable dynamique>
C'est déjà très classique, vous pouvez utiliser MySQL, MSSQL, Oracle, etc.
a) Ouvrir la base de données ; b) Requête d'instruction SQL c) Fermer la base de données
5. Encapsulation et architecture du programme PHP côté serveur (le programme PHP côté serveur introduit le mode conception)
a) appname.php <Accepter la demande du client>
b) appname.class.php <Encapsuler la logique côté serveur, les opérations de base de données, la gestion des erreurs, etc. dans des classes, y compris les attributs, les méthodes, les constructeurs et les destructeurs>
c) config.php
d) error_handler.php
est un exemple d'introduction de modèles de conception côté serveur : (Concevoir l'architecture du programme de scripts PHP côté serveur pour améliorer l'évolutivité et la réutilisation)
Un programme de suggestion de mots-clés très simple : (comprenant index.html, css/style.css, js.js et le code PHP php/suggest.php, suggest.class.php, error_handler.php, config.php prend en charge la base de données)
index.html(css/style.css, js.js ; notez que deux événements client JS déclenchent onkeyup, onclick)
onkeyup envoie une requête au serveur de manière asynchrone en temps réel lorsque l'utilisateur entre, et le serveur répond onclick envoie une requête au serveur lorsque l'utilisateur clique sur rechercher ;
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//en">
<html>
<tête>
<title> Design Pattern PHP AJAX (les mots clés suggèrent DEMO) </title>
<link type="text/css" rel="stylesheet" href="css/style.css"/>
<script type="text/javascript" src="js.js"></script>
</tête>
<corps>
<noscript>
<strong>Cet exemple nécessite un navigateur compatible JavaScript !</strong>
</noscript>
<div class="projet">
<span class="title">Bienvenue dans Design Pattern PHP AJAX (les mots clés suggèrent DEMO) </span>
<br />
<br />
<div class="actualités">
<br /><input type="text" id="keyword" onkeyup="keyup()" /><input type="button" id="search" onclick="search()" value="search"> <br /><br />
suggérer des mots-clés :
<div id="show"></div>
</div>
</div>
</corps>
</html>
css/style.css
corps
{...}{
famille de polices : Arial ;
taille de police : petite ;
couleur d'arrière-plan : #fff ;
}
.titre
{...}{
taille de police : x-large ;
}
div.projet
{...}{
couleur d'arrière-plan : #99ccff ;
remplissage : 5 px ;
bordure : #000099 1px solide ;
}
div.nouvelles
{...}{
couleur d'arrière-plan :#fffbb8 ;
remplissage : 2 px ;
bordure : 1px en pointillés ;
}
#montrer
{...}{
couleur : #008000 ;
style de police : italique ;
}js.js (définir la fonction de réponse dans JS et la fonction de rappel permettant au client de traiter la réponse du serveur)
/////////////////////////////////////////////// /// /////////
//1. Créer un objet XMLHttpRequest
/////////////////////////////////////////////// /// /////////
var xmlHttp = createXmlHttpRequestObject();
fonction createXmlHttpRequestObject()
...{
var xmlHttp;
essayer
...{
// essaie de créer un objet XMLHttpRequest
xmlHttp = nouveau XMLHttpRequest();
}
attraper(e)
...{
// suppose IE6 ou version antérieure
var XmlHttpVersions = nouveau tableau('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
pour (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
essayer
...{
// essaie de créer un objet XMLHttpRequest
xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
}
attraper (e) ...{}
}
}
si (!xmlHttp)
alert("Erreur lors de la création de l'objet XMLHttpRequest.");
autre
retourner xmlHttp ;
}
//Affiche la réponse correcte du serveur au div avec l'identifiant de show
affichage de la fonction (message)
...{
showDIV=document.getElementById("show");
showDIV.innerHTML=message;
}
//Affiche le message d'erreur de la réponse côté serveur au div avec l'identifiant de show
fonction displayError(message d'erreur)
...{
//Afficher le message d'erreur
display("Erreur lors de la récupération du nouveau message !<br/>"+errormessage);
}
////////////////////////////////////////////// /// //////////
//2. fonction événementielle (fonction keyup)
/////////////////////////////////////////////// /// /////////
var keyupAddress="php/suggest.php?action=keyup&keyword=";
touche de fonction()
...{
si(xmlHttp)
...{
//Envoyer une requête asynchrone lorsque le serveur n'est pas occupé
si(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
essayer
...{
var mot-clé=document.getElementById("mot-clé").value;
//Faire une requête asynchrone
xmlHttp.open("GET",keyupAddress+keyword,true);
xmlHttp.onreadystatechange=handlereadystatechange ;
xmlHttp.send(null);
}
attraper(e)
...{
displayError(e.toString);
}
}
}
}
/////////////////////////////////////////////// /// /////////
//3. Fonction de rappel, cette fonction est déclenchée lorsque l'état de réponse du serveur change.
/////////////////////////////////////////////// /// /////////
fonction handlereadystatechange()
...{
si(xmlHttp.readyState==4)
...{
si(xmlHttp.status==200)
...{
essayer
...{
//Obtenir la réponse du serveur
var xmlResponse = xmlHttp.responseXML;
suggestArray=xmlResponse.getElementsByTagName("suggérer");
var showText="";
pour(var i=0;i<suggestArray.length;i++)
...{
var textNodes=suggestArray[i].getElementsByTagName("text");
var timesNodes=suggestArray[i].getElementsByTagName("times");
pour(var j=0;j<textNodes.length;j++)
...{
showText+=textNodes[j].childNodes[0].nodeValue+" ("+timesNodes[j].childNodes[0].nodeValue+") <br />";
}
}
//Affiche la réponse à la page
display(showText);
}
attraper(e)
...{
displayError(e.toString());
}
}
}
}
/////////////////////////////////////////////// /// /////////
//2. fonction événementielle (fonction de recherche)
/////////////////////////////////////////////// /// /////////
var searchAddress="php/suggest.php?action=search&keyword=";
fonction recherche()
...{
si(xmlHttp)
...{
//Envoyer une requête asynchrone lorsque le serveur n'est pas occupé
si(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
essayer
...{
var mot-clé=document.getElementById("mot-clé").value;
//Faire une requête asynchrone
xmlHttp.open("GET",adresse de recherche+mot-clé,true);
xmlHttp.onreadystatechange=handlereadystatechange ;
xmlHttp.send(null);
}
attraper(e)
...{
displayError(e.toString);
}
}
}
}
Remarque finale : la structure du programme du script PHP côté serveur (suggest.php est la fonction de traitement principale côté serveur, et il existe également suggest.class.php, error_handler.php, config.php, etc.)
suggest.php (récupère les paramètres du client, et appelle les deux méthodes de la classe suggest pour générer une réponse au format XML et la renvoyer au client)
<?php
require_once('suggest.class.php');
header('Content-Type : texte/xml');
//Assurez-vous que le navigateur de l'utilisateur ne mettra pas les résultats en cache
header('Expire : mercredi 23 décembre 1980 00:30:00 GMT');
header('Last-Modified: '.gmdate('D, d MYH:i:s').' GMT' );
header('Cache-Control : pas de cache, doit être revalidé');
header('Pragma : pas de cache');
$action=$_GET['action'];
$keyword=$_GET['keyword'];
$oSuggest=nouvelle suggestion();
si($action=='keyup'&&$keyword!='')
{
$suggestXML=$oSuggest->getSuggests($keyword);
}
si($action=='recherche'&&$mot-clé!='')
{
$suggestXML=$oSuggest->submitKeyword($keyword);
}
echo $suggestXML ;
?>classe suggest.class.php
<?php
require_once('error_handler.php');
require_once('config.php');
suggestion de classe
{
//Variables membres
private $conn;
//Constructeur, lien de base de données
fonction__construct()
{
$this->conn=new mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_DATABASE);
si (mysqli_connect_errno()) {
printf("Échec de la connexion : %s ", mysqli_connect_error());
sortie();
}
}
//Destructeur, déconnectez le lien de la base de données
fonction __destruct()
{
$this->conn->close();
}
//Fonction membre getSuggests (cette fonction répond principalement à une action côté client = keyup, c'est-à-dire une requête asynchrone lorsque l'utilisateur tape)
fonction publique getSuggests($keyword)
{
//Générer une suggestion (générer des mots-clés dans la base de données identiques à la première moitié du mot-clé saisi)
$suggest_query='select * parmi les mots-clés où les mots-clés comme ''.$keyword.'%' sont triés par fois desc limit 5';
$suggest_result=$this->conn->query($suggest_query);
$suggest_num=$suggest_result->num_rows;
$strOUT='<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
si($suggest_num==0)
{
//$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>0</times></suggest></suggest>';
}
autre
{
$strOUT=$strOUT."<suggère>";
pour($i=0;$i<$suggest_num;$i++)
{
$suggest_row = $suggest_result->fetch_row();
$strOUT=$strOUT.'<suggest><text>'.$suggest_row[1].'</text><times>'.$suggest_row[2].'</time></suggest>';
}
$strOUT=$strOUT.'</suggest>';
}
retourner $strOUT ;
}
//Fonction membresubmitKeyword (cette fonction répond principalement à l'action=recherche côté client, c'est-à-dire la requête asynchrone lorsque l'utilisateur clique sur Rechercher)
fonction publique submitKeyword ($keyword)
{
$select_query='select * parmi les mots-clés où mot-clé=''.$keyword.''';
$select_result=$this->conn->query($select_query);
$select_num=$select_result->num_rows ;
//Ajoutez de nouveaux mots-clés à la base de données lorsque vous les rencontrez et augmentez le nombre de mots-clés existants lorsque vous les rencontrez.
$strOUT='<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
//Existe déjà, augmentez le nombre de fois
si($select_num!=0)
{
$select_row = $select_result->fetch_row();
$times_now=$select_row[2];
$times_now=$times_now+1;
$update_query='mettre à jour les mots-clés définis fois ='.$times_now.' où mot-clé=''.$keyword.''';
$update_result=$this->conn->query($update_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>'.$times_now.'</time></suggest></suggests>';
}
autre
{
//Aucune insertion de sauvegarde
$insert_query='insérer dans les valeurs de mots-clés (mot-clé, heures) (''.$keyword.'',1)';
$insert_result=$this->conn->query($insert_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>1</times></suggest></suggest>';
}
retourner $strOUT ;
}
}
?>
Les deux dernières fonctions, config.php enregistrent les informations de configuration de l'application (telles que les informations de configuration de la base de données)
<?php
définir('DB_HOST', 'localhost');
définir('DB_USER','phpajaxuser');
définir('DB_PASSWORD','phpajaxuser');
définir('DB_DATABASE','phpajax');
?>
error_handler.php enregistre la gestion personnalisée des exceptions
<?php
//Définir la fonction de gestion des erreurs définie par l'utilisateur
set_error_handler('error_handler', E_ALL);
fonction error_handler($errNo,$errStr,$errFile,$errLine)
{
if(ob_get_length()) ob_clean();
$error_message='ERRNO : '.$errNo.chr(10).'TEXT : '.$errStr.chr(10).'LOCATION : '.$errFile.' '.$errLine;
echo $message_erreur;
sortie;
}
?>Enfin, des instructions SQL sont nécessaires pour ajouter la base de données afin d'enregistrer les mots-clés dans la base de données.
CREATE TABLE `mots-clés` (
`id` int(10) non signé NOT NULL auto_increment,
`mot-clé` varchar(32) NOT NULL par défaut '',
`times` int(10) non signé NOT NULL par défaut '0',
CLÉ PRIMAIRE (`id`)
) TYPE=MyISAM AUTO_INCREMENT=1;
6. Peu de connaissances sur PHP pour de futures recherches :
Comment PHP lit les données d'un serveur distant (un peu similaire à Web Crawl) :
fichier_get_contents ;
Ou CURL<Bibliothèque d'URL client>www.php.net/curl