Trabajar con ficheros.

En nuestras aplicaciones web, solemos manejar ficheros cuando los enviamos al servidor (uploads) o cuando los manipulamos localmente al realizar operaciones de entrada/salida.

01-Jul-2017

En este módulo, veremos el trabajo de con ficheros desde dos puntos de vista diferentes, primero como realizar el envío de ficheros a nuestro servidor (uploads) utilizando formularios y segundo, como trabajar con los ficheros locales de nuestro servidor realizando las operaciones de lectura y escritura.

Envío de ficheros

Formularios de envío de ficheros (uploads)

Las páginas de subida de ficheros (uploads) se suelen crear en la mayoría de los casos mediante la utilización de formularios HTML a los cuales es obligatorio añadirles el atributo enctype="multipart/form-data" para que se pueda procesar de forma correcta la petición de envío del fichero.

Estos formularios deben de incluir como mínimo un campo de tipo ‘file’ que es el que recoge el fichero y su información y opcionalmente un campo de tipo oculto, de nombre MAX_FILE_SIZE donde se debe de especificar el tamaño máximo del fichero en bytes que se va ha enviar al servidor.


Diseño del formulario para el envío de ficheros

Vamos a crear una página HTML con un formulario Bootstrap de ejemplo desde el que enviaremos un campo de texto y un archivo utilizando el método POST a un script de nuestro servidor para que realice las operaciones de upload.

Vista del formulario

Formulario Bootstrap para el envío del fichero

Contenido HTML de la página (form_envio.html)

<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Formulario de envio</title>
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet">

<script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js" type="text/javascript"></script> </head>
<body>
<div class="container">
<DIV id="PANEL_0" class="panel panel-primary text-justify">
<DIV class="panel-heading">
<H3 class="panel-title">
Envio de solicitud</H3>
</DIV>
<DIV class="panel-body">

<FORM id="form_envio" method="POST" action="procesa.php" name="form_envio" enctype="multipart/form-data">
<DIV class="form-group has-feedback">
<label for="nombre" role="button">Nombre solicitante</label>
<INPUT id=
"nombre" type="text" name="nombre" size="35" aria-describedby="spannombre" placeholder="Nombre completo" class="form-control" />
<SMALL id="nombre" class="form-text text-muted">Escribir en formato: Apellidos, Nombre</SMALL>
<SPAN class="glyphicon glyphicon-font form-control-feedback"></SPAN>
<SPAN id="spannombre" class="sr-only">...</SPAN>
</DIV>
<DIV class="form-group has-feedback">

<label for="fichero" role="button">Fichero adjunto:</label>
<INPUT id=
"fichero" type="file" name="fichero" class="form-control" />
</DIV>
<input type="hidden" name="MAX_FILE_SIZE" value="10000">
<BUTTON id=
"btn_enviar" type="submit" class="btn btn-sm btn-primary">Enviar fichero</BUTTON>
<BUTTON id=
"btn_cancelar" type="reset" class="btn btn-sm btn-danger">Reiniciar</BUTTON>
</FORM>

</DIV>
</DIV>
</div>
</body>
</html>

El array global $_FILES

Una vez ha sido enviado el fichero PHP rellenará el array global $_FILES con información referente al/los ficheros recibidos. $_FILES es un array asociativo, donde se definen una serie de claves para acceder a los datos, estas claves se corresponden con el nombre campo del formulario donde se recogió el fichero.

Las variables definidas para los archivos enviados varían en función de la versión y configuración de PHP que se utilice. Las variables de las que hablamos a continuación serán definidas en la página destino después de la recepción correcta del fichero.

$_FILES contienen la información sobre el fichero recibido.

  • $_FILES['fichero']['name']:
    • El nombre original del fichero en la máquina cliente.
  • $_FILES['fichero']['type']:
    • El tipo mime del fichero (si el navegador lo proporciona). Un ejemplo podría ser "image/gif".
  • $_FILES['fichero']['size']:
    • El tamaño en bytes del fichero recibido.
  • $_FILES['fichero']['tmp_name']:
    • El nombre del fichero temporal que se utiliza para almacenar en el servidor el archivo recibido.

NOTA: Se ha tomado como clave ‘fichero' para el fichero recibido tal y como se ha definido en el campo de tipo file del script de ejemplo anterior.

Por defecto, los ficheros serán almacenados en el directorio temporal del servidor a no ser que se especifique otra localización con la directiva upload_tmp_dir en php.ini.

Luego será tarea del programa de mover el fichero a la carpeta donde realmente deseamos que quede almacenado.


Script donde se procesan los datos recibidos del formulario de envío

Vamos a crear el script encargado de comprobar y mover el fichero recibido del formulario. (procesa.php)

<?php
//Código  que incluiremos al principio de la página encargada de procesar el fichero  recibido.
//*********************************************************************************************

// Si no se ha creado el array global $_FILES cancelamos todo el script
if(empty($_FILES)) {
	die("Error crítico en el envío del fichero.");
	exit();
}
// Indicador de error de envío
$ErrorEnvio=false;
// Carpeta de destino
$DirUpload='./archivos/';
// Si no existe la carpeta de destino la creamos
if(!file_exists($DirUpload)) mkdir($DirUpload);
// Carpeta y nombre del archivo de destino
$archivo_destino = $DirUpload.$_FILES['fichero']['name'];
/* Si se ha conseguido enviar el archivo adjunto, comprobaremos su tamaño y lo moveremos
	   a la carpeta de destino */
if (is_uploaded_file($_FILES['fichero']['tmp_name'])) {
  // si el tamaño del archivo subido es 0, activamos el indicador de error
  if(filesize($_FILES['fichero']['tmp_name'])==0) {
    $ErrorEnvio=true;
  /* Por el contrario si el tamaño del archivo es distinto de 0, movemos el archivo de la carpeta temporal
     a la carpeta de destino */
  } else {
    move_uploaded_file($_FILES['fichero']['tmp_name'], $archivo_destino);
  }
/* Si no existe el fichero en la carpeta temporal será porque habrá fallado el envío y activamos
   el indicador de error */
} else {
  $ErrorEnvio=true;
}
?>
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Procesar envío</title>
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet">

<script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js" type="text/javascript"></script> </head>
<body> <div class="container">
<?php //Código que incluiremos en el cuerpo del documento para avisar de cómo a finalizado el proceso. //************************************************************************************************ if($ErrorEnvio) { ?> <div class="alert alert-danger" role="alert"> <p><?php echo $_POST['nombre']; ?>, se ha producido algún error al intentar enviar el fichero
(<?php echo $_FILES['fichero']['name']; ?>). Inténtelo de nuevo.</p> </div> <?php } else { ?> <div class="alert alert-success" role="alert"> <p>Usuario: <?php echo $_POST['nombre']; ?></p> <p>El documento ha sido almacenado de forma correcta.</p> <ul> <li><strong>Nombre</strong>: <?php echo $_FILES['fichero']['name'];?></li> <li><strong>Tipo</strong>: <?php echo $_FILES['fichero']['type'];?></li> <li><strong>Tamaño</strong>: <?php echo $_FILES['fichero']['size'];?> bytes</li> </ul> <p>Si quieres consultarlo se encuantra en la carpeta de archivos <?php echo $DirUpload; ?></p> </div> <?php } ?> </div> </body> </html>

 

Resultado de procesar el envío correctamente

 

Operaciones sobre ficheros

PHP nos ofrece varias formas de trabajar con ficheros para realizar las operaciones típicas de lectura y escritura, dándonos la opción de utilizar las instrucciones de apertura, lectura, escritura y cierre como en otros lenguajes, o la posibilidad de leer y escribir contenidos completos de archivos.

Trabajo secuencial

fopen. Abrir un fichero.

resource fopen(string $nombre_fichero,  string $modo_apertura)

fopen() Abre el fichero indicado en el parámetro nombre_fichero en el modo de apertura indicado en el parámetro modo_apertura y devuelve un puntero al fichero abierto o FALSE si se produce un error.

Parámetros

  • nombre_fichero → Ruta de acceso al fichero
  • modo_apertura → aunque existen muchos modos de apertura los más comunes suelen ser: ‘r’ lectura, ‘w’ escritura y ‘a’ añadir

fclose. Cerrar un fichero abierto.

bool fclose(resource $gestor_fichero)

fclose() cierra el puntero a un fichero abierto previamente con fopen().

Devuelve TRUE en caso de éxito o FALSE en caso de error.

Parámetros

  • gestor_fichero → Identificador obtenido con fopen.

fgets. Leer desde un fichero abierto.

string fgets(resource $gestor_fichero [,int $longitud])

fegts() lee/obtiene una línea desde el puntero a un fichero.

Parámetros

  • gestor_fichero → Identificador obtenido con fopen.
  • longitud → Total de bytes que se desean leer, si se omite se realiza una lectura hasta el final de línea.

La lectura termina cuando se han leído longitud - 1 bytes, o una nueva línea. Si no hay más datos que leer o se produce un error devuelve FALSE.


feof. Final de fichero.

bool feof(resource $gestor_fichero)

Cuando se realizan lecturas secuenciales en ficheros, para controlar cuando hemos llegado al final del fichero utilizaremos la función feof() indicando como parámetro el gestor de fichero obtenido con fopen.

feof devuelve TRUE cuando se alcanza el final del fichero, mientras hayan más datos que poder leer devuelve FALSE.


EJEMPLO: Lectura secuencial de datos (fgets.php)

Supongamos que tenemos un archivo de nombre clientes.dat guardado en la carpeta datos que contiene la información básica de una serie de clientes.
Cada línea es un registro el cual está formado por el nombre, teléfono y edad del cliente, en el que se ha utilizado como separador de campo el carácter | (pipe).

Contenido del archivo ./datos/clientes.dat

Luis|666666666|45
Carmen|666777888|37
Fernando|666888999|40
Enrique|666555444|48
Rosa|555666555|25

Vamos a realizar una lectura secuencial de cada registro, para mostrarlos dentro de una tabla.

<body>
<div class="container">
<h1>LISTADO DE CLIENTES</h1>
<table class="table table-striped">
<tr> <!--Creamos los encabezados de columna-->
	<th>Nombre</th>
	<th>Teléfono</th>
	<th>Edad</th>        
</tr>
<?php
// Definimos constante el carácter de separación de campo
define("SEP_CMPO","|");
// Abrimos el fichero en modo de escritura
$gestor=@fopen('./datos/clientes.dat',"r");
// Si se ha podido abrir el fichero
If($gestor) {
   // Realizamos la primera lectura del Registro
   $Registro=fgets($gestor);
   // Mientras no se encuentre el final del fichero
   While(!feof($gestor)) {
     // Separamos los campos y los almacenamos en un array
     $Campos=explode(SEP_CMPO,$Registro);
     // Mostramos el contenido de cada campo
     echo "<tr><td>{$Campos[0]}</td><td>{$Campos[1]}</td><td>{$Campos[2]}</td></tr>";
     // Realizamos una nueva lectura
     $Registro=fgets($gestor);
   }
// Cerramos el fichero 
fclose($gestor);
}
?>
</table>
</div>
</body>

El resultado que se mostraría es:

Resultado de la lectura secuencial con fgets

fwrite. Escribir en un fichero.

int fwrite(resource $gestor_fichero, string $Buffer [, int $longitud])

fwrite() devuelve el número de bytes escritos, o FALSE si se produjo un error.

Parámetros

  • gestor_fichero → Identificador obtenido con fopen.
  • Buffer → Variable de tipo String que almacena la información que deseamos grabar en el fichero.
  • longitud → Si se proporciona el parámetro longitud, la escritura se detendrá después de que longitud bytes hayan sido escritos o se alcance el final de string, lo que suceda primero.

EJEMPLO: Escritura en ficheros (fwrite.php)

Para escribir datos en un fichero, lo abriremos utilizando el modo escritura (write) 'w' con la función fopen() y posteriormente utilizaremos la función fwrite(). Si el fichero ya existe será truncado a longitud cero (perderá su contenido anterior).

En nuestro ejemplo vamos a escribir los datos: nombre, telefono y edad recibidos por el método POST desde un formulario. Para ello crearemos un registro uniendo todos los datos y utilizando un caracter como separador de campo.
<?php
// Definimos constante el carácter de separación de campo
define("SEP_CMPO","|");
// Definimos constante para los saltos de final de párrafo
define("CRLF","\r\n");
// Abrimos el fichero en modo de escritura
$gestor=@fopen('./datos/clientes.dat',"w");
// Si se ha podido abrir el fichero
If($gestor) {
	// Cargamos el buffer con los datos que se han recibido del formulario utilizando el método POST
	$Buffer = $_POST['nombre'].SEP_CMPO.$_POST['telefono'].SEP_CMPO.$_POST['edad'].CRLF;
	// Realizamos la escritura del buffer en el fichero
	fwrite($gestor,$Buffer);
	// Cerramos el fichero
	fclose($gestor);
}
?>

Tener en cuenta que para que funcione este script es necesario que reciba datos de un formulario. En los scripts de ejemplo, encontrareis una página de nombre form_fwrite.html para realizar las pruebas.


EJEMPLO: Añadir datos al fichero (fwrite_a.php)

Para añadir datos al final del fichero, lo abriremos utilizando el modo añadir (append) 'a' con la función f_open() y posteriormente utilizaremos la función fwrite().

Ahora deseamos añadir nuevos registros a nuestro fichero de clientes, pero en esta ocasión los tenemos almacenados en un array desde donde los vamos a ir leyendo uno a uno para grabarlos al final del fichero abierto.
<?php
// Definimos constante el carácter de separación de campo
define("SEP_CMPO","|");
// Definimos constante para los saltos de final de párrafo
define("CRLF","\r\n");
// Array donde tenemos almacenados los registros que deseamos AÑADIR en el fichero
$registros=[ ['Luis','666666666',45],
             ['Carmen','666777888',37],
             ['Fernando','666888999',40],
             ['Enrique','666555444',48],
             ['Rosa','555666555',25]];
			
// Abrimos el fichero en modo de añadir al final
$gestor=@fopen('./datos/clientes.dat',"a");
// Si se ha podido abrir el fichero
If($gestor) {
	foreach($registros as $registro) {
	// Cargamos el buffer con los datos que se van leyendo del array
	$Buffer = $registro[0].SEP_CMPO.$registro[1].SEP_CMPO.$registro[2].CRLF;
	// Realizamos la escritura del buffer en el fichero
	fwrite($gestor,$Buffer);
	}
	// Cerramos el fichero
	fclose($gestor);
}
?>

Instrucciones para leer/escribir contenidos completos en ficheros

file_get_contents. Leer todo el contenido de un archivo.

La función file_get_contents nos permite leer todo el contenido de un archivo local o remoto y almacenarlo en un buffer de tipo string.

Es la forma más habitual de transmitir el contenido de un archivo a una cadena, utilizando mapeados de memoria para mejorar el rendimiento.

string file_get_contents(string $nombre_fichero [, bool $use_include_path = false [,resource $context  [,int $offset = 0 [,int $maxlen]]]])

file_get_contents nos devuelve el contenido del fichero especificado en $nombre_fichero, comenzando desde $offset especificado hasta $maxlen bytes. Si se omiten estos dos parámetros se realiza la lectura completa del fichero.

Parámetros:

  • nombre_fichero: Nombre del fichero a leer.
  • context: Un recurso de contexto válido creado con stream_context_create(). Si no se necesita usar un contexto a medida, se puede saltar este parámetro usando NULL.
  • offset: El índice donde comienza la lectura en el flujo original (fichero).
    NOTA: La búsqueda de (offset) no está soportada con ficheros remotos. Intentar buscar un fichero no local puede funcionar con índices pequeños, pero es impredecible debido a que trabaja sobre el flujo almacenado en buffer.
  • maxlen: La longitud máxima de los datos leídos. De manera predeterminada se lee hasta que se alcance el final del fichero.

Errores:

Si falla la lectura devuelve el valor FALSE, teniendo que utilizar el operador de idéntico === para comprobar el resultado.

Las posibles causas por las que se pueda generar un error de nivel E_WARNING son:

  • nombre_fichero no se pudo encontrar
  • maxlength es menor de cero
  • falla la búsqueda del offset especificado.

EJEMPLO: Lectura de un archivo remoto y otro local (file_get_contents.php)

<?php
//	LEER EL CONTENIDO DE UN ARCHIVO REMOTO
//-------------------------------------------------------------
// Leemos todo el contenido de una página web remota 
$pagina = @file_get_contents('http://www.minubeinformatica.com/index.php');
// Si se produce algún tpo de error mostramos mensaje de aviso
if($pagina===false) {
	echo '<p>Error al intentar leer el archivo remoto.</p>';
} else {
// La variable $pagina almacena ahora el contenido procesado desde el servidor de la página index.php
// convertimos los caracteres en entidades html para poder mostrar el código fuente de la página
	$pagina=htmlentities($pagina);
	echo '<h1>Contenido página web remota</h1>';
	echo "<div><pre>$pagina</pre></div>";	
}

//	LEER EL CONTENIDO DE UN ARCHIVO LOCAL
//-------------------------------------------------------------
// Leemos el contenido del  archivo local
$contenido_fichero= @file_get_contents('./datos/citas-tecnologia.dat');
// Si se produce algún tpo de error mostramos mensaje de aviso
if($contenido_fichero===false) {
	echo '<p>Error al intentar leer el archivo.</p>';
// Mostramos el contenido del archivo leido
} else {
	echo '<h1>Contenido completo de citas-tecnologia.dat</h1>';
	echo "<div><pre>$contenido_fichero</pre></div>";	
}

// Leemos 50 caracteres del contenido de un archivo local comenzando desde el caracter 20
$contenido_fichero= @file_get_contents('./datos/citas-tecnologia.dat',NULL, NULL, 20, 50);
if($contenido_fichero===false) {
	echo '<p>Error al intentar leer el archivo.</p>';
// Mostramos el contenido del archivo leido	
} else {
	echo '<h1>50 caracteres del contenido de citas-tecnologia.dat</h1>';	
	echo "<div><pre>$contenido_fichero</pre></div>";	
}
?>

El resultado de ejecutar el script sería:

Resultado de file_get_contents

file_put_contents. Escribe un buffer de tipo string en un archivo

La función file_put_contents nos permite escribir contenido de un buffer de datos en un archivo local o remoto.

Esta función es una manera práctica de escribir contenidos completos en archivos ya que es similar a utilizar las funciones fopen(), fwrite() y fclose() en una sola función.

int file_put_contents(string $nombre_fichero , variant $buffer [, int $flags = 0 [, resource  $context  ]] )

Si nombre_fichero no existe, se crea, si existe, el fichero existente será sobrescrito, a menos que el parámetro flags (bandera) esté establecida a FILE_APPEND.

Esta función devuelve el número de bytes que fueron escritos en el fichero, o FALSE en caso de error, teniendo que utilizar el operador de idéntico === para comprobar el resultado.

Parámetros

  • nombre_fichero: Ruta del fichero donde se escribe la información
  • data: La información a escribir. Puede ser tanto un recurso string, como array o stream.
    Si data es un recurso stream, el buffer restante de ese flujo será copiado al fichero especificado.
    También se puede especificar el parámetro data como un array de una sóla dimensión. Esto es equivalente a file_put_contents($nombre_fichero, implode('', $array)).
  • flags: El valor de flags puede ser cualquier combinación de los siguientes valores, unidos con el operador binario OR (|).
Bandera (Flag)Descripción
FILE_USE_INCLUDE_PATHBuscar nombre_fichero en el directorio incluido. Revisar la función include_path para más información.
FILE_APPENDSi el fichero nombre_fichero ya existe, añade la información al fichero en vez de sobrescribirlo.
LOCK_EXAdquirir acceso exclusivo al fichero mientras se está ejecutando la escritura. En otras palabras, ocurre una llamada a flock() entre la llamada a fopen() y la llamada a fwrite(). Esto no es indéntico a una llamada a fopen() con el modo "x".

EJEMPLO: Escritura de datos en un fichero (file_put_contents.php)

Para ilustrar el ejemplo de la utilización de la función file_put_contents(), voy a realizar las mismas operaciones utilizadas en los ejemplos de la función fwrite() vista en los apartados anteriores.

Primero escribiremos el contenido de un registro recibido por medio de $_POST y a continuación añadiremos al final del fichero los registros almacenados en un array de datos.

<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>Ejemplo file_put_contents()</title>
</head>

<body>
<?php
/* CONSTANTES, ARRAYS Y VARIABLES DE TRABAJO
   ---------------------------------------------*/
// Definimos constante el carácter de separación de campo
define("SEP_CMPO","|");
// Definimos constante para los saltos de final de párrafo
define("CRLF","\r\n");
// Array donde tenemos almacenados los registros que deseamos escribir en el fichero
$registros=[ ['Luis','666666666',45],
             ['Carmen','666777888',37],
             ['Fernando','666888999',40],
             ['Enrique','666555444',48],
             ['Rosa','555666555',25]];
// Path al fichero local de datos donde guadar los registros
$fichero = './datos/clientes.dat';
// Contador de bytes y registros escritos
$bytes_escritos=0;
$registros_escritos=0;

/* GUARDAR EL ARRAY OBTENIDO POR EL METODO POST ENVIADO DESDE EL FORMULARIO
   ------------------------------------------------------------------------*/
   
/* Creamos el buffer de datos uniendo todos los elementos del array $_POST con el caracter | 
   y añadiendo un salto de línea */
$buffer=implode(SEP_CMPO,$_POST).CRLF;

/* Grabamos el buffer en el fichero, obtenemos el total de bytes escritos e 
   incrementamos el contador de registros. 
   En esta primera escritura será creado el fichero */
$bytes_escritos=file_put_contents($fichero,$buffer);
$registros_escritos++;

/* AÑADIR LOS ELEMENTOS DEL ARRAY $registros 
  ------------------------------------------*/
  
// Recorremos el array para ir extrayendo cada uno de sus registros
foreach($registros as $registro) {
	// Creamos el buffer de datos uniendo todos los elementos del array $registro con el caracter | y añadiendo un salto de línea
	$buffer=implode(SEP_CMPO,$registro).CRLF;
	// Grabamos el buffer al final del fichero utilizando el flag FILE_APPEND
	$bytes_escritos+=file_put_contents($fichero,$buffer,FILE_APPEND);
	$registros_escritos++;
}

// Mensaje de final del proceso
echo "<p>Se han escrito <strong>$registros_escritos</strong> registros con un total de <strong>$bytes_escritos</strong> bytes en el fichero $fichero</p>";
?>
</body>
</html>

Tener en cuenta que para que funcione este script es necesario que reciba datos de un formulario. En los scripts de ejemplo, encontrareis una página de nombre form_file_put_contents.html para realizar las pruebas.

Trabajar con archivos de configuración (.ini)

En algunas ocasiones necesitamos almacenar valores sobre la configuración de una parte de nuestra web, como es el caso de los datos necesarios para realizar la conexión a la base de datos del servidor.

Para realizar esta tarea se suelen utilizar los archivos de configuración o archivos .ini donde por medio de secciones, vamos definiendo las propiedades y sus valores de configuración.

Un diseño de ejemplo de un archivo .ini podría ser el siguiente:

[Conexion]
Host=localhost
BD=datosweb
Usuario=administrador
Clave=1bF4xj1

Donde cada propiedad u opción de la sección viene precedida de un  signo = y el valor que le asignamos, escribiendo cada una en una nueva línea.

Para leer el contenido de estos archivos, PHP nos ofrece la función parse_ini_file().

parse_ini_file. Procesar archivos .ini.

La función parse_ini_file, procesa un archivo ini y devuelve las configuraciones existentes en un array asociativo.

array parse_ini_file ( string $fichero_ini [, bool $process_sections =  false [, int $scanner_mode = INI_SCANNER_NORMAL ]] )

Esta función carga el contenido del fichero .ini en un array asociativo, donde cada clave es una de las secciones que lo componen. Si se produce algún error durante la carga y análisis posterior del contenido del archivo parse_ini_file() devolverá el valor FALSE.
Parámetros:

  • fichero_ini: Nombre del fichero de configuraciones que deseamos cargar.
  • process_sections: Al establecer el parámetro process_sections a TRUE, se obtiene un array multidimesional, con los nombres de las secciones y las configuraciones incluidas. El valor por defecto de process_sections es FALSE
  • scanner_mode: admite tres posibles valores:
    • INI_SCANNER_NORMAL: valor utilizado por defecto para analizar las asignaciones a las propiedades.
    •  INI_SCANNER_RAW: cuando no deseamos que PHP analice los valores de las propiedades.
    • INI_SCANNER_TYPED: En este modo, los tipos boolean, null e integer se preservan siempre que sea posible. Los valores de string "true""on" y "yes" son convertidos a TRUE"false""off""no" y "none" se consideran como FALSE"null" se convierte a NULL en el modo tipificado. También, todos los string numéricos son convertidos al tipo integer si fuera es posible.

EJEMPLO: Lectura de un archivo de configuraciones (parse_ini_file.php)

Supongamos que tenemos un archivo de nombre config.ini que contiene las opciones para realizar la conexión a la base de datos y otras propiedades referentes a la configuración de la web.

[Conexion]
Host=localhost
BD=datosweb
Usuario=administrador
Clave=1bF4xj1

[Diseño]
Tema=spacelab
ColorFondo=#959595

[Limites]
Conexiones=100
MaxRAM=1048576

Veamos cómo podemos cargar las configuraciones y mostrarlas o trabajar con una en concreto

<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Ejemplo parse_ini_file</title>
  <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet">
  <script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js" type="text/javascript"></script>
</head>

<body>
<div class="container">
<?php 
// Nombre del archivo de configuraciones
$fileini='config.ini';
// Array donde almacenar las configuraciones
$secciones=[];
// Cargamos el archivo de configuraciones
// Al no establecer el parámetro process_sections, obtendremos un 
// array con todas sus opciones sin las secciones a las que pertenecen
$secciones=parse_ini_file($fileini);
// Mostramos el contenido del array
echo '<h2>Opciones del archivo de configuración</h2>';
echo '<pre>',print_r($secciones),'</pre>';
// Volvemos a cargar el archivo estableciendo el parámetro process_sections a true
// Ahora obtendremos un array multidimensional donde cada dimensión será una sección del archivo ini
// con todas sus opciones
$secciones=parse_ini_file($fileini,true);
// Mostramos el contenido del array
echo '<h2>Secciones y Opciones del archivo de configuración</h2>';
echo '<pre>',print_r($secciones),'</pre>';

// Obtenemos la clave de acceso a la BD
$clave=$secciones['Conexion']['Clave'];
echo '<h2>Obtener una opción en concreto de su sección</h2>';
echo '<p>Clave de acceso a la BD: ',$clave,'</p>';
 ?>
</div>
</body>
</html>

El resultado que obtendríamos sería:

Resultado de procesar el archivo de configuraciones con parse_ini_file