Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Webmasters - Curso de
Webmasters - Curso de
En este curso aprenderemos desde cero a utilizar PHP para poder crear
aplicaciones en el lado del servidor con acceso a bases de datos,
manipulación de imagenes...
1. Introduccion al PHP
PHP es lo que llamamos un lenguaje de programacion del lado del
servidor, esto significa que el código se interpreta en el...
2. Instalar fácilmente Apache y PHP
Es muy duro para los novatos en PHP instalar un servidor al ordenador
para comprobar sus códigos. Yo ya hará unos tres meses que...
3. Comentarios
Para que en futuras revisiones a tu código por tu parte y sobretodo por
parte de otros programadores este código sea inteligible...
4. Variables
Una variable es un nombre que contiene unos determinados datos, ya
sean de texto o numéricos, y en php tienen la peculiaridad de...
5. Constantes
Una constante es como una variable pro con la diferencia que una vez
toma un valor este no puede variar durante la ejecucion del...
6. Tipos de datos en PHP
PHP es un lenguaje de los denominados de tipado dinámico, lo que
significa que una misma variable puede tener tipos ( numero,...
7. Vectores en PHP
Los vectores o array ( a veces mal llamados arreglos ) son listas
ordenadas de elementos. Para definir un vector en PHP...
8. Operadores
Los operadores son expresiones que nos permiten manipular los datos
que les pasamos, cada uno de los datos que se le pasa a un...
8.1. Operadores de Aritmética
Los operadores de aritmética són los operadores básicos para el trabajo
con números, nos permiten sumar dos valores,...
8.2. Operadores de Asignación
Los operadores de asignación, són aquellos que nos permiten modificar
el valor de una variable, el operador de asignación...
8.3. Operadores de Comparación
Los operadores de comparación son operadores en su mayoría binarios
que nos permiten comparar variables devolviendo un valor...
8.4. Operadores de Control de Errores
Para evitar que se muestre en página un determinado error que se
puede producir eventualmente en una linea PHP dispone del...
8.5. Operadores de Incremento
Los operadores de incremento (++) permiten aumentar en una unidad el
valor de una variable numérica, los de decremento (--)...
8.6. Operadores de Logica
Los operadores de Lógica nos permiten crear expresiones mas
complejas para evaluar nuestras estructuras de control,...
8.7. Operadores de Cadena
En esta categoría encontramos el operador binario de concatenacion (.),
que se encarga de unir dos cadenas dadas la una a...
9. Estructuras de control
Porque los scripts PHP no son lineales, debemos poder controlar la
ejecucion de una acción o de un determinado bloque de...
9.1. Condicional if
La estructura if nos permite ejecutar un bloque de acciones si se cumple
una determinada condicion, de lo contrario nos...
9.2. Bucle while
Esta instruccion nos permite efectuar un bloque de acciones mientras se
cumpla una determinada condicion, cuando deje de...
9.3. Bucle do while
El bucle do while es en su esencia igual al bucle while con la diferéncia
de que ejecuta las acciones antes de comprobar la...
9.4. Bucle for
El bucle for nos permite ejecutar un determinado bloque de acciones un
número determinado de veces, a esta estructura le...
9.5. Bucle foreach
El bucle foreach nos permite iterar para cada elemento de un vector, su
sintaxi es sencilla, solo hay que indicar el...
9.6. El ciclo switch
En muchas ocasiones, programando en PHP, nos encontramos que
queremos hacer una u otra acción dependiendo del valor de una...
10. Las funciones
En toda aplicacion mas o menos compleja hay bloques de acciones que
realizamos mas de una vez y PHP no es una excepcion, para que...
11. Procesamiento de formularios
Al enviar un formulario HTML, los datos són enviados al servidor Web y
este es capaz de procesarlos y realizar un seguido de...
12. Cookies en PHP
Antes de leer este artículo recomiendo leer el artículo cookies en
JavaScript pues aquí no explicare que es una cookie, sólo como...
13. Envio de Emails
En este articulo aprenderemos a enviar emails (correo electrónico) de
una forma compleja, gracias a mis experiencias. Antes...
14. Sesiones PHP
Utilizaremos sesiones para almacenar una serie de variables en el
servidor relacionándolas ( grácias a una variable pasada por...
15. PHP orientado a objetos
Cuando a principios de los años 80 se empezó a experimentar la
Programacion Orientada a Objetos (POO) esta ha ido suplantando la...
16. Image GD, descripción y ejemplos
A menudo, cuando estamos programando una aplicación, contamos con
una gran cantidad de datos interesantes para el usuario pero...
16.1. Creación de una imagen con GD
El primer paso para empezar a trabajar con gráficos y image GD, es la
creación de una imagen, que puede ser en blanco (para...
16.2. Uso del color con GD
La utilización de colores en GD es algo mas compleja que en HTML
aunque ambos utilizan el modelo RGB. Crear un color...
16.3. Dibujo de líneas con GD
En este tutorial de 3 páginas veremos cómo podemos dibujar todo tipo
de líneas (normales, gruesas, discontinuas, punteadas......
16.4. Dibujo de rectángulos con GD
Con GD, podemos dibujar rectángulos y rectángulos coloreados
facilmente utilizando las funciones que explicaremos en este...
16.5. Dibujo de arcos y elipses con GD
Una elipse es una sección cónica, una especie de huevo, y un caso
particular de elipse es el círculo, por otra parte, un arco...
Introduccion al PHP
PHP es lo que llamamos un lenguaje de programacion del lado del servidor,
esto significa que el código se interpreta en el servidor y no en el ordenador
del usuario.
Vamos a ver un ejemplo sencillo de código escrito en php para que nos sea
mas fácil de comprender:
000 <html>
001 <head>
002
<title>Prueba</title>
003
004 </head>
005 <body>
006 <?
007
008 $texto = "Hola mundo";
009 echo $texto;
010 ?>
011
</body>
</html>
Maximizar Seleccionar XML,PHP
Este código producirá el siguiente resultado que es lo que se enviará al
navegador del visitante:
000 <html>
001 <head>
002
<title>Prueba</title>
003
004 </head>
005 <body>
006 Hola mundo
007 </body>
</html>
Maximizar Seleccionar XML
Vemos que el código php esta delimitado por las etiquetas <? y ?>, aunque
tambien puede usarse <?php en lugar de <?.
Otra característica del php es que las variables se identifican con el signo del
dolar ($) y que cada instruccion debe finalizarse con un punto y coma (;).
Todo esto se puede instalar por separado, o se puede hacer con paquetes
que instalan y configuran PHP, Apache y MySQL. Aunque en este capítulo
enseñaré a instalar el XAMPP, existen otros como el WAMP o el easyPHP.
Tabla de contenido
· El XAMPP
· Otros paquetes.
El XAMPP
El XAMPP es el único paquete de los que hemos comentado en este capítulo
disponible para multiplataforma (Windows, Mac OS X, GNU/Linux y Solaris).
Incluye, entre otros, aplicaciones como el Apache, el MySQL, el intérprete
PHP, el OpenSSL, el phpMyAdmin, el Mercury Mail Transport System y el
FileZilla FTP Server.
Una vez bajado el ejecutable, lo abrimos y vemos que nos pregunta por el
idioma en que queremos realizar la instalación (hay 11, uno de ellos el
español).
Proceso de instalación.
La instalación se ha finalizado.
Otros paquetes.
Además del XAMPP, hay otros paquetes de instalación del servidor local. No
os quedéis tan solo con esto, probar ne tantos como podáis. Aquí os dejo dos:
EasyPHP
WAMP Server
WAMP es el acrónimo de Windows Apache MySQL PHP. Es bastante más
completo, ya que incorpora el PHP5, el Apache 2 y el MySQL 5. No dispone
de más idiomas que no sean el inglés o el francés y ocupa unos 17 MB.
Comentarios
Para que en futuras revisiones a tu código por tu parte y sobretodo por parte
de otros programadores este código sea inteligible para la mente humana, es
un buen costumbre comentar lo que se esta haciendo en PHP pero en
palabras.
Los comentarios que soporta PHP són los de C, C++ y los del shell de Unix,
asi podemos usar // y /* */ para comentarios y comentarios multilinea
respectivamente como haríamos en C:
000 <?
001 echo 'Esto se ve';
002 // esto no se ve
003 echo 'esto tambien se ve';
004 /* esto tampoco
005 se ve */
006 ?>
Maximizar Seleccionar PHP
000 <?
001 # esto no se ve
002 echo 'pero esto si';
003 ?>
Maximizar Seleccionar PHP
000 <?
001 /* /* No hacer nunca esto */ */
002 ?>
Maximizar Seleccionar PHP
Como veis, PHP interpreta como comentario desde el primer /* al primer */ sin
tener en cuenta que hay otro */, esto nos producirá un error asi que habrá que
tener cuidado.
Variables
Una variable es un nombre que contiene unos determinados datos, ya sean
de texto o numéricos, y en php tienen la peculiaridad de ir precedidas por el
signo del dolar ($).
000 <?
001 $miVariable = 'Hola ';
002 $miVariable2 = 33;
003 // Imprimimos Hola 33
004
005
echo $miVariable.$miVariable2;
?>
Maximizar Seleccionar PHP
Como vemos, asignamos valor a una variable con el operador de igualdad (=),
y concatenamos con el operador punto (.).
000 <?
001 $nombreVariable = "miVariable";
002 $$nombreVariable = "Hola";
003 // Imprimimos Hola
004
005
echo $miVariable;
?>
Maximizar Seleccionar PHP
Para que una variable sea accesible desde cualquier parte de nuestro script
php, la definiremos cómo global de la siguiente manera:
000 <?
001 global $miVariableGlobal = 'Hola';
002 ?>
Maximizar Seleccionar PHP
Variables predefinidas
El PHP tiene muchas variables predefinidas, pero hay que tener en cuenta
que todas estas variables no suelen estar activas en todos los servidores,
para saber de que variables disponemos, podemos usar la función de info de
PHP:
000 <?
001 phpinfo();
002 ?>
Maximizar Seleccionar PHP
Estas són las variables que usaremos más comunmente y que probablemente
nuestro servidor tendra correctamente habilitadas:
1 $SERVER_NAME
Cuando imprimimos a nuestros servido la variable $SERVER_NAME nos
devolverá normalmente el nombre del server si estamos trabajando en local
nos saldria http://localhost/ o el nombre que le hayamos puesto a la maquina y
si tenemos la web alojada por ejemplo en este caso nos
saldría www.programacionweb.net
2 $SERVER_SOFTWARE
En este caso nos saldria el servidor que andamos usando si usamos el IIS o
el apache tal version.
3 $DOCUMENT_ROOT
En la variable DOCUMENT_ROOT lo que nos pasaria cuando imprimimos en
el navegador nos diria la ruta del fichero exacta , tambien pensando depende
de la configuracion delservidor que no dara su ruta, no penseis que nos dará
www.nuestraweb.com/nuestroarchivo.php ke este no es caso
4 $HTTP_REFERER
Haciendo referers queremos decir que nos dira de donde procede la persona
que visita nuestra web, es decir , de donde viene.
5 $HTTP_USER_AGENT
Como muy bien dice la siguiente variable es USER_AGENT y que quiere decir
esto? Pues que nos dira en que navegador estamos utilizando,
Netscape,mozilla,Internet Explorer,etc...
6 $REMOTE_ADDR
Esta variable nos puede ser muy util por un motivo muy concreto, ¿Cuantas
veces hemos pensado quiero saber la IP del visitante que nos esta visitando?
Pues esta misma variable es la que nos ayuda a esto
7 $SERVER_ADMIN
Simplemente nos devolverá el email de configuracion del servidor donde esta
alojado el script PHP.
8 $REQUEST_METHOD
Si imprimimos esta variable nos devolvera el tipo de petición que usamos para
acceder a la pagina si fue con POST o con GET
9 $HTTP_ACCEPT
Los tipos de archivos que el visitante puede recibir de este servidor con el
navegador actual
10 $REMOTE_PORT
Como ya habiamos comentado la variable de $REMOTE_ADDR no ibamos a
dejar aparte el puerto que se esta utilizando para comunicarse con el servidor
web
NOTA: No nombré todas las variables predefinidas, todo hay que decirlo esto
es un breve resumen hay muchas mas
Constantes
Una constante es como una variable pero con la diferencia que una vez toma
un valor este no puede variar durante la ejecucion del script, otra
particularidad de las constantes es que son globales, por lo que se pueden
leer desde el interior de una funcion sin tener que pasarlas como parametro.
Al contrario que las variables, las constantes se expresan sin signo del dolar
($), y se tienen que definir usando la funcion define:
000 <?
001 define ('miConstante','valor de mi constante');
002 echo miConstante;
003 ?>
Maximizar Seleccionar PHP
Existe otra funcion, llamada defined que nos permite saber si se ha declarado
una constante determinada, lo haremos de la siguiente manera:
000 <?
001 $definida = defined("miVariable");
002 // Mostrara 0 si existe la variable y 1 si no existe
003 echo $definida;
004 ?>
Maximizar Seleccionar PHP
En algunos casos no es posible acceder al valor de una constante
directamente por su nombre, pues este nombre puede coincidir con el de una
funcion y el resultado producido no sería el esperado, en ese caso usaremos
la funcion constant para leer el valor de dicha constante:
000 <?
001 define ('echo','valor de mi constante');
002 echo constant('echo');
003 ?>
Maximizar Seleccionar PHP
Constantes mágicas
Existen unas constantes llamadas magicas que son accesibles para cualquier
script PHP, estas nos proporcionan información sobre el script que depende
del lugar en el que las usemos:
__FILE__ - Contiene el nombre y la ruta del archivo que se está ejecutando
__LINE__ - Contiene la línea que se está ejecutando en ese momento exacto
del fichero actual
__FUNCTION__ - Añadida en la versión 4.3 de PHP, contiene el nombre de la
función que se está ejecutando actualmente
__CLASS__ - Añadida tambien en la versión 4.3, contiene el nombre de la
clase que se ejecuta actualmente
__METHOD__ - Añadida el la versión 5, contiene el nombre del método actual
000 <?php
001 // La variable $var1 es un numero ( entero )
002 $var1 = 3;
003 // La variable $var2 es un texto ( cadena de caracteres )
004 $var2 = "9 años";
005
006 // Si juntamos las variables $var1 y $var2, obtenemos un texto
007
008 $var3 = $var1 . $var2; // "39 años"
009 // Si en cambio las sumamos obtendremos un número
$var3 = $var1 + $var2; // 12 ( 3 + 9)
?>
Maximizar Seleccionar PHP
boolean - Lógico
Puede contener 2 valores True o False. Al usarlo cómo entero su valor puede
ser 1 ( True ) o 0 ( False ).
000 <?php
001 $var1= 1 != 2 ; // $var1 es true
002 ?>
Maximizar Seleccionar PHP
integer - Entero
Puede contener enteros ( sin decimales ) positivos y negativos, se pueden
escribir en notación octal, decimal y hexadécimal:
000 <?php
001 $var1 = 027; // Notación octal ( 23 en decimal )
002 $var1 = 23; // Notación decimal
003
$var1 = 0x17; // Notación hexadecimal ( 23 en decimal )
004
?>
Maximizar Seleccionar PHP
float - Decimal
Las cadenas con comillas dobles, a parte de \" y \' tienen otros caracteres
especiales:
\n - Salto de línea (en el código, no en la presentación de la pág.)
\r - Retorno de carro (Enter)
\t - Tabulador
\$ - Dólar
La existencia de un carácter especial \$ para el dólar, es porque en el interior
de comillas dobles podemos usar variables. Si vamos a acceder a elementos
de un vector, lo agruparemos con { y } detrás del $:
null - vacío
No tiene valor, se comporta como cadena vacía, cero o false;
array - vector
Los veremos en profundidad en el próximo capítulo vectores en PHP.
object - Objeto
Los veremos más adelante en el capítulo PHP orientado a objetos
Vectores en PHP
Los vectores o array ( a veces mal llamados arreglos ) son listas ordenadas
de elementos. Para definir un vector en PHP utilizamos la función array:
000 <?php
001 $vector = array ( "elemento 1", "elemento 2" );
002 ?>
Una vez definido el vector, podemos acceder a sus elementos, sus elementos
estarán identificados por un número ( empezando por 0 ) o una clave que se
puede definir así:
000 <?php
001 $vector = array ( "clave 1" => "elemento 1", "clave 2" => "elemento 2" )
002 ;
?>
000 <?php
001 echo $vector[0];// elemento 1
002 echo $vector['clave 1'];// elemento 1
003 ?>
Maximizar Seleccionar PHP
000 <?php
001 $vector = array ( "elemento 1", "elemento 2" );
002 // Añadimos "elemento 3" al final
003 $vector[] = "elemento 3";
004 // Añadimos un elemento con clave "clave 3"
005
$vector['clave 3'] = "elemento 4";
006
007 // Cambiamos el texto al elemento 3 ( 2 contando el 0 )
008 $vector[2] = "elemento N";
009 // Borramos el 'clave 3';
010 unset ( $vector['clave 3'] );
011 print_r ($vector);
012 /* Array
013 (
014 [0] => elemento 1
015 [1] => elemento 2
016 [2] => elemento N
) */ ?>
Maximizar Seleccionar PHP
Array ( [0] => elemento 1 [1] => elemento 2 [2] => elemento 3 [3] => elemento N )
Operadores
Los operadores son expresiones que nos permiten manipular los datos que
les pasamos, cada uno de los datos que se le pasa a un operador se llama
operando, y según el número de operandos de que disponga un operador
estaremos hablando de un operador unario (un operando), binario (dos
operandos), ternario...
Los operadores no los utilizamos aisladamente, sino que solemos utilizar mas
de uno en una misma expresión compleja, en este caso tendremos que tener
en cuenta las normas de preferencia para no encontrarnos con resultados no
deseados.
Tabla de contenido
· Normas de preferencia
· Tipos de operadores
Normas de preferencia
Las operaciones no se realizarán de izquierda a derecha sino que se
realizarán siguiendo un orden de preferencia que PHP asigna a cada
operando, estas son las preferencias de PHP en cuanto a los operadores:
new
[
! ~ ++ -- (int) (float) (string) (array) (object) @
*/%
+-.
<< >>
< <= > >=
== != === !==
&
^
|
&&
||
?:
= += -= *= /= .= %= &= |= ^= <<= >>=
print
and
xor
or
,
Para cambiar el orden en que se realizan las operaciones utilizaremos los
paréntesis (), consiguiendo que se realicen primero las operaciones del
interior del paréntesis y, acto seguido, el resto de operaciones siguiendo en
cada caso el mismo orden de preferencia anteriormente citado:
000 <?php
001 // el operador de multiplicación es l signo asterisco ( * )
002 $a = 2 + 4 * 2; // El resultado es 10
003
$a = (2+4) * 2; // el resultado es 12
004 ?>
Maximizar Seleccionar PHP
Tipos de operadores
PHP dispone de una gran cantidad de operadores que podríamos organizar
en las siguientes categorías:
Operadores de Aritmética
Operadores de Asignación
Operadores Bit a Bit
Operadores de Comparación
Operadores de Control de Errores
Operadores de ejecución
Operadores de Incremento
Operadores de Lógica
Operadores de Cadena
Operadores de Matrices
Operadores de Tipo
Estos operadores en su mayor parte són para trabajar con valores numéricos,
a excepción de los 4 últimos de la lista anterior, y se explicaran uno a uno en
el curso de operadores PH
Operadores de Aritmética
Los operadores de aritmética són los operadores básicos para el trabajo con
números, nos permiten sumar dos valores, restarlos, dividirlos... Se trata de
operadores binarios en todos los casos ya que requieren dos operandos para
funcionar correctamente.
000 <?
001 $a = 3 % 2; // $a toma valor 1
002 ?>
Maximizar Seleccionar PHP
.
Operadores de Asignación
Los operadores de asignación, són aquellos que nos permiten modificar el
valor de una variable, el operador de asignación básico es el 'es igual a' (=),
que da el valor que lo sigue a la variable que lo precede:
000 <?
001 $miVariable = 'suValor';
002 ?>
Maximizar Seleccionar PHP
000 <?
001 $a = 1;
002 $a += 1; // Sumamos y asignamos
003
$a = $a + 1; // Operacion equivalente
004
?>
Maximizar Seleccionar PHP
En este ejemplo vemos que podemos poner el operador de suma seguido del
de asignacion para incrementar el valor de la variable, asimismo podriamos
usar el operador de concatenacion (.=), el de multiplicacion (*=)...
consiguiendo efectos similares.
Operadores de Comparación
Los operadores de comparación son operadores en su mayoría binarios que
nos permiten comparar variables devolviendo un valor booleano a 1 (TRUE) si
se cumple la condición que expresan y a 0 (FALSE) en el caso contrario.
000 <?
001 echo ($variable == 1) ? 'Vale 1' : 'Vale mas de uno';
002 ?>
Maximizar Seleccionar PHP
Este operador que se representa con el signo arroba (@), permite evitar que
se imprima en la página de resultado un error prodcido por la ejecución del
código PHP en una línea determinada:
000 <?php
001 echo 'Hola mundo';
002 @ funcionquenoexiste (); // Esto debería producir un error
003 ?>
Maximizar Seleccionar PHP
Encontrarás mas informacion sobre este operador y otros métodos para evitar
errores eneste artículo del usuario include.
Operadores de Incremento
Los operadores de incremento (++) permiten aumentar en una unidad el valor
de una variable numérica, los de decremento (--) por lo contrario disminuyen
la misma variable en una unidad.
000 <?
001 $variable = 2;
002
echo $variable++; // Imprime 2 y luego incrementa
003
004 echo ++$variable; // incrementa y luego imprime 4
?>
Maximizar Seleccionar PHP
Operadores de Logica
Los operadores de Lógica nos permiten crear expresiones mas complejas
para evaluar nuestras estructuras de control, permitiendonos enlazar
varias operaciones de comparación con los diferentes operadores booleanos.
000 <?
001 echo ((1 == 1)&&(2 != 2)); // Devuelve 0
002 ?>
Maximizar Seleccionar PHP
Existe otro operador lógico, en este caso unario, que es el operador No (!),
este operador delante de un valor binario, devuelve el valor contrario (0 si es 1
y 1 si es 0):
000 <?
001 echo !((1 == 1)&&(2 != 2)); // Devuelve 1
002 ?>
Maximizar Seleccionar PHP
Operadores de Cadena
En esta categoría encontramos el operador binario de concatenacion (.), que
se encarga de unir dos cadenas dadas la una a continuacion de la otra:
000 <?
001 $texto = 'hola ' . 'mundo';
002 echo $texto;
003 ?>
Maximizar Seleccionar PHP
000 <?
001 $texto = 'hola ';
002 $texto .= 'mundo';
003 echo $texto;
004 ?>
Maximizar Seleccionar PHP
Este operador nos será de gran utilidad para almacenar una gran cantidad de
datos en una misma variable de manera limpia, veamos un ejemplo:
000 <?
001 $html = "<html>\n";
002 $html .= "<head>\n";
003
004 $html .= "<title>Mi página</title>\n";
005 $html .= "</head>\n";
006
$html .= "<body>\n";
007
008 $html .= "Este es el contenido de mi\n";
009 $html .= "preciosa página\n";
010 $html .= "</body>\n";
011 $html .= "</html>\n";
echo $html;
?>
Maximizar Seleccionar PHP
Estructuras de control
Porque los scripts PHP no son lineales, debemos poder controlar la ejecucion
de una acción o de un determinado bloque de acciones, para hacer esto, PHP
dispone de lo que se llama estructuras de control, que nos permiten ejecutar o
no, una o mas veces un determinado bloque de acciones.
Condicional if
La estructura if nos permite ejecutar un bloque de acciones si se cumple una
determinada condición, de lo contrario nos permite ejecutar otro bloque de
acciones identificado por la sentencia else, si el resultado de la condición es
distinto de 0, se ejecutarán las acciones del if, de lo contrario las del else:
000 <?
001 if($var1 == 12){
002 echo 'La variable vale 12';
003 }
004 else {
005 echo 'La variable tiene otro valor';
006 }
007
?>
Maximizar Seleccionar PHP
Hay otra sentencia que usamos a menudo para unir más de un condicional if,
es la sentencia elseif, ésta nos permite dar otra condición por si no se ha cumplido la
primera, después de elseif podemos volver a usar else con normalidad:
000 <?
001 if($var1 == 12){
002 echo 'La variable vale 12';
003
004 }
005 elseif($var1 == 3){
006 echo 'La variable vale 3';
007 }
008 else {
009
010 echo 'La variable tiene otro valor';
}
?>
Maximizar Seleccionar PHP
En este caso, si var1 es distinto de 12, evaluará si vale 3, si es así mostrará el segundo
mensaje, si no el tercero.
Bucle while
Esta instruccion nos permite efectuar un bloque de acciones mientras se
cumpla una determinada condicion, cuando deje de cumplirse, se continuará
ejecutando el resto del código PHP, la condicion se cumple mientras no de
resultado 0 y esta formada poroperaciones PHP, sobretodo por operaciones
lógicas y de comparacion.
000 <?
001 $var1 = 0;
002 while($var1 < 10){
003 echo "\$var1 = $var1<br>";
004 $var1++; // Incrementamos la variable
005 }
006 ?>
Maximizar Seleccionar PHP
Hay que tener cuidado con este tipo de bucle, en el interior del bloque de
acciones siempre se debe modificar algun parametro de la condicion para que
esta acabe cumpliendose, de lo contrario crearemos un bucle infinito.
Bucle do while
El bucle do while es en su esencia igual al bucle while con la diferéncia de
que ejecuta las acciones antes de comprobar la condicion, consiguiendo que
se ejecuten las acciones una vez si la condicion retorna 0 o FALSE, así, este
bucle se ejecutará siempre una vez mas que while si tienen la misma
condicion:
000 <?
001 $var1 = 0;
002 do {
003 echo "\$var1 = $var1<br>";
004 $var1 ++;
005 } while ($var1 <= 10);
006 ?>
Maximizar Seleccionar PHP
$var1 = 0
$var1 = 1
$var1 = 2
$var1 = 3
$var1 = 4
$var1 = 5
$var1 = 6
$var1 = 7
$var1 = 8
$var1 = 9
$var1 = 10
Bucle for
El bucle for nos permite ejecutar un determinado bloque de acciones un
número determinado de veces, a esta estructura le pasaremos tres
parámetros que separaremos por punto y coma (;) y que serán:
accion inicial - Inicializa la variable de control del bucle
condicion - Se evalua en cada iteracion, cuando devuelve 0 o FALSE se
continua ejecutando el código de después del for
accion - Se ejecuta en cada bucle y debe modificar la variable de la condicion
Vamos a ver un ejemplo para que nos quede todo claro, ya que el concepto
puede costar un poco de comprender.
000 <?
001 for ($var1 = 0; $var1 < 10; $var1++){
002 echo "\$var1 = $var1";
003 }
004
?>
Maximizar Seleccionar PHP
Bucle foreach
El bucle foreach nos permite iterar para cada elemento de un vector, su sintaxis es sencilla, solo hay que
indicar el identificador de la matriz, la expresion as y seguidamente la variable que identificará el valor del
elemento:
000 <?
001 $vector =array("uno", "dos", "tres");
002 foreach ($vector as $valor) {
003
004 echo "Valor: $valor<br>";
005 }
?>
Maximizar Seleccionar PHP
Esta expresión tambien nos permite trabajar con vectores con indice, en este caso trabajaremos así:
000 <?
001 $vector = array(
002 "uno" => 1,
003
"dos" => 2,
004
005 "tres" => 3,
006 "diecisiete" => 17
007 );
008 foreach($vector as $indice => $valor) {
009
010 print "\$vector[$indice] => $valor.\n";
}
?>
Maximizar Seleccionar PHP
Como vemos en este caso especificamos la variable que identifica el indice y la que
identifica el valor separadas por =>
El ciclo switch
En muchas ocasiones, programando en PHP, nos encontramos que queremos
hacer una u otra acción dependiendo del valor de una variable, en este caso,
podríamos usar una sucesión de condicionales if, pero el código resultante
será confuso y difícil de modificar en el futuro.
000 <?
001 switch ($i) {
002
case 0:
003
004 echo "Variable en valor bajo";
005 break;
006 case 1:
007 echo "Variable en valor alto";
008 break;
009 default:
010 echo "La variable no es binária";
011 }
?>
Maximizar Seleccionar PHP
Este código hará un switch para la variable $i, en el caso que esta sea 0,
imprimirá el mensaje 'Variable en valor bajo', si es 1 imprimirá 'Variable en
valor alto' y sino, nos dirá que la variable no es un número decimal.
Vemos que cada valor se relaciona con un caso, en el interior del cual
realizamos las acciones requeridas y una instrucción llamada break, de lo
contrario, se seguirían ejecutando las instrucciones de los demás casos.
000 <?
001 echo '<b>variable1:</b> '.$_POST["variable1"];
002
echo '<br><b>variable2:</b> '.$_POST["variable2"];
003
?>
Maximizar Seleccionar PHP
variables.php
000 <?
001 if(isset($_GET["mensaje"]))
002 switch ($_GET["mensaje"]){
003
004 case 0:
005 echo 'Bienvenido a mi web';
006 break;
007 case 1:
008 echo 'Mensaje 2';
009
010 break;
011 case 2:
012 echo 'Último mensaje';
013 break;
014 default:
015
echo 'Error en el parametro';
} else echo 'No se pasó parametro';
?>
Maximizar Seleccionar PHP
A partir de ahí, miramos si esta definida la variable para ver si esta pasada
con la funciónisset, luego hacemos un ciclo switch para mostrar un u otro
mensaje según el valor de la variable pasada.
El ejemplo, nos mostrará un mensaje distinto dependiendo de si mensaje vale
0, vale 1,vale 2, tiene otro valor o no esta definido.
Nota:
Debemos observar que según que parámetros pasemos por URL algunos
buscadores cómo google, no agregaran nuestra url, por ejemplo, google no
indexa páginas con la variable id.
Las funciones
En toda aplicación mas o menos compleja hay bloques de acciones que
realizamos mas de una vez y PHP no es una excepción, para que no
tengamos que escribir estas acciones repetidamente, todos los lenguajes de
un nivel mas o menos alto incorporan lo que llamamos funciones.
000 <?
001 function miFuncion ($argumento_1, $argumento_2) {
002 // Codigo de la funcion
003 }
004
?>
Maximizar Seleccionar PHP
Tabla de contenido
· Llamando a una funcion
· El valor de retorno
000 <?
001 miFuncion("hola", "pepe");
002 ?>
Maximizar Seleccionar PHP
El valor de retorno
Es interesante saber que las funciones pueden devolver un valor al lugar
donde las llamamos, esto se hace gracias a la instrucción return seguida del
valor de retorno, veamos este ejemplo:
000 <?
001 function saludo($nombre,$momento){
002 return "Hola $nombre buenas $momento";
003
004 }
005 echo saludo("Pepe","tardes");
?>
Maximizar Seleccionar PHP
Procesamiento de formularios
Al enviar un formulario HTML, los datos són enviados al servidor Web y este
es capaz de procesarlos y realizar un seguido de acciones en función de los
datos introducidos, los datos del formulario se envían utilizando uno de los
siguientes métodos, dependiendo delmethod del formulario:
GET - Los datos del formulario són enviados al servidor a través de los
encabezados HTTP, estos datos són visibles en la URL y en los logs del
servidor, es poco recomendado para datos de usuario.
POST - Los datos del formulario són enviados al servidor como datos de la
petición, no se recomienda para pasar parametros de modularización,
paginación...
Estos datos, podemos recojerlos desde nuestra aplicación PHP utilizando
los arrays superglobales, $_GET y $_POST de manera respectiva.
000 <?php
001 echo $_POST['telefono'];
002 ?>
Maximizar Seleccionar PHP
Tabla de contenido
· Pasando variables a la URL
· Obteniendo variables de la URL
· Conclusiones
Una vez abierto el formulario, podemos colocar algún input para que
ingresen un texto, por ejemplo el nombre de la persona:
Luego, para darle más dinamismo aún, colocaremos un select, donde podrán
elegir el valor de una lista predefinida por nosotros. En este caso
preguntaremos la edad:
000 </form>
Maximizar Seleccionar XML
000 <?
001 !$HTTP_GET_VARS
002
?>
Maximizar Seleccionar PHP
000 Hola <? echo"$nombre"; ?>, tu tienes <? echo"$edad"; ?> años.
Maximizar Seleccionar PHP
000 <?
001 !$HTTP_GET_VARS
002 ?>
003 <? $_GET['nombre']=$nombre; ?>
004
<? $_GET[‘edad’]=$edad; ?>
005
Hola <? echo"$nombre"; ?>, tu tienes <? echo"$edad"; ?> años.
Maximizar Seleccionar PHP
Conclusiones
Como habrán notado, es muy fácil pasar variables por la url para imprimirlas
en una página. Además del ejemplo, se puede jugar mucho con formularios y
hacer herramientas útiles
Cookies en PHP
Para usar cookies en PHP, tenemos que tener en cuenta que la cookie se
envia antes de enviar la página, es decir, que enviaremos la cookie al
navegador antes de enviar ningún caracter de la página o recibiremos un
error.
La función que usaremos para enviar una cookie es setcookie, que funciona
de la siguiente manera:
000 <?php
001 setcookie (nombre,valor,fecha);
002
?>
Maximizar Seleccionar PHP
Donde 'nombre', será un identificador de la cookie que contendrá el texto
indicado por 'valor' y que tendrá vigéncia hasta 'fecha'.
Vamos a hacer un ejemplo que incrementara el valor de una cookie cada vez
que se visite cierta página:
000 <?php
001 $visitas = $_COOKIE["visitas"]+1;
002 setcookie ("visitas", $visitas, time () + 7*24*60*60);
003
004 echo "Nos has visitado $visitas veces";
?>
Maximizar Seleccionar PHP
000 <?
001 $visitas = $_COOKIE["visitas"]+1;
002 ?>
Maximizar Seleccionar PHP
000 <?php
001 $visitas++;
002 setcookie ("visitas", $visitas, time () + 7*24*60*60);
003
004 echo "Nos has visitado $visitas veces";
?>
Maximizar Seleccionar PHP
Envio de Emails
En este articulo aprenderemos a enviar emails (correo electrónico) de una
forma compleja, gracias a mis experiencias.
Antes de nada recordaremos la chuleta:
000 <?
001 mail("destinatario","asunto","cuerpo","adicional");
002
?>
Maximizar Seleccionar PHP
Un ejemplo:
0 <?
0 mail("webmaster@programacionweb.net","Ejemplo de envio","Este email ha sido enviado a:\n\n\tw
0 ebmaster@programacionweb.net","Reply to: zarator@programacionweb.net");
0
0 ?>
1 Maximizar Seleccionar PHP
0
0
2
información@gtvfilm.net23.net
Asunto
El asunto de un mensaje es una introducción al contenido del mensaje. Este
campo no es obligatorio ya que si no lleva asunto aparece (sin asunto), si el
asunto es muy largo se te abreviará con ... (tres puntos) .
El mensaje será una línea de texto .. es decir no se ejecutará nada solo será
texto, menos \x. Hay tres códigos \t, \n y \r (esto también se ejecuta en alertas
html).
\n = salto de línea
\t = sangría
\r = vuelta de línea
Nota:
En algunos programas o servidores se confunde \r con \n (salto de linea).
Si es html:
Aquí se ejecuta todo tipo de html. Si el receptor del email usa hotmail deberás
saber que este modifica los códigos como los <a href='[externo?id=tuweb]'>
(pone cabecera) <p onclick=''> (si antes era onclick='a()' ahora se queda sin
nada), es decir censura algunos códigos.
Adicionales
Estos características se añaden después del contenido del mensaje y van
precedidos de un \n. Estos se muestran en la cabecera. Como su nombre
indica no son obligatorios.
Un ejemplo popular:
Una anécdota fue de que a un colega le colaron un virus desde un email que
incitaba a descargarselo. Observe que después de ejecutarse el virus llegaron
2 mensajes mas con virus uno de ellos decía que había un nuevo virus que te
descargaras sobreelvirus.pif (que también era virus) y en el siguiente decía
que había un portal de seguridad www.seguridadvirus.com y se adjuntaba
www.seguridadvirus.com (una cosa muy curiosa) puedes llamar a un archivo
www.yo.txt y por tanto la extensión *.com es un archivo MS-DOS y por tanto
puede ser virus.
Termino con esto los adicionales .. aun que no sean obligatorios aportan
mucha informacion.
0 <?php
0 /*EMAIL FORM Por Jorge Luis Martinez M
0 http://misCodigos.jlmnetwork.com*/
0
0
1 $ip = $REMOTE_ADDR;
0 $referido = getenv("HTTP_REFERER");
0
2 //Limite, Se Refiere Al Tamaño Maximo Que Puede Tener Un Archivo, Este Numer
0 o Se Da En Bytes.
0 $limite = 80000;
3
0 if(!isset($HTTP_POST_VARS["email"]))
0 {
4 ?>
0 <SCRIPT LANGUAGE="javascript">
0 alert("Debe Introducir El Email Al Que Desea Enviar La Informacion.\n\nServicio De Formularios\
5 nhttp://misCodigos.jlmnetwork.com/");
0 history.go(-1);
0 </SCRIPT>
6 <?
0 }
0 else
7 {
0
0 $mensaje = "Email Enviado Desde La Pagina, Con El Siguiente Contenido:\n\n";
8
0 while (list($variable, $contenido) = each($HTTP_POST_VARS))
0 {
9 if($variable != "archivo")
0 {
1 $mensaje .= $variable." = ".stripslashes($contenido);
0 $mensaje .= "\n";
0 }
1 }
1 $mensaje .= "\n";
0 $mensaje .= "Informacion Adicional:\n\n";
1 $mensaje .= "Enviado Desde: ".$referido."\n";
2 $mensaje .= "IP: ".$ip;
0 $mensaje .= "\n\nEnvio De Formularios Con Archivos Adjuntos, Un Servicio Gratuito De http://misC
1 odigos.jlmnetwork.com/";
3
0 $cabeceras = "From: misCodigos <miscodigos@jlmnetwork.com>\n";
1 $cabeceras .= "Reply-To: $email\n";
4
0 if($archivo != "none")
1 {
5 if($archivo_size > $limite)
0 {
1 ?>
6 <SCRIPT LANGUAGE="javascript">
0 alert("Lo Siento, El Archivo Ocupa Mas De <? echo $limite; ?> bytes, El Maximo Permitido Es De
1 <? echo $limite; ?> bytes.\n\nServicio De Formularios\nhttp://misCodigos.jlmnetwork.com/");
7 history.go(-1);
0 </SCRIPT>
1 <?
8 }
0 else
1 {
9 $file = fopen($archivo, "r");
0 $contenido = fread($file, $archivo_size);
2 $encoded_attach = chunk_split(base64_encode($contenido));
0 fclose($file);
0
2 $cabeceras .= "MIME-version: 1.0\n";
1 $cabeceras .= "Content-type: multipart/mixed; ";
0 $cabeceras .= "boundary=\"Message-Boundary\"\n";
2 $cabeceras .= "Content-transfer-encoding: 7BIT\n";
2 $cabeceras .= "X-attachments: $archivo_name";
0
2 $body_top = "--Message-Boundary\n";
3 $body_top .= "Content-type: text/plain; charset=US-ASCII\n";
0 $body_top .= "Content-transfer-encoding: 7BIT\n";
2 $body_top .= "Content-description: Mail message body\n\n";
4
0 $cuerpo = $body_top.$mensaje;
2
5 $cuerpo .= "\n\n--Message-Boundary\n";
0 $cuerpo .= "Content-type: $archivo_type; name=\"$archivo_name\"\n";
2 $cuerpo .= "Content-Transfer-Encoding: BASE64\n";
6 $cuerpo .= "Content-disposition: attachment; filename=\"$archivo_name\"\n\n";
0 $cuerpo .= "$encoded_attach\n";
2 $cuerpo .= "--Message-Boundary--\n";
7
0 mail($email,$asunto,$cuerpo,$cabeceras);
2 }
8 }
0 else
2 {
9 mail($email,$asunto,$mensaje,$cabeceras);
0 }
3 ?>
0 <SCRIPT LANGUAGE="javascript">
0 location.href = '<? echo $redireccion; ?>';
3 </SCRIPT>
1 <?
0 }
3 ?>
2 Maximizar Seleccionar SCRIPT,XML,PHP
0
3
3
0
3
4
0
3
5
0
3
6
0
3
7
0
3
8
0
3
9
0
4
0
0
4
1
0
4
2
0
4
3
0
4
4
0
4
5
0
4
6
0
4
7
0
4
8
0
4
9
0
5
0
0
5
1
0
5
2
0
5
3
0
5
4
0
5
5
0
5
6
0
5
7
0
5
8
0
5
9
0
6
0
0
6
1
0
6
2
0
6
3
0
6
4
0
6
5
0
6
6
0
6
7
0
6
8
0
6
9
0
7
0
0
7
1
0
7
2
0
7
3
0
7
4
0
7
5
0
7
6
0
7
7
0
7
8
0
7
9
0
8
0
0
8
1
0
8
2
0
8
3
0
8
4
0
8
5
0
8
6
0
8
7
0
8
8
0
8
9
0
9
0
0
9
1
0
9
2
Sesiones PHP
tilizaremos sesiones para almacenar una serie de variables en el servidor
relacionándolas ( grácias a una variable pasada por cookie o por URL ) con un
usuario concreto para que estén disponibles en diferentes páginas de nuestro
sitio web.
Una vez almacenada una variable de sessión, podremos leerla desde todas
las páginas de nuestra web mientras la sesión no se destruya.
Tabla de contenido
Guardar una variable
· Leer una variable guardada
· Borrar una variable
000 <?php
001 // Inicializamos sesion
002 session_start();
003 // Guardamos una variable
004 $_SESSION['nombre'] = 'Fernando Díaz';
005 ?>
Maximizar Seleccionar PHP
000 <?php
001 // Inicializamos sesion
002 session_start();
003 ?>
Maximizar Seleccionar PHP
000 <?php
001 // Inicializamos sesion
002 session_start();
003 // Comprovamos si existe la variable
004
if ( isset ( $_SESSION['nombre'] ) ) {
005
006 // Si existe
007 echo $_SESSION['nombre'];
008 } else {
009 // Si no existe
010 echo 'desconocido';
011 }
?>
Maximizar Seleccionar PHP
000 <?php
001 // Inicializamos sesion
002 session_start();
003 // Borramos la variable
004
unset ( $_SESSION['nombre'] ) {
005
006 // Borramos toda la sesion
007 session_destroy();
?>
Maximizar Seleccionar PHP
Tabla de contenido
· Clases y Objetos
· Métodos y atributos
· Herencia de clases
· Constructores y destructores
· Encapsulamiento
Clases y Objetos
Para entender la programación orientada a objetos debemos primero entender
lo que es una clase, pero primero diremos que un objeto es un conjunto de
atributos y métodos agrupados.
000 <?
001 class Imagen {
002 // Aquí el código de la clase
003 }
004
?>
Maximizar Seleccionar PHP
Métodos y atributos
Esta clase contendrá un seguido de atributos, que definiremos con la palabra
reservadavar, y métodos, que programaremos como funciones
usando function.
000 <?
001 class Imagen {
002 var $src; // Estos són los atributos
003 var $border; // de los objetos asociados
004 // Esta funcion es el constructor
005 function Imagen($src,$border) {
006 $this->src=$src;
007 $this->border=$border;
008 }
009 }
010 // Creamos un objeto imagen
011 $logo = new Imagen("logo.gif",3);
012 ?>
Maximizar Seleccionar PHP
000 <?
001 class Imagen {
002 var $src;
003
004 var $border;
005 function Imagen($src,$border) {
006 $this->src=$src;
007 $this->border=$border;
008 }
009
// Esta funcion es un método de Imagen
010
011 function Imprimir() {
012 echo "<img src=\"";
013 echo $this->src;
014 echo "\" border=\"";
015
016 echo $this->border;
017 echo "\">";
018 }
019 }
020 $logo = new Imagen("logo.gif",3);
// Llamamos el nuevo método
$logo->Imprimir();
?>
Maximizar Seleccionar PHP
Vamos a ver cómo podemos definir una subclase de la clase Imagen definida
en la pagina anterior para imágenes de tamaño 468 x 60, esta subclase se
llamará Banner y será de la siguiente manera:
000 <?
001 // Definimos la subclase de Banner
002 class Banner extends Imagen {
003 // Esta es la nueva funcion Imprimir para banners
004
function Imprimir() {
005
006 echo "<img src=\"";
007 echo $this->src;
008 echo "\" border=\"";
009 echo $this->border;
010 echo "\" width=\"468\" height=\"60\">";
011 }
012 }
?>
Maximizar Seleccionar PHP
000 <?
001 $banner_1 = new Banner("anunciante1.gif",0);
002 $banner_1->Imprimir();
003 ?>
Maximizar Seleccionar PHP
Constructores y destructores
Si trabajamos con PHP5, para definir un constructor, usamos el
método __construct, vamos a ver un ejemplo:
000 <?
001 class Imagen {
002
var $src; // Estos són los atributos
003
004 var $border; // de los objetos asociados
005 // Esta funcion es el constructor
006 function __construct($src,$border) {
007 $this->src=$src;
008 $this->border=$border;
009 }
010 }
011 // Creamos un objeto imagen
012
$logo = new Imagen("logo.gif",3);
?>
Maximizar Seleccionar PHP
Encapsulamiento
Este es un concepto nuevo en PHP5, el encapsulamiento permite el uso de
variables y métodos internos a un objeto que no pueden ser accedidos
internamente, de esta manera existen tres tipos de objetos:
public - Son accesibles desde todo el código.
protected - Son accesibles desde la clase actual y las clases derivadas.
private - Son accesibles desde la clase actual
Vamos a ver el ejemplo de antes pero con atributos protegidos:
000 <?
001 class Imagen {
002
protected $src; // Estos són los atributos
003
004 private $border; // de los objetos asociados
005 // Esta funcion es el constructor
006 function __construct($src,$border) {
007 $this->src=$src;
008 $this->border=$border;
009 }
010 }
011 // Creamos un objeto imagen
012
$logo = new Imagen("logo.gif",3);
?>
Maximizar Seleccionar PHP
Y estos son los cambios principales de PHP5, ademas de incorporar un
constructor de copia
000 __clone
Maximizar Seleccionar
Esta biblioteca, tiene una versión para PHP que podremos instalar facilmente
en nuestro servidor si tenemos permisos de administrador, y que viene
instalada en la mayoría de servidores linux del mercado.
La versión para PHP biblioteca contiene una gran cantidad de funciones para
el dibujo y el tratamiento de imagenes que iremos viendo en futuros artículos,
y que nos permiten realizar excelentes reportes visuales de nuestros datos,
como los de los siguientes ejemplos:
Gráfica de lineas
Graficas de quesitos en 3D
Si disponemos de PHP con GD, podremos disfrutar de la creación al vuelo de
imagenes, esta poderosa herramienta, nos permite entre muchas otras cosas
la creación de todo tipo de gráficas, de todas ellas, las más vistosas són las
gráficas de quesitos en 3D que vamos a ver cómo podemos generar.
000 <?php
001 // Creamos la imagen
002 $im = imagecreate(200,200);
003
004 // Definimos un color para el quesito
005 $fondo = imagecolorallocate ($im, 255,255,255);
006 $rojo = imagecolorallocate ($im, 255,0,0);
007
008 // Dibujamos el quesito
009 imagefilledarc ($im, 100, 100, 200, 175, 0, 45, $rojo, IMG_ARC_PIE);
010
011 // Enviamos la imagen
012 header("Content-type: image/png");
013 imagepng($im);
014 ?>
Maximizar Seleccionar PHP
000 <?php
001 // Creamos la imagen
002 $im = imagecreate(200,200);
003
004 // Definimos un color para el quesito
005 $fondo = imagecolorallocate ($im, 255,255,255);
006 $rojo = imagecolorallocate ($im, 255,0,0);
007 $rojo_oscuro = imagecolorallocate ($im, 150,0,0);
008
009
010 // Dibujamos el efecto sombra 3D
011
012 for ($i = 0; $i < 10; $i ++)
013 imagefilledarc ($im, 100, 100+(10-$i), 200, 175, 0, 45, $rojo_oscuro, IM
014 G_ARC_PIE);
015
016 // Dibujamos el quesito
017 imagefilledarc ($im, 100, 100, 200, 175, 0, 45, $rojo, IMG_ARC_PIE);
018
019 // Enviamos la imagen
020 header("Content-type: image/png");
imagepng($im);
?>
Maximizar Seleccionar PHP
Ahora vamos a hacer el mismo ejemplo pero con unos cuantos quesitos, de
manera que habremos generado nuestra primera gráfica de quesitos
completa:
000 <?php
001 // Creamos la imagen
002 $im = imagecreate(200,200);
003
004 // Definimos un color para el quesito
005 $fondo = imagecolorallocate ($im, 255,255,255);
006 $rojo = imagecolorallocate ($im, 255,0,0);
007 $rojo_oscuro = imagecolorallocate ($im, 150,0,0);
008 $verde = imagecolorallocate ($im, 0, 255,0);
009 $verde_oscuro = imagecolorallocate ($im, 0, 150,0);
010 $azul = imagecolorallocate ($im, 0, 0, 255);
011 $azul_oscuro = imagecolorallocate ($im, 0, 0, 150);
012
013
014 // Dibujamos el efecto sombra 3D
015
016 for ($i = 0; $i < 10; $i ++){
017 imagefilledarc ($im, 100, 100+(10-$i), 200, 175, 0, 45, $rojo_oscuro, IMG
018 _ARC_PIE);
019 imagefilledarc ($im, 100, 100+(10-$i), 200, 175, 45, 145, $verde_oscuro,
020 IMG_ARC_PIE);
021 imagefilledarc ($im, 100, 100+(10-$i), 200, 175, 145, 360, $azul_oscuro, I
022 MG_ARC_PIE);
023 }
024
025 // Dibujamos el quesito
026 imagefilledarc ($im, 100, 100, 200, 175, 0, 45, $rojo, IMG_ARC_PIE);
027 imagefilledarc ($im, 100, 100, 200, 175, 45, 145, $verde, IMG_ARC_PIE);
028
029 imagefilledarc ($im, 100, 100, 200, 175, 145, 360, $azul, IMG_ARC_PIE);
// Enviamos la imagen
header("Content-type: image/png");
imagepng($im);
?>
Tabla de contenido
EL siguiente paso es crear un color, que al ser el primero creado, será usado
como color de fondo.
000 <?php
001 $im = @imagecreate(100, 100)
002 or die("Error creando la imagen");
003
004
$fondo = imagecolorallocate($im, 255, 255, 255); // blanco
005
006 // Aqui podemos trabajar con la imagen
007
008 header("Content-type: image/png");
009 imagepng($im);
010 imagedestroy($im);
?>
Maximizar Seleccionar PHP
000 <?php
001 var_dump(gd_info());
002
?>
Maximizar Seleccionar PHP
000 <?php
001 $im = imagecreatefrompng("image.png");
002 header("Content-type: image/png");
003
imagepng($im);
004
005 imagedestroy($im);
?>
Maximizar Seleccionar PHP
Tabla de contenido
Crear un color
· Obtencion de un color de la imagen
· Utilización del color
Crear un color
Para usar un determinado color con GD en PHP, primero tenemos que
reservar ese color en la imagen. Para reservarlo usaremos la
funcion imagecolorallocate y almacenaremos su valor de retorno en una
variable para pasarsela después como color a las funciones de dibujo,
coloreado...
Nota:
El primer color creado con imagecolorallocate será utilizado como color de
fondo de la imagen.
000 <?php
001 $color = imagecolorallocate($im, 255, 0, 0);
002 // 100% rojo, 0% verde, 0% azul
003 ?>
Maximizar Seleccionar PHP
000 <?php
001 $imagen = ImageCreateFromPng("manzana.png");
002
003 $color = ImageColorAt($imagen, 100, 200); // x: 100, y: 200
?>
Maximizar Seleccionar PHP
000 <?php
001 imagefill ( $imagen, 1, 1, $color );
002 // Usamos el cubo de pintura con el color creado en x=1 y=1
003
?>
Maximizar Seleccionar PHP
Dibujo de líneas con GD
En este tutorial de 3 páginas veremos cómo podemos dibujar todo tipo de
líneas (normales, gruesas, discontinuas, punteadas... ) usando la librería GD
de PHP.
Tabla de contenido
· Dibujo de lineas básicas
· Dibujo de lineas gruesas
000 <?php
001 $im = @imagecreate(100, 100)
002 or die("Error creando la imagen");
003
$fondo = imagecolorallocate($im, 255, 255, 255); // blanco
004
005 $linea = imagecolorallocate($im, 0, 0, 0); // negro
006
007 // Dibujamos la línea
008 imageline($im, 10, 10, 90, 90, $linea);
009
010 header("Content-type: image/png");
011
imagepng($im);
012
imagedestroy($im);
?>
Maximizar Seleccionar PHP
Y aquí tenemos su resultado:
000 <?php
001 $im = @imagecreate(100, 100)
002 or die("Error creando la imagen");
003
$fondo = imagecolorallocate($im, 255, 255, 255); // blanco
004
005 $linea = imagecolorallocate($im, 0, 0, 0); // negro
006
007 // Cambiamos el grosor a 10
008 imagesetthickness($im, 10);
009
010
011 imageline($im, 10, 10, 90, 90, $linea);
012 header("Content-type: image/png");
013
imagepng($im);
imagedestroy($im);
?>
Tabla de contenido
· Dibujo de rectángulos
· Rectángulos coloreados
Dibujo de rectángulos
Para dibujar un rectángulo utilizaremos la función imagerectangle, pasándole
las coordenadas del rectándulo y el color de la siguiente manera:
Rectángulos coloreados
Otro tipo de rectángulo que podemos dibujar són los rectángulos coloreados (areas de un
color) que haremos con la función imagefilledrectangle, que funciona exactamente igual
que la anterior pero genera un resultado distint
000 <?php
001 $im = @imagecreate(101, 101)
002 or die("Error creando la imagen");
003
$fondo = imagecolorallocate($im, 255, 255, 255); // blanco
004
005 $linea = imagecolorallocate($im, 0, 0, 0); // negro
006
007 // Dibujamos la elipse
008 imageellipse($im, 50, 50, 100, 100, $linea);
009
010
011 header("Content-type: image/png");
012 imagepng($im);
imagedestroy($im);
?>
Y este será el resultado (que sería relleno de color negro de haber usado
imagefilledellipse):
Dibujo de arcos
Para dibujar un arco, usaremos la función imagearc o imagefilledarc, que
tiene la misma sintaxis que la función anterior salvo que añade el ángulo
inicial y el final:
000 imageellipse ($im, $cx, $cy, $an, $al, $in, $fi, $col);
Maximizar Seleccionar CSS
000 <?php
001 $im = @imagecreate(101, 101)
002 or die("Error creando la imagen");
003
$fondo = imagecolorallocate($im, 255, 255, 255); // blanco
004
005 $linea = imagecolorallocate($im, 0, 0, 0); // negro
006
007 // Dibujamos el arco
008 imagearc($im, 50, 50, 100, 100, 90, 180, $linea);
009
010
header("Content-type: image/png");
011
012 imagepng($im);
imagedestroy($im);
?>
Y este será el resultado (que sería relleno de color negro de haber usado
imagefilledarc):