Tengo este listado desde hace un tiempo y aunque quizás le falte un poco de actualización, no viene mal tenerlo en cuenta.

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.
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
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:

$a['b']['c'] = array();
// 2 accesos por iteración a la tabla hash
// donde PHP almacena las variables
for($i = 0; $i <5; $i++)
$a['b']['c'][$i] = $i;
// con un alias por referencia es mas rápido
$ref =& $a['b']['c'];
for($i = 0; $i < 5; $i++)
$ref[$i] = $i;

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 cedena 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.

Leyendo sobre GD para un proyectito que tengo que hacer, di con esta funcion imagerotate(). Seguramente es muy conocida, pero nunca la habia utilizado. Como su nombre lo indica, lo que hace es rotar una imagen, en la cantidad de grados que le pasemos.

    // Imagen que se va a rotar
    $imagen = 'imagen.jpg';

    // Grados de rotacion
    $grados = 180;

    // Cabeceras
    header('Content-type: image/jpeg') ;

    // Crear el canvas
    $source = imagecreatefromjpeg($imagen) ;

    // Rotar usando imagerotate
    $img_rotada = imagerotate($source, $grados, 0) ;

    // Salida de la imagen
    imagejpeg($img_rotada) ;
    

Leyendo el muy buen blog de david walsh, di con este pequeño ejemplo para ir previsualizando el texto que vamos introduciendo en un formulario. Muy lindo para agregarlo a nuestros fomularios de comentarios.

Demo: http://davidwalsh.name/dw-content/jquery-live-preview.php

Codigo: http://davidwalsh.name/jquery-comment-preview

Este tutorial describe las distintas formas que pueden utilizarse conectar a
una pagina externa usando PHP o mostrar una pagina externa a través de
PHP.

Aqui hay una pequeña información de como lograrlo con diferentes
metodos.  Si alguien desea añadir al tema, mostrando otro método es bienvenido.  Lo estoy haciendo porque me vi en la necesidad de estudiar sobre el tema para unas aplicaciones en el trabajo y creo que será útil para muchos que deseamos aprender sobre el tema.

Hay varias maneras de mostrar un URL remoto en PHP. La elección de un
método sobre otro depende de las necesidades de su simplicidad, control y portabilidad.

Los tres métodos descritos en este post son los estándares file function, la extensión
cURL, y la clase de PEAR HTTP_Request.

Estos tres métodos pueden generalmente hacer todo lo que necesita y por lo menos uno de ellos deben estar disponibles, sea cual sea su configuración del servidor o capacidad de instalar las extensiones personalizadas.

Otras formas de recuperar las URL remotas incluye la extensión pecl_http (http://pecl.php.net/package/pecl_http),
que, aunque todavía en desarrollo, ofrece algunas características prometedoras,
y utilizando el fsockopen() para abrir un zócalo sobre el que envía una petición
HTTP que lo construye pieza por pieza.

El uso del estandar “file function” como la función file_get_contents() es
simple y conveniente.

Sigue automáticamente las redirecciones, así que si utiliza esta función para recuperar el directorio

http://www.example.com/persona/ y el servidor le redirecciona a

http://www.example.com/people/, obtendrá el contenido de la página de índice
de directorio, no un mensaje que le dice que la URL ha cambiado de dirección.

También las funciones de archivo estándar de trabajo tanto con HTTP y FTP.

El  inconveniente de este método es que requiere la directiva de configuración
allow_url_fopen a estar activado.

La extensión CURL es una poderosa herramienta.  Se basa en el popular libcurl (http://curl.haxx.se/)
para proporcionar un rápido, configurable mecanismo para el manejo de una amplia
variedad de peticiones de red. Si esta extensión está disponible en su servidor, le recomendamos que utilice.

Si se desactiva allow_url_fopen y cURL no está disponible, el módulo
PEAR HTTP_Request salva el día.

Al igual que todos los módulos de PEAR, es puro PHP, por lo que si puede guardar un archivo PHP en su servidor, puede utilizarlo. HTTP_Request soporta casi cualquier cosa que te gustaría hacer cuando se solicite una URL remota, incluyendo la modificación de cabeceras de
petición y el cuerpo, utilizando un método arbitrario, respuesta y recuperación
de los encabezados.

Para mas información sobre como instalar los modulo de PEAR puedes ir a

http://pear.php.net/manual/en/installation.getting.php

Para recibir información de URL seguras, solo escribe https en vez de http.

Siempre y cuando en PHP haya sido construido en una libreria SSL tal como OpenSSL, todas las funciones que pueden recibir información de URL regulares pueden recibir información de URL seguras.

Verifica la sección de “openssl” en la salida de phpinfo() para ver si tu configuración
de php tiene soporte de SSL.

Aquí hay varios ejemplos de lo que se puede hacer con los 3 métodos.

Obteniendo una URL con file_get_contents()

      $page = file_get_contents('http://www.example.com/algo.txt');
      echo $page;

Obteniendo una URL con cURL

      $c = curl_init('http://www.example.com/algo.txt');
      curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
      $page = curl_exec($c);
      curl_close($c);
      echo $page;

Obteniendo una URL con HTTP_Request

sendRequest();
      $page = $r->getResponseBody();
      echo $page;

Mostrar una pagina protegida con file_get_contents()

      $url = 'http://FDW:PASS@www.example.com/proyecto.php';
      $page = file_get_contents($url);
      echo $page;

Mostrar una pagina protegida con cURL

      $c = curl_init('http://www.example.com/proyecto.php');
      curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
      curl_setopt($c, CURLOPT_USERPWD, 'FDW:PASS');
      $page = curl_exec($c);
      curl_close($c);
      echo $page;

Mostrar una pagina protegida con HTTP_Request

     setBasicAuth('FDW','PASS');
      $r->sendRequest();
      $page = $r->getResponseBody();
      echo $page;

Enviar por el método de POST requiere de manejo especial en cada argumento. Con el método de GET, estos argumentos están en la cadena de consulta, pero en un POST van en la solicitud cuerpo.

Además, la solicitud necesita una cabecera Content-Length que le dice al servidor el tamaño del contenido a esperar en la solicitud cuerpo.

Mostrar una dirección URL con el método de POST en vez del metdo de GET es bien útil cuando la cadena es muy larga, más de 200 caracteres aproximadamente.

La especificación de HTTP 1.1 en el RFC 2616 no impone una longitud máxima en las
URL, por lo que el comportamiento varía entre las diferentes web y servidores proxy.

Si al mostrar las URL con GET y recibes resultados inesperados o resultados con el código de estado 414 ( “Request-URI Too Long”), convierte la solicitud al método de POST.

Usar el metodo de POST con file_get_contents()

      $url = 'http://www.example.com/submit.php';
      $body = 'FDW=programacion&PHP=f18';
      $options = array('method' => 'POST', 'content' => $body);
      $context = stream_context_create(array('http' => $options));
      $page = file_get_contents($url, false, $context);
      echo $page;

Usar el metodo de POST con cURL

$url = 'http://www.example.com/submit.php';
$body = 'FDW=programacion&PHP=f18';
$c = curl_init($url);
curl_setopt($c, CURLOPT_POST, true);
curl_setopt($c, CURLOPT_POSTFIELDS, $body);
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

Usar el metodo de POST con HTTP_Request

setMethod(HTTP_REQUEST_METHOD_POST);
      $r->addPostData('FDW','programacion');
      $r->addPostData('PHP','f18');
      $r->sendRequest();
      $page = $r->getResponseBody();
      echo $page;

Las cookies se envían al servidor en el encabezado de solicitud de cookies. La extensión cURL tiene una opción específica en cookies, pero con HTTP_Request, tienes que agregar el encabezado de cookies al igual que con otras cabeceras de petición.

Los valores de Cookie múltiples se envían en una lista delimitada por coma.
En los ejemplos vamos a enviar dos cookies: una con el nombre de user y con el valor FDW y otra con el nombre de actividad y con el valor de programacion.

Enviar cookies con file_get_contents()

$options = array('http' =>
          array(
              'method'  => 'GET',
              'header'  => 'Content-type: text/plain;charset=UTF-8\r\n'.
              'Referer: http://www.forosdelweb.com\r\n'.
              'User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; es-ES; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6\r\n'.
              'Cookie: user=FDW; actividad=programacion;\r\n'
          )
      );
      $context = stream_context_create($options);
      $page = file_get_contents('http://www.example.com/needs-cookies.php', false, $context);
      echo $page;

Enviar cookies con cURL

$c = curl_init('http://www.example.com/needs-cookies.php');
curl_setopt($c, CURLOPT_COOKIE, 'user=FDW; actividad=programacion');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);
echo $page;

Enviar cookies con HTTP_Request

      addHeader('Cookie','user=FDW; actividad=programacion');
      $r->sendRequest();
      $page = $r->getResponseBody();
      echo $page;

Seguir redireccionamientos con file_get_contents()
Nota: El file_get_contents() sigue automáticamente las redirecciones (header(“Location: redireccion.php”)).

$url = 'http://www.example.com/redirector.php';
print file_get_contents($url);

Seguir redireccionamientos con cURL

$c = curl_init('http://www.example.com/redirector.php');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_FOLLOWLOCATION, true);
$page = curl_exec($c);
curl_close($c);

Seguir redireccionamientos con HTTP_Client

Nota: HTTP_request no sigue las redirecciones, pero el módulo de PEAR HTTP_Client logra lo que queremos.

 get($url);
      $response = $client->currentResponse();
      print $response['body'];
 

Como hemos indicado anteriormente el file_get_contents() sigue automáticamente las redirecciones (header(“Location: redireccion.php”)).

A partir de PHP 5.0.0, file_get_contents() y fopen() nos da unas opciones especificas acerca de como obtener el stream. En PHP 5.1.0 y posteriores, una de esas opciones es max_redirects el número máximo de redirecciones a seguir. Si indicamos el max_redirects a 0 o 1, solo hace una solicitud.

El max_redirects realmente no indica el número de redirecciones deben seguirse, pero el número máximo de solicitudes que deben efectuarse en el momento siguiente a la cadena de redireccionamiento. Es decir, un valor de 1 le dice a PHP que al menos una solicitud debe seguir, y no un redireccionamiento. Un valor de 2 le dice a PHP para que al menos de 2 solicitudes deben seguir y no más de 1 redireccionamiento. (Un valor de 0, sin embargo, se comporta como un valor de 1, PHP hace sólo 1 solicitud.)

No seguir redirecciones con file_get_contents()

$context = stream_context_create(array('http' => $options));
print file_get_contents($url, false, $context);

No seguir redirecciones con cURL
Nota: Para no seguir las redirecciones no uses CURLOPT_FOLLOWLOCATION

$c = curl_init('http://www.example.com/redirector.php');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
$page = curl_exec($c);
curl_close($c);

No seguir redirecciones con HTTP_Request
Nota: HTTP_Request no sigue redirecciones

 sendRequest();
  print $r->getResponseBody();

Si quieres obtener una URL remota, pero no quieres esperar demasiado tiempo si el servidor remoto está ocupado o lento.

Configurar tiempo limite con file_get_contents()
Nota: Estableceremos el tiempo limite a 15 segundos

ini_set('default_socket_timeout', 15);
$page = file_get_contents('http://slow.example.com/');
 

Configurar tiempo limite con cURL
Nota: Estableceremos el tiempo limite a 15 segundos

$c = curl_init('http://slow.example.com/');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_CONNECTTIMEOUT, 15);
$page = curl_exec($c);
curl_close($c);
 

Configurar tiempo limite con HTTP_Request
Nota: Estableceremos el tiempo limite a 15 segundos

    $req = new HTTP_Request('http://slow.example.com/', $opts);
    $req->sendRequest();
 

Si dependes de un servicio remoto, puede estar funcionando y en marcha, pero no estará en condiciones de manejar sus pedidos debido a problemas de red entre tu servidor y el servidor remoto. Limitar la cantidad de tiempo que espera de
PHP para conectar a un servidor remoto es una buena idea, si se utilizan datos procedentes de fuentes remotas que sea parte del proceso de construcción de la página.

Todas las técnicas que describiremos limita la cantidad de tiempo de espera de PHP para conectar a un servidor remoto. Si estas realmente preocupado por las respuestas rápidas, adicionalmente configura el límite de cuánto tiempo
PHP espera recibir los datos de los zócalos conectados.

Para una conexión stream, utilice la función de stream_set_timeout(). Para esta función necesitas abrir un stream con fopen() y no con file_get_contents(). En los ejemplo limitaremos el tiempo de leer a 20 segundos.

Aunque el establecimiento de conexión y los tiempos de lectura puede mejorar el rendimiento, también puede dar lugar a respuestas ilegibles. La secuencia de comandos puede leer sólo una respuesta parcial ante un tiempo de expiración.

Si ha establecido los tiempos, asegúrese de validar toda la respuesta que ha recibido. Por otra parte, en situaciones en las que la generación de la página rápido es fundamental, puedes recuperar los datos externos en un proceso separado y escribir a una memoria caché local.

De esta forma, sus páginas pueden usar el caché, sin temor a límites de tiempo o respuestas parciales

Configurar el tiempo de leer con fopen()

$url = 'http://slow.example.com';
$stream = fopen($url, 'r');
stream_set_timeout($stream, 20);
$response_body = stream_get_contents($stream);

Configurar el tiempo de leer con cURL

$c = curl_init('http://slow.example.com/');
curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
curl_setopt($c, CURLOPT_CONNECTTIMEOUT, 15);
curl_setopt($c, CURLOPT_TIMEOUT, 20);
$page = curl_exec($c);
curl_close($c);

Configurar el tiempo de leer con HTTP_Request

require_once 'HTTP/Request.php';
$opts = array('readTimeout' => array(20,0));
$req = new HTTP_Request('http://slow.example.com/', $opts);
$req->sendRequest()

Para mostrar una página que incluye variables de cadena en la consulta, puedes hacer uso de
http_build_query() para crear la cadena de consulta. Se acepta una serie de clave/valor en pares y devuelve una única cadena con todo escapado correctamente. Usted es responsable del simbolo de ? en el URL que establecen la consulta.

Ejemplo con file_get_contents()

$vars = array('FDW' => 4, 'Programación' => 'PHP & f18');
$qs = http_build_query($vars);
$url = 'http://www.example.com/search.php?' . $qs;
$page = file_get_contents($url);

Ya hemos visto como obtener información de otros servidores. Si deseas manejar la informacion en vez de imprimirlo directamente en la pagina lo pasas a una variable y luego lo puedes manejar. Ejemplo de un codigo que desea mostrar en la pagina el resultado de las palabras que buscas pero que estén destacadas (“highlighted”).

$body = '

Me gusta mucho la programación de PHP.

Deseas saber sobre programación de PHP.
Yo deseo aprender sobre file_get_contents(), cURL y HTTP_Request.
¡cURL no es una etiqueta de HTML!';

$words = array('PHP','cURL');
$replacements = array();

foreach ($words as $i => $word) {
    $replacements[] = "$word";
}

$parts = preg_split("{(< (?:\"[^\"]*\"|'[^']*'|[^'\">])*>)}", $body, -1,
PREG_SPLIT_DELIM_CAPTURE);

foreach ($parts as $i => $part) {

    if (isset($part[0]) && ($part[0] == '< ')) { continue; }
    $parts[$i] = str_replace($words, $replacements, $part);
}
$body = implode('',$parts);
print $body;

$body representa el resultado que hayamos obtenido usando uno de los métodos que hemos usado.

Para poder manipular los links de lo que hayamos obtenido usando cualquiera de los metodos mencionados podemos usar este codigo.

En este caso usare file_get_contents()

$html = file_get_contents('http://www.example.com/');
function extract_links($html) {
    $links = array();
    preg_match_all('/]*)[\"\']?[^>]*>(.*?)< \/a>/i', $html,$matches,PREG_SET_ORDER);
    foreach($matches as $match) {
        $links[] = array($match[1],$match[2]);
    }
    return $links."";
}
$links = extract_links($html);
foreach ($links as $link) {
    echo $link[0] . "\n";
}

En este código usaremos cURL para ver los estatus de los links. Es una buena forma para ver si los links que hemos posteado en la pagina estan rotos o han sido movidos. Solo escribe el nombre en el navegador

http://localhost/nombre_de_este_arch…s_de_links.com No tiene que ser otra direccion puede ser hasta tus propios archivos.

Una vez que una página se haya cargado, el programa utiliza el XPath para obtener una lista de enlaces en la página. Entonces, después de un preprocesamiento busca cada uno de los vínculos, los enlace son recuperados.

Debido a que sólo necesita las cabeceras de estas respuestas, no necesitamos usar el método de GET, esto lo hacemos con la opción CURLOPT_NOBODY.

Al activar CURLOPT_HEADER le indica a curl_exec() que incluya en la respuesta la cabecera en la cadena que envia. Basado en la respuesta, el estatus del link es impreso a la misma vez con la nueva localidad si ha sido movido.

$url = $_GET['url'];
 // Load the page
list($page,$pageInfo) = load_with_curl($url);
if (! strlen($page)) {
    die("No page retrieved from $url");
}
// Convert to XML for easy parsing
$opts = array('output-xhtml' => true, 'numeric-entities' => true);
$xml = tidy_repair_string($page, $opts);
$doc = new DOMDocument();
$doc->loadXML($xml);
$xpath = new DOMXPath($doc);
$xpath->registerNamespace('xhtml','http://www.w3.org/1999/xhtml');

// Compute the Base URL for relative links
$baseURL = '';
// Check if there is a  in the page
$nodeList = $xpath->query('//xhtml:base/@href');
if ($nodeList->length == 1) {
    $baseURL = $nodeList->item(0)->nodeValue;
}
// No , so build the Base URL from $url
else {
    $URLParts = parse_url($pageInfo['url']);
    if (! (isset($URLParts['path']) && strlen($URLParts['path']))) {
        $basePath = '';
    } else {
        $basePath = preg_replace('#/[^/]*$#','',$URLParts['path']);
    }
    if (isset($URLParts['username']) || isset($URLParts['password'])) {
        $auth = isset($URLParts['username']) ? $URLParts['username'] : '';
        $auth .= ':';
        $auth .= isset($URLParts['password']) ? $URLParts['password'] : '';
        $auth .= '@';
    } else {
        $auth = '';
    }
    $baseURL = $URLParts['scheme'] . '://' .
               $auth . $URLParts['host'] .
               $basePath;
}

// Keep track of the links we visit so we don't visit each more than once
$seenLinks = array();

// Grab all links
$links = $xpath->query('//xhtml:a/@href');

foreach ($links as $node) {
    $link = $node->nodeValue;
    // resolve relative links
    if (! preg_match('#^(http|https|mailto):#', $link)) {
        if (((strlen($link) == 0)) || ($link[0] != '/')) {
            $link = '/' . $link;
        }
        $link = $baseURL . $link;
    }
    // Skip this link if we've seen it already
    if (isset($seenLinks[$link])) {
        continue;
    }
    // Mark this link as seen
    $seenLinks[$link] = true;
    // Print the link we're visiting
    echo $link.': ';
    flush();

    list($linkHeaders, $linkInfo) = load_with_curl($link, 'HEAD');
    // Decide what to do based on the response code
    // 2xx response codes mean the page is OK
    if (($linkInfo['http_code'] >= 200) && ($linkInfo['http_code'] < 300)) {
        $status = 'OK';
    }
    // 3xx response codes mean redirection
    else if (($linkInfo['http_code'] >= 300) && ($linkInfo['http_code'] < 400)) {
        $status = 'MOVED';
        if (preg_match('/^Location: (.*)$/m',$linkHeaders,$match)) {
                $status .= ': ' . trim($match[1]);
        }
    }
    // Other response codes mean errors
    else {
        $status = "ERROR: {$linkInfo['http_code']}";
    }
    // Print what we know about the link
    echo "$status\n";
}

function load_with_curl($url, $method = 'GET') {
    $c = curl_init($url);
    curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
    if ($method == 'GET') {
        curl_setopt($c,CURLOPT_FOLLOWLOCATION, true);
    }
    else if ($method == 'HEAD') {
        curl_setopt($c, CURLOPT_NOBODY, true);
        curl_setopt($c, CURLOPT_HEADER, true);
    }
    $response = curl_exec($c);
    return array($response, curl_getinfo($c));
}

Este tutorial se ha publicado gracias a la colaboracion de abimaelrc y se ira actualizando periódicamente

A lo mejor es muy famoso, pero acabo de encontrarme con este editor online y me ha parecido muy interesante.  Soporta varios lenguajes, correción de sintáxis y FTP.

Bueno, no es para tanto, pero algo cierto hay, segun las estadísticas que hacen en PHP Classes, uno de los sitios de referencia para los desarrolladores PHP.  Al parecer, la cantidad de programadores Indios para realizar trabajos en PHP esta a punto de desplazar a los estadounidenses del primer lugar, siempre hablando de las propias estadísticas del sitio, pero que seguramente reflejan bastante la realidad.

Url:  http://www.phpclasses.org/blog/post/99-India-will-become-number-1-source-of-PHP-developers-soon.html

O al menos eso es lo que dice su creador, sobre doophp y presenta este benchmarks

En PHP Freaks, publican esta lista,  con 10 sugerencias para que nuestro código tenga algo de dignidad. Algunas son clásicas en este tipo de listas, como el de refactorizar nuestro código y un par de sugerencias hacen punto en ciertas limitaciones propias de PHP.

Url: http://www.phpfreaks.com/blog/10-ways-to-avoid-writing-crappy-code

Me ha tocado varias veces crear documentos pdf  en algunos sitios (mysql ->php -> pdf).  Si bien he podido hacerlo con html2fpdf o alguna otra clase que no recuerdo ahora, el documento pdf que obtenia no era para nada perfecto, especialmente si incluía muchas imágenes o “cosas raras”.  Según leo en smashingmag , hay otra libreria llamada mPDF que parece funciona mucho mejor (no la he probado aún).

El uso de webservices desde PHP puede generar algunos dolores de cabeza en ciertos momentos del desarrollo.  Un framework que puede acortar nuestros tiempos, puede ser WSO2.  Esta libreria open source soporta la mayoria de los servicios mas utilizados, como REST por ejemplo.

Url: http://webservices.phpmagazine.net/2009/07/wso2-web-services-framework-fo.html