Estructuras de control

Estas estructuras nos van a pemritir evaluar condiciones, tomar decisiones y controlar el flujo del prograna, mediante sentencias condicionales y Sentencias de control de bucles.

1/ Sentencias condicionales: Ejecutan una sección del código, cuando se cumple una condición.
2/ Sentencias de control de bucles: Grupos de instrucciones definidas que se ejecutan repetidamente hasta que se cumpla una cierta condición.

PHP posee varias estructuras de control de bucles:

if...else
switch
while
for
foreach
do...[while]

Sentencia if else

La sentencia if sirve para evaluar una expresión.
La sentencia else es simple y no se le puede incluir una evaluación como en el caso de la sentencia if.
La sentencia else if complementa a la sentencia if para definir otras evaluaciones adicionales y pueden haber más de una de estas sentencias, que se evaluan ordenadamente y al evaluar una como verdadera, las otras no las tendrá en cuenta.

$tiempo = date("H"); // Según la hora del día, lanza un mensaje u otro. 


if($tiempo > "6" && $tiempo < "14"){ // Si son entre las 6 y las 14 horas
   echo "Buenos días!";
   }
else if($tiempo > "14" && $tiempo < "20"){ // Si son entre las 14 y las 20 horas.
   echo "Buenas tardes!";
   }
else if($tiempo > "20" && $tiempo < "6"){ // Si son entre las 20 y las 6 horas.
   echo "Buenas noches!";
   }

$precden1 = 3;
$precden2 = 4.5; 


// En este caso la evaluación es True
if($precden1 == 3){ 
   echo "La evaluación fue verdadera";
   }
// En este caso la evaluación es True. Se utiliza una expresión compuesta
if(($precden1 == 3) and ($precden1 >= $precden2 or $precden2 > 4.4)){ 
   echo "2. La evaluación fue verdadera";
   }
// En este caso la evaluación es False pero como se usa el operador ! False 
// se transforma en True y por lo tanto se ejecuta la sentencia interna al if   
if( ! (($precden2 > 10) or ($precden1 == 3 and $precden1 >= $precden2))){ 
   echo "3. La evaluación fue verdadera";
   }

1. La evaluación fue verdadera

2. La evaluación fue verdadera

3. La evaluación fue verdadera

Alternativa de llaves "{}" if else

Alternativa de llaves "{}" if else ==> ":" (dos puntos), endif

la altemativa consiste en reemplazar el uso de la llave de apertura de bloque por dos puntos (:) y la llave de cierre de bloque por la palabra clave end + nombre de estructura de control (endif, endwhite, endforeach, endfor, endswitch).

$alternif = "Quim";

if($alternif === "quim"):
	echo "Nombre equivocado!";
elseif($alternif === "qUIm"):
	echo "Nombre equivocado!";
elseif($alternif === "quiM"):
	echo "Nombre equivocado!";
elseif($alternif === "Quim"):
	echo "Nombre correcto!"; // expresión idéntica
else:
	echo "Nombres incorrectos!";
endif;

Nombre correcto!

Subir

Bucle While

Sentencia simple que ejecuta la instrucción o el bloque de instrucciones que se encuentra dentro de las llaves mientras que se siga cumpliendo la expresión que se evalúa antes de cada ejecución del bucle.
Para que el bucle no sea infinito algo tendná que ir cambiando dentro del bucle para que alguna vez la condición deje de cumplirse.

Si la primem vez que se ejecuta la sentencia while la evaluación de la expresión resutase falsa, las sentencias que hay dentro del bucle while no se ejecutan ni siquiera una vez (si queremos que siempre se ejecute al menos una vez, la opción más adecuada será la sentencia do "hacer").

$arrayFrutas = array("naranja", "plátano", "manzana", "frambuesa");

$i = 0;
$c = count($arrayFrutas);

// Mientras ($i = 0) sea menor que número de índices del array ...
while ($i < $c) {
   $a = $arrayFrutas[$i]; // irá mostrando sus elementos.
   echo $i . "/ " . $a; // Muestra el índice y valor correspondiente al índice.
   $i++; // Incrementa el número del índice hasta 
   	  // igualar número de índices de array, entonces se
	  // deja de cumplir la condición y sale de la sentencia.
}

0/ naranja

1/ plátano

2/ manzana

3/ frambuesa

Subir

Bucle do...while

Ejecutará una instrucción una vez, si la condición se cumple (verdadero) continuará con el bloque de instrucciones, el número específicado de veces que hayamos indicado, cuando la condición sea falsa (no se cumpla), saldrá del bucle. Este bucle se ejecurá siempre por lo menos una vez.

la utilizaremos cuando no sepamos cuantas veces se ha de ejecutar un bucle, al igual que el bucle WHILE, con la diferencia de que sabemos seguro que el bucle por lo menos se ejecutará una vez, ya que primero ejecuta la sentencia con do y luego evalua la condición con while.

$varDo = 0;
$varCont = 0;

// Hacer que ...
do{
  // se incremente en "1" el valor de estas variables.
  $varDo++;
  $varCont++;
  // Mostrar por pantalla ...
  echo $varCont . "^o do, vale ==> " . $varDo . "";
  }
  // mientras que el valor sea inferior o igual a "3".
while ($varDo <= 3 && $varCont <= 3); // Muestra 4 veces el mensaje.

1^o do, vale ==> 1

2^o do, vale ==> 2

3^o do, vale ==> 3

4^o do, vale ==> 4

Subir

Bucle Switch

Evalúa una variable o una expresión y luego en una o varias sentencias case se compara esa variable o el resultado de esa expresión con diferentes valores.
Si alguna de las sentencias case cumple la condición, se ejcutará su bloque de instrucciones, pero a diferencia de la sentencia if else, switch continuará evaluando las sentencias case que tenga por debajo de la que cumplió la condición.
Si no queremos que pase esto debemos colocar dentro de cada case la sentencia break.
Para terminar, cuando acabamos de montar la estructura de sentencias case y no hemos colocado dentro de ellas ninguna sentencia break, deberemos incluir la sentencia default detrás del último case que se ejecutará siempre, tanto si una sentencia case cumple la condición como si no la cumple, así no se creará un bucle infinito.

$micolor = "azul";
switch ($micolor){
	
	case "rojo":
	   echo "Tu color favorito es el rojo";
	   break; 
	case "amarillo":
	   echo "Tu color favorito es el amarillo";
	   break; 
	case "verde":
	   echo "Tu color favorito es el verde";
	   break; 
	case "azul": // Se cumple la condición 
	   echo "Tu color favorito es el" . $micolor;
	  break; // Deja de evaluar el resto de sentencias case 
	  
	// Si no se cumple la condición en ninguna sentencia "switch",
		     sale del bucle con el siguiente mensaje 
	default; 
	   echo "Tu color favorito no es ni rojo, ni amarillo, ni verde, ni azul";

}

Tu color favorito es el azul

Subir

Bucle for

for se utiliza cuando se sabe de antemano cuántas veces se debe ejecutar la secuencia de comandos.
Parámetros de for:

1^er parámetro: Generalmente se utiliza para ajustar el contador (pero puede ser cualquier código que se ejecutará una vez al principio del bucle).
2^o parámetro: Evalúa por cada iteración del bucle. Si se evalúa como TRUE, el bucle continúa. Si se evalúa como FALSE, el bucle termina.
3^er parámetro: Generalmente se utiliza para incrementar un contador (pero puede ser cualquier código que se ejecuta al final de la iteración).

//   parame_1 || parame_2 || parame_3
for ($varFor=1; $varFor<=3; $varFor++)
	{
	// Se repetirá hasta cumplir el 2º parámetro 
	echo $varFor . "^a vuelta de for ==> " . $varFor . "";
	}

1^a vuelta de for ==> 1

2^a vuelta de for ==> 2

3^a vuelta de for ==> 3

// Caso 1: 
// Con las tres expresiones 
for ($for1 = 3; $for1 >= 1; $for1--){
	// Muestra en decremento los valores: 3, 2, 1 
	echo "Caso 1: " . $for1;
}

// Caso 2:
// Sin la 1ª expresión, no hay inicialización (se hace antes)
$for1 = 3; // Inicializar variable.
for (...; $for1 >= 1; $for1--){
	// Muestra en decremento los valores: 3, 2, 1 
	echo "Caso 2: " . $for1;
}

// Caso 3:
//  Sin la 2ª expresión, no hay (control de bucle) 
for ($for1 = 3; ...; $for1--){
	// al no haber 2ª expresión, debe haber una sentencia
	// break para que no haya bucle infinito.
	// Entrará en sentencia "if" cuando "$for1" sea igual a 2 
	if ($for1 == 2){
		echo "Caso 3: sale por sentencia break";
		break;
	}
	// "$for1" al decrementar, primero vale "3", luego "2" 
	echo "Caso 3: " . $for1;
}


// Caso 4:
// Sin las 3 expresiones, no hay expresiones explícitas en la sentencia for: 
// se omiten las tres expresiones.
// La expresión de inicialización: se omite, por lo que
// la variable será cero "0" (o el valor que traiga de antes)
// La expresión de control de bucle: se define dentro del bloque
// en este caso es if ($for2 == 2).
// La expresión de incremento/decremento: se omite, por lo que
// dentro del bloque se incluye la sentencia ++$for2. 
for (...; ...; ...){
	// Al no haber 2ª expresión, debe haber una sentencia
	// break para que no haya bucle infinito.
	// Entrará en sentencia "if" cuando "$for2" sea igual a 2 
	if ($for2 == 2){
		echo "Caso 4: sale por sentencia break";
	   	break;
	}
	// Primero "$for2" vale "1", y "2" en la siguiente iteración. 
	echo "Caso 4: " . ++$for2;
}

// Caso 5:
// Sintaxis alternativa (sin llaves de apertura y cierre) 
for ($for1 = 3; $for1 >= 1; $for1--):
// Mediante "$for2--", decremento, inicializa una cuenta atrás. 
     echo "Caso 5: " . $for1; // Muestra 3, 2, 1 
endfor;

Caso 1

Caso 1: 3

Caso 1: 2

Caso 1: 1

__________________________________

Caso 2

Caso 2: 3

Caso 2: 2

Caso 2: 1

__________________________________

Caso 3

Caso 3: 3

Caso 3: sale por sentencia break

__________________________________

Caso 4

Caso 4: 1

Caso 4: 2

Caso 4: sale por sentencia break

__________________________________

Caso 5

Caso 5: 3

Caso 5: 2

Caso 5: 1

Subir

Bucle foreach

foreach se utiliza para recorrer arrays. El bucle se ejecutará tantas veces como elementos tenga la matriz.
foreach sólo funciona sobre arrays y sobre objetos desde la versión 5, y emitirá un error al intentar usarlo con una variable de un tipo diferente de datos o una variable no inicializada.
foreach tiene dos sintaxis: en ambas , en cada iteracón se recibe el valor del elemento de la matriz. Pero en la segunda sintaxis, además, recive la clave y el valor del elemento.

Recivir el valor del Array:

$vector = array("valUno", "valDos", "valTres");

// Recorrer los elementos del Array, asignando cada elemento a una variable "$valor" 
foreach ($vector as $valor){
  // Se asigna a $valor, el elemento actual de la matriz, 
  // (el puntero se mueve por uno) así que en la siguiente
  // iteración del bucle, se asigna el siguiente valor de la matriz. 
  echo $valor; // Muestra cada elemento del array en cada iteración. 
  }

valUno ... valDos ... valTres

Recibir la clave y el valor del Array:

$varArray = array(
    "valUno" => 1,
    "valDos" => 2,
    "valTres" => 3);

// Asignar una variable para la clave y otra para el valor de cada elemento.  
foreach ($varArray as $varClave => $varValor){
	// Mostrar de cada elemento su clave y valor. 
    echo "$varArray[$varClave] => $varValor";
}

$varArray[valUno] => 1 ... $varArray[valDos] => 2 ... $varArray[valTres] => 3

Array multidimensional

Es un array que dentro tiene otro array. Este, a su vez, puede tener otro array y así sucesivamente, esto se denomina dimensión al nivel de anidamiento o de inclusión de arrays que se alcanza. Así que un array multidimensional de dimensión 2 está compuesto por un array que dentro tiene otros arrays y estos últimos, ya no contienen más arrays.

// ARRAYS MULTIDIMENSIONALES 
$multidimensional = array();
$multidimensional [0][0] = "uno 0"; // Array 1 
$multidimensional [0][1] = "uno 1"; // Array 1 
$multidimensional [0][2] = "uno 2"; // Array 1 
	$multidimensional [1][0] = "dos 0"; // Array interior 
	$multidimensional [1][1] = "dos 1"; // Array interior 
	
	
// Recorrer el primer Array 
foreach ($multidimensional as $valor1) {
    
	// Recorrer el Array interior 
	foreach ($valor1 as $valor2) {
        
		echo $valor2 . " <br />";
    
	}

}

uno 0
uno 1
uno 2
dos 0
dos 1

Array de dimensión 2

$compra = array( 
  array('Titulo' => "ROSA", 'Precio' => 1.25, 'Numero' => 14),
  array('Titulo' => "MARGARITA", 'Precio' => 0.75, 'Numero' => 21),
  array('Titulo' => "ORQUIDEA", 'Precio' => 1.15, 'Numero' => 7)
			   ); 

// Mostrar estructura de tabla 
	echo "<table>";
	
	echo "<thead> <tr> <th colspan="3">FLORISTERIA</th> </tr>";
	echo "<tr> <td></td> <td>COSTES</td> <td>CANTIDAD</td> 
       </tr> </thead> ";
	echo "<tbody>";
	echo "<tr>";
			  
for ($fila = 0; $fila < 3; $fila++){
    echo "<td>" . $compra[$fila]["Titulo"] . "</td>" .
	"<td> " . $compra[$fila]["Precio"] . "</td>" . 
	"<td> " . $compra[$fila]["Numero"] . "</td>";
	
	echo "</tr>";
}

	echo "</tbody>";
	
	echo "</table>";

FLORISTERIA
	COSTES	CANTIDAD
ROSA	1.25	14
MARGARITA	0.75	21
ORQUIDEA	1.15	7

foreach() mostrar como lista ordenada

Usando bucle foreach para mostrar elementos como una lista ordenada

Número de fila 0
- ROSA
- 1.25
- 14
Número de fila 1
- MARGARITA
- 0.75
- 21
Número de fila 2
- ORQUIDEA
- 1.15
- 7

Foreach en Objetos

Cuando se utiliza la sentencia foreach con objetos de una clase, lo que se obtiene en cada bucle es cada una de las propiedades públicas del objeto.

Las propiedades y métodos son accesibles dependiendo de su ámbito, desde dentro de una clase se muestran todos, mientras que desde fuera de la clase serán visibles únicamente los definidos como public.

// Incluimos el archivo que recorrerá las propiedades del objeto ______________
include "recorrer_objeto.php"; 



// Código del archivo recorrer_objeto.php _____________________________________ 
<?php

	echo "<h4>Recorrer propiedades de un Objeto</h4>";
	
	// Precisa de los datos del archivo indicado 
	require_once("Persona4.php");
	
	// Se crea una clase de la clase 'Persona4' 
	$objPersona = new Persona4();

	$aPropiedades1 = get_class_vars("Persona4");
	$aPropiedades2 = get_object_vars( $objPersona );
	$aMetodos	   = get_class_methods("Persona4");

    // También podría haberse usando 'get_class()' y el nombre de un Objeto:	
	// $aPropiedades1 = get_class_vars( get_class($objPersona) );
	// $aMetodos = get_class_methods( get_class($objPersona) ); 

	echo "<h3>PROPIEDADES 1:</h3>";
	
	// Recorre todas la propiedades públicas de la clase 
    foreach( $aPropiedades1 as $nombre => $valor ){
        echo "<p>" . $nombre . ": [" . utf8_encode($valor) . "]<br/>";
	}
	
	echo "<h3>PROPIEDADES 2:</h3>";
	
	// Recorre todas la propiedades públicas de la clase  
    foreach( $aPropiedades2 as $nombre => $valor ){
        echo "<p>" . $nombre . ": [" . utf8_encode($valor) . "]<br/>";
	}

	echo "<h3>PROPIEDADES (obtenidas desde la clase):</h3>";
	
	// Recorre todas la propiedades   
	$objPersona->getPropiedades();	
	// Se devolverán TODAS las propiedades 

	echo utf8_encode("<h3>MÉTODOS:</h3>");
	
    // Recorre todos los métodos públicos o no clasificados
	// No recorre las funciones 'protegidas' y 'privadas'  
    foreach( $aMetodos as $nombre => $valor ){
        echo "<p>" . $nombre . ": [" . utf8_encode($valor) . "]<br/>";
	}
		echo "</p>";

	echo "<p>Finalizado</p>";

?>



// Archivo Persona4.php que contiene la clase ___________________________ 

<?php

	class Persona4
	{

		// Propiedades 
		private $nombre    = null;
		private $apellidos = null;
		public  $provincia = null;
		public  $pais	   = "ESPAÑA";
		public  $importe   = 100;

		// Constantes: 
		const PERSONA_HOMBRE = "HOMBRE";
		const PERSONA_MUJER  = "MUJER";

		// Constructor vacío: 
        function Persona4() {
        }

		// Métodos: 

        function getNombre() {
            return $this->nombre;
        }

        function setNombre( $nombre ) {
            $this->nombre = $nombre;
        }
		
		// Función privada 
        private function getPais() {
            return $this->pais;
        }
		
		// Función pública 
		public function getPropiedades(){
			$aPropiedades1 = get_class_vars("Persona4");
			foreach( $aPropiedades1 as $nombre => $valor ){
				echo "<p>" . $nombre . ": 
				     [" . utf8_encode($valor) . "]<br/>";
			}
			echo "</p>";
		}

	}// clase 

?>

Recorrer propiedades de un Objeto

PROPIEDADES 1:

provincia: []

pais: [ESPAÑA]

importe: [100]

PROPIEDADES 2:

provincia: []

pais: [ESPAÑA]

importe: [100]

PROPIEDADES (obtenidas desde la clase):

nombre: []

apellidos: []

provincia: []

pais: [ESPAÑA]

importe: [100]

MÉTODOS:

0: [Persona4]

1: [getNombre]

2: [setNombre]

3: [getPropiedades]

Finalizado

Subir

Break, continue

break: romper el flujo natural de un bucle y sale de el. break accepta un parametro opcional, que será el que determine cuantas estructuras de control hay que escapar.
continue: nos deja saltarnos la iteración que esta teniendo lugar para pasar directamente a la siguiente.

$salirBucle = array(0 => 'madrugada', 1 => 'mañana', 2 => 'mediodia', 
              3 => 'tarde',  4 => 'noche', 5 => 'ocaso', 6 => 'crepúsculo');

echo "La sentencia break nos hace salir del bucle 
	  en la vuelta del valor 'noche'";
	
	foreach($salirBucle as $valSalBucle){
		// Si valor es 'noche' sale del bucle 
		if($valSalBucle == 'noche'){
			
			break; 
			
		}
		
		echo $valSalBucle;
		
	}

La sentencia break nos hace salir del bucle en la vuelta del valor 'noche'

madrugadamañanamediodiatarde

$saltarIteracion = array(0 => 'madrugada', 1 => 'mañana', 2 => 'mediodia', 
              3 => 'tarde', 4 => 'noche', 5 => 'ocaso', 6 => 'crepúsculo');

echo "La sentencia continue salta la iteración en la vuelta indicada y sigue
	  mostrando el resto de los elementos de la matriz.";
	
	foreach($saltarIteracion as $valSaltVuelta){
		
		// Si valor es 'noche' salta esta iteración y continua. 
		if($valSaltVuelta == 'noche'){
			
			continue; 
		
		}
		
		echo $valSaltVuelta;
	
	}

La sentencia continue salta la iteración en la vuelta indicada y sigue mostrando los siguientes elementos de la matriz.

madrugadamañanamediodiatardeocasocrepúsculo

Return (devolver valor)

Todas las funciones necesitan devolver un valor después de haber echo un cálculo, comparación u otra operación, podemos devolver ese valor con la instrucción return, al utilizar return, terminará la ejecución de la función ya que una vez devuelto el valor, no será necesario seguir ejecutando más instrucciones.

function retorno($par_1, $par_2)
	{
		// Cálculo de los dos parámetros 
		$reslt = $par_1 * $par_2;
		return $reslt; // Retorna el valor de la variable 
	}
	  
    $par_1 = "6"; // Valor de parámetro 1 
    $par_2 = "3"; // Valor de parámetro 2 
	
    // Mediante la variable llamamos a función con sus parámetros 
    $reslt = retorno($par_1, $par_2); // reusltado 18 
	
    // Sacamos el resultado por pantalla 
    echo $reslt;

Retornar un valor nulo NULL

Si no hay valor a retornar, return devuelve NULL.

// No hay parámetro para el retorno 
function campo(){
	// Termina la ejecución y no hay valor de retorno 
	return;// Retorna NULL  
}
	// Devolver valor de la función campo() 
	echo gettype(campo());

NULL

exit() o die() (fin de ejecución)

die() es un alias de exit() así que todo lo que se ejecuta con exit() es válido para die().
Esta construcción del lenguaje da por terminada la ejecución del código. Todo lo que haya generado la página PHP hasta ese punto del progama se envía al navegador cliente y a partir de exit() o die() ya no se ejecuta el resto de código.

exit es una construcción de lenguaje PHP y puede ser llamada sin paréntesis si no se le pasa status.
Si status es una cadena, esta función imprime el status justo antes de salir.
Si status es un valor integer, ese valor será usado también como el status de salida y no se mostrará. Los status de salida deben estar en el rango 0 a 254, el status de salida 255 es reservado por PHP y no debe ser usado. El status 0 es usado para finalizar el programa de forma satisfactoria.

El uso más común es cuando no podemos conectar con la base de datos.

Ejemplo exit()

$miArchivo = '/ruta/hacia/archivo-datos';
	
	// Abrir un fichero o URL con 'fopen()' ... 
	$documento = fopen($miArchivo, 'r')

	// o mensaje de salida de código si no encuentra el archivo 
	or exit("No se pudo abrir el archivo ($miArchivo)");

Ejemplo die()

function mensaje_error($texto) {
     
     // Aquí podemos agregar más cosas 
     $llegar = 'Hola!'; // Complemento al iniciar 
     $marchar = 'Adiós!'; // Complemento para terminar 
     
     // Mostramos el mensage '$texto' entre 
     // los  complementos de inicio y fin. 
     die($llegar . '<br />' . $texto . '<br /> '. $marchar);
}

// Llamamos a la función 
mensaje_error('¡¡ Aquí puede haber un ERROR !!');

Goto (pasar a)

Permite saltar directamente a otra sección del programa, identificada mediante una etiqueta seguida de dos puntos. Saltariamos a otra sección del código con: (goto etiqueta;), y la etiqueta sería: (etiqueta:).

NOTA:

- La etiqueta referida debe estar en el mismo archivo.
- No se puede salir ni entrar directamente a una función o método.
- No podremos entrar directamente dentro de un bucle, pero si podremos salir de él.

echo "Despues de esta línea saltamos la siguiente línea de código con goto.";

	goto saltaraqui; // goto y etiqueta identificadora 


echo "La ejecución del código salta esta línea.";

	saltaraqui: // Etiqueta 

echo "El código seguirá a partir de la etiqueta indicada en goto.";

Despues de esta línea saltamos la siguiente línea de código con goto.

El código seguirá a partir de la etiqueta indicada en goto.

include(), inclusión de ficheros

La función include() ordena la inclusión de otro archivo que puede ser de cualquier extensión. El archivo al que hace referencia la sentencia include puede ir entre paréntesis () o sin ellos, pero siempre entre comillas " ". Cuando se utiliza la función include dentro de estructuras de bucle o de control se debe codificar entre llaves, {}, aunque sea la única sentencia, ya que, en caso contrario, puede generar errores.

include() difiere de require() en que la sentencia include() se re-evalua cada vez que se encuentra (y solo cuando esta siendo ejecutada), mientras que la sentencia require() se reemplaza por el archivo referenciado cuando se encuentra por primera vez, se vaya a evaluar el contenido del archivo o no (por ejemplo, si esta dentro de una sentencia if cuya condicion evaluada es falsa).

# include dentro de una sentencia de control entre llaves 

$var1 = 2; 
// opción más segura 
if($var1 == 2)
    {  
 	include "includeArchivo.php";
    }

La ventaja de los archivos que incluimos es que los podremos utilizar tantas veces como los necesitemos y en muchas otras páginas.

El archivo incluido heredará las variables del ámbito en donde se llama a la sentencia include(). A su vez las variables escritas en el archivo incluido se podrán utilizar en el archivo llamante, aunque sigen rigiendo las variables locales

include "includeArchivo.php"; // Incluiye este archivo todas las veces que lo necesitemos

Soy el ARCHIVO INCLUDE !!

include_once(), incluir una vez

La función include_once() ordena la inclusión de un archivo después de comprobar que el archivo aun no a sido incluido, si el archivo ya ha sido incluido una sola vez, no volverá a incluirse.

include ("includeArchivo.php"); // Volvemos a incluir archivo 
include_once "includeArchivo.php"; // Si el archivo ya está incluido, no vuelve a incluirse

Soy el ARCHIVO INCLUDE !!

require(), requiere un fichero

Su funcionalidad es la misma que include(), pero con la única diferencia que si no encuentra la ruta del archivo referenciado por la sentencia, se obtiene un error fatal, mientras que con include() obtendremos un mensaje de advertencia y el código seguirá ejecutándose a pertir de la siguiente instrucción de la sentencia include().

require() difiere de include() en que la sentencia include() se re-evalua cada vez que se encuentra (y solo cuando esta siendo ejecutada), mientras que la sentencia require() se reemplaza por el archivo referenciado cuando se encuentra por primera vez, se vaya a evaluar el contenido del archivo o no (por ejemplo, si esta dentro de una sentencia if cuya condicion evaluada es falsa).

require "requireArchivo.php"; // Incluiye este archivo
	
	// Si el archivo está, muestra un mensaje 
	if("requireArchivo.php" ){
		echo "El archivo ya está incluido en la página !!";
	}else{
		// Si el archivo no está, carga y evalua el archivo 
		require_once "requireArchivo.php";
	}

Soy el ARCHIVO REQUIRE !!

Volvemos a requerir el mismo archivo con la sentencia require()

El archivo ya está incluido en la página !!

Al haberlo requerido previamente, hacemos aparecer un mensaje para que no nos de un error.

require_once(), requiere una vez

Ya hemos podido ver que al requerir un archivo, si este ya existe en la página, la función require_once() no lo volverá a cargar, actuará como si no existiera la llamada a la sentencia.

La utilidad de la sentencia require_once() se hace evidente cuando se quiere evitar problemas por redefiniciones de variables o asignaciones a variables.

Volver