Ver Mensaje Individual
  #2 (permalink)  
Antiguo 24/12/2013, 21:25
nksn
 
Fecha de Ingreso: mayo-2009
Ubicación: Japon
Mensajes: 60
Antigüedad: 15 años, 5 meses
Puntos: 12
Respuesta: introduccion sistemas dinamicos ( php + ajax )

www/src/main.js (documento js de usuario)

una vez que se cargue el documento, se prepara el conector ajax

los eventos ([input].onmousdedown) llama a la funcion load() del controlador ajax, la cual deja datos en cola para que el objeto XMLHTTP los procese

los datos son enviados desde javascript a sus respectivos documentos ".php", los cuales tiene ya predefinido sus funciones y/o acciones,
estos retornan "arrays" codificados con serialize(), los cuales serán decodificados con unserialize() por javascript

finalmente se realizan los parsers de datos en javascript y da formato en html para ser puesto en el contenedor

NOTA: nunca envíen sentencias SQL desde ajax para que sean ejecutadas en php, es muy peligroso

Código Javascript:
Ver original
  1. /*      inicializamos el conector
  2. */
  3. var connector
  4. window.onload = function()
  5. {
  6.     connector = new ajax();
  7. }
  8.  
  9. /*      función para envío
  10. */
  11. function send()
  12. {
  13.     connector.load
  14.     ({
  15.         /*      documento de lado del servidor
  16.         */
  17.         // url : 'http://localhost/ejemplo_input.php',
  18.         url : './ejemplo_input.php',
  19.        
  20.         /*      funcion cuando la carga/proceso este completo
  21.         */
  22.         onload : function(text, status)
  23.         {
  24.             if(text == 'completo')
  25.             {
  26.                 /*      el registro fue existoso,
  27.                 */
  28.                 alert('se ha guardado los datos')
  29.             }
  30.             else
  31.             {
  32.                 /*      convertimos los datos en objeto o array
  33.                 */
  34.                 var datos = unserialize(text);
  35.                
  36.                 /*      acciones segun el tipo
  37.                 */
  38.                 switch(datos['type'])
  39.                 {
  40.                     /*      problemas con envio
  41.                     */
  42.                     case 'php':
  43.                         alert('error en php #' + datos['nro'] + ' , ' + datos['msg']);
  44.                         break;
  45.                    
  46.                     /*      problemas con mysql (revisar ejemplo_input.php);
  47.                     */
  48.                     case 'mysql':
  49.                         alert('error en mysql #' + datos['nro'] + ' , ' + datos['msg']);
  50.                         break;
  51.                 }
  52.             }
  53.         },
  54.        
  55.         /*      ocurrio un error durante la carga
  56.         */
  57.         onerror : function(text, status)
  58.         {
  59.             alert('error durante la carga, ('+ status + ') ' + text);
  60.         },
  61.        
  62.         /*      cargamos las variables post
  63.         */
  64.         post :
  65.         {
  66.             'usuario'       : document.getElementById('name').value,
  67.             'otra_variable' : 'test'
  68.         }
  69.     });
  70. }
  71.  
  72.  
  73.  
  74. /*      función para listado
  75. */
  76. function getData()
  77. {
  78.     var pagina = document.getElementById('pagina').value;
  79.    
  80.     connector.load
  81.     ({
  82.         /*      documento de lado del servidor
  83.         */
  84.         //url : 'http://localhost/ejemplo_datos.php',
  85.         url : './ejemplo_datos.php',
  86.            
  87.         /*      funcion cuando la carga/proceso este completo
  88.         */
  89.         onload : function(text, status)
  90.         {
  91.             /*      convertimos los datos en objeto o array
  92.             */
  93.             var datos = unserialize(text);
  94.            
  95.             /*      acciones segun el tipo de respuesta
  96.             */
  97.             switch(datos['type'])
  98.             {
  99.                 /*      datos correctos
  100.                 */
  101.                 case 'data':
  102.                     /*      reescribimos la variable (asi no tener que acceder en modo array)
  103.                     */
  104.                     datos = datos['data'];
  105.                     console.log(datos);
  106.                    
  107.                     /*      verificar datos
  108.                     */
  109.                     switch(datos.length)
  110.                     {
  111.                         case 0:
  112.                             alert('no hay datos');
  113.                             break;
  114.                        
  115.                         case 25:
  116.                             alert('hay mas datos en la siguiente pagina');
  117.                             break;
  118.                        
  119.                         default:
  120.                             alert('ultima pagina');
  121.                     }
  122.                    
  123.                     /*      inicializar variables del loop de forma local
  124.                     */
  125.                     var html = '',
  126.                         resultado;
  127.                        
  128.                     /*
  129.                             Loop de datos, aqui es practicamente lo mismo que result = mysql_fetch_assoc() en php
  130.                            
  131.                             NOTA: no usare DOM, ya que le complicara la cabeza a mas de uno
  132.                     */
  133.                     for(var a in datos)
  134.                     {
  135.                         /*      result = mysql_fetch_assoc();
  136.                         */
  137.                         resultado = datos[a];
  138.                        
  139.                         /*      incluir datos al buffer
  140.                         */
  141.                         html += '<div>id ' + resultado['id'] + ' : ' + resultado['usuario'] + '</div>';
  142.                     }
  143.                    
  144.                     /*      datos del buffer al contenedor
  145.                     */
  146.                     document.getElementById('contenedor').innerHTML = html;
  147.                     break;
  148.                
  149.                
  150.                 /*      problemas con envios o errores de datos
  151.                 */
  152.                 case 'php':
  153.                     alert('error en php #' + datos['nro'] + ' , ' + datos['msg']);
  154.                     break;
  155.                
  156.                
  157.                 /*      problemas con mysql (revisar ejemplo_input.php);
  158.                 */
  159.                 case 'mysql':
  160.                     alert('error en mysql #' + datos['nro'] + ' , ' + datos['msg']);
  161.                     break;
  162.             }
  163.         },
  164.        
  165.        
  166.         /*      ocurrio un error durante la carga
  167.         */
  168.         onerror : function(text, status)
  169.         {
  170.             alert('error durante la carga, ('+ status + ') ' + text);
  171.         },
  172.        
  173.         /*      cargamos las variables post
  174.         */
  175.         post :
  176.         {
  177.             'pagina' : pagina
  178.         }
  179.     });
  180. }


/www/src/ajax.js (el controlador AJAX)

crea un objeto XMLHTTP y va poniendo datos en cola (esta es una librería muy vieja, la hice hace 3 años atrás aproximadamente)

Código Javascript:
Ver original
  1. var ajax = function()
  2. {
  3.     /*  se carga el objeto XMLHTTP
  4.     */
  5.     try
  6.     {
  7.         req = new XMLHttpRequest();
  8.     }
  9.     catch(err1)
  10.     {
  11.         /*      exepcion para IE
  12.         */
  13.         try
  14.         {
  15.             req = new ActiveXObject('Msself.xml2.XMLHTTP');
  16.         }
  17.         catch(err2)
  18.         {
  19.             try
  20.             {
  21.                 req = new ActiveXObject('Microsoft.XMLHTTP');
  22.             }
  23.             catch(err3)
  24.             {
  25.                 req = false; alert('ajax no soportado');
  26.             }
  27.         }
  28.     }
  29.    
  30.     /*      varuable interna de request
  31.     */
  32.     this.xml = req;
  33.    
  34.     /*      buffer de peticiones (request)
  35.     */
  36.     this.req = [];
  37. };
  38.  
  39. // prototipo (metodos)
  40. ajax.prototype =
  41. {
  42.     /*      funcion de carga / cola
  43.     */
  44.     load : function (object)
  45.     {
  46.         /*      se comprueba las variables post
  47.         */
  48.         if(!object.post){ object.post = {} }
  49.        
  50.         /*      se pone en cola el archivo
  51.         */
  52.         this.req.push
  53.         ({
  54.             url     : object.url,
  55.             onerror : object.onerror,
  56.             onload  : object.onload,
  57.             post    : object.post
  58.         });
  59.        
  60.         /*      se realiza un llamado al engine
  61.         */
  62.         this.engine();
  63.     },
  64.    
  65.    
  66.     /*      controlador del motor ajax
  67.     */
  68.     engine : function()
  69.     {
  70.         /*
  71.             se comprueba el estado de ajax
  72.             si esta "ocupado" no se ejecuta ninguna accion
  73.         */
  74.        
  75.         if(this.xml.readyState == 4 || this.xml.readyState == 0)
  76.         {
  77.             /*
  78.                     se carga el objeto actual,
  79.                     sirve para evitar problemas de contexto
  80.             */
  81.             var self    = this;
  82.            
  83.             /*      se carga la varliable de peticion
  84.             */
  85.             var request = this.req[0];
  86.            
  87.             /*      se abre la url
  88.             */
  89.             self.xml.open('POST', request.url, true);
  90.            
  91.             /*      se incluye el header para post
  92.             */
  93.             self.xml.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
  94.            
  95.             /*      se incluye la funcion para cambio de estado
  96.             */
  97.             self.xml.onreadystatechange = function()
  98.             {
  99.                 /*      si esta completado el proceso, se parsea la respuesta
  100.                 */
  101.                 if(self.xml.readyState == 4)
  102.                 {
  103.                     /*      try a catch para evitar que se interumpa su ejecucion
  104.                     */
  105.                     try
  106.                     {
  107.                         switch(self.xml.status)
  108.                         {
  109.                             case 200: // correcto
  110.                             case 304:
  111.                                 /*  llamar a la funcion de usuario "onload" y enviar el los datos
  112.                                 */
  113.                                 request.onload(self.xml.responseText, self.xml.status);
  114.                                 break;
  115.                                
  116.                             default:
  117.                                 /*
  118.                                         ocurrio un error durante la carga,
  119.                                         realizar un mensaje a consola y llamar a la funcion "onerror"
  120.                                 */
  121.                                 console.log('ajax error: ('+ self.xml.status +') ',self.xml.responseText);
  122.                                
  123.                                 /*      verificar si la funcion existe (no vacia)
  124.                                 */
  125.                                 if(request.onerror)
  126.                                 {
  127.                                     request.onerror(self.xml.responseText, self.xml.status)
  128.                                 }
  129.                         }
  130.                     }
  131.                     catch(e)
  132.                     {
  133.                         /*      ocurrio un error en request.onload o request.onerror
  134.                         */
  135.                         console.log(e);
  136.                         alert('error ajax:' + e.message);
  137.                     }
  138.                    
  139.                     /*      eliminar la peticion actual (ya fue procesada)
  140.                     */
  141.                     self.req.splice(0,1);
  142.                    
  143.                     /*      si hay mas datos en el buffer, se llama nuevamente a esta funcion
  144.                     */
  145.                     if(self.req.length > 0)
  146.                     {
  147.                         self.engine();
  148.                     }
  149.                 }
  150.             }
  151.            
  152.             /*      buffer the las variables post
  153.             */
  154.             var post_string = '';
  155.            
  156.             /*      se prepara y da formato a las variables
  157.             */
  158.             for(a in request.post)
  159.             {
  160.                 /*      evitar problemas con caracteres reservados
  161.                 */
  162.                 request.post[a] = encodeURIComponent(request.post[a]);
  163.                
  164.                 /*      se incrementa el buffer
  165.                 */
  166.                 post_string += (post_string != '' ? '&' : '') + a + '=' + request.post[a];
  167.             }
  168.            
  169.             /*      se envian los headers de la peticion
  170.             */
  171.             self.xml.send(post_string);
  172.         }
  173.     }
  174. }

ejemplo de uso

Código Javascript:
Ver original
  1. // inicializar cotrolador
  2. var conector = new ajax();
  3.  
  4. // se pone un pedido en cola
  5.  
  6. conector.load(
  7. {
  8.    // url a cargar
  9.    url : 'url',
  10.  
  11.    // función cuando la carga se completa
  12.    onload : function(texto_de_respuesta, estado)
  13.    {
  14.           // se ejecuta la funcion del pedido
  15.    },
  16.  
  17.    // función cuando ocurre un error
  18.    onerror : function(texto_de_repuesta, estado)
  19.    {
  20.          // codigo de exepcion
  21.    },
  22.  
  23.    // variables post
  24.    post :
  25.    {
  26.          'nombre de la variable' : 'contenido [string:int]'
  27.    }
  28. })

sigue....