Aunque las opciones que ofrece GD son muy básicas, son suficientes para desarrollar scripts con capacidades muy superiores. Ahora voy a presentaros estas funciones básicas con ejemplos, para que puedas crear aplicaciones más complejas.

Crear la imagen de cero o desde un archivo

Para tratar imágenes en GD trabajamos con recursos o variables tipo resource de imágenes. Esto es una varible que representa a la imagen.

Para crear un nuevo recurso de imagen podemos usar la función imagecreate() aúnque es más recomendable usar la función imagecreatetruecolor()

Si queremos partir de una imagen ya existente, para convertirla en recurso tendremos que usar la función adecuada dependiendo del formato de la imagen. Los principales formatos son JPEG, PNG y GIF; con las funciones imagecreatefromjpeg(), imagecreatefrompng() y imagecreatefromgif() respectivamente.

Si quieres ahorrarte el pensar a la hora de crear un recurso a partir de imagen, o desconoces el formato de entrada de la imagen (y quieres que lo haga automáticamente) puedes usar esta función para crear cualquier tipo de imagen.

[descargar código]

Esta función puede crear una imagen a partir de JPEG, PNG, GIF o URL (requiere CURL)

Si queremos saber las dimensiones de un recurso de imagen, usaremos las funciones imagesx($im) e imagesy($im) que devuelven el ancho y alto del recurso, en píxeles, respectivamente.

Copiar, recortar y redimensionar

La modificación más básica que podemos hacer a una imagen es recortarla y redimensionarla.

En ambos casos la forma de trabajar es, en primer lugar crear un nuevo recurso con las dimensiones apropiadas, y en segundo lugar copiar de la imagen origen a la imagen destino aplicando el cambio deseado.

Recortar una imagen

Para recortar una imagen de, por ejemplo, 500 x 400 en 50px por la derecha y por abajo, haremos lo siguiente:

1. Creamos un nuevo recurso de 500 – 50 = 450 por 400 – 50 = 350px
2. Usamos la función imagecopy para copiar de la imagen origen, en nuestra nueva imagen

   bool imagecopy ( resource $im_destino , resource $im_origen , int $pos_x_destino , int $pos_y_destino , int $pos_x_origen , int $pos_y_origen , int $ancho_origen , int $alto_origen )

3. Los dos primeros parámetros son los recursos destino y origen
4. Los dos siguientes son la posición en eje x e y de la imagen destino, donde queremos comenzar a copiar (en nuestro caso 0,0; porque el eje está arriba y a la izquierda)
5. Los dos siguientes son el ancho y el alto de la imagen que queremos recortar del aimagen original. En nuestro caso 450 y 350.

[descargar código] Ejemplo: [original] [recortada dinámicamente]

Redimensionar una imagen

En este ejemplo vamos a redimensionar a la mitad la imagen origen, sea cual sea su tamaño.

Crearemos primero un nuevo recurso con las dimexiones x/2 e y/2, y usaremos la función imagecopyresampled() (también podríamos usar imagecopyresized(), pero la que vamos a usar suaviza los píxeles interpolándolos – tiene mejor calidad)

Dibujar figuras y texto

Las figuras que GD nos deja pintar son muy básicas, parecidas a las que ofrece el programa Paint

En este punto lo más importante es crear colores para una imagen. Los colores se deben crear y asociar a una imagen mediante la función imagecolorallocate(). El color lo indicamos mediante parámetros RGB (Red Green Blue) que podemos extraer fácilmente de cualquier paleta, como la del Photoshop o el Gimp

Dibujar un rectángulo

Quizás la figura más simple. Podemos dibujar sólo el borde del rectángulo con la función imagerectangle() o el rectangulo relleno de color, con la función imagefilledrectangle()

bool imagerectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

bool imagefilledrectangle ( resource $imagen , int $x1 , int $y1 , int $x2 , int $y2 , int $color )

Otras figuras

Existen muchas figuras que puedes dibujar con GD, desde una línea hasta un polígono, pasando por la elipse o el píxel. Sólo busca la que más te conviene en la documentación, o combina varias para obtener la figura deseada.

Escribir texto

Es realmente sencillo. Si no te quieres complicar la vida, puedes usar la función imagestring() que te da la opción de elegir entre 5 fuentes internas indicando sólo el número de referencia…

… o si quieres tener más control sobre el estilo, puedes usar fuentes TrueType con la función imagettftext() (en la web DaFont tienes miles de fuentes TrueType gratuitas)

[descargar código]
Demo:

Tratar bien la transparencia en PNG

Las imágenes PNG admiten un canal Alpha que indica la opacidad en cada punto de la imagen, para crear efectos semitransparentes. Si te interesa que esta transparencia se muestre correctamente, deberás calentarte un poco más la cabeza, y tener el canal Alpha siempre en cuenta. Te aconsejo que incluyas estas dos líneas después de crear una nueva imagen con transparencia (aunque tendrás que estar siempre atento de que el canal alpha no se pierda!)

Recuerda también que puedes crear colores con canal de transparencia usando imagecolorallocatealpha() en lugar de imagecolorallocate()

Exportar la imagen para visualizarla

Después de haber modificado nuestra imagen tal como deseamos, tendremos que exportarla. Existe una función para cada formato de salida (imagejpeg(), imagepng(), imagegif(), etc…). Personalmente te recomiendo siempre exportar en PNG porque se conserva la calidad y la nitidez mucho mejor.

En todos los casos tendremos la opción de generar el código de la imagen, si queremos que el archivo PHP simule ser la propia imagen, o indicarle dónde queremos que almacene la imagen resultado.

Para el primer caso, tendremos que indicar mediante las cabeceras que lo que estamos a punto de mostrar es una imagen. Para esto usamos la función header() indicando el tipo de archivo en concreto de que se trata (image/jpeg, image/png o image/gif).

Una vez creado este archivo, podemos mostrar el resultado en una página HTML simplemente creando una etiqueta de imagen que referencie a ese archivo .php

Si queremos almacenar en nuestro disco la imagen resultante, tendremos que pasar como segundo parámetro a la función el nombre del archivo que queremos generar.

Recuerda que me interesa mucho tu opinión. Crees que falta algo? tienes dudas? vas a trabajar con la librería GD ahora que sabes cómo funciona? has hecho experimentos curiosos con imágenes dinámicas? …

Esta es una técnica para redimensionar imágenes a un tamaño fijo (aunque no guarde proporción), sin distorsionar la imágen.

No, no se trata del escalado líquido. Esa técnica es demasiado compleja. Se trata de recortar la imágen para adaptarla a la nueva resolución, perdiendo el mínimo espacio posible.

Foto de Basajaun en Flickr Licencia CC(by-nc-sa)

Para hacer esto, he desarrollado este algoritmo, que paso a compartir con todos para que lo uséis como os de la gana (requiere Biblioteca GD)

[Descargar código]

Cómo utilizar

Si no estás familiarizado con la edición de imágenes en PHP, no te preocupes. Para utilizar la función de arriba, tenemos que pasarle como parámetro una imágen tipo resource de GD y dos números indicando el ancho y alto que queréis forzar a la foto.

Para que se vea, hay que editar las cabeceras HTTP indicando que el contenido es una imágen. Y a este archivo de imágen (aunque sea un PHP) se le puede llamar desde la etiqueta img de HTML. Dejemos que hable el código:

imagen.php

miPagina.html

Puedes ver un ejemplo en …

Esta técnica la uso en Gpsia para mostrar las imágenes al tamaño que yo le diga, sin que se vean distorsionadas. Échale un ojo, y de paso ves las rutas tan increíbles que está subiendo la gente.

Podemos leer un archivo XML a partir de una cadena de texto (con domxml_open_mem) o diciendo dónde está el archivo XML ( con domxml_open_file)

Como ejemplo usaremos el archivo XML que proporciona el API Google Weather (no documentada) para hacer predicciones meteorológicas en determinado lugar.

El método más importante es get_elements_by_tagname, que nos devuelve los tags que tienen ese nombre, en forma de array.

En nuestro caso, vamos a hacer una comprobación por si el documento XML nos informa de que ha habido un error, con el tag problem_cause ver ejemplo

Para obtener la descripción, tendremos que usar el método get_attribute_node que nos dice el valor del atributo que queramos, para un elemento [nombreTag atributo="valor"].

Y ahora, vamos a ir directos al ajo. Echad un vistazo a la estructura del API Google Weather, y al siguiente código, después lo explico.

[Ver resultado]

La función que se define al comienzo sirve para ahorrarnos código al extraer el atributo “data” de los nodos, porque todos los tags tienen lo importante ahí.

El resto del código creo que está bastante claro. Puedes ver una [Demo] y el [código fuente].

Si te ha gustado el post, te parece interesante, o tienes dudas escríbeme un comentario, tengo ganas de leerte!

Nota: Si no tienes esta extensión instalada en tu host, pregunta al servicio técnico para que te lo instalen, o mira esta página para hacerlo tú mismo.

Para tener esta feature, descargamos la última versión de GeoLite Country (es la versión gratuita de la base de datos).

Esto es un archivo comprimido, que contiene un archivo tipo DAT. Lo descomprimimos en nuestro directorio, y nos olvidamos de él.

Si vais a programar en PHP aquí hay algunos archivos de muestra. También hay soporte para otros lenguajes.

El que más nos importa es el archivo geoip.inc que contiene la librería para gestionar la base de datos en PHP. Guardamos el archivo en el mismo directorio que la base de datos.

Ahora, sólo nos queda un poco de código:

Ver ejemplo

Esto mostrará por pantalla algo como

El codigo de tu pais es: ES

Si queremos usar el nombre del país en Español, podéis descargaros este archivo que he preparado. Contiene un array asociativo con las claves de los paises, y sus valores, usadlo así:

Ver ejemplo

Debería aparecer algo similar a:

Tu vienes de España

Nota1: Recomiendo tener todos los archivos en el mismo directorio, si no lo hacéis así, tened cuidado con poner bien la ruta a cada archivo!

Nota2: Si algún código que has copiado de esta web no te funciona, comprueba que las comillas sean correctas (reescríbelas con tu teclado) WordPress traduce las comillas simples y dobles que se usan en código, por otras raras que se usan en textos.

PHP is a bamboo raft. A series of hacks held together by string. Still keeps afloat though.

PHP es una balsa de bambú. Unos cuantos apaños unidos con una cuerda. Aún así consigue ir a flote

Me parece un juicio muy injusto, y a los comentaristas de Boozox también!

• Memiux: [...] un poco exagerado lo de PHP xD
• daniel: El que diga eso de php, es que no tiene ni idea [...]
• Jose D: [...] yo también defiendo a php que está que se sale por todos lados [...]

Coincido con todos ellos, PHP no es una triste balsa da bambú! PHP es un lenguaje muy potente sobretodo para lo que está enfocado (desarrollo de webs dinámicas). Cuenta con infinidad de funciones y bibliotecas útiles para cualquier cosa que se te pase por la mente, y de hecho un porcentaje muy elevado (la mayor parte) de las webs en internet están respaldadas por este lenguaje.

No en vano, webs como Youtube, yahoo, wikipedia, facebook, digg, flickr…. han elejido como lenguaje idóneo el PHP.

Se le acusa de provocar desorden en el código y en la estructura de los programas, pero esto es un hecho que se desprende de la habilidad y la experiencia de quien programa.

Es posible que el hecho de que la versatilidad y facilidad de PHP permita su uso a personas inexpertas, de como resultado la proliferación de código de mala calidad, pero no se puede generalizar, y declarar que en PHP se programan apaños y chapuzas.

He programado toda mi vida en PHP y jamás me ha presentado una frontera, el límite ha sido siempre mi imaginación.

Por ello quiero defender el papel de PHP, y promover su uso para cualquier tipo de tarea en internet.

Larga vida a PHP !!!!

El algoritmo

El filtro gaussiano consiste en la mezcla de los colores de una imágen para conseguir un efecto de desenfoque. Esta es una explicación muy general, y por supuesto el algoritmo es más complejo que esto.

En primer lugar, consideraremos la imágen como una matriz de puntos (pixeles), con unos valores determinados de rojo, verde y azul. A partir de aquí, los valores de cada punto de la nueva imágen, serán una combinación de los puntos cercanos. De esta forma, si un punto es de color rojo, y cercano a él hay puntos negros, este rojo se oscurecerá (y los negros se enrojecerán).

Pero para determinar cuáles son los pixeles que son cercanos, y los que no, se debe especificar al filtro un radio de acción. Con esto, si por ejemplo indicamos un radio de 10 pixeles, cada píxel de la nueva imágen se verá modificado por los todos los pixeles a menos de 10 unidades de distancia. Pero no todos los pixeles modifican con la misma “fuerza”, cuanto más cerca estén del pixel que se está modificando, más valor tendrán en el cálculo del nuevo color. Es aquí donde aparece nuestro simpático amigo Gauss.

La función de la distribución Gaussiana va a ayudarnos a adjudicar cuánto aporta cada pixel, en función de lo cerca o lejos que se encuentre. Esta función tiene la forma donde (x-b) es la distancia entre el pixel que está siendo modificado y el píxel del que se está tomando el valor, a y c valen 1, y f(x) resulta un número Real entre 0 y 1 que representa el porcentaje de influencia.

Resumiendo

Lo que está claro es que hay que mezclar los píxeles entre sí, y que usaremos un radio de influencia en que cuanto más lejos está un píxel de otro, menos le afecta.

Después de analizar el problema, y aplicar una fórmula estadística, podemos concluir que el valor de cada pixel es:

La suma de todos los píxeles dentro del radio R, multiplicados cada uno por (tal y como se ha descrito antes), y todo esto, dividido entre la suma de todos los valores de la fórmula en los puntos que intervienen.

Y todo eso es sólo para calcular uno de los tres componentes (Rojo, Verde o Azul) de un sólo pixel.

De modo que, a falta de una fórmula mágica de optimización, el efecto de desenfoque Gaussiano no es ninguna broma, realiza una cantidad muy elevada de cálculos (que aumenta junto al Radio y al tamaño de la imágen).

El archivo de descarga

Aquí os dejo el código fuente y la descarga del filtro Desenfoque Gaussiano para Imaset 2.1
Tened en cuenta que, como he dicho, es un filtro muy costoso, y aplicarlo puede llevar bastantes segundos.

La forma de poder usarlo es: descargar el archivo ZIP, descomprimir su contenido, y subir el archivo gaussian.xml al directorio “/filters” y el archivo es_ES.php al directorio “/lang”

Ejemplo del filtro Gaussiano en Imaset

Como se puede apreciar, realiza un toque de suavizado, si se aplica poco desenfoque (poco radio).

Código fuente

Os dejo como siempre el código fuente de este filtro.

Ya he conseguido dar con el problema, y he cambiado el archivo de descarga para que sustituyáis los archivos en el plugin.

El problema que ocasionaba esto es bastante complejo de explicar, pero está relacionado con la yuxtaposición de arrays. En el código de Imaset yo había optado por usar la función array_merge(), la cual une los arrays que le pases como parámetro, pero esta función no mantiene los índices numéricos, y para la aplicación era importante que los mantuviera.

La solución es usar el concatenador básico de arrays, es decir, el operador suma.

PHP permite dos tipos principales de funciones para expresiones regulares: las de tipo ereg (Expresiones regulares POSIX) y las de tipo preg (Compatibles con Perl). Son muy similares, aúnque las segundas llegan a ser algo más potentes.

Una expresión regular, consiste en comparar un patrón frente a un texto, para comprobar si el texto contiene lo especificado en el patrón.

Por poner un par de ejemplos:

Patrón: in
Coindicen:

• intensidad
• cinta
• interior

Patrón: [mp]adre
Coindicen:

• Mi madre se llama Luisa
• Tu padre es jardinero

A continuación voy a repasar la sintaxis básica de una expresión regular

Sintaxis y metacaracteres

El punto

El punto representa cualquier caracter. Escribiendo un punto en un patrón querrás decir que ahí hay un caracter, cualquiera. Desde la A a la Z (en minúscula y mayúscula), del 0 al 9, o algún otro símbolo.

Ejemplos:
ca.a coincide con cana, cama, casa, caja, etc…
No coincide con casta ni caa

Principio y fin de cadena

Si queremos indicar al patrón qué es el principio de la cadena o qué es el final, debemos hacerlo con ^ para inicio y $ para final.

Ejemplos:
“^olivas” coincide con “olivas verdes“, pero no con “quiero olivas”

Cuantificadores

Para indicar que cierto elemento del patrón va a repetirse un número indeterminado de veces, usaremos + o * . Usando + queremos decir que el elemento anterior aparece una o más veces. Usando * queremos decir que el elemento anterior aparece cero o más veces.

Ejemplos:
“gafas+” coincide con “gafassss” pero no con “gafa”
sin embargo
“clo*aca” coincide con “claca“, “cloaca“, “cloooooooaca“, etc..

Si lo que queremos indicar al patrón es que un elemento puede que esté (una vez) o puede que no, lo haremos con el interrogante de la siguiente forma:
“coches?” coincide con “coche” y con “coches”

Para definir la cantidad de veces que va a repetirse el elemento, tendremos que hacer uso de las llaves: { }, indicando en su interior el intervalo, o la cantidad exacta de veces que va a repetirse.

Ejemplos:
“abc{4}” coincide con “abcccc“, pero no con “abc” ni “abcc“, etc…
“abc{1,3}” coincide con “abc“, “abcc“, “abccc“, pero no con “abcccc”

Si un parámetro queda vacío, significa “un número indeterminado“. Por ejemplo: “x{5,}” significa que la x ha de repetirse 5 veces, o más.

Rangos

Los corchetes [] incluidos en un patrón permiten especificar el rango de caracteres válidos a comparar. Basta que exista cualquiera de ellos para que se de la condición. Dentro de ellos pondremos cualquier cantidad de caracteres, uno a continuación del otro; o un rango del abecedario o de los números enteros del 0 al 9.

Ejemplos:
“c[ao]sa” coincide con “casa” y con “cosa”
“[a-f]” coincide con todos los caracteres alfabéticos de la “a” a la “f”
“[0-9][2-6][ANR]” coincide con “12A“, “35N“, “84R“, etc..
pero no con “21A“, ni “33L“, ni “3A“, etc…

Dentro de los corchetes, hay que tener en cuenta que el símbolo ^ ya no significa inicio, sinó que es un negador, es decir: “[^a-Z]” coincidirá con cualquier texto que NO tenga ningún caracter alfabético (ni minúsculas ni mayúsculas), y “^@ ” coincide con cualquier caracter excepto “@” y “espacio”

Alternancia

Para alternar entre varias opciones, usaremos el símbolo | (barra vertical, en los teclados suele ser “Alt Gr + 1″). Con este mecanismo haremos un disyuntor, que nos permitirá dar varias opciones. Si una de ellas coincide, el patrón será cierto.

Ejemplos:
“aleman(ia|es)” coincide con “alemania” y con “alemanes”
“(norte|sur|este|oeste)” coincide con cualquiera de los puntos cardinales.

Agrupadores

Los paréntesis nos sirven para agrupar un subconjunto. Como hemos visto en el ejemplo anterior, nos es útil para definir la alternancia, pero agrupar un subpatrón nos permite trabajar con él como si fuera un único elemento.

Ejemplos:
“(abc)+” coincide con “abc“, “abcabc“, “abcabcabc“, etc
“ca(sca)?da” coincide con “cascada” y con “cada”

Escapar caracteres

Si por ejemplo quisiéramos que en el patrón hubiese un punto, o un símbolo asterisco, sin que se interprete como metacaracter, tendremos que “escaparlo”. Esto se hace poniendo una barra invertida justo antes: \. o \*
Esto puede hacerse con cualquier caracter que quieras introducir de forma literal, y no interpretada.

Las funciones

Una vez tenemos clara la sintaxis, nos pondremos manos a la obra con el código. En este caso usaremos las funciones que nos proporciona PHP, aúnque la sintaxis es común a muchos lenguajes.

Funciones tipo POSIX

Existen seis funciones de este tipo, que son las siguientes:

• ereg(). Devuelve true si se cumple el patrón, o false si no se cumple.
• eregi(). Igual que ereg(), pero sin distinguir mayúsculas y minúsculas
• ereg_replace(). Usando la potencia de las expresiones regulares, permite modificar una cadena de texto.
• eregi_replace(). Igual que la anterior, sin distinguir minúsculas y mayúsculas.
• split(). Divide una cadena en un array, según un patrón REGEX. Hace la misma tarea que la función explode, pero indicando una expresión regular como separador.
• spliti(). Igual que el anterior, sin diferenciar minúscula y mayúscula.

Funciones tipo PCRE

Estas funciones son un poco más complejas, y consecuentemente más potentes. La diferencia más significativa en cuanto a sintaxis es que el patrón deberá estar delimitado por dos caracteres. Usualmente se usan barras ( / ), aunque podemos usar cualquier símbolo, como ( # ), sobretodo en un patrón que contenga barras. Otra diferencia importante son los modificadores.

• preg_match(). Chequea el patrón en una cadena alfanumérica. Devuelve true si coincide, o false en caso contrario. Además captura las coincidencias en un array.
• preg_match_all(). Igual que preg_match, pero almacenando todas las subcadenas que coincidan con el patrón (no sólo una como es el caso de preg_match)
• preg_replace(). Nos permite reemplazar textos mediante expresiones regulares. Los argumentos pueden ser arrays, con lo que se realiza más de una sustitución con una sola función.
• preg_split(). Separa la cadena dada mediante una expresión regular.
• preg_grep(). Busca el patrón dentro de un array, y devuelve otro array con las ocurrencias.

Ejemplos prácticos

A continuación muestro algunos ejemplos de uso de estas funciones:

Uso sencillo de preg_match.

Uso de la referencia hacia atrás en preg_match_all

Simple comprobación con el patrón de IP

Referencias

• Expresiones Regulares (Ignside), lectura muy recomendada
• Funcionamiento interno de los RegEx (Inglés), si tienes curiosidad y entiendes inglés.
• Librería de expresiones regulares ya hechas, para no reinventar la rueda.
• Referencia sintaxis de funciones PCRE del manual oficial.
• Referencia Modificadores del manual oficial.
• Expresión Regular en Wikipedia
• Tutorial de Expresiones Regulares en Wikilearning

Lo primero de todo, crearemos un par de funciones.

La función menor() devuelve el menor de los dos números pasados como parámetros. La función mayor() hará lo contrario.

La forma clásica

La forma más típica de ejecutar una función, es símplemente escribiendo su nombre, seguido de unos paréntesis, con los parámetros separados por comas. De esta forma, al escribir:

Nos devolvería el siguiente texto:

Entre 12 y 5, el menor es 5

Con la función call_user_func(_array)

Las función call_user_func nos permite ejecutar una función, dado el nombre en cadena alfanumérica.

La diferencia con call_user_fucn_array, es que en esta última los parámetros son pasados en un array.

Dependiendo de la variable GET comparación, se ejecutará una función u otra. La alternativa con call_user_func_array es:

Directamente de una cadena

Esta es una forma sorprendente de ejecutar funciones. Parte de lo mismo que la anterior, el nombre de la función en una variable alfanumérica. Pero en este caso puede ser tratada directamente como función, así por la cara.

Esta libertad recuerda a JavaScript, donde pueden igualarse variables a funciones de forma muy sencilla.

Conocéis alguna forma más? Os parece útil disponer de diferentes métodos para llamar a funciones?

Instanciación

El primer paso para usar esta librería es siempre el mismo, independientemente de lo que queramos hacer:

Como se observa, hemos incluido el fichero de la librería, y hemos instanciado la clase PclZip, con un nombre de archivo.
Este nombre de archivo puede ser uno existente, que queremos manipular, o uno inexistente, que queremos crear a continuación. Será más adelante cuando le indicamos lo que queremos hacer con archivo.zip (leer o escribir), hasta aquí únicamente lo hemos referenciado.

Lectura

En caso de que el archivo Zip sí exista, y queramos explorar su contenido, tenemos varias alternativas.

La primera es usar el método listContent(), el cual nos devuelve una lista de propiedades de los archivos y carpetas contenidos en el archivo zip.

Lo cual nos devuelve algo como esto:

File 0 / [filename] = data/file1.txt
Archivo 0 / [stored_filename] = data/file1.txt
Archivo 0 / [size] = 53
Archivo 0 / [compressed_size] = 36
Archivo 0 / [mtime] = 1010440428
Archivo 0 / [comment] =
Archivo 0 / [folder] = 0
Archivo 0 / [index] = 0
Archivo 0 / [status] = ok

Archivo 1 / [filename] = data/file2.txt
Archivo 1 / [stored_filename] = data/file2.txt
Archivo 1 / [size] = 54
Archivo 1 / [compressed_size] = 53
Archivo 1 / [mtime] = 1011197724
Archivo 1 / [comment] =
Archivo 1 / [folder] = 0
Archivo 1 / [index] = 1
Archivo 1 / [status] = ok

Si nos interesa más extraer el contenido descomprimiendo archivos y carpetas, tendremos que usar el método extract(), el cual nos brinda muchas opciones. Veamos un ejemplo:

En este ejemplo todos los archivos se extraen en la carpeta “data”. Todos los archivos cuya ruta empiece por “install/release”, serán extraidos directamente en “data”, y no en “data/install/release”.

Existen muchas opciones con las que indicar exactamente lo que queremos que haga al extraer nuestros archivos. Puedes consultarlas en la documentación.

Escritura

Si tu intención es crear un archivo zip “al vuelo”, esta librería también va a yudarte, gracias al método create(), que creará un archivo zip con los archivos y carpetas que le indiquemos. Si le indicamos una carpeta, automáticamente incluirá todo el contenido en su interior. Además mantendrá la estructura de carpetas intacta dentro del archivo zip que creemos.

En el anterior código los archivos “file.txt” y “text.txt”, que se encuentran en la carpeta “data”, en el archivo zip creado se encontrarán en la carpeta “install”.

La librería nos permite manipular archivos zip con toda comodidad, usando los métodos add(), delete() o merge() , que añade archivos, elimina archivos, y fusiona archivos, respectivamente.

Ejemplo de añadir archivos:

Como podéis ver, se trata de una librería completa y funcional. Recomiendo su uso frente a otras alternativas.

Si quieres ver un ejemplo de su uso, puedes echar un vistazo al explorador de archivos zip que he incorporado en Codis.

Descargar pclzip-2-6.zip