• Flot: realizado puramente con Javascript utilizando jQuery, puedes interaccionar con los datos incluso ofrece la posibilidad de realizar zoom.

  

• Open Flash Chart: es una de las mejores opciones, tanto por el aspecto visual, como por la cantidad de clases disponibles en diferentes lenguajes, como son PHP, Perl, Python, Java, Ruby on Rails, y .Net; que posibilitan conectar con los gráficos.

  

• AmCharts: realizado con Flash, ofrece diferentes tipos de gráficos, todos ellos muy atractivos. Se pueden usar datos extraidos de ficheros XML, incluso se pueden leer datos generados dinamicamente con PHP, .NET, Java, Ruby on Rails, Perl y ColdFusion. Es complematemente gratuito siempre y cuando respetemos el link que incorporan en la parte superior de las tablas.

  

• Emprise Javascript Charts: para crear gráficas utilizando unicamente Javascript.

  

• Plotkit: otra solución Javascript perfectamente documentada, basada en la librería MochiKit.

  

• Flotr: éste script se basa en la librería prototype. Puedes hacer zooms, crear leyendas, soporte para valores negativos, etc.

  

• PHP/SFW Charts: como su propio nombre indica, para poder fusionar PHP con Flash. Realmente recomendable, además goza de un monton de gráficos diversos.

  

• Visfire: bastante simple, permite funcionar con ASP, ASP.Net, PHP, JSP, ColdFusion, Ruby on Rails o solamente HTML.

  

• FusionCharts: funciona de manera equivalente a Visfire.

  

• JFreeCharts: el último scriot puede resultar muy interesante, puesto que funciona con Java, de forma que cualquier programador pueda mostrar sus gráficas en unos sencillos pasos. Una joya para los desarrolladores en Java.

  

Fuente: Informatica Practica

Una función muy útil en estos casos es strip_tags

Si quisiéramos por ejemplo que los usuarios de nuestra web dejen sus comentarios en un articulo por medio de un formulario, deberíamos aplicar esta función a los datos ingresados para poder mostrarlos en nuestra web. Este sería un ejemplo:

<?php
$texto=strip_tags($texto);
?>

Cabe destacar que la función strip_tags elimina también el código HTML por lo que no permitirá dar ningún tipo de formato a los datos ingresados. Si quisiéramos darle la posibilidad al usuario de utilizar alguna etiqueta, la función cuenta con un argumento mediante el cual se especifica la o las etiquetas permitidas:

<?php
     $texto=strip_tags($texto, ‘<b>’);
?>

Pero hay que tener mucho cuidado con esto (Como lo advierte uno de los warnings de la página oficial de PHP) porque esta función no elimina el código incluido dentro de los atributos de las etiquetas permitidas, por lo que si el usuario introduce algo como esto:

<b onmouseover=”<script>alert(’XSS’)</script>”>Texto en Negrita</b>

El resultado, luego de que los datos pasen por la función y sean incluidos en una página web, sería el ya clásico:

Por lo que para solucionar esto, deberiamos aplicar la función preg_replace. El script quedaría de la siguiente forma:

<?php
     $texto=strip_tags($texto, ‘<b>’);
     $texto=preg_replace(’/<(.*)\s+ (\w+=.*?)>’, ”, $texto);
?>

Con esto solucionariamos el “pequeño” bug de la función strip_tags.

Otra opción (muy utilizada en scripts de foros) es la de permitir un pseudocodigo (por ejemplo BBCode) que luego es reemplazado por las etiquetas HTML verdaderas:

Si el usuario ingresara lo siguiente:

[b]Negrita[/b]

Reemplazariamos el BBCode por HTML para mostrarlo en pantalla (utilizando la función str_replace) y el resultado podríamos incluirlo en una página sin correr ningún riesgo:

<?php
     $texto=strip_tags($texto);
     $texto=str_replace(’[b]’,'<b>’);
     $texto=str_replace(’[/b]’,'</b>’);
?>

Existen varios tipos de ataques que explotan la vulnerabilidad XSS, por lo que recominedo investigarla mucho mas a fondo.

Fuente: http://www.codigo200.com/previniendo-ataques-xss-con-php

1. Si un método puede ser static, decláralo estático. La velocidad se incrementa en un factor de 4.
2. echo es más rápido que print, aunque la diferencia es despreciable.
3. Inicializa el contador de tus bucles for antes y no en el propio bucle.
4. Si tienes que iterar un objeto o un array, utiliza SPL en lugar de bucles recursivos.
5. Destruye las variables que ya no utilices con unset() para liberar memoria, especialmente si son objetos o arrays pesados. Si utilizas OOP, revisa el destructor __destruct() en este sentido.
6. Si tienes que recorrer un array enorme y no te interesa guardarlo, considera utilizar array_shift() para ir leyendo y borrando a la vez.
7. No abuses de __get(), __set() y __autoload().
8. require_once() es pesado. Muy pesado en PHP < 5.0.
9. Utiliza paths absolutos a los ficheros en los include() y require(), el SO tarda menos en resolver las rutas al fichero.
10. Si necesitas saber el timestamp de acceso a un script, considera utilizar $_SERVER['REQUEST_TIME'] en lugar de time()
11. Comprueba si puedes usar strncasecmp(), strpbrk() y stripos() en lugar de expresiones regulares.
12. str_replace() es más rápido que preg_replace(), pero strtr() es hasta 4 veces más rápido que str_replace().
13. Si la función, como la función de reemplazo de cadenas, acepta dos arrays y un carácter como argumentos, y tu lista de argumentos no es muy larga, considera escribir varias sentencias de reemplazo redundantes, pasando un carácter cada vez, en lugar de una linea de código que acepte arrays como búsqueda y reemplazo.
14. La supresión de errores con @ es bastante ineficiente a la par que desaconsejable.
15. eval() is evil (y además horrorosamente lento).
16. $row['id'] es hasta 7 veces más rápido que $row[id]
17. Si una variable de clase es constante, utiliza const.
18. Los mensajes de error son ineficientes, utilizalos sólo cuando sea necesario.
19. No uses funciones dentro de los bucles, como for ($x=0; $x < count($array); $x++). La función count() se ejecuta cada vez que se repita el bucle.
20. Incrementar una variable local en un método es lo más rápido. Casi lo mismo que llamar a una variable local en una función.
21. Incrementar una variable global es dos veces más lento que hacerlo con una variable local.
22. Incrementar una propiedad de un objeto (por ejemplo $this->prop++) es 3 veces más lento que hacerlo sobre una variable local.
23. Incrementar una variable indefinida es hasta 10 veces más lento que hacerlo en una ya inicializada.
24. Declarar una variable global sin utilizarla también enlentece la ejecución. PHP comprueba si existe.
25. La cantidad de métodos definidos en una clase no afecta al rendimiento.
26. Los métodos de la clase concreta se ejecutan más rápidos que los de la clase base.
27. $localvar++ es hasta 15 veces más rápido que function inc(){ $localvar++; }.
28. Las cadenas encerradas entre comillas simples son más rápidas que las que lo están con comillas dobles porque PHP no expande las variables que puedan contener. Si usas PHP 5+, la diferencia es mínima.
29. Cuando se aplica echo a una lista de cadenas por argumento, es más rápido separarlas con una coma (,) en lugar del operador de concatenación (.). Esto sólo funciona con echo por ser una construcción del lenguaje y no una función.
30. Un script PHP es servido por Apache entre 2 y 10 veces más lento que una página estática. Cachea resultados cuando sea posible.
31. Los scripts PHP se “compilan” cada vez que son ejecutados a menos que se guarde el código objeto en un cache. Las diferentes herramientas de compilación de PHP incrementan el rendimiento hasta un 100%.
32. Puestos a cachear, Memcached es mucho más rápido y versátil que un cache a disco. APC también da buen resultado pero es menos escalable.
33. Usa ip2long() y long2ip() para almacenar direcciones IP como números en lugar de como cadenas. Reduce el espaco en un factor de 4 y los cálculos de rango, máscara y ordenaciones son más sencillos y rápidos.
34. Usa la extensión SOAP nativa en lugar de NuSOAP.
35. Valida las direcciones de correo electrónico con checkdnsrr().
36. php_filter() mejor y más rápido que tu sistema home made de validación.
37. Las funciones mysql_* son más lentas que mysqli_*, pero no tan eficientes como el driver mysqlnd para PDO (disponible en el inminente PHP 5.3)
38. Usa sentencias preparadas, en lugar de concatenar las consultas a mano, para mejorar el rendimiento y frenar significativamente las SQL-Injections. ( y Matt puede decir misa, hacedme caso a mi )
39. No reinventes la rueda, mira a ver si puedes aprovechar algo de PEAR, PECL, SourceForge, CakePHP, CodeIgniter, Zend Framework, …
40. Utiliza highlight_file() para postear código formateado y bonito en los foros (por favor!!).
41. Si guardas un objeto o array serializado en la base de datos, considera usar gzcompress() y gzuncompress() para ahorrar espacio. GZip puede reducir el tamaño de un texto plano hasta en un 90%.
42. El operador ternario no es más rápido que un if-else.
43. empty() es más rápido que $var == '', pero es más rápido el operador identidad $var === ''. En general la identidad es más rápida en cualquier situación.
44. do-while es más rápido que while, pero más lento que for. Lo primero a optimizar de un programa son los bucles ( un viejo truco de Algoritmia y Arquitectura de computadores )
45. Si necesitas determinar si una cadena tiene un cierto tamaño, es más rápido utilizar la construcción del lenguaje !isset($str{5}) que la función strlen($str) < 5
46. el preincremento ++$i es más rápido que el postincremento $i++ debido a interioridades del interprete de Zend, de echo es una de las optimizaciones a nivel de OPCODE más utilizadas por los compiladores de PHP.
47. Usa preg_* en lugar de ereg_*, está a punto de desaparecer y es mucho más lento.
48. Usa direcciones IP en lugar de nombres de dominio.
49. El manejador de flujos ob_start() puede aumentar el rendimiento hasta en un 25%.
50. El paso de argumentos por referencia en PHP no es igual al paso de una referencia en C mediante un puntero. En PHP una referencia sirve para acceder a una variable mediante dos nombres distintos (nombre de variable y valor de la variable son cosas distintas en PHP). Por tanto pasar arrays por referencia como en C, en realidad, es más lento que hacerlo por valor. En PHP 5+ los objetos se pasan explícitamente por referencia.
51. Un uso apropiado de las referencias como alias de nombre de variable:

     

    1.  

    2. $a[‘b’][‘c’] = array();

    3. // 2 accesos por iteración a la tabla hash

    4. // donde PHP almacena las variables

    5. for($i = 0; $i < 5; $i++)

    6. $a[‘b’][‘c’][$i] = $i;

    7.  

    8.  

    9. // con un alias por referencia es mas rápido

    10. $ref =& $a[‘b’][‘c’];

    11. for($i = 0; $i < 5; $i++)

    12. $ref[$i] = $i;

    13.  

52. La manera más rápida a este lado de Rio Grande para detectar si el SO es Unix o no es utilizar la constante DIRECTORY_SEPARATOR.
53. La manera más rápida de concatenar muchas cadenas de poco tamaño es abrir un flujo de salida con ob_start() y hacer un echo de todas ellas para despues recoger la cadena final con ob_get_contents(). Esto es así porque en el tratamiento de cadenas el factor limitante es la reserva de memoria y al crear un flujo se reservan de golpe 40K, aumentando en pedazos de 10K cuando hace falta más.
54. En las sentencias switch() ordena los casos empezando por los más frecuentes.
55. Procesar ficheros XML con expresiones regulares es más rápido que hacerlo con SAX o DOM. Atención: el uso de expresiones regulares para procesar XMl puede acortar significativamente su esperanza de vida.
56. Eliminar los comentarios o escribir en una sola linea no hace que se ejecute más rápido, lo único que consigues es que los demás te odien a muerte.
57. Usar objetos no hace que todo sea más rápido, más bien al contrario, pero utilizarlos mejora otras muchas cosas.
58. Cuanto menos (x)HTML en la salida del script, más rápido renderiza la pagina.
59. Utiliza constantes en lugar de funciones: PHP_VERSION vs. php_version(), PHP_OS vs. php_uname(), PHP_SAPI vs. php_sapi_name(), etc.
60. Si todo lo demás falla … escribe una extensión en C.

Conclusión: no prestes mucha atención a todo esto; dependiendo de la carga y la máquina, algunas optimizaciones apenas van a ser apreciables por el usuario final. Sólo con cambiar los while por do-while no va a hacer que tu programa corra como el viento, cuanto mejor conozcas tu stack de software y los entresijos de la aplicación más profundas serán las mejoras que puedas aplicar.

Vamos con un pequeño truco que nos ofrece una de las funciones de PHP, que sirve para mostrar código resaltado con colores. Es una función útil para mostrar en la salida un trozo de código PHP, pero con distintos colores y saltos de línea, lo que facilita su lectura.

PHP incorpora unos patrones para resaltar texto con código PHP, en distintos colores. Este se puede invocar con la función highlight_file(), que recibe dos parámetros:

- Primero, el nombre del archivo que queremos que muestre su código resaltado
- Segundo, un parámetro opcional que es un boleano, con valor por defecto FALSE. El valor verdadero o TRUE significa que queremos que nos devuelva un string con el código resaltado. El valor falso o FALSE, que es el comportamiento predeterminado, sirve para que nos muestre en la salida el código PHP formateado y con colores.

Esta función puede ser útil en páginas de tutoriales de PHP, para mostrar código resaltado con colores sin tener que complicarnos la vida, así como en la documentación de programas realizados con PHP.

Para ver la función en marcha es muy sencillo. Simplemente tenemos que llamarla así:

Código:

<?
highlight_file ("fichero.php");
?>

Se supone que "fichero.php" estará en el mismo directorio donde está el archivo PHP con el que estamos trabajando.

Si fichero.php tuviera un código como este, resaltaria el código php:

Código:

<html>
  <head>
     <title>Probando</title>
  </head>

   <body>

      <h1>Hola amigos</h1>

      <p>Esto es una <b>prueba</b> para ver como funciona</p>

   <?

   function tiene_acentos($cadena){

   $buscar = "áéíóúüÁÉÍÓÚÜñÑ";

   for ($i=0; $i<strlen($cadena); $i++){

      if (strpos($buscar, substr($cadena,$i,1))!==false)

         return true;

      }

      return false;

   }

   ?>

   </body>
</html>

Fuente: http://desarrolloweb.com/articulos/codigo-php-resaltado.html Copyleft

En este ejemplo vamos a hacer un sistema para llevar la cuenta de las páginas que ha visto un visitante. Es decir, si entra a una página del sitio por primera vez, contamos que ha visto una página, luego con cada página adicional que visite, seguiremos acumulando 1 en la cuenta de páginas vistas dentro del sitio. Del mismo modo, si se recarga una página o se vuelve a la misma página que ya se estuvo, también haremos que se acumule 1 en su cuenta.

Lo que tendremos que hacer en este ejercicio es lo siguiente:

• Inicializar la sesión
• Si no tenemos el contador de páginas creado, lo inicializamos al valor 1
• Si tenemos el contador de páginas creado, lo incrementamos en 1.

Código:

<?php

if (!isset($_SESSION["cuenta_paginas"])){
   $_SESSION["cuenta_paginas"] = 1;
} else {
   $_SESSION["cuenta_paginas"]++;
}

echo "Desde que entraste has visto " . $_SESSION["cuenta_paginas"] . " páginas";
?>
<a href="otracuenta.php">Ver otra página</a>

Como se ha podido ver, lo primero que debemos hacer es inicializar la sesión con session_start().

Luego de inicializar la sesión podemos trabajar con variables de sesión en cualquier lugar del código PHP. Nosotros vamos a crear y utilizar una variable de sesión para llevar la cuenta del número de páginas que hemos visto.

Código:

$_SESSION["cuenta_paginas"]

Para ver si una variable de sesión ha sido creada podemos utilizar la función isset() pasándole como parámetro la variable que deseamos saber si ha sido creada. Si no fue creada anteriormente, simplemente la creamos (inicializando su valor a 1). Si fue creada, pues que tenemos que incrementar en 1. Eso se consigue con este código:

Código:

if (!isset($_SESSION["cuenta_paginas"])){
   $_SESSION["cuenta_paginas"] = 1;
} else {
   $_SESSION["cuenta_paginas"]++;
}

Eso es todo! Ahora lo que se supone que tenemos son otras páginas en el mismo sitio que también tienen que incrementar en 1 el contador de páginas vistas por ese usuario en esa sesión.

Eso lo podríamos hacer con el mismo trozo de código, como el que hemos visto antes, colocado al principio del archivo PHP.

Código:

if (!isset($_SESSION["cuenta_paginas"])){
   $_SESSION["cuenta_paginas"] = 1;
} else {
   $_SESSION["cuenta_paginas"]++;
}

?>

Luego, en cualquier momento, si deseamos mostrar el número de páginas vistas en un momento dado, tendríamos que hacer algo como esto:

Código:

<?

   echo "Has visto " . $_SESSION["cuenta_paginas"] . " páginas, contando actualizaciones de paginas";

?>

Podemos ver el ejemplo relatado en funcionamiento.

Fuente: http://www.desarrolloweb.com/articulos/235.php Copyleft

Algunos códigos, lo que hacen es crear una segunda imagen, mas pequeña, lo cual ayuda a mejorar la carga de la web, pero aumenta el espacio que ocupara en el servidor.

Aquí os traigo un código, que nos ayudara a tratar este tema, el cual no crea ninguna segunda copia de nuestra imagen, este código, hace que el servidor redimensione nuestra imagen, creando una nueva en memoria, que sera la que nos muestre en la web, con esto conseguimos una navegación rápida porque nos mostrara la imagen al tamaño que elijamos y el espacio utilizado sera el mismo porque la imagen la creara en la memoria.

Código:

<?php   

  $anchura=basename($_GET['ancho']);
  $hmax=basename($_GET['alto']);
  $nombre=basename($_GET['imagen']);
  $datos = getimagesize($nombre);
  if($datos[2]==1){$img = @imagecreatefromgif($nombre);}
  if($datos[2]==2){$img = @imagecreatefromjpeg($nombre);}
  if($datos[2]==3){$img = @imagecreatefrompng($nombre);}
  $ratio = ($datos[0] / $anchura);
  $altura = ($datos[1] / $ratio);
  if($altura>$hmax){$anchura2=$hmax*$anchura/$altura;$altura=$hmax;$anchura=$anchura2;}
  $thumb = imagecreatetruecolor($anchura,$altura);
  imagecopyresampled($thumb, $img, 0, 0, 0, 0, $anchura, $altura, $datos[0], $datos[1]);
  if($datos[2]==1){header("Content-type: image/gif"); imagegif($thumb);}
  if($datos[2]==2){header("Content-type: image/jpeg");imagejpeg($thumb);}
  if($datos[2]==3){header("Content-type: image/png");imagepng($thumb); }
  imagedestroy($thumb);     

?>

Guardaremos el código en un archivo que llamaremos redimensionar.php y lo pondremos en la carpeta donde vamos a coger las imagenes que queremos redimensionar.

Supongamos que las imagenes se encuentran en una carpeta llamada "img" que esta en el directorio raíz, una vez guardado el archivo redimensionar.php en la carpeta "img" junto a las imagenes, crearemos nuestra pagina php y donde queramos mostar la imagen pondremos lo siguente:

Código:

<?php
	$Nombre = "nombre.jpg";
	$Ancho = "150";
	$Alto = "300";
	$Titulo = "Titulo";   

   echo "<img src='img/" . "redimensionar.php?imagen=". $Nombre ."&ancho=". $Ancho ."&alto=". $Alto '." title='". $Titulo ."' >";
?>

El nombre de la imagen, el ancho y el alto, son los datos que se proporcionan, para redimensionar la imagen, esta la creara proporcionalmente, no creara la imagen con las medidas de altura y anchura indicadas, sino que introducirá la foto de forma que nunca salga de esas medidas, por ejemplo:

Una foto de 800x600 le indicamos que queremos que el alto sea de 600 y el ancho 600, el resultado sera una imagen de 600x450 y si la foto es de 600x800 nos dara una foto de 450x600.

Dentro de una página Web hecha con HTML le incluimos el siguiente SCRIPT:

Código:

<?php    

   echo "Hola Mundo";    

?>

Esto enviará como resultado al navegador lo siguiente:

Hola Mundo

Lo increíble de esto es que jamás mostrará el código del programa... sólo enviará la respuesta del programa después de procesada.

Creo que ya comprendes entonces que es lo que hace PHP, si hacemos volar la imaginación te darás cuenta la amplia cantidad de aplicaciones que le podemos dar a este poder... manipular fechas y tiempos, manipular bases de datos, realizar cálculos matemáticos, personalizar las presentaciones según lo deseemos, etc.

Por lo pronto, comencemos con la sintaxis de este lenguaje y para ello analicemos el siguiente SCRIPT:

Código:

<?php    

   $MYVAR = "1234";    

   $myvar = "4321";   echo $MYVAR. "";    

   echo $myvar. "";    

?>

Esto dará como resultado:

1234
4321

Lo primero que vemos en este SCRIPT es que las instrucciones de PHP comienzan con por lo que incluso se pueden crear varios conjuntos de instrucciones dentro de una misma pagina Web. Lo siguiente que observamos es que las variables comienzan con el símbolo $ y que se diferencian las mayúsculas de las minúsculas, es decir, son sensible case. Las etiquetas
están concatenadas por un punto "." con lo que el navegador hará una salto de línea, y por último notarás que todas las lineas de comandos terminan con punto y coma ";" , esto es muy importante de no olvidar.

Pero veamos ahora un ejemplo más complejo aún:
Código:

<?php    

   $SUM1 = 12;    

   $SUM2 = 4;    

   $TOT = $SUM1 + $SUM2;    

   echo "La sumatoria de " . $SUM1. " más " .$SUM2. " es igual a " .$TOT";    

   // Este programa realiza la suma de 12 + 4 y lo presenta en pantalla    

?>

Creo que esto no necesita mucha explicación, como es fácil ver lo que este pequeño programa hace es: declarar el contenido de la primera variable, declarar el contenido de la segunda variable, realizar la suma de ambas variables y asignarla a una nueva variable, y por último realiza la salida del resultado pero incluyendo texto para hacer más fácil la interpretación del mismo. Veremos como resultado en pantalla:

La sumatoria de 12 más 4 es igual a 16

Notemos que para poder hacer la mezcla de variables con texto hemos recurrido a la concatenación y esto se hace interponiendo un punto ".". Podemos observar también que hay un comentario dentro del SCRIPT, este comentario no afectará en nada al programa pero es importante acostumbrar usarlos para mantener organizados nuestro programa y no confundirnos en un programa más extenso.

Existen varias formas de incluir comentarios y estas son:

Código:

<?php    

   // Esto da comienzo a una línea con comentarios.    

   // Esto es un comentario   /* Esto da comienzo a un grupo de líneas de comentario, se cierra con */    

   /* Esto es un comentario    

       que incluye varias líneas.    

       Es por eso que uso este tipo de inclusión. */    

?>

Con esto hemos explicado brevemente como se pueden manipular y mostrar datos desde php de forma facil y sencilla, mas adelante pondremos algun ejemplo de como realizar conexiones a bases de datos MySQL.