Sintaxis básica de PHP

Índice de contenidos
Introducción............................................................................................................................................................... 3
Objetivos .................................................................................................................................................................... 3
Introducción y características del lenguaje............................................................................................................ 4
Introducción ..................................................................................................................................................... 4
Características principales.............................................................................................................................. 4
Introducción a PHP.......................................................................................................................................... 5
Comentarios..................................................................................................................................................... 8
Tipos de datos y operadores ................................................................................................................................... 8
Introducción ..................................................................................................................................................... 8
Lenguajes compilados vs lenguajes interpretados ..................................................................................... 9
Variables ......................................................................................................................................................... 10
Constantes...................................................................................................................................................... 11
Operadores .................................................................................................................................................... 12
Arrays .............................................................................................................................................................. 18
Estructuras de control de flujo .............................................................................................................................. 19
Introducción ................................................................................................................................................... 19
Estructura condicional if ............................................................................................................................... 20
Estructura condicional switch ...................................................................................................................... 22
Estructuras repetitivas ........................................................................................................................................... 22
Bucles .............................................................................................................................................................. 22
Bucle for.......................................................................................................................................................... 23
Bucle foreach ................................................................................................................................................. 24
Bucle while ..................................................................................................................................................... 25
Funciones ................................................................................................................................................................. 26
Funciones........................................................................................................................................................ 26
Recepción de datos de formularios ............................................................................................................ 29

Página 2 de 35
Introducción
Ya hemos instalado nuestro entorno de software libre y tenemos configurado el Aptana Studio para crear
proyectos directamente en la carpeta del servidor. Este es el momento para comenzar a iniciarnos en el
lenguaje.

En este tema veremos las características básicas de PHP, las estructuras de control de flujo, tipos de datos
y funciones. Aprenderemos también a hacer nuestras primeras aplicaciones web completas, recibiendo
datos del cliente (navegador) y procesándolos en el servidor.

Recordemos que la misión de los lenguajes de servidor, y en concreto de PHP, es generar de forma dinámica
código HTML válido que pueda comprender el navegador. Para ello, deberemos integrar perfectamente los
scripts en PHP dentro de nuestro código HTML, sabiendo que estos no pasarán del servidor y serán sustituidos
por los resultados que mostremos en cada uno mediante la instrucción echo.

Para empezar a dominar el lenguaje, haremos una revisión de sus estructuras y tipos de datos, para después
adentrarnos en las funciones y la lectura de datos de un formulario. En este momento ya tendremos establecida
la forma en la que un usuario puede comunicarse con la aplicación y hacer una petición, esa petición será
analizada y respondida creando de esa manera una doble comunicación petición-respuesta que es la base
de las aplicaciones web.

Objetivos

Los objetivos que perseguimos en esta unidad son:

1
Al final de este tema, el alumno deberá ser capaz de realizar aplicaciones webs sencillas, sin acceso a bases de
datos, pero peticiones y respuestas

2
Comprender las estructuras básicas de un lenguaje de programación como PHP así como sus estructuras de
control de flujo y tipos de datos

3
Comprobar formularios en el servidor y emitir una respuesta

4
Integrar el código PHP y HTML de forma que se consigan respuestas en HTML perfectamente formadas

Página 3 de 35
Introducción y características del lenguaje

Introducción

PHP es un lenguaje de servidor creado en 1994 por Rasmus Lerdorf, aunque no es hasta 1995 cuando aparece
la primera versión disponible para el público. Actualmente se puede encontrar en más de 200 millones de sitios
web.

Características principales

Las principales características de PHP son:

1
Se ejecuta en el lado del servidor Web.

2
Es interpretado.

• No lleva un proceso previo de compilación que me permite detectar errores.

3
Tiene soporte para almacenar datos en Bases de Datos.

• MySQL, Postgres, Microsoft SQL Server, Oracle..

4
Permite procesar información de formularios.

Página 4 de 35
Introducción a PHP

Las páginas PHP son páginas web “normales” que cambian su extensión de .html (o .htm) a .php. Como
ya vimos en el último punto del tema anterior, el código PHP va insertado en bloques delimitados por los
símbolos "<?php” y “?>”.

Una página puede tener uno o varios de estos bloques, y lo que se incluya dentro de ellos se interpretará como
código PHP en el servidor.

En PHP las instrucciones van separadas por un punto y coma (;), pudiendo escribir más de una instrucción
por línea, aunque no se recomienda para facilitar la depuración.

El objetivo de toda página PHP es que el resultado que llega al cliente sea una página HTML bien formada que
integre los resultados de la ejecución correctamente.

Vamos a crear nuestra primera página. Para ello, vamos a crear un nuevo proyecto PHP, tal y como hicimos
en la prueba del tema anterior, con el nombre “holamundo”. En este caso, en vez de añadir un fichero
PHP mediante plantilla, añadiremos uno en blanco que volveremos a llamar “index.php”. En esta página
escribiremos:

<html>
<head>
<title>Aprendiendo PHP</title>
<body>

<p>Esta es una página supersimple</p>

<?php

echo "¡Hola Mundo!";

?>

< /body>
< /html>

Vamos a ir familiarizándonos con la instrucción echo, la cual utilizaremos constantemente a lo largo del curso.
Esta instrucción es la responsable de mostrar resultados. En este sencillo ejemplo, lo único que vamos a
mostrar es la cadena “¡Hola Mundo!”.

Mediante la configuración de ejecución que realizamos en el último punto del tema anterior, o bien mediante
la URL “http://localhost/holamundo” comprobaremos el resultado.

Mientras visualizamos la página que acabamos de crear en el navegador, pulsa el botón derecho del ratón sobre
cualquier parte de esta y escoge “Ver código fuente de la página”. Examina el código recibido por el navegador.

Después, accede mediante el explorador de archivos a la carpeta donde está albergado el proyecto e intenta abrir el
archivo php con el navegador.

Con las conclusiones que hayas podido obtener, contesta a las siguientes preguntas:
¿La página que vemos en el navegador accediendo mediante la dirección del servidor es la misma que la que
abrimos mediante el explorador de archivos?
No, accediendo mediante el servidor, el código PHP ya se ha interpretado y solo obtenemos código HTML.
Si abrimos el archivo directamente con el navegador, veremos el código PHP sin interpretar, pues al no ser
interpretable en cliente, lo interpreta como texto plano.

Página 5 de 35
¿La página que vemos accediendo mediante la dirección del servidor es una página HTML correctamente
formada?
No, ya que en este ejemplo lo que mostramos con el echo es un literal no incluido en ninguna etiqueta HTML.
¿Qué crees que puede estar sucediendo si cuando accedemos a una web correctamente escrita en HTML/PHP
mediante la dirección del servidor, se visualiza código PHP en el navegador?
Si el servidor no estuviera activo, no podríamos acceder al recurso. Por eso, si podemos acceder es que el
servidor funciona, pero no interpreta PHP. La única opción posible es que el servidor no acepte (o tenga
desactivado) PHP.

Vamos a profundizar en la pregunta 2 del ejercicio de autoevaluación anterior.

Decíamos que el objetivo es que la web sea completa, bien poniendo las etiquetas HTML necesarias fuera de
los bloques de código de PHP, o bien mostrándolas como literales dentro de los mismos.

En el ejemplo anterior, si examinamos el código fuente que nos llega al navegador, obtenemos lo siguiente:

<html>
<head>
<title>Aprendiendo PHP</title>
<body>
<p>Esta es una página supersimple</p>¡Hola Mundo!"
</body>
</html>

Página 6 de 35
Cómo vemos, todo el bloque PHP ha desaparecido y en su lugar aparece el resultado de la ejecución del
mismo, es decir, el literal que pretendíamos mostrar mediante echo. El problema es que ese literal queda fuera
de ninguna etiqueta HTML. Imaginemos que queremos mostrarlo en un párrafo, para conseguirlo tendríamos
dos opciones:

<html>
<head>
<title>Aprendiendo PHP</title>
<body>

<p>Esta es una página supersimple</p>

<p>
<?php

echo "¡Hola Mundo!";

?>
</p>

</body>
</html>

<html>
<head>
<title>Aprendiendo PHP</title>
<body>

<p>Esta es una página supersimple</p>

<?php

echo "<p>¡Hola Mundo!</p>";

?>

</body>
</html>

Hagamos la prueba con ambas opciones, y comprobar posteriormente que el código generado que recibe el
navegador es el mismo en ambos casos.

Escribir el código necesario para que nuestra página muestre un título < h1> mediante un bloque PHP, el
párrafo del ejemplo mediante HTML, y dentro del mismo, se integre con PHP la cadena “¡Hola Mundo!”.

Página 7 de 35
<html>
<head>
<title>Aprendiendo PHP</title>
<body>

<?php

echo "<h1>Ejemplo PHP</h1>";

?>
<p>Esta es una página supersimple.

<?php echo " ¡Hola Mundo!";?>

</p>

</body>

Comentarios

Podemos usar dos tipos de comentarios:

De una línea
Precedida por // o #

De varias líneas
Entre /* y */

<?
// este comentario no se verá en la página

echo "Esto se leerá "; // Esto no se leerá

/* este es un comentario de

varias líneas y no se leerá

hasta que no cerremos así....*/

echo "<p>Este es el segundo comentario que se leerá</p>";

echo "<!-- ¿Y qué pasa con éste comentario? -->"
?>

En el ejemplo vemos varios comentarios de PHP (en azul), pero ¿qué pasa con el comentario de la pregunta?
Al ser un comentario de HTML, para PHP forma parte del literal y se enviará al cliente. Pero el navegador al
interpretarlo, lo detectará como un comentario HTML y no lo mostrará.

Tipos de datos y operadores

Introducción

Si ya programamos con otros lenguajes como Java o C++, estaremos acostumbrados a trabajar con diferentes
tipos de datos.

Página 8 de 35
Lenguajes compilados vs lenguajes interpretados

Para poder comprender el modelo de tipos de datos de PHP, debemos partir desde el principio. Los lenguajes
de programación se pueden dividir de muchas maneras distintas, una de ellas es diferenciarlos entre los que
requieren un proceso de compilación y los que no.

Tradicionalmente los programas de escritorio que se van a distribuir requieren de un proceso de compilación.
Esto no es más que la utilización de un programa intermedio que “traduce” el lenguaje en cuestión a
código máquina, órdenes directas para el procesador escritas en lenguaje muy próximo al binario y que se
empaquetan en un archivo ejecutable reconocible para el sistema operativo. La interpretación, en cambio,
se hace en el mismo momento de la ejecución por un programa llamado “intérprete”. Este intérprete
puede ser:

• Un programa específico, como en el caso de Python.

• El navegador, como sucede con JavaScript.

• Un módulo del servidor, como sucede con PHP.

Lo que todos tienen en común es que van interpretando los programas según van leyendo línea a línea.

En los lenguajes compilados, los tipos de datos se deben declarar para que, en el momento de la traducción
a código máquina, el compilador “sepa” cuánto espacio reservar en la memoria para cada uno de ellos. Por eso,
si ya trabajamos con alguno de ellos no nos sonará raro una definición como “int a” o “string b”, en ambos casos
la letra sería el nombre que le damos a la variable, mientras que “int” se refiere a que será un tipo numérico
entero y “string” a una cadena de texto. Una vez definido el tipo de datos, se reserva un espacio coherente con
tipo de dato en memoria y este ya no se podría modificar.

Página 9 de 35
En cambio, en los lenguajes interpretados como PHP, al no generarse un ejecutable que requiera de espacio
en la memoria del ordenador, es el propio intérprete quien se encarga de manejar esos datos en un caché
variable. Esto nos evita tener que especificar los tipos de datos, ya que cada variable se adaptará a lo que hay
al otro lado del igual (=) cada vez que asignemos un valor.

Esto que a simple vista es una ventaja, ha de tenernos alerta en determinadas situaciones pues es un origen
muy común de errores. Por ejemplo, si tenemos dos variables $a y $b definidas con los siguientes valores:

$a="12";
$b="2";

Al sumarlas no obtendríamos 14, pues al estar entrecomillados las interpreta como texto y no las puede
sumar.

Variables

Una variable representa una o varias posiciones de memoria a las que accedemos mediante un nombre
o identificador. El contenido de estas puede variar a lo largo de la ejecución del programa.

En PHP, los nombres de las variables deben empezar por el carácter dólar ($), seguidos de una letra y uno o
más caracteres alfanuméricos y son sensibles a mayúsculas/minúsculas.

Con echo, podemos concatenar variables o cadenas literales usando el punto (.)

<?php
# Definimos la variable $nombre como vacía
$nombre="";
# Definimos la variable $Nombre con un valor
$Nombre="Pepe";
?>
<!-- esto es HTML, hemos cerrado el script -->
<p>Vamos a ver el contenido de las variables</p>
<!-- un nuevo script PHP -->
<?
echo "<p> El valor de la variable <em>nombre</em> es: ".$nombre."</p>";
echo "<p> El valor de la variable <em>Nombre</em> es: ".$Nombre."</p>";
?>

NOTA: En PHP los literales deben ir entre comillas, y se acepta indistintamente comillas dobles o simples.
Pero debemos tener en cuenta que un literal que se abra con un tipo de comillas, solo se podrá cerrar con
otra comilla del mismo tipo.

Al ser un lenguaje interpretado, no es necesario reservar un espacio en memoria física para cada variable, por
ello, no es necesario definir un tipo de dato. Esto, como ya explicamos, no quiere decir que no existan los tipos
de dato, los tipos existen, pero se trata de lenguajes donde una misma variable puede modificar el tipo de dato
que alberga simplemente modificando su valor.

Una variable puede tener uno de los siguientes tipos de dato:

1
Un valor numérico entero

Página 10 de 35
2
Un valor numérico real (la parte entera y la decimal se separan por un punto)

3
Una cadena (entre comillas simples o dobles)

4
Un booleano: Representa un valor lógico verdadero o falso.

5
Un array

6
Un objeto

$edad=15;
$saldo=15.2;
$nombre='Agustín';

Constantes

Son un tipo especial de variable cuyo valor no cambia a lo largo de la ejecución del script. A diferencia de
JavaScript, en PHP si existe una sintaxis específica para definirlas:

define(“CONSTANTE”,valor)

No comienzan por “$” como las variables, y por convenio, se escriben en mayúsculas.

<?php
/* Definimos la constante EURO_A_DOLAR y le asignaremos el valor 1.29 */
define(“EURO_A_DOLAR",1.29);
_
/* Definimos la constante DÓLAR_A_EURO que vale 1/1.29 */
define(“DÓLAR_A_EURO",1/1.29);
?>

Página 11 de 35
Operadores

Por sí solas las variables no hacen gran cosa, necesitamos operadores. Estos permiten manipular el valor de
las variables, realizar operaciones matemáticas con sus valores y comparar valores.

Tenemos los siguientes tipos:

Aritméticos

Asignación

Comparación

Lógicos

Operadores aritméticos

Realizan operaciones matemáticas elementales:

+
Suma

-
Resta

*
Multiplicación

/
División

%
Módulo (resto de la división)

**
Exponenciación (2 ** 3, elevar 2 la a tercera potencia)

Página 12 de 35
Operadores de asignación

El operador de asignación es el igual (=). Es el operador más utilizado y el más sencillo. Se utiliza para
guardar un valor en una variable. Esta asignación será lo que defina el tipo de la variable en un momento dado.

Partes del operador

Nombre de la variable = Expresión (variables, valores, condiciones lógicas…)
$numero1=3;
$numero2=4;
$numero1=5;
$numero1=$numero2;

Además, podemos combinarlo con operadores aritméticos para realizar operaciones sobre las propias
variables. $var (operador)= valor es exactamente lo mismo que $var= $var (operador) valor.

+=
Suma y asignación

-=
Resta y asignación

*=
Multiplicación y asignación

/=
División y asignación

%=
Módulo y asignación

.=
Concatenación y asignación

$numero =5;
$numero +=3; //$numero=$numero+3;
$numero -=1; //$numero =$numero -1;
$numero *=2; //$numero =$numero *2;
$numero /=5; //$numero =$numero /5;
$numero %=4; //$numero =$numero %4;

Caso especial: Incremento (++) y decremento (--). Estos operadores pueden ser considerados a la vez
matemáticos y de asignación. Son operadores unarios, por lo que una misma variable es leída y modificada.

CASO ESPECIAL
$numero=5; $numero =5;
$numero=$numero+1; ++$numero;
echo $numero; // $numero=6 echo $numero //$numero=6

Página 13 de 35
$numero =5; var $numero=5;
$numero =$numero-1; --$numero;
echo $numero; // &numero=4 echo $numero //&numero=4

Pueden ir:

Delante de la variable
Su valor se incrementa antes de ejecutar la sentencia donde aparece.

Después de la variable
Su valor se incrementa después de ejecutar la sentencia donde aparece.

¿Cuánto valen numero1 y numero2 en cada caso?

$numero1 =5; $numero1 =5;

$numero2 =2; $numero2 =2;
$numero3 =$numero1++ + $numero2; $numero3 = ++$numero1 + $numero2;

En el primer recuadro: numero3=7, numero1=6.

En el segundo numero3=8, numero1=6

Página 14 de 35
Se pueden realizar otras operaciones matemáticas mediante llamadas a determinadas funciones
predefinidas, como puede ser la potencia o la raíz cuadrada.

*El funcionamiento de estos operadores es exactamente igual que en JavaScript. Revisar el tema anterior y los
ejemplos en caso de duda.

Operadores de comparación

Se utilizan principalmente en nuestras condiciones para comparar dos variables y verificar si cumple o no
la propiedad del operador. El resultado de su aplicación es un valor booleano.

==
Comprueba si son iguales (OJO! No confundir con el operador de asignación)

!=
Comprueba si son distintos

===
Comprueba si son iguales y de exactamente el mismo tipo

!==
Comprueba si son distintos o de distinto tipo

Página 15 de 35
 <>
Diferente (igual que !=)

<
Menor qué, comprueba si un valor es menor que otro

>
Mayor qué

<=
Menor o igual

>=
Mayor o igual

<=>
Comparador de orden. (PHP 7)

??
Uno o el otro (PHP 7)

$numero1=3;
$numero2=5;
$resultado=$numero1 > $numero2; //$resultado=false;
$resultado =$numero1 < $numero2; //$resultado=true;
$numero1=5;
$numero2=5;
$resultado =$numero1 >= $numero2; //$resultado=true;
$resultado =$numero1 <= $numero2; //$resultado=false;
$resultado =$numero1 == $numero2; //$resultado=true;
$resultado =$numero1 != $numero2; //$resultado=false;

NOTA: El operador igual (==) es origen de un gran número de errores de programación. Nunca se debe
confundir con el operador asignación (=).

//El operador "=" asigna valores

$numero1=5;
$resultado=$numero1=3;
//numero1 vale 3 y resultado vale3
//El operador "==" compara variables
$numero1=5;
$resultado=$numero1==3;
//numero1 vale 5 luego resultado vale false

Página 16 de 35
Los operadores relacionales también pueden usarse para comparar cadenas de texto (alfabéticamente)

$texto1="Hola";
$texto2="Hola";
$texto3="Adios";
$resultado=$texto1==$texto3; //false
$resultado =$texto1=$texto2; //false
$resultado =$texto1>=$texto2; //false

Operadores lógicos

Prueban una vinculación lógica entre dos predicados (o uno, en el caso de la negación) lógicos. Su resultado
será booleano.

1
and Operación lógica "y", será verdadero si ambos son verdaderos.

2
or Operación lógica "o", será verdadero si uno de ellos es verdadero

3
xor Operación lógica "xor", será verdadero si uno de ellos es verdadero, pero no ambos.

4
! Operación de negación, si era verdadero pasa a falso y viceversa.

5
&& Operación lógica "y"

6
|| Operación lógica "o"

$valor1=true;
$valor2=false;
$resultado =$valor1 && $valor2; //$resultado=false
$valor1=true;
$valor2=true;
$resultado =$valor1 && $valor2; //$resultado=true

$visible=true;
alert(!$visible); // "false"

$valor1=true;
$valor2=false;
$resultado=$valor1 || $valor2; //resultado=true
$valor1=false;
$valor2=false;
$resultado=$valor1 || $valor2; //resultado=false

Página 17 de 35
Arrays

Un array es una lista de elementos a la cual accedemos mediante un nombre común. El modo de
diferenciar cada elemento de la lista es a través de un índice. Los arrays pueden tener varias dimensiones:

Una dimensión: Vectores

Accedemos al valor mediante un índice.

$a[3]=5;

Dos dimensiones: Tablas o Matrices

Accedemos al valor mediante dos índices.

$a[3][2]=5;

Igual que ocurre en otros lenguajes de programación, tenemos dos tipos de arrays, los escalares y los
asociativos. Lo habitual es que sean escalares y accedamos a las posiciones mediante un índice, pero en
algún momento nos puede interesar acceder a cada posición mediante un identificador, para ello utilizaremos
arrays asociativos.

NOTA: El uso de arrays asociativos cobrará especial relevancia cuando, en el tema 4, trabajemos con bases
de datos. Tras hacer una consulta a una base de datos, el resultado podremos cargarlo en un array asociativo
donde cada campo de la base de datos será un identificador diferente, de esa forma podremos trabajar con
los datos obtenido

Definición de arrays

Los arrays se definen mediante la función “array(valores)”:

$numeros=array(1,2,6,9);

Para construir un array de varias dimensiones, no existe una estructura propia más allá del “vector de
vectores”. Dicho de otra manear, un array unidimensional donde en cada posición definamos otro array
unidimensional, de esta forma ya tendremos una matriz.

$numeros=array(

array(1,2,6,9),
array(5,8,6,2));

Si queremos que nuestro vector sea asociativo, lo definiremos de la siguiente manera:

$notas=array(“Pepin”=>3,”Manuela=>2);

Acceso a posiciones de arrays

Los índices de cada dimensión se escriben entre corchetes, y pueden ser:

Array escalar
Valores numéricos enteros.

Página 18 de 35
$semana[0]=“lunes”;

Array asociativo
Valores numéricos enteros.

$dias[“enero”]=31;

Si queremos añadir un elemento al final del array, simplemente debemos dejar los corchetes vacíos:

$nombres[]=“manolo”;

Hay que recordar, que al igual que sucede con JavaScript, el hecho de que sea un lenguaje de tipado dinámico
permite que las distintas posiciones de un mismo array tengan tipos de datos diferentes.

$elementos[0]=“Fermín”;
$elementos[1]=5;
$elementos[2]=44.2;

Estructuras de control de flujo

Introducción

En un lenguaje de programación, las estructuras de control permiten alterar el flujo de ejecución de un

bloque de código. Normalmente este flujo es lineal, el intérprete va leyendo el código línea a línea, pero estas
estructuras permiten saltarse líneas o volver atrás.

En general, estas estructuras se dividen en dos tipos:

• Las estructuras condicionales (o simplemente de control de flujo)

• Los bucles o estructuras repetitivas.

Cuando utilizamos estructuras de control que alteran el flujo de ejecución, se deben agrupar las líneas
afectadas en bloques mediante llaves ({ y }), salvo en los casos donde solo afecte a una línea en los que no es
obligatorio.

Página 19 de 35
Estructura condicional if

Permite tomar decisiones en función del valor de una variable. Las sentencias se ejecutan si se cumple
la condición. En el siguiente ejemplo vemos cómo, en el caso de que afecte a varias líneas, estás se enmarcan
dentro de un bloque delimitado por llaves ({}), y en el ejemplo posterior, en cambio, cómo solamente afecta a
una línea, podemos omitir el cierre.

if(condicion){

instruccion1;
instruccion2;

...
}

if(condicion)

instruccion;

Mediante la instrucción else, podemos definir las instrucciones a ejecutar en caso de que no se cumpla la
condición principal, y mediante else if, podemos definir condiciones parciales.

if(condicion){

instruccion1;
instruccion2;

}
else{

instruccion3;
instruccion4;

if(condicion){

instruccion1;
instruccion2;

} else if(condicion2){

instruccion3;
instruccion4;

}else{

Instruccion5;
Instruccion6;

Ejemplo 1
if($variable1==$variable2)
echo "<p>Las dos variables son iguales</p>";

Página 20 de 35
else if($variable1<$variable2)
echo "<p>La segunda variable es mayor</p>";
else
echo "<p>Las primera variable es mayor</p>";

Ejemplo 2
if($edad<=12)
echo "<p>¡Hola, bebé!</p>";
else if($edad<=19)
echo "<p>¡En la flor de la vida!</p>";
else if($edad<=35)
echo "<p>Bueno, sigues siendo joven…<p>";
else
echo "<p>Hay que pensar en cuidarse un poco más</p>";

Completar las condiciones de los if para que los mensajes se muestren de forma correcta:

$numero1=? //numero1 contiene un numero cualquiera

$numero2=? //numero2 contiene un numero cualquiera
if(...) echo "numero1 no es mayor que numero2";
if(...) echo "numero2 es positivo";
if(...) echo "numero1 es negativo o distinto de cero");
if(...) echo "Incrementar en 1 unidad numero1 no lo hace mayor o igual que numero1");

• ! (numero1>numero2)

• numero2>0

• (numero1<) | | (numero1!=0)

• ++numero1<numero2

Página 21 de 35
Estructura condicional switch

La estructura switch evalúa una expresión y ejecuta las instrucciones del caso que se corresponda con
el valor de la expresión hasta que se encuentre con una instrucción break o el final del switch. Puede tener
opcionalmente un caso default que se ejecuta si el valor de la expresión evaluada no coincide con ninguno
de los casos anteriores.

switch(variable){
case n1:
instrucciones;
break;
case n2:
instrucciones;
break;
default:
instrucciones;
break;
}

Ejemplo
witch($intentos){
case 1: //Correspondiente a if($intentos==1)
echo "<p>Solo te queda un intento</p>";
break;
case 2: //Correspondiente a if($intentos==2)
echo "<p>Solo te quedan dos intento</p>";
break;
default:
echo "<p>Aún tienes más de dos intentos</p>";
break;
}

Estructuras repetitivas

Bucles

Los bucles son estructuras que alteran el flujo, permitiendo la repetición de un bloque de instrucciones.

Página 22 de 35
Bucle for

Se utiliza para ejecutar un conjunto de instrucciones un determinado número de veces mientras

la variable de control del bucle cumpla una determinada condición. Esta variable (habitualmente
denominada $i), se declara en la propia definición del bucle asignándole un valor inicial, también se define
la condición de parada del bucle (habitualmente, que $i alcance cierto valor), y por último, el incremento ($i
puede avanzad de uno en uno o no).

En cada iteración:

1
Se modifica la variable de control.

2
Se comprueba la condición que la variable debe cumplir antes de ejecutar las funciones del cuerpo del bucle.

3
El incremento de la variable de control puede ser positivo o negativo.

for(desde; hasta;
incremento) {
instrucciones;
}

Tenemos el siguiente ejemplo:

for($i=0; $i<10; $i=$i+1){

echo "<p>Hola Mundo</p>";
}
En el ejemplo anterior se escribirán 10 párrafos con el contenido “Hola Mundo”, ya que $i se inicia en cero, se
ejecuta el bucle mientras sea menor que diez y se aumenta su valor en cada repetición sumándole uno.

Es mucho más habitual que el índice sea utilizado en el cuerpo del bucle, para así poder obtener
resultados diferentes en cada ejecución:

for($i=0; $i<10; $i=$i+1) {

echo "<p>Hola Mundo número " . $i."</p>";
}

Página 23 de 35
La principal utilidad de este bucle en casi cualquier lenguaje de programación es el acceso secuencial al
contenido de un array utilizando el índice.

for($i=0; $i< 8 $i++){

echo "<p>El día numero ".$i." es ".$dias_semana[$i]."</p>";
}

NOTA: Para la utilización de este bucle para recorrer un array es imprescindible conocer el número de
elementos que contiene en ese momento. Para ello, tenemos la función count($array).

for($i=0; $i< count($arr); $i++){

echo "<p>Posición: ".$i." – Contenido: ".$arr[$i]."</p>";
}

¡Practica tú mismo!

El factorial de un número entero n es una operación matemática que consiste en multiplicar todos los factores
n x (n-1) x (n-2) x … x 1. Así, el factorial de 5 (escrito como 5!) es igual a 5 x 4 x 3 x 2 x 1= 120.

Utilizando la estructura for, crea un script que calcule el factorial de un número entero.

Bucle foreach

Es, en realidad, un versión resumida del bucle for para aplicar en el caso de que queramos recorrer un
array secuencialmente y pasando por todos los elementos. Es específico para recorrer arrays, tanto
escalares como asociativos. Utilizamos una variable auxiliar, donde en cada iteración se cargará un elemento
del array (Ojo! No el índice, sino el propio contenido).

foreach (array as elementoAuxiliar) {

instrucciones;
}

foreach ($diasSemana as $dia){

echo "<p>".$dia."</p>";
}

Página 24 de 35
Bucle while

Permite ejecutar una o más instrucciones mientas se cumpla la condición de continuación del bucle.

while(condición){
instrucciones;
}

while($i<50){
echo "<p>".$i."</p>";
$i=$i+1;
}

Existe otra versión que evalúa la condición al final, por lo que garantiza la ejecución del bucle al menos, una
vez.

do{
instrucciones;
}while(condición)

¡Practica tú mismo!

Tenemos un array que llamaremos “$dias_semana” e introduciremos mediante cadenas de texto los nombre
de cada día de la semana en posiciones sucesivas.

Posteriormente recorreremos el array:

• Mediante un bucle for que generará una lista no ordenada en HTML.

• Mediante un bucle foreach que generará una lista ordenada en HTML.

• Mediante un bucle while que generará un párrafo HTML por cada día de la semana.

Página 25 de 35
Funciones

Funciones

En ocasiones tenemos partes de código que se repiten, las funciones nos permiten agrupar dicho código y
referirnos a él por un nombre.

Además, podemos parametrizar el modo en que se comporta la función pasándole una serie de argumentos
o parámetros. También pueden retornar un valor que puedo almacenar en una variable.

Argumentos Retorno

• Permiten especificar las entradas de la función. • Especifica el valor que devuelve la función.

• Ejemplo (suma): Los sumandos. • Ejemplo (suma): El resultado de la suma.

function nombreFuncion(parametro1, parametro2,..){
instrucciones;
}

Las instrucciones que contiene la función no se ejecutan hasta que la invoco explícitamente usando
nombreFuncion(args).

Página 26 de 35
La función puede definirse en cualquier parte del script PHP donde se utilice, pero por claridad del código es
mejor agruparlas y definirlas o bien todas al principio o bien todas al final. También podemos referenciarlas
en otro fichero que se incluya desde el actual.

La función del ejemplo simplemente nos permite ahorrar código invocándola desde diferentes lugares. En
cambio, otras veces las funciones permiten dar un resultado diferente en función a los parámetros que le
enviemos:

En todas las funciones anteriores la propia función emite una salida. Muchas veces, preferimos que nos
devuelva un valor para seguir trabajando con él. En estos casos utilizamos la palabra reservada return.

Al hablar de funciones, es importante definir el ámbito de las variables. Pero PHP lo resuelve de forma
distinta:

1
Las variables que definamos dentro de la función son locales al ámbito de la función y se destruyen al salir
de la misma.

Página 27 de 35
2
Para acceder a variables globales desde la función, tendremos que declararlas dentro de la misma con el
calificador global explícitamente.

function miFuncion(){
$i=3;
}
$i=4;
miFuncion();
echo $i;

En este ejemplo, tenemos dos variables diferentes, la de dentro de la función se crea en ella y se destruye al
finalizar la función, la exterior es global. El valor de $i al finalizar el script será 4.

function miFuncion(){
global $i=3;
}
$i=4;
miFuncion();
echo $i;
En este segundo caso, cuando invocamos a la función estamos modificando la misma variable global que
teníamos definida afuera, por lo que el valor de $i al finalizar todo el script, será 3.

Funciones predefinidas

PHP incluye muchas funciones predefinidas que nos permiten realizar tareas de manera sencilla. Vemos
algunas de las más importantes:

count($array)
Devuelve el número de elementos de un array.

$prendas=array("pantalón","chaqueta","camisa","jersey");
$numeroPrendas=count($prendas);

intval($cad)
Devuelve el equivalente entero a una cadena de caracteres que contiene un entero.

$cadena="15";
$numero=intval($cadena);

date($format)
Devuelve la fecha actual en el formato especificado.

echo date("d:M:Y");

random($min,$max)
Devuelve un número aleatorio entre los números máximo y mínimo especificados.

echo rand(0,10);

Página 28 de 35
isset($var)
Nos devuelve un booleano que nos indica si una variable está definida.

if(isset($variable))
echo "<p>El valor es ".$variable ."</p>";

Recepción de datos de formularios

En este punto aprenderemos a recoger los valores que introduzca el usuario mediante controles de
formulario en HTML. Es una parte imprescindible para la realización de una aplicación web, pues los
formularios son la forma que tienen los usuarios de comunicarse con la misma.

Aunque HTML no forma parte de los contenidos de este curso, debido a lo importante de los formularios para
este punto haremos un pequeño repaso de los controles más comunes.

En este apartado veremos:

1
Formularios HTML

2
Métodos de envío

3
Acceso a las variables desde PHP

4
Acceso a valores de distintos tipos de controles

Página 29 de 35
1. Fomularios HTML

El navegador habitualmente envía datos al servidor por medio de formularios. El usuario rellena los datos que
corresponda y posteriormente los envía al servidor.

Desde el servidor, debemos recoger esos datos para darles un tratamiento. Normalmente, estos datos
van a utilizarse para realizar gestiones con la base de datos.

Para definir un formulario en HTML utilizamos la etiqueta form:

action
El atributo action especifica quién será el script PHP encargado de procesar los datos del formulario.

method
El atributo method permite especificar el método HTTP.

<form action="procesa_formulario.php" method="post">

<label for="nombre">Nombre:</label>
<input type="text" name="nombre" />
<label for="apellidos">Apellidos:</label>
<input type="text" name="apellidos" />
<label for="comentario">Comentario:</label>
<textarea name="comentario" rows="5"></textarea>
<input type="submit" value="Enviar" />
</form>

Página 30 de 35
2. Métodos de envío

El atributo method permite especificar el método HTTP de envío de los datos. Puede ser de dos tipos:

GET
Los datos del formulario se envían en la propia URL de la petición.

• Ejemplo: http://www.mipagina.com?nombre=pepe&apellidos=glez

POST
Los datos del formulario se envían de manera oculta con la petición.

• Es el método pensado originalmente para envío de datos.

Por norma general, para los formularios utilizaremos POST.

Solo hay un caso en el que puede interesar el uso de GET: cuando el formulario, en vez de datos personales, se
usa para determinar el contenido de la página y nos parezca interesante que el usuario pueda tener una URL
directa a dicho contenido. Se entenderá mejor con un ejemplo:

Imaginemos que utilizamos un formulario con tan solo un <select> que nos permita seleccionar un producto
del que mostraremos información en la página “producto.php”. Para que “producto.php” adapte su contenido
a un producto concreto, le enviamos la referencia desde el formulario anterior. En este caso, el usuario no
tendría una URL directa a la página de un producto si no enviamos los datos por GET.

Página 31 de 35
3. Acceso a las variables desde PHP

Una vez el usuario pulsa el submit del formulario, la información introducida llega a la página PHP especificada
en el atributo action del formulario.

En la página PHP lo recibiremos mediante un array asociativo llamado $_POST o $_GET en función al método
de envío. El identificador de cada una de las posiciones corresponde con el atributo name especificado en el
HTML.

echo "<p>Hola ".$_POST["nombre"] ." ".$_POST["apellidos"]."</p>";

Siguiendo con el ejemplo del formulario, esta sería el posible “procesa_formulario.php”:

<html>
<meta charset="UTF-8" />
<head>
<title>Respuesta</title>
</head>
<body>
<?php
echo "<p>Hola ".$_POST["nombre"]." ".$_POST["apellidos"]."</p>";
echo "<p>Hemos recibido su comentario. Seguro que le hacemos mucho
caso</p>";
?>
</body>
</html>

Este sería el detalle de la secuencia:

4. Acceso a valores de distintos tipos de controles

Tenemos:

Página 32 de 35
Text (textarea, password, email, number, etc.)

<label

for="nombre">Nombre:</label>
<input type="text" name="nombre" />
<label for=“contraseña">Password:</label>
<input type=“password" name=“contraseña" />
<label for="comentario">Comentario:</label>
<textarea name="comentario" rows="5"></textarea>

Radio
En el caso de campos de tipo radio, donde todas las opciones tienen el mismo valor en el atributo name, el
valor del atributo value en la opción elegida.

<input type='radio' name='color' value='Rojo'>Rojo

<input type='radio' checked name='color'
value='Verde'>Verde
<input type='radio' name='color' value='Azul'>Azul

Checkbox
En el caso de campos de tipo checkbox, donde todas las opciones
tienen distinto valor en el atributo name, el valor del atributo
value en las casillas marcadas.

Página 33 de 35
<input type='checkbox' name="acondicionado"
value="Aire"> Aire acondicionado
<input type='checkbox' checked name="tapiceria"
value="Tapicieria">Tapiceria en piel
<input type='checkbox' name="llantas" value="aluminio">
Llantas de aluminio

Select
En el caso de campos de tipo select, los valores del
atributo value de las opciones elegidas.

<select name="precio">
<option selected value="menos">Menos de 6.000
euros</option>
<option value="intermedio">6.001 - 14.000 euros</option>
<option value="mas">Sobre de 14.000 euros</option>
</select>

¡Practica tú mismo!

Crea un proyecto PHP llamado "ejercicio5", que estará formado de los siguientes archivos:

• index.html

• procesa_formulario.php

Llamando al formulario “index.html” nos aseguramos de que cuando se ejecute el proyecto, la primera página
en mostrarse será el formulario.

El formulario, podrá ser de cualquier temática, pero debe contener:

• Algún campo textual

• Radios

• Checkboxes

• Un select

Los datos se enviarán a “procesa_formulario.php” que los procesará y los mostrará en una lista HTML.

Página 34 de 35
NOTA: ¿Tuviste algún problema con los checkboxes? Si hiciste el ejercicio anterior, comprobarás que los
checkboxes, si no se controlan, son una fuente de errores. Cada vez que el usuario deje uno sin marcar,
tendremos un error en PHP. Lo que está pasando es que solo se envían los checkboxes que han sido
seleccionados. Desde PHP recogemos un valor que no existe. Esto lo solucionaremos mediante la función isset
que vimos en apartados anteriores.

Si tenemos varios checkboxes para que el usuario marque los idiomas que habla:

echo "Idiomas: <ul>";

if(isset($_POST["ingles"])
echo "<li>Inglés</li>";
if(isset($_POST["italiano"])
echo "<li>Italiano</li>";

…
echo "</ul>";

Página 35 de 35