No solo podemos codificar en PHP, también podemos hacerlo en HTML, JavaScript, CSS, y XML; ofreciéndonos toda una gama de posibilidades de desarrollo en la nube.

Para trabajar con los archivos PHP -o con los formatos antes citados- debemos hacerlo a través de un servidor FTP que deberemos de configurar previamente -asimismo deberemos de registrarnos en el sistema antes de comenzar- y a partir de entonces tendremos acceso a los ficheros con los que queremos trabajar.

Resulta realmente útil contar con un editor PHP online, o en la nube como se suele decir, para en cualquier caso de emergencia podamos acceder a nuestros ficheros desde cualquier equipo y modificarlos, siendo también modificables desde nuestro smartphone con Android o nuestro iPhone -actualmente en desarrollo-.

Os dejamos con un video de presentación de la plataforma, para que conozcáis más a fondo en qué consiste el proyecto CodeAnywhere:

Enlace: CodeAnywhere: Potente editor PHP online con acceso FTP

Antes de mostrar el código para redimensionar imágenes proporcionalmente y con tamaño fijo en PHP, vamos a intentar explicar en qué consiste: En primer lugar tenemos una imágen de unas dimensiones cualquieras, en nuestro caso de 560x560px.

Ejemplo de imágen a redimensionar.

Pongámonos en el caso de que queremos crear un thumbnail de dicha imágen con unas dimensiones fijas de 160x100px. Nos sería imposible en principio redimensionarla de forma proporcional ya que las imagen original y el thumbnail tienen proporciones diferentes, con lo que u obtendríamos una imágen a 160x160px ó a 100x100px para que sea de tamaño proporcional.

Ejemplo de dos imágenes proporcionales.

En este caso, si queremos que la imágen final tenga un tamaño fijo lo ideal sería que el tamaño restante sea rellenado por un marco de color transparente. En este caso cogeríamos la imágen de 100x100px y le añadiríamos un marco a ambos lados de 30px en cada lado.

Ejemplo de imágen proporcional con tamaño fijo.

Una vez explicado este punto, pasamos a mostraros la función y a detallarla:

Redimensionar imágen proporcionalmente y con tamaño fijo en PHP

function createThumb($sImagen, $nWidth = false, $nHeight = false)
{
    // Variables
    $sNombre = null;
    $sPath = null;
    $sExt = null;
    $aImage = null;
    $aThumb = null;
    $aImageMarco = null;
    $ImTransparente = null;
    $aSize = null;
    $nWidthMarco = false;
    $nWidthHeight = false;
    $nX = false;
    $nY = false;

    // Obtenemos el nombre de la imagen
    $sNombre = basename( $sImagen );
    // Obtenemos la ruta especificada para buscar la imagen
    $sPath = dirname( $sImagen ) . '/';
    // Obtenemos la extension de la imagen
    $sExt = mime_content_type( $sImagen );

    // Creamos el directorio thumbs
    if( ! is_dir( $sPath . 'thumbs/' ) )
        @mkdir( $sPath . 'thumbs/', 0777, true ) or die( 'No se ha podido crear el directorio "' . $sPath . 'thumbs/".' );

    // Creamos la imagen a partir del tipo
    switch( $sExt )
    {
        // Imagen JPG
        case 'image/jpeg':
            $aImage = @imageCreateFromJpeg( $sImagen );
            break;
        // Imagen GIF
        case 'image/gif':
            $aImage = @imageCreateFromGif( $sImagen );
            break;
        // Imagen PNG
        case 'image/png':
            $aImage = @imageCreateFromPng( $sImagen );
            break;
        // Imagen BMP
        case 'image/wbmp':
            $aImage = @imageCreateFromWbmp( $sImagen );
            break;
        default:
            return 'No se conoce el tipo de imagen enviado, por favor cambie el formato. Sólo se permiten imágenes *.jpg, *.gif, *.png ó *.bmp.';
            break;
    }

    // Obtenemos el tamaño de la imagen original
    $aSize = getImageSize( $sImagen );

    // Calculamos las proporciones de la imagen //

    // Obteniendo el alto (Recogiendo ancho y no alto)
    if( $nWidth !== false && $nHeight === false )
        $nHeight = round( ( $aSize[1] * $nWidth ) / $aSize[0] );
    // Obteniendo el ancho (Recogiendo alto y no ancho)
    elseif( $nWidth === false && $nHeight !== false )
        $nWidth = round( ( $aSize[0] * $nHeight ) / $aSize[1] );
    // Obteniendo proporciones (Recogiendo alto y ancho)
    elseif( $nWidth !== false && $nHeight !== false )
    {
        // Guardamos las dimensiones del marco
        $nWidthMarco = $nWidth;
        $nHeightMarco = $nHeight;

        // Si el ancho es mayor
        if( $nWidth < $nHeight )
        {
            $nHeight = round( ( $aSize[1] * $nWidth ) / $aSize[0] );
            $nX = 0;
            $nY = round( ( $nHeightMarco - $nHeight ) / 2 );
        }
        // Si el alto es mayor
        elseif( $nHeight < $nWidth )
        {
            $nWidth = round( ( $aSize[0] * $nHeight ) / $aSize[1] );
            $nX = round( ( $nWidthMarco - $nWidth ) / 2 );;
            $nY = 0;
        }
    }
    // El ancho y el alto no se han enviado, informamos del error
    elseif( $nWidth === false && $nHeight === false )
        return 'No se ha especificado ningún valor para el ancho y el alto de la imágen.';

    // La nueva imagen reescalada
    $aThumb = imageCreateTrueColor( $nWidth, $nHeight );

    // Reescalamos
    imageCopyResampled( $aThumb, $aImage, 0, 0, 0, 0, $nWidth, $nHeight, $aSize[0], $aSize[1] );

    // Si tenemos que crear el marco
    if( $nWidthMarco !== false && $nHeightMarco !== false )
    {
        // El marco
        $aImageMarco = imageCreateTrueColor( $nWidthMarco, $nHeightMarco );

        // Establecemos la imagen de fondo transparente
        imageAlphaBlending( $aImageMarco, false );
        imageSaveAlpha( $aImageMarco, true );

        // Establecemos el color transparente (negro)
        $ImTransparente = imageColorAllocateAlpha( $aImageMarco, 0, 0, 0, 0xff/2 );

        // Ponemos el fondo transparente
        imageFilledRectangle( $aImageMarco, 0, 0, $nWidthMarco, $nHeightMarco, $ImTransparente );

        // Combinamos las imagenes
        imageCopyResampled( $aImageMarco, $aThumb, $nX, $nY, 0, 0, $nWidth, $nHeight, $nWidth, $nHeight );

        // Cambiamos la instancia
        $aThumb = $aImageMarco;
    }

    // Salvamos
    imagePng( $aThumb, $sPath . 'thumbs/' . $sNombre );

    // Liberamos
    imageDestroy( $aImage );
    imageDestroy( $aThumb );

    return true;
}

La función puede recibir tres parámetros, siendo el primero la ruta de la imágen a redimensionar, el segundo sería el ancho que queremos darle y el tercero el alto. Si especificamos ambos parámetros, ancho y alto, la imágen se redimensionará a dicho tamaño fijo dándole un marco transparente. Si especificamos solo el ancho tendremos una imágen proporcional con respecto al ancho, en nuestro caso si especificamos que la imagen de 560x560px la queremos con un ancho de 160px, el resultado final tendrá unas dimensiones de 160x160px. De igual forma con el alto, si especificamos para la imágen de 560x560px un alto de 100px, el resultado final tendrá unas dimensiones de 100x100px. También cabe destacar que se creará automáticamente un directorio llamado “thumbs” y ahí se almacenarán las imágenes resultantes. Siéntete libre de cambiar el código a tu gusto.

Cualquier error o sugerencia en el código será bien recibida en los comentarios.

Una vez que conocemos quién es GoogleBot y qué es lo que hace nos percataremos de la importancia que tiene que este software se de una vuelta por nuestra página web, la rastree, indexe y todo lo que ello conlleva. La pregunta que resolveremos hoy es cómo saber cuando pasa GoogleBot por mi web, y con un sencillo código PHP podemos conocerlo.

En la página principal de nuestra web deberemos de colocar este pequeño código -obviamente es necesario unos conocimientos mínimos de PHP- que lo que hará es reconocer al visitante como GoogleBot y, en caso de que así sea, nos enviará un email a la dirección que queramos indicando que está visitando nuestra web. Aquí tenéis el código:

<?php

if( strpos( $_SERVER["HTTP_USER_AGENT"], "Googlebot" ) !== false )
	mail( "direccion@mail.com", "Alerta de GoogleBot", "Página visitada: " . $_SERVER["REQUEST_URI"] );

?>

Donde veis que indica “direccion@mail.com”, tenéis que poner vuestro correo electrónico donde queráis que se os informe. Por supuesto también podéis saber cuando pasa GoogleBot por vuestra web visitando las herramientas para webmasters de Google, pero ahí no podéis ver con exactitud la fecha, hora y páginas que ha visitado nuestro querido bot.

Fuente: Javielinux

Chevereto es un Script gratuito de almacenamiento de imágenes que está teniendo una muy buena acojida por el numeroso grupo de usuarios que ha decidido adaptarlo para sus proyectos; pero conozcámoslo un poco más.

Chevereto cuenta con las siguientes características:

• Desarrollado en PHP y Javascript: Ha sido desarrollado utilizando PHP y Javascript, dos lenguajes muy extendidos.
• No necesita Base de Datos: Ya que rastrea los archivos y obtiene información necesaria a través de ellos, por lo que su instalación resulta más sencilla.
• Permite redimensionar imágenes: El uploader puede decidir si sus imágenes pueden tener un tamaño final al subirlas.
• Integración con acortadores de URL: Una vez subida una imágen, obtenemos un enlace para su visualización y/o descarga, pero podemos tener dicha url ya acortada.
• Soporte para jQuery: Si usas este framework para Javascript, puedes integrarlo perfectamente con Chevereto.
• Es código abierto: Con lo que puedes editar y adaptar el código para lo que quieras, además de poder ayudar en el desarrollo del script.
• Buena documentación: Cuentan con una documentación para que su instalación y su uso sea más fácil.

Todas estas son las cualidades de Chevereto para que, quien quiera, pueda tener su propio hosting de imágenes gracias a su sencillo pero poderoso script.

Enlace: Chevereto: Script gratuito de almacenamiento de imágenes
Demo: Demo de Chevereto

Una buena práctica para que aparezcamos antes en Google es añadir a estos servicios de actualización la URL blogsearch de Google.

Todos los desarrolladores que no quieran utilizar WordPress y crean mejor sus propios blogs o proyectos deben de tener en cuenta los ping XML-RPC para avisar de su nuevo contenido. Así que hoy he tenido que realizar una función que realice ping de forma automática como lo hace WordPress. Para empezar buscaremos la función de WordPress que se encarga los ping XML-RPC y la extraeremos y modificaremos a nuestro gusto. Empecemos:

¿Que son los ping XML-RPC?

Una forma clara de poder explicar los ping XML-RPC es imaginarse dos ordenadores, uno de ellos sera un cliente, nuestro caso es donde tenemos nuestro blog, y el ordenador un servidor que se encargara de recibir el ping. El ordenador cliente mandará una petición, comunicándose mediante Internet usando el estándar XML. El servidor ejecutará esta petición examinando que clase o método debe llamar para procesar la petición. Una vez terminado de ejecutar, el servidor enviará la respuesta hacia el cliente. Para más información puedes visitar la Wikipedia

¿Cómo puedo hacer ping XML-RPC con PHP?

Una vez extraída la función weblog_ping de WordPress implementarla para nuestros proyectos es realmente sencillo. Primero deberemos de descargar la librería encargada de realizar los ping XML-RPC, llamada IXR y su sitio oficial para descargar es scripts.incutio.

Cuando hayamos descargado la librería IXR la incluiremos en nuestro proyecto para poderla llamar desde nuestra propia función weblog_ping, que será la encargada de realizar los ping a las distintas URL.

function weblog_ping($server = "") 
{
	// Incluimos la clase IXR
	include_once ("class-IXR.php");

	// Realizamos la conexión con la URL
	$client = new IXR_Client($server, false);
	// Esperamos un tiempo de respuesta de 3 segundos
	$client->timeout = 3;
	// Useragent que queramos por el cual nos identifique el servidor, podeis poner cualquiera.
	$client->useragent .= " -- El useragent que queramos utilizar";

	// Deberemos decir False ya que si no nos mostrara toda la peticion desde que sale del cliente hasta la respuesta del cliente
	// Si teneis problemas habilitarla para ver que esta pasando
	$client->debug = false;

	// Ejecutamos la peticion al servidor indicando que deseamos que ejecute el procedimiento extendedPing del servidor, que sera el encargado de recorrer nuestra URL en busca de cambios
	if( $client->query("weblogUpdates.extendedPing", "El nombre de nuestro blog", "URL de nuestro blog", "URL de nuestro RSS" )
		echo "Servidor: " . $server . " OK";
	else
		echo "Servidor: " . $server . " ERROR";
}

Finalmente para que nuestro blog llame a las distintas URL de servicios de actualización deberemos llamar a la función weblog_ping pasándole como argumento a que servidor queremos realizar el ping XML-RPC.

// Ping a bitacoras
weblog_ping("http://ping.bitacoras.com");

// Ping a technorati
weblog_ping("http://rpc.technorati.com/rpc/ping");

// Ping a blogalaxia
weblog_ping("http://ping.blogalaxia.com");

// Ping a google
weblog_ping("http://blogsearch.google.com/ping/RPC2");

Ya solo nos queda realizar por ejemplo una tabla con distintas URL de ping o un campo en una tabla opciones con varias URL y luego extraer la información de la base de datos y finalizarlo con un bucle para que llame a las distintas URL de forma dinámica. Pero ya estas pinceladas es a gusto de cada uno.

Más información: Javieraroche o blogterrier

Antes que nada necesitaremos descargarnos dos ficheros que contendrán la información de los diferentes países y el método para detectarlos. Los ficheros se tratan de geoip.inc y GeoIP.dat.

Una vez que nos hagamos con los ficheros, vamos a crear un fichero llamado geoIP.php (por ejemplo) y colocaremos los ficheros descargados en el mismo sitio. A continuación debemos incluir el siguiente código PHP en el fichero geoIP.php que nos devolverá el País al que pertenece el usuario por la IP:

function geoIP()

{
	// Incluimos la libreria
	require( 'geoip.inc' );

	// Variables

	$gIP = null;
	$sGeo = null;

	// Instanciamos la variable y le indicamos el fichero .dat y el tipo de Geolocalizacion
	$gIP = geoip_open( 'GeoIP.dat', GEOIP_STANDARD );

	// Obtenemos el Pais por la IP
	$sGeo = geoip_country_name_by_addr( $gIP, $_SERVER['REMOTE_ADDR'] );

	// Cerramos
	geoip_close( $gIP );

	return $sGeo;

}

Con ésta sencilla función podremos obtener la procedencia de un visitante a través de la IP, ya lo que hagamos con ésta información es cosa nuestra.

Fuente: ManualDePHP

Solucionar error Fatal error Allowed memory size

Deberemos modificar nuestro php.ini con el editor que más nos guste, en mi caso el editor nano. En este servidor tengo instalado Xampp y editaremos el archivo php.ini de la siguiente forma:

nano /opt/lampp/etc/php.ini

Una vez abierto buscaremos la línea que contenga “memory_limit = XXM” en mi caso “memory_limit = 32M” y lo sustituimos por “memory_limit = 64M”. De esta forma reservaremos memoria suficiente para poder instalar Symfony y poder ejecutar los Script que necesiten más memoria en su procesamiento.

Una vez editado el archivo y guardado deberemos reiniciar Apache para que los cambios realizados hagan efecto. Ahora cuando ejecutemos un Script que necesite más memoria se podrá realizar sin ningún tipo de problema. En mi caso sólo necesitaba 64M, pero si estas realizando un gran Script puedes poner el tamaño que más se amolde a tus necesidades

Las figuras que nos deja dibujar PHP con la librería GD son las más básicas, como puede traernos cualquier editor de imágenes básico. Vamos a ver como se crean las siguientes figuras: rectángulo, cuadrado, y círculo. Para ello necesitamos tener habilitado la librería GD para nuestro servidor PHP. Antes de empezar podéis echar un vistazo a como crear imágenes en Html mediante PHP GD.

¿Como dibujar un rectángulo en PHP GD?

Una de las figuras más simples que todos conocemos, y para crearlo utilizaremos la función “imagefilledrectangle” para crear un rectángulo con relleno o la función “imagerectangle” para dibujar solo el contorno.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );

// Creamos la instancia del rectangulo
imagefilledrectangle( $imImage, 0, 0, 300, 50, $imRelleno );

// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

¿Como dibujar un cuadrado en PHP GD?

Las funciones para realizar un cuadrado son exactamente iguales que realizar un rectángulo pero lógicamente añadiremos el mismo ancho y alto.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );

// Creamos la instancia del cuadrado
imagefilledrectangle( $imImage, 0, 0, 50, 50, $imRelleno );

// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

¿Como dibujar un circulo en PHP GD?

Para dibujar un circulo tendremos que utilizar la función “imageellipse” para realizar el contorno y “imagefilledellipse” para rellenarla de color.

// Tamaño de la imagen
$imImage = @imagecreate( 600, 100 );
// Color de fondo en RGB
$imFondo  = imagecolorallocate( $imImage, 255, 255, 255 );
// Color de relleno en RGB
$imRelleno = imagecolorallocate( $imImage, 141, 203, 61 );
// $imImage : identificador de la imagen creado
// 25: Coordenada horizontal del centro del ciruclo
// 25: Coordenada vertical del centro del circulo
// 50: Ancho del circulo
// 50: Alto del circulo
// $imRelleno: Color del relleno
imagefilledellipse( $imImage, 25, 25, 50, 50, $imRelleno );
// Cabecera php para mostrar imagenes
header("Content-type: image/png");
// Imprimimos la imagen en PNG
imagepng( $imImage );
// Liberamos la memoria usada para crear la imagen
imagedestroy( $imImage );

Para crear nuevas figuras, como por ejemplo un arco tenéis más funciones. Podéis pasaros por el fantástico manual de PHP GD y ver todas las funcionalidades de la libreria GD.

Mostrar fecha y hora con formato “Hace x horas, x minutos, x segundos” en PHP

Primero debemos de convertir el valor del campo timestamp en fecha de unix (segundos desde 1970-01-01 00:00:00 GMT), usando la función UNIX_TIMESTAMP de SQL.

SELECT *, UNIX_TIMESTAMP( CAMPO_FECHA_HORA ) FROM TABLA

A continuación, a la hora de mostrar dicho campo, pasaremos el resultado del campo “CAMPO_FECHA_HORA” por esta función:

function hace($fecha_unix)
        //obtener la hora en formato unix
        $ahora=time();
        
        //obtener la diferencia de segundos
        $segundos=$ahora-$fecha_unix;
        
        //dias es la division de n segs entre 86400 segundos que representa un dia;
        $dias=floor($segundos/86400);

        //mod_hora es el sobrante, en horas, de la division de días;    
        $mod_hora=$segundos%86400;
        
        //hora es la division entre el sobrante de horas y 3600 segundos que representa una hora;
        $horas=floor($mod_hora/3600);
        
        //mod_minuto es el sobrante, en minutos, de la division de horas;       
        $mod_minuto=$mod_hora%3600;
        
        //minuto es la division entre el sobrante y 60 segundos que representa un minuto;
        $minutos=floor($mod_minuto/60);
        
        if($horas<=0){
                echo $minutos." minutos";
        }elseif($dias<=0){
                echo $horas." horas ".$minutos." minutos";
        }else{
                echo $dias." dias ".$horas." horas ".$minutos." minutos";
        }

De esta manera, usando esta función, tendremos el campo fecha hora en un formato mucho más amigable para el usuario. También hay que saber donde aplicar este tipo de formato y donde encaja mejor un formato clásico, pero siempre es bueno tener una alternativa útil de cara al usuario.

Fuente: RibosoMatic

¿Que son las directivas open basedir y Safe Mode?

El Modo Seguro de PHP (Safe Mode) es un intento para resolver el problemas de seguridad en un servidor compartido. Trata de resolver este problema a nivel de PHP verificando si el dueño del script actual coincide con el dueño del fichero a ser operado por una función de fichero (readfile(), mkdir(), etc).

Mientras que la directiva open basedir limita la interacción de los archivos con archivos fuera de la carpeta donde se está ejecutándose el script actual.

¿Como “salto la protección” open basedir y Safe Mode para Curl en servidores compartidos?

En servidores compartidos, como por ejemplo 000webhost, tenemos este problema a la hora de ejecutar un script Curl con FollowLocation. Desde el manual oficial de PHP encuentro que el usuario eion ha realizado una función para corregir este problema. Para entender la función y simplificar su explicación lo que realiza realmente es la primera petición curl obteniendo solo la cabecera, donde en ella podemos encontrar la redirección 301. Volverá a realizar la petición pero esta vez a la redirección y así sucesivamente. Es una buena alternativa para “saltarse” open basedir y Safe Mode para Curl en servidores como 000webhost.

Obtener función Curl para que PHP realize el “salto de protección” open basedir y Safe Mode

El anterior post, “Curl en PHP“, dispone de esta función dando la posibilidad de realizar peticiones Curl en servidores como 000webhost que no disponen de open basedir Or Safe Mode.

Enlace: Descargar Curl para PHP