La tarea del lado del servidor suele ser realizar operaciones lógicas de acuerdo con la solicitud del cliente y devolver la respuesta resultante. Esta respuesta suele estar en formato XML (por lo que el lado del servidor necesita usar el DOM de PHP para crear una respuesta XML)
1. PHP usa DOM para crear una respuesta XML, que es analizada por el JS del cliente y luego mostrada en la página (por lo tanto; necesitas dominar la API DOM de PHP)
De hecho, existen dos formas de generar XML en PHP:
Utilice la API DOM (Método 1)
La otra es hacer eco directamente del contenido XML (Método 2);
Ver ejemplo:
Página HTML (contiene tres funciones de activación JS: onmouseover, onmouseout, onclick; activan sus propias funciones respectivamente)
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//es">
<html>
<cabeza>
<título> Servidor PHP Ajax </título>
<script tipo="text/javascript" src="js.js"></script>
</cabeza>
<cuerpo>
<span onmouseover="PHPechoXML()" onmouseout="PHPDOMXML()">Palabras predeterminadas</span>
<div id="mostrar"></div>
dividir<input type="text" id="firstNumber"/>por
<tipo de entrada="texto" id="segundoNúmero"/>
<tipo de entrada="botón" valor="Enviar" onclick="CSparameter()"/>
<div id="resultado"></div>
</cuerpo>
</html>
Página JS (defina tres funciones de activación JS respectivamente: PHPechoXML, PHPDOMXML y CSparameter)
Hay funciones de creación de objetos XMLHttpRequest y funciones respectivas de procesamiento de respuestas del servidor.
///////1. Crear objeto XMLHttpRequest
var xmlHttp = createXmlHttpRequestObject()
función createXmlHttpRequestObject()
;
...{
var xmlHttp;
intente
...{
// intenta crear el objeto XMLHttpRequest
xmlHttp = nueva XMLHttpRequest();
}
captura (e)
...{
// asume IE6 o anterior
var XmlHttpVersions = nueva matriz ('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
para (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
intentar
...{
// intenta crear el objeto XMLHttpRequest
xmlHttp = nuevo ActiveXObject(XmlHttpVersions[i]);
}
atrapar (e) ...{}
}
}
si (!xmlHttp)
alert("Error al crear el objeto XMLHttpRequest.");
demás
devolver xmlHttp;
}
///////2. Función de respuesta a eventos de JavaScript (activador al pasar el mouse)
// leer un archivo del servidor
función PHPichoXML()
...{
// sólo continúa si xmlHttp no es nulo
si(xmlHttp)
...{
//intenta conectarse al servidor
intentar
...{
//iniciamos la lectura de un archivo del servidor
//Enviar una solicitud asincrónica al archivo PHPechoXML.php en el lado del servidor
xmlHttp.open("GET", "PHPechoXML.php", verdadero);
xmlHttp.onreadystatechange = handleRequestStateChange;
xmlHttp.send(nulo);
}
//muestra el error en caso de falla
atrapar (e)
...{
alert("No se puede conectar al servidor: " + e.toString());
}
}
}
///////3. Función de respuesta a eventos de JavaScript (activador onmouseout)
funciónPHPDOMXML()
...{
// sólo continúa si xmlHttp no es nulo
si(xmlHttp)
...{
//intenta conectarse al servidor
intentar
...{
//iniciamos la lectura de un archivo del servidor
//Enviar una solicitud asincrónica al archivo PHPDOMXML.php en el lado del servidor
xmlHttp.open("GET", "PHPDOMXML.php", verdadero);
xmlHttp.onreadystatechange = handleRequestStateChange;
xmlHttp.send(nulo);
}
//muestra el error en caso de falla
atrapar (e)
...{
alert("No se puede conectar al servidor: " + e.toString());
}
}
}
// maneja la respuesta recibida del servidor, función de devolución de llamada de estado del lado del servidor
función manejarRequestStateChange()
...{
si (xmlHttp.readyState == 4)
...{
// continuar sólo si el estado HTTP es "OK"
si (xmlHttp.status == 200)
...{
intentar
...{
// lee el mensaje del servidor
var xmlResponse = xmlHttp.responseXML
//Capture posibles errores en IE y Opera
if(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Estructura XML no válida: "+xmlHttp.responseText);
}
//Captura errores potenciales en FireFox
var rootNodeName=xmlResponse.documentElement.nodeName;
if(rootNodeName=="error del analizador")
...{
throw("Estructura XML no válida: "+xmlHttp.responseText);
}
//Obtener la respuesta XML del servidor, analizarla y mostrarla en la página web
//obtenemos el elemento del documento XML
xmlRoot = xmlResponse.documentElement;
// obtener matrices con títulos de libros e ISBN
cityArray=xmlRoot.getElementsByTagName("ciudad");
//generar salida HTML
varhtml = "";
// iterar a través de las matrices y crear una estructura HTML
para (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// obtenemos una referencia al elemento <div> en la página
myDiv = document.getElementById("mostrar");
//muestra la salida HTML
myDiv.innerHTML = "El servidor dice: <br />" + html;
}
captura (e)
...{
//muestra mensaje de error
alert("Error al leer la respuesta: " + e.toString());
}
}
demás
...{
//mostrar mensaje de estado
alerta("Hubo un problema al recuperar los datos: " +
xmlHttp.statusText);
}
}
}
///////4. Función de respuesta a eventos de JavaScript (activador al hacer clic)
función CSparámetro()
...{
// sólo continúa si xmlHttp no es nulo
si(xmlHttp)
...{
//intenta conectarse al servidor
intentar
...{
//Obtener el valor en el formulario
var primerNúmero=document.getElementById("primerNúmero").value;
var secondNumber=document.getElementById("segundoNumber").value;
//Establecer como parámetro para realizar una solicitud asincrónica a CSparameter.php en el lado del servidor
var param="firstNumber="+firstNumber+"&segundoNumber="+segundoNumber
// inicia la lectura de un archivo desde el servidor
xmlHttp.open("GET", "CSparameter.php?"+param, verdadero);
xmlHttp.onreadystatechange = handleRequestStateChangePara;
xmlHttp.send(nulo);
}
//muestra el error en caso de falla
atrapar (e)
...{
alert("No se puede conectar al servidor: " + e.toString());
}
}
}
// Función de devolución de llamada de cambio de estado del servidor (el servidor acepta los parámetros del cliente y devuelve una respuesta XML después del cálculo lógico. El cliente analiza el XML y devuelve las actualizaciones a la página)
// maneja la respuesta recibida del servidor
función handleRequestStateChangePara()
...{
si (xmlHttp.readyState == 4)
...{
// continuar sólo si el estado HTTP es "OK"
si (xmlHttp.status == 200)
...{
intentar
...{
// lee el mensaje del servidor
var xmlResponse = xmlHttp.responseXML;
//Captura errores potenciales en IE y Opera
if(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Estructura XML no válida: "+xmlHttp.responseText);
}
//Captura errores potenciales en FireFox
var rootNodeName=xmlResponse.documentElement.nodeName;
if(rootNodeName=="error del analizador")
...{
throw("Estructura XML no válida: "+xmlHttp.responseText);
}
//obtener el elemento del documento XML
xmlRoot = xmlResponse.documentElement;
cityArray=xmlRoot.getElementsByTagName("resultado");
//generar salida HTML
varhtml = "";
// iterar a través de las matrices y crear una estructura HTML
para (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// obtenemos una referencia al elemento <div> en la página
myDiv = document.getElementById("resultado");
//muestra la salida HTML
myDiv.innerHTML = "El servidor dice: <br />" + html;
}
captura (e)
...{
//muestra mensaje de error
alert("Error al leer la respuesta: " + e.toString());
}
}
demás
...{
//mostrar mensaje de estado
alerta("Hubo un problema al recuperar los datos: " +
xmlHttp.statusText);
}
}
}
Script PHP del lado del servidor (responsable de aceptar solicitudes asincrónicas del Cliente, responderlas y devolverlas al Cliente en formato XML)
PHEchoXML.php (el primer método para que PHP genere una respuesta XML, echo genera contenido XML)
<?php
// El primer método para que PHP del lado del servidor genere archivos XML es hacer eco del XML directamente.
encabezado('Tipo de contenido: texto/xml');
//generar encabezado XML
echo '<?xml versión="1.0" codificación="UTF-8" standalone="yes"?>';
echo '<ciudades>';
$cityArray=array('París','Londres','NuevaYork','Pekín','Tokoy');
foreach ($ciudadArray como $ciudad)
{
echo '<ciudad>'.$ciudad.'</ciudad>';
}
echo '</cities>';
?>
PHPDOMXML.php (El segundo método para que PHP genere una respuesta XML, utilizando la API DOM de PHP para generar una respuesta en formato XML)
<?php
encabezado('Tipo de contenido: texto/xml');
$cityArray=array('Shanghai','Pekín','Shanxi','Shandong');
//Crear un documento XML
$dom=nuevo DOMDocumento();
//Etiqueta más externa
$ciudadesTag=$dom->createElement('ciudades');
$dom->appendChild($ciudadesTag);
//La etiqueta interna se puede generar mediante bucle
foreach ($ciudadArray como $ciudad)
{
$ciudadTag=$dom->createElement('ciudad');
$nombreciudad=$dom->createTextNode($ciudad);
$cityTag->appendChild($nombredeciudad);
$ciudadesTag->appendChild($ciudadTag);
}
//Guardar la estructura XML como una cadena y generarla
$xmlString=$dom->saveXML();
eco $xmlString;
?>
2. Transferencia de parámetros entre el lado del cliente y el lado del servidor:
Puede haber un formulario en la página web del lado del cliente, de modo que los parámetros se puedan pasar al <método GET o POST, variable o XML> del lado del servidor, y el lado del servidor genera una respuesta XML que cumple con los requisitos según los parámetros pasados (interacción de parámetros del lado del cliente y del lado del servidor implementada);
Ver ejemplo:
Como en 1, el script en el lado PHP para el paso de parámetros es el siguiente CSparameter.php (acepta los parámetros de la solicitud asincrónica del cliente, realiza procesamiento lógico y genera una respuesta XML para enviar de vuelta al cliente) <?php
//Personaliza la función de manejo de errores en el lado del servidor
require_once('error_handler.php');
header('Content-Type: text/xml');
//Aceptar parámetros de solicitud asincrónica del cliente
$primerNúmero=$_GET['primerNúmero'];
$segundoNúmero=$_GET['segundoNúmero']
//Realizar cálculos lógicos
$resultado=$primerNúmero/$segundoNúmero;
//Generar una respuesta en formato XML y devolverla al Cliente
$dom=nuevo DOMDocumento();
$resultadosTag=$dom->createElement('resultados');
$dom->appendChild($resultadosTag
=$dom->createElement('resultado');
$resultadoTexto=$dom->createTextNode($resultado);
$etiquetaresultado->appendChild($textoresultado);
$resultadosTag->appendChild($resultadosTag
=$dom->saveXML();
eco $xmlString
;
3. Manejo de excepciones de error en el lado PHP (los errores o excepciones mencionados aquí se refieren a errores lógicos):
a) De forma predeterminada, PHP no generará una excepción cuando ocurra un error o una excepción (esto se debe a que los display_errors predeterminados en php.ini están desactivados y el error se guardará en el registro de errores de Apache), por lo que es escrito Difícil de depurar. <A menudo es difícil localizar los errores mostrados por el navegador>
b) Pero si display_errors está activado, se mostrará el error, pero el mensaje de error no será amigable.
http://www.downcodes.com/
c) Puede escribir su propia función de manejo de excepciones de errores de PHP (no es necesario que display_errors esté activado) para mostrar los errores de una manera obvia para facilitar la depuración;
Por lo general, escribe su propia función de manejo de excepciones de la siguiente manera:
Muestra la función de generación de excepciones de error del lado del servidor definida error_handler.php (se puede reutilizar fácilmente en programas PHP)
<?php
//establecer una función de manejo de errores definida por el usuario método de manejo de excepciones de errores definido por el usuario
set_error_handler('error_handler', E_ALL);
función error_handler($errNo,$errStr,$errFile,$errLine)
{
//Si el buffer de salida no está vacío, vacíelo
if(ob_get_length()) ob_clean();
//Definir salida personalizada
$error_message='ERRNO: '.$errNo.chr(10).'TEXTO: '.$errStr.chr(10).'UBICACIÓN: '.$errFile.', Línea'.$errLine;
eco $mensaje_error;
salida;
}
?>
4. Acceso del lado del servidor a la base de datos <Utilice MySQL para acceder a los datos y lograr una verdadera dinámica>
Esto ya es muy clásico, puedes usar MySQL, MSSQL, Oracle, etc.
a) Abrir la base de datos; b) Consulta de sentencia SQL c) Cerrar la base de datos
5. Encapsulación y arquitectura del programa PHP del lado del servidor (el programa PHP del lado del servidor introduce el modo de diseño)
a) appname.php <Aceptar solicitud del cliente>
b) appname.class.php <Encapsule la lógica del lado del servidor, las operaciones de la base de datos, el manejo de errores, etc. en clases, incluidos atributos, métodos, constructores y destructores>
c) configuración.php
d) error_handler.php
es un ejemplo de introducción de patrones de diseño en el lado del servidor: (Diseñe la arquitectura del programa de scripts PHP del lado del servidor para mejorar la escalabilidad y la reutilización)
Un programa de sugerencia de palabras clave muy simple: (incluido index.html, css/style.css, js.js y código PHP php/suggest.php, sugerencia.class.php, error_handler.php, config.php admite bases de datos)
index.html(css/style.css, js.js; tenga en cuenta que dos eventos del cliente JS activan onkeyup, onclick)
onkeyup envía una solicitud al servidor de forma asíncrona en tiempo real cuando el usuario ingresa, y el servidor responde cuando el usuario hace clic en buscar; onclick envía una solicitud al servidor.
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//es">
<html>
<cabeza>
<title> Patrón de diseño PHP AJAX (las palabras clave sugieren DEMO) </title>
<enlace tipo="text/css" rel="hoja de estilo" href="css/style.css"/>
<script tipo="text/javascript" src="js.js"></script>
</cabeza>
<cuerpo>
<sin guión>
<strong>¡Este ejemplo requiere un navegador compatible con JavaScript!</strong>
</noscript>
<div clase="proyecto">
<span class="title">Bienvenido a Design Pattern PHP AJAX (las palabras clave sugieren DEMO) </span>
<br />
<br />
<div class="noticias">
<br /><tipo de entrada="texto" id="palabra clave" onkeyup="keyup()" /><tipo de entrada="botón" id="búsqueda" onclick="búsqueda()" valor="búsqueda"> <br /><br />
sugerir palabras clave:
<div id="mostrar"></div>
</div>
</div>
</cuerpo>
</html>
css/estilo.css
cuerpo
{...}{
familia de fuentes: Arial;
tamaño de fuente: pequeño;
color de fondo: #fff;
}
.título
{...}{
tamaño de fuente: extragrande;
}
proyecto.div
{...}{
color de fondo: #99ccff;
relleno: 5px;
borde:#000099 1px sólido;
}
div.noticias
{...}{
color de fondo:#fffbb8;
relleno: 2px;
borde: 1px discontinuo;
}
#espectáculo
{...}{
color: #008000;
estilo de fuente: cursiva;
}js.js (define la función de respuesta en JS y la función de devolución de llamada para que el Cliente procese la respuesta del Servidor)
////////////////////////////////////////////////// /// /////////
//1.Crear objeto XMLHttpRequest
////////////////////////////////////////////////// /// /////////
var xmlHttp = createXmlHttpRequestObject();
función crearXmlHttpRequestObject()
...{
var xmlHttp;
intentar
...{
// intenta crear el objeto XMLHttpRequest
xmlHttp = nueva XMLHttpRequest();
}
captura (e)
...{
// asume IE6 o anterior
var XmlHttpVersions = nueva matriz ('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
para (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
intentar
...{
// intenta crear el objeto XMLHttpRequest
xmlHttp = nuevo ActiveXObject(XmlHttpVersions[i]);
}
atrapar (e) ...{}
}
}
si (!xmlHttp)
alert("Error al crear el objeto XMLHttpRequest.");
demás
devolver xmlHttp;
}
//Muestra la respuesta correcta del servidor al div con el id de show
visualización de funciones (mensaje)
...{
showDIV=document.getElementById("mostrar");
showDIV.innerHTML=mensaje;
}
//Muestra el mensaje de error de la respuesta del lado del servidor al div con el id de show
función displayError(mensaje de error)
...{
//Mostrar mensaje de error
display("¡Error al recuperar el nuevo mensaje!<br/>"+errormessage);
}
////////////////////////////////////////////////// /// //////////
//2.función controlada por eventos (función de teclado)
////////////////////////////////////////////////// /// /////////
var keyupAddress="php/suggest.php?action=keyup&keyword=";
tecla de función()
...{
si(xmlHttp)
...{
//Envía una solicitud asincrónica cuando el servidor no está ocupado
si(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
intentar
...{
var palabra clave=document.getElementById("palabra clave").value;
//Hacer una solicitud asincrónica
xmlHttp.open("GET",keyupAddress+palabra clave,true);
xmlHttp.onreadystatechange=handlereadystatechange;
xmlHttp.send(nulo);
}
captura (e)
...{
displayError(e.toString);
}
}
}
}
////////////////////////////////////////////////// /// /////////
// 3. Función de devolución de llamada, esta función se activa cuando cambia el estado de respuesta del servidor.
////////////////////////////////////////////////// /// /////////
función manejarreadystatechange()
...{
si(xmlHttp.readyState==4)
...{
si(xmlHttp.status==200)
...{
intentar
...{
//Obtener respuesta del servidor
var xmlResponse = xmlHttp.responseXML;
sugerirArray=xmlResponse.getElementsByTagName("sugerir");
var mostrarTexto="";
for(var i=0;i<suggestArray.length;i++)
...{
var textNodes=suggestArray[i].getElementsByTagName("texto");
var timesNodes=suggestArray[i].getElementsByTagName("times");
for(var j=0;j<textNodes.length;j++)
...{
showText+=textNodes[j].childNodes[0].nodeValue+" ("+timesNodes[j].childNodes[0].nodeValue+") <br />";
}
}
//Mostrar la respuesta a la página
mostrar(mostrarTexto);
}
captura (e)
...{
displayError(e.toString());
}
}
}
}
////////////////////////////////////////////////// /// /////////
//2.función controlada por eventos (función de búsqueda)
////////////////////////////////////////////////// /// /////////
var searchAddress="php/suggest.php?action=search&keyword=";
función de búsqueda()
...{
si(xmlHttp)
...{
//Envía una solicitud asincrónica cuando el servidor no está ocupado
si(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
intentar
...{
var palabra clave=document.getElementById("palabra clave").value;
//Hacer una solicitud asincrónica
xmlHttp.open("GET",dirección de búsqueda+palabra clave,true);
xmlHttp.onreadystatechange=handlereadystatechange;
xmlHttp.send(nulo);
}
captura (e)
...{
displayError(e.toString);
}
}
}
}
Nota final: la estructura del programa del script PHP del lado del servidor (suggest.php es la función de procesamiento principal en el lado del servidor, y también hay sugerencias.class.php, error_handler.php, config.php, etc.)
sugerir.php (obtiene los parámetros del cliente y llama a los dos métodos de la clase sugerida para generar una respuesta en formato XML y enviarla de regreso al cliente)
<?php
require_once('suggest.class.php');
encabezado('Tipo de contenido: texto/xml');
//Asegúrate de que el navegador del usuario no almacene en caché los resultados
header('Expira: miércoles, 23 de diciembre de 1980 00:30:00 GMT');
header('Última modificación: '.gmdate('D, d MYH:i:s').' GMT' );
header('Control de caché: sin caché, debe revalidar');
encabezado('Pragma: sin caché');
$acción=$_GET['acción'];
$palabra clave=$_GET['palabra clave'];
$oSuggest=nueva sugerencia();
if($acción=='keyup'&&$palabra clave!='')
{
$suggestXML=$oSuggest->getSuggests($palabra clave);
}
if($acción=='búsqueda'&&$palabra clave!='')
{
$suggestXML=$oSuggest->submitKeyword($palabra clave);
}
eco $sugerirXML;
?>suggest.class.php clase
<?php
require_once('error_handler.php');
require_once('config.php');
sugerencia de clase
{
//variables miembro
privado $conn;
//Constructor, enlace de base de datos
función__construcción()
{
$this->conn=nuevo mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_DATABASE);
si (mysqli_connect_errno()) {
printf("Error de conexión: %s ", mysqli_connect_error());
salida();
}
}
//Destructor, desconecta el enlace de la base de datos
función __destruir()
{
$this->conn->close();
}
// Función miembro getSuggests (esta función responde principalmente a la acción del lado del cliente = keyup, es decir, una solicitud asincrónica cuando el usuario está escribiendo)
función pública getSuggests($palabra clave)
{
// Generar sugerencia (generar palabras clave en la base de datos que sean iguales a la primera mitad de la palabra clave ingresada)
$suggest_query='seleccione * de palabras clave donde la palabra clave es como ''.$palabra clave.'%' orden por tiempos desc límite 5';
$suggest_result=$this->conn->query($suggest_query);
$suggest_num=$suggest_result->num_rows;
$strOUT='<?xml versión="1.0" codificación="UTF-8" standalone="yes"?>';
si($suggest_num==0)
{
//$strOUT=$strOUT.'<suggests><suggest><text>'.$palabra clave.'</text><times>0</times></suggest></suggests>';
}
demás
{
$strOUT=$strOUT."<sugiere>";
para($i=0;$i<$suggest_num;$i++)
{
$suggest_row = $suggest_result->fetch_row();
$strOUT=$strOUT.'<suggest><text>'.$suggest_row[1].'</text><times>'.$suggest_row[2].'</times></suggest>';
}
$strOUT=$strOUT.'</suggests>';
}
devolver $cadOUT;
}
// Función miembro de envío de palabras clave (esta función responde principalmente a la acción = búsqueda del lado del cliente, es decir, la solicitud asincrónica cuando el usuario hace clic en buscar)
función pública enviarPalabra clave ($palabra clave)
{
$select_query='seleccionar * de palabras clave donde palabra clave=''.$palabra clave.''';
$select_result=$this->conn->query($select_query);
$select_num=$select_result->num_rows;
// Agregue nuevas palabras clave a la base de datos cuando las encuentre y aumente la cantidad de palabras clave existentes cuando las encuentre.
$strOUT='<?xml versión="1.0" codificación="UTF-8" standalone="yes"?>';
//Ya existe, aumenta el número de veces.
si($select_num!=0)
{
$select_row = $select_result->fetch_row();
$times_now=$select_row[2];
$veces_ahora=$veces_ahora+1;
$update_query='actualizar palabras clave establecidas veces ='.$times_now.' donde palabra clave=''.$palabra clave.''';
$update_result=$this->conn->query($update_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>'.$times_now.'</times></suggest></suggests>';
}
demás
{
//No se guarda la inserción
$insert_query='insertar en palabras clave(palabra clave, tiempos) valores (''.$palabra clave.'',1)';
$insert_result=$this->conn->query($insert_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$palabra clave.'</text><times>1</times></suggest></suggests>';
}
devolver $cadOUT;
}
}
?>
Las dos últimas funciones, config.php, guardan la información de configuración de la aplicación (como la información de configuración de la base de datos)
<?php
define('DB_HOST', 'localhost');
define('DB_USER','phpajaxuser');
define('DB_PASSWORD','phpajaxuser');
define('DB_DATABASE','phpajax');
?>
error_handler.php guarda el manejo de excepciones personalizado
<?php
//Establecer la función de manejo de errores definida por el usuario
set_error_handler('error_handler', E_ALL
función error_handler($errNo,$errStr,$errFile,$errLine)
{
if(ob_get_length()) ob_clean();
$error_message='ERRNO: '.$errNo.chr(10).'TEXTO: '.$errStr.chr(10).'UBICACIÓN: '.$errFile.' '.$errLine;
eco $mensaje_error;
salida;
}
?>Finalmente, se necesitan declaraciones SQL para agregar la base de datos y guardar palabras clave en la base de datos.
CREAR TABLA `palabras clave` (
`id` int(10) sin firmar NO NULL auto_increment,
`palabra clave` varchar(32) NOT NULL predeterminado '',
`times` int(10) unsigned NOT NULL predeterminado '0',
CLAVE PRIMARIA (`id`)
) TYPE=MyISAM AUTO_INCREMENT=1;
6. Pocos conocimientos sobre PHP para futuras investigaciones:
Cómo PHP lee datos de un servidor remoto (algo similar al rastreo web):
file_get_contents;
O CURL<Biblioteca de URL del cliente>www.php.net/curl