9. SESION: ENVIO DE EMAIL

mail()

mail — Enviar correo

Descripción

bool mail ( string $to , string $subject , string $message [, string $additional_headers [, string $additional_parameters ]] )

Envía un email.

Parámetros

to

Receptor o receptores del correo.

Es formato de este string debe cumplir con » RFC 2822. Algunos ejemplos son:

• usuario@example.com
• usuario@example.com, otrousuario@example.com
• Usuario <usuario@example.com>
• Usuario <usuario@example.com>, Otro usuario <otrousuario@example.com>

subject

Título del mail a ser enviado.

Precaución

El título debe satisfacer » RFC 2047.

message

Mensaje a enviar.

Cada línea debería ser separada por un LF (\n). Las líneas no deberían ser más largas de 70 caracteres.

Precaución

(Sólo en Windows) Cuando PHP habla directamente con un servidor SMTP, si se encuentra un punto al principio de la línea, se elimina. Para evitar esto, es necesario reemplazar estos casos con un doble punto.

<?php
$text = str_replace("\n.", "\n..", $text);?>

additional_headers (opcional)

String a ser insertado al final de la cabecera del email.

Se usa típicamente para añadir cabeceras extra (From, Cc y Bcc). En caso de tener múltiples cabeceras adicionales, deben ser separadas con un CRLF(\r\n).

Nota:

Cuando se envía un correo, el correo debe contener una cabecera From. Puede establecerse con el parámetro additional_headers, o puede definirse un valor por defecto en php.ini.

Si no se realiza esta acción se obtendrá un mensaje de error similar a Warning: mail(): "sendmail_from" not set in php.ini or custom "From:" header missing. La cabecera From también establece Return-Path bajo Windows.

Nota:

Si no se reciben los mensajes enviados, intentar el uso de sólo LF (\n). Algunos agentes de transferencia de correo de baja calidad en Unix reemplzan LF por CRLF automáticamente (lo que conlleva doblar CR si se usa CRLF). Esto debería ser el último recurso, si bien no cumple con » RFC 2822.

additional_parameters (opcional)

El parámetro additional_parameters puede usarse para indicar opciones adicionales como opciones de línea de comando al programa configurado para ser usado cuando se envía correo, definido por la opción de configuración sendmail_path. Por ejemplo, puede usarse para establecer la dirección de correo de remitente usado por sendmail con la opción -f.

El usuario usado por el servidor web debe ser añadido como usuario de confianza en la configuración de sendmail para evitar que se añada la cabecera 'X-Warning' al mensaje cuando se añade la dirección de remitente (-f) usando este método. Para los usuarios de sendmail, este fichero es /etc/mail/trusted-users.

Valores devueltos

Retorna TRUE si el correo ha sido aceptado con éxito para reparto, o FALSE en otro caso.

Es importante tener en cuenta que si el correo es aceptado para reparto, NO quiere decir que el correo haya alcanzado el destino indicado.

Historial de cambios

Versión	Descripción
4.3.0 (sólo Windows)	Se aceptan todas las cabeceras personalizadas (como From, Cc, Bcc y Date) y no distinguen entre mayúsculas y minúsculas. (Como las cabeceras personaliazadas no son interpretadas por el MTA en primer lugar pero son analizadas por PHP, PHP < 4.3 sólo soportaba el elemento de cabecera Cc y distinguía entre mayúsculas y minúsculas).
4.2.3	El parámetro additional_parameters es deshabilitado en safe_mode y la función mail() mostrará un mensaje de aviso, retornando FALSE cuando se usa.
4.0.5	Se añade el parámetro additional_parameters.

Ejemplos

Ejemplo #1 Enviar correo

Usando mail() para enviar un correo simple:

<?php// El mensaje$mensaje = "Línea 1\nLínea 2\nLínea 3";// En caso de que cualquiera de las líneas sea más larga de 70 caracteres,
// debe usarse wordwrap()$mensaje = wordwrap($mensaje, 70);// Sendmail('caffeinated@example.com', 'Mi título', $mensaje);?>

Ejemplo #2 Enviar un correo con cabeceras extra.

Adición de cabeceras básicas, diciendo al MUA las direcciones From y Reply-To:

<?php
$para      = 'nobody@example.com';$titulo = 'El título';$mensaje = 'Hola';$cabeceras = 'From: webmaster@example.com' . "\r\n" .
    'Reply-To: webmaster@example.com' . "\r\n" .
    'X-Mailer: PHP/' . phpversion();mail($para, $titulo, $mensaje, $cabeceras);?>

Ejemplo #3 Enviar un correo con parámetros de línea de comando adicionales.

El parámetro additional_parameters puede ser usado para indicar parámetros adicicionales al programa configurado para usar en el envío de correo configurado en sendmail_path.

<?php
mail('nadie@example.com', 'El título', 'El mensaje', null, '-fwebmaster@example.com');?>

Ejemplo #4 Envío de un correo HTML

Es posible también enviar correos HTML con mail().

<?php// Varios destinatarios$para  = 'aidan@example.com' . ', '; // atención a la coma$para .= 'wez@example.com';// subject$titulo = 'Recordatorio de cumpleaños para Agosto';// message$mensaje = '
<html>
<head>
  <title>Recordatorio de cumpleaños para Agosto</title>
</head>
<body>
  <p>¡Estos son los cumpleaños para Agosto!</p>
  <table>
    <tr>
      <th>Quien</th><th>Día</th><th>Mes</th><th>Año</th>
    </tr>
    <tr>
      <td>Joe</td><td>3</td><td>Agosto</td><td>1970</td>
    </tr>
    <tr>
      <td>Sally</td><td>17</td><td>Agosto</td><td>1973</td>
    </tr>
  </table>
</body>
</html>
';// Para enviar un correo HTML mail, la cabecera Content-type debe fijarse$cabeceras  = 'MIME-Version: 1.0' . "\r\n";$cabeceras .= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";// Cabeceras adicionales$cabeceras .= 'To: Mary <mary@example.com>, Kelly <kelly@example.com>' . "\r\n";$cabeceras .= 'From: Recordatorio <cumples@example.com>' . "\r\n";$cabeceras .= 'Cc: birthdayarchive@example.com' . "\r\n";$cabeceras .= 'Bcc: birthdaycheck@example.com' . "\r\n";// Mail itmail($para, $titulo, $mensaje, $cabeceras);?>

Nota:

Si la intención es enviar HTML u otro tipo de correos complejos, es recomendable usar el paquete PEAR » PEAR::Mail_Mime.

Notas

Nota:

La implementación Windows de mail() difiere en muchas formas de la implementación Unix. Primero, no usa un ejecutable local para componer mensajes ya que sólo opera en sockets directos, lo que significa que se necesita un MTA escuchando en un un socket de red (que puede estar tanto en localhost como en una máquina remota).

Segundo, las cabeceras personalizadas como From:, Cc:, Bcc: y Date: no son interpretadas por el MTA en primer lugar, pero son analizadas por PHP.

Por esto, el parámetro to no debería ser una dirección de correo de la forma "Algo <alguien@example.com>". Es posible que el comando mail no analice esto correctamente cuando dialoga con el MTA.

Nota:

Es importante indicar que la función mail() no es conveniente para grandes volúmenes de correo en bucle. Esta función abre y cierra un socket SMTP para cada correo, algo que no es muy eficiente.

Para enviar una gran cantidad de correo, ver los paquetes » PEAR::Mail y » PEAR::Mail_Queue. 

error_log

error_log — Enviar un mensaje de error a algún lugar

Descripción

bool error_log ( string $message [, int $message_type = 0 [, string $destination [, string $extra_headers ]]] )

Envía un mensaje de error al registro de errores del servidor web o a un archivo.

Parámetros

message

El mensaje de error que debería ser registrado.

message_type

Indica dónde debería ir el error. Lo tipos de mensaje posibles son:

Tipos de registro de error_log()

0	message es enviado al registro del sistema de PHP, usando el mecanismo de registro del Sistema Operativo o un archivo, dependiendo de qué directiva de configuración esté establecida en error_log. Esta es la opción predeterminada.
1	message es enviado por email a la dirección del parámetro destination. Este es el único tipo de mensaje donde se usa el cuarto parámetro extra_headers.
2	Ya no es una opción.
3	message es añadido al inicio del archivo destination. No se añade automáticamente una nueva línea al final de la cadena message.
4	message es enviado directamente al gestor de registro de SAPI.

destination

El destino. Su significado depende del parámetro message_type tal como se describió arriba.

extra_headers

Las cabeceras extra. Se usa cuando el parámetro message_type está establecido a 1. Este tipo de mensaje usa la misma función interna que mail().

Valores devueltos

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

Historial de cambios

Versión	Descripción
5.2.7	El valor posible de 4 se añadió a message_type.

Ejemplos

Ejemplo #1 Ejemplos de error_log()
<?php// Enviar una notificación al registro del servidor si no podemos
// conectarnos a la base de datos.if (!Ora_Logon($username, $password)) {
    error_log("¡Base de datos Oracle no disponible!", 0);
}// Notificar al administrador mediante un email si agotamos FOOif (!($foo = allocate_new_foo())) {
    error_log("Problema serio, nos hemos quedado sin FOOs!", 1,
               "operator@example.com");
}// otra manera de llamar a error_log():error_log("¡Lo echaste a perder!", 3, "/var/tmp/my-errors.log");

Mail_Mime						proporciona clases para crear mensajes MIME.	Estilo BSD
»Versión actual	»Resumen de errores
1.8.3 (estable) fue lanzado el 12/03/2012 ( de cambios ) Easy Install ¿No está seguro? Obtenga más información . pear install Mail_Mime Pyrus instalación Trate de PEAR2 instalador @ s, Pyrus. php pyrus.phar instalación de pera / Mail_Mime Mapa de desarrollo de	Paquete Rango de Mantenimiento: 34 de 191 paquetes con bugs abiertos Número de bugs abiertos : 1 (180 errores en total) El promedio de edad de los bugs abiertos: 239 días El más antiguo fallo abierta: 239 días Número de abiertas las solicitudes de funciones : 4 (32 peticiones de nuevas funcionalidades en total) Notificar un error nuevo Mail_Mime
»Descripción
Mail_Mime ofrece clases para hacer frente a la creación y manipulación de los mensajes MIME. Permite a las personas para crear mensajes de correo electrónico que consiste en: * Piezas de texto * HTML piezas * HTML en línea Imágenes * Adjuntos * Los mensajes adjuntos Soporta mensajes grandes, base64 y codificaciones quoted-printable y caracteres no ASCII en nombres de archivos, temas, destinatarios, etc codificada utilizando RFC2047 y / o RFC2231.

8. SESION: FUNCIONES DEFINIDAS POR USUARIOS

Funciones definidas por el usuario

Una función puede ser definida usando una sintaxis como la siguiente:

Ejemplo #1 Pseudo código para demostrar el uso de funciones

<?phpfunction foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
    echo "Función de ejemplo.\n";
    return $valordevuelto;
}?>

Cualquier código PHP válido puede aparecer dentro de una función, incluso otras funciones y definiciones de clases.

Los nombres de las funciones siguen las mismas reglas que otras etiquetas de PHP. Un nombre de función válido comienza con una letra o guión bajo, seguido de cualquier número de letras, números, o guiones bajos. Como expresión regular se expresaría así: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.

Sugerencia

Vea también Guia de Entorno de Usuario para Nombres.

Las funciones no necesitan ser definidas antes de que se referencien, excepto cuando una función está condicionalmente definida como se muestra en los dos ejemplos de abajo.

Cuando una función está definida de una forma condicional como en los dos ejemplos mostrados, sus definiciones deben ser procesadas antes de ser llamadas.

Ejemplo #2 Funciones condicionales

<?php

$haceralgo = true;
/* No podemos llamar a foo() desde aquí
   ya que no existe aún,
   pero podemos llamar a bar() */
bar();

if ($haceralgo) {
  function foo()
  {
    echo "No existo hasta que la ejecución del programa llegue hasta mí.\n";
  }
}
/* Ahora podemos llamar de forma segura a foo()
   ya que $haceralgo se evaluó como verdadero */
if ($haceralgo) foo();

function bar()
{
  echo "Existo desde el momento inmediato que comenzó el programa.\n";
}
?>

Ejemplo #3 Funciones dentro de funciones

<?phpfunction foo()
{
  function bar()
  {
    echo "No existo hasta que se llame a foo().\n";
  }
}
/* No podemos llamar aún a bar()
   ya que no existe. */
foo();
/* Ahora podemos llamar a bar(),
   el procesamiento de foo()
   la ha hecho accesible. */
bar();
?>

Todas las funciones y las clases de PHP tienen ámbito global - pueden ser llamadas fuera de una función incluso si fueron definidas dentro, y viceversa.

PHP no soporta la sobrecarga de funciones, ni es posible 'desdefinir' ni redefinir funciones previamente declaradas.

Nota: Los nombres de las fuciones son insensibles a mayúsculas-minúsculas, por lo que es una buena idea llamar a las funciones tal y como aparecen en sus declaraciones.

El número variable de argumentos y los argumentos predeterminados están soportados por las funciones. Vea también las referencias de funciones para func_num_args(), func_get_arg(), y func_get_args() para más información.

En PHP es posible llamar a funciones recursivas. Sin embargo, evite las llamadas a funciones/métodos recursivos con más de 100-200 niveles de recursividad ya que pueden agotar la pila y causar la terminación del script actual.

Ejemplo #4 Funciones recursivas

<?phpfunction recursividad($a)
{
    if ($a < 20) {
        echo "$a\n";
        recursividad($a + 1);
    }
}?>

 

 

 

 

 

 

 funciones

Argumentos

La información puede ser pasada a las funciones mediante la lista de argumentos, la cual es una lista de expresiones delimitadas por comas. Los argumentos son evaluados de izquierda a derecha.

PHP soporta argumentos pasados por valor (por defecto), pasados por referencia, y valores de argumentos predeterminados. Las Listas de argumentos de longitud variable también están soportadas, vea también las referencias de funciones para func_num_args(), func_get_arg(), y func_get_args() para más información.

Ejemplo #1 Pasar arrays a funciones

<?phpfunction tomar_array($entrada)
{
    echo "$entrada[0] + $entrada[1] = ".$entrada[0]+$entrada[1];
}?>

Hacer que los argumentos sean pasados por referencia

Por defecto, los argumentos de las funciones son pasados por valor (por lo que si el valor del argumento dentro de la función se cambia, no se cambia fuera de la función). Para permitir a una función modificar sus argumentos, éstos deben pasarse por referencia.

Para hacer que un argumento a una función sea siempre pasado por referencia hay que poner delante del nombre del argumento el signo 'ampersand' (&) en la definición de la función:

Ejemplo #2 Pasar parámetros de una función por referencia

<?phpfunction añadir_algo(&$cadena)
{
    $cadena .= 'y algo más.';
}$cad = 'Esto es una cadena, ';añadir_algo($cad);
echo $cad;    // imprime 'Esto es una cadena, y algo más.'?>

Valores de argumentos predeterminados

Una función puede definir valores predeterminados al estilo C++ para argumentos escalares como sigue:

Ejemplo #3 Uso de parámetros predeterminados en funciones

<?phpfunction hacercafé($tipo = "capuchino")
{
    return "Hacer una taza de $tipo.\n";
}
echo hacercafé();
echo hacercafé(null);
echo hacercafé("espresso");?>

El resultado del ejemplo sería:

Hacer una taza de capuchino.
Hacer una taza de .
Hacer una taza de espresso.

PHP también permite el uso de arrays y del tipo especial NULL como valores predeterminados, por ejemplo:

Ejemplo #4 Usar tipos no escalares como valores predeterminados

<?phpfunction hacercafé($tipos = array("capuchino"), $fabricanteCafé = NULL)
{
    $aparato = is_null($fabricanteCafé) ? "las manos" : $fabricanteCafé;
    return "Hacer una taza de ".join(", ", $tipos)." con $aparato.\n";
}
echo hacercafé();
echo hacercafé(array("capuchino", "lavazza"), "una tetera");?>

El valor predeterminado debe ser una expresión constante, no (por ejemplo) una variable, un miembro de una clase o una llamada a una función.

Observe que cuando se usan argumentos predeterminados, cualquiera de ellos debería estar a la derecha de los argumentos no predeterminados; si no, las cosas no funcionarán como se esperaba. Considere el siguiente trozo de código:

Ejemplo #5 Uso incorrecto de argumentos predeterminados en una función

<?phpfunction haceryogur($tipo = "acidófilo", $sabor)
{
    return "Hacer un tazón de yogur $tipo de $sabor.\n";
}

echo haceryogur("frambuesa");   // no funcionará como se esperaba?>

El resultado del ejemplo sería:

Warning: Missing argument 2 in call to haceryogur() in 
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
Hacer un tazón de yogur frambuesa de .

Ahora compare el ejemplo de arriba con este:

Ejemplo #6 Uso correcto de argumentos predeterminados en una función

<?phpfunction haceryogur($sabor, $tipo = "acidófilo")
{
    return "Hacer un tazón de yogur $tipo de $sabor.\n";
}

echo haceryogur("frambuesa");   // funciona como se esperaba?>

El resultado del ejemplo sería:

Hacer un tazón de yogur acidófilo de frambuensa.

Nota: A partir de PHP 5, los valores predeterminados se pueden pasar por referencia.

Listas de argumentos de longitud variable

PHP tiene soporte para listas de argumentos de longitud variable en funciones definidas por el usuario. Esto realmente es bastante fácil si se usan las funciones func_num_args(), func_get_arg(), y func_get_args().

No se necesita una sintaxis especial, y la lista de argumentos aún puede ser proporcionada explícitamente con definiciones de funciones, y se comportará con normalidad.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

include

La sentencia include incluye y evalúa el archivo especificado.

La siguiente documentación también se aplica a require.

Los archivos son incluidos con base en la ruta de acceso dada o, si ninguna es dada, el include_path especificado. Si el archivo no se encuentra en el include_path, include finalmente verificará en el propio directorio del script que hace el llamado y en el directorio de trabajo actual, antes de fallar. El constructor include emitirá una advertencia si no puede encontrar un archivo, éste es un comportamiento diferente al de require, el cual emitirá un error fatal..

Si una ruta es definida — ya sea absoluta (comenzando con una letra de unidad o \ en Windows o / en sistemas Unix/Linux) o relativa al directorio actual (comenzando con . o ..) — el include_path será ignorado por completo. Por ejemplo, si un nombre de archivo comienza con ../, el interprete buscará en el directorio padre para encontrar el archivo solicitado.

Para más información sobre como PHP maneja la inclusión de archivos y la ruta de accesos para incluir, ver la documentación de include_path.

Cuando se incluye un archivo, el código que contiene hereda el ámbito de las variables de la línea en la cual ocurre la inclusión. Cualquier variable disponible en esa línea del archivo que hace el llamado, estará disponible en el archivo llamado, desde ese punto en adelante. Sin embargo, todas las funciones y clases definidas en el archivo incluido tienen el ámbito global.

Ejemplo #1 Ejemplo básico de include

vars.php
<?php

$color = 'verde';$fruta = 'manzana';
?>
test.php
<?php
echo "Una $fruta $color"; // Una
include 'vars.php';

echo "Una $fruta $color"; // Una manzana verde
?>

Si la inclusión ocurre al interior de una función dentro del archivo que hace el llamado, entonces todo el código contenido en el archivo llamado se comportará como si hubiera sido definida dentro de esa función. Por lo tanto, seguirá el ámbito de las variables de esa función. Una excepción a esta regla son las constantes mágicas las cuales son evaluadas por el intérprete antes que ocurra la inclusión.

Ejemplo #2 Incluyendo dentro de funciones

<?php
function foo()
{
    global $color;

    include 'vars.php';

    echo "Una $fruta $color";
}
/* vars.php está en el ámbito de foo() así que *
* $fruta NO está disponible por fuera de éste  *
* ámbito. $color sí está porque fue declarado *
* como global.                                 */
foo();                      // Una manzana verdeecho "Una $fruta $color";   // Una verde
?>

Cuando un archivo es incluido, el intérprete abandona el modo PHP e ingresa al modo HTML al comienzo del archivo objetivo y se reanuda de nuevo al final. Por esta razón, cualquier código al interior del archivo objetivo que deba ser ejecutado como código PHP, tendrá que ser encerrado dentro de etiquetas válidas de comienzo y terminación de PHP.

Si las "envolturas URL fopen" están activadas en PHP (las cuales lo están en la configuración predeterminada), se puede especificar el archivo a ser incluido usando una URL (vía HTTP u otra envoltura soportada - ver Protocolos y Envolturas soportados para una lista de protocolos) en lugar de una ruta de acceso local. Si el servidor objetivo interpreta el archivo objetivo como código PHP, las variables se pueden pasar al archivo incluido usando una string de petición como la usada con HTTP GET. Esto no es, en estricto rigor, lo mismo que haber incluido el archivo y que haya heredado el ámbito de variables del archivo padre; el script realmente está siendo ejecutado en el servidor remoto y el resultado entonces se incluye dentro del script local.

Advertencia

Versiones de PHP para Windows anteriores a 4.3.0, no soportan el acceso remoto a archivos para esta función, no funcionará ni activando siquiera allow_url_fopen.

Ejemplo #3 include por medio de HTTP

<?php
/* Este ejemplo asume que www.example.com está configurado para interpretar archivos
* .php y no archivos .txt. Además, aquí 'Funciona' quiere decir que las variables
* $foo y $bar están disponibles dentro del archivo incluido. */

// No funciona; file.txt no puede ser manejado por www.example.com como PHPinclude 'http://www.example.com/file.txt?foo=1&bar=2';
// No funciona; busca por un archivo llamado 'file.php?foo=1&bar=2' en el
// sistema de archivos local.include 'file.php?foo=1&bar=2';
// Si funciona.include 'http://www.example.com/file.php?foo=1&bar=2';
$foo = 1;$bar = 2;
include 'file.txt';  // Funciona.include 'file.php';  // Funciona.
?>

Advertencia

Advertencia de seguridad

El archivo remoto puede ser procesado en el servidor remoto (dependiendo de la extensión del archivo y del hecho de si el servidor remoto corre PHP o no) pero aun así tiene que producir un script PHP válido, porque será procesado en el servidor local. Si el archivo desde el servidor remoto debe ser procesado allá y entregar la salida solamente, readfile() es la mejor función para usar. De lo contrario, debe tenerse especial cuidado para asegurar que el script remoto produce un código válido y deseado.

Ver también Archivos remotos, fopen() y file() para información relacionada.

Manejando retornos: Es posible ejecutar una sentencia return dentro de un archivo incluido con el fin de terminar el procesamiento en ese archivo y volver a script que lo llamó. Además, es posible retornar valores desde los archivos incluidos. Se puede tomar el valor de la llamada "include" de la misma forma como se haría con una función normal. Esto no es, sin embargo, posible si se incluyen archivos remotos, a menos que la salida del archivo remoto tenga unas etiquetas válidas de inicio y terminación de PHP (igual que con cualquier archivo local). Se pueden declarar la variables necesarias dentro de esas etiquetas y serán introducidas en el punto del archivo en el cual fue incluido.

Debido a que include es un constructor especial del lenguaje, los paréntesis no son necesarios en torno a su argumento. Se debe tener cuidado cuando se compara el valor de retorno.

Ejemplo #4 Comparando el valor de retorno de include

<?php// no funciona, evaluado como include(('vars.php') == 'OK'), es decir include('')if (include('vars.php') == 'OK') {
    echo 'OK';
}
// si funcionaif ((include 'vars.php') == 'OK') {
    echo 'OK';
}?>

Ejemplo #5 include y la sentencia return

return.php
<?php

$var = 'PHP';

return $var;
?>
noreturn.php
<?php

$var = 'PHP';
?>
testreturns.php
<?php

$foo = include 'return.php';

echo $foo; // muestra 'PHP'
$bar = include 'noreturn.php';

echo $bar; // muestra 1
?>

$bar tiene el valor 1 debido a que el include fue exitoso. Nótese la diferencia entre los ejemplos anteriores. El primero usa return dentro del archivo incluido, mientras que el otro no. Si el archivo no se pueden incluir, se retorna FALSE y se emite un E_WARNING.

Si hay funciones definidas en el archivo incluido, se pueden utilizar en el archivo principal independientemente que hayan return antes o después. Si el archivo se incluye dos veces, PHP 5 arrojará un error fatal ya que las funciones ya han sido declaradas, mientras que PHP 4 no se queja acerca de las funciones definidas después de un return. Se recomienda el uso de include_once en lugar de comprobar si el archivo ya estaba incluido y hacer el retorno de forma condicionada dentro del archivo incluido.

Otra forma de "incluir" un archivo PHP en una variable es capturar la salida mediante el uso de Funciones de control de salida con include. Por ejemplo:

Ejemplo #6 Usando buffering de salida para incluir un archivo PHP dentro de una cadena

<?php
$string = get_include_contents('somefile.php');

function get_include_contents($filename) {
    if (is_file($filename)) {
        ob_start();
        include $filename;
        return ob_get_clean();
    }
    return false;
}
?>

Con el fin de incluir archivos de forma automática dentro de scripts, véase también las opciones de configuración auto_prepend_file y auto_append_file en php.ini.

Nota: Puesto que esto es una construcción del lenguaje y no una función, no puede ser llamada usando funciones variables.

 

require

require es idéntico a include excepto que en caso de fallo producirá un error fatal de nivel E_COMPILE_ERROR. En otras palabras, éste detiene el script mientras que include sólo emitirá una advertencia (E_WARNING) lo cual permite continuar el script.

 

 

 <?php
// file and get, if you need to include a file.php?query_string.

function pinclude($file, $type, $get = null) {
    $p = explode('/', $file);
    $file = end($p);
    $dir = '';
    $n = count($p) - 1;

    for($i = 0; $i < $n; $i++)
        $dir .= $p[$i] . '/';

    if($get !== null) {
        $tmp = $_GET; // back up
        $_GET = array();
        $get = explode('&', $get);
        $n = count($get);

        for($i = 0; $i < $n; $i++) {
            if(strpos($get[$i], '=') === false)
                $_GET[$get[$i]] = 1;
            else {
                list($name, $val) = explode('=', $get[$i], 2);
                $_GET[$name] = $val;
            }
        }
    }

    ob_start();
    chdir($dir);
    require $file;
    $out = ob_get_clean();

    if($tmp)
        $_GET = $tmp;

    return $out;
}

$out = pinclude('./dir/yourfile.php', 'a=b&c=d&e');
echo $out;
// i'm sorry but i forgot post requests...
?>

 

 

 

Por qué usar los includes?

El uso de includes es excepcionalmente bueno para ahorrarte trabajo. Puedes hacer un header o un menú generico y cargarlo con el include.

Uso:

La utilización del include es muy simple:

<?php include("tuarchivo.htm"); ?>

Ejemplo:

Vamos a usar tres archivos, que fusionaremos. Luego observaremos el codigo de salida.

Archivo 1 : header.php :

<html>
<head>
<title> Muestra de includes </title>

</head>
<body>

Archivo 2: footer.php :

</body>
</html>

Archivo 3: union.php :

<?php include("header.php"); ?>
<p>
Hola, este es el contenido.
</p>
<?php include("footer.php"); ?>

Y el resultado:

<html>
<head>
<title> Muestra de includes </title>
</head>
<body>

<p>
Hola, este es el contenido.
</p>
</body>
</html>

Nota: Los archivos a incluír no tienen que ser obligatoriamente archivos PHP. Pueden ser de cualquier tipo

Diferenciación:

PHP contiene otra funcion con caracteristicas muy similares, que es la funcion require(). Las caracteristicas y el modo de uso de include y de require son identicas, salvo por una cosa: El mensaje de error generado si falta un documento:

Con include, si el nombre de archivo no existe, recibiras una advertencia (warning) y el script seguirá. Con require en cambio el script se detendrá, pues se marcará un error fatal.

Ejemplo:

Include:

<?php
include("noexiste.php");
echo ("Hola. El script siguió!");
?>

Y lo que obtendremos:

Warning: include(noexiste.php) [function.include]:
failed to open stream:
No such file or directory in C:\tutorial\probando.php on line 2

Warning: include() [function.include]:
Failed opening 'noexiste.php' for inclusion
(include_path='.;C:\php5\pear')
in C:\tutorial\probando.php on line 2

Hola. El script siguió!

Require:

<?php
require("noexiste.php");
echo ("Hola. El script siguió!");
?>

Y aqui obtenemos:

Warning: require(noexiste.php) [function.require]:
failed to open stream:
No such file or directory in C:\tutorial\probando.php on line 2

Fatal error: require() [function.require]:
Failed opening required 'noexiste.php'
(include_path='.;C:\php5\pear')
in C:\tutorial\probando.php on line 2

Vemos que con require no se ejecutó la siguiente parte del script. Atención: En php 3 y anteriores, las funciones include y require se diferenciaban por un asunto aún mayor: Include podía ser usado condicionalmente, mientras que require se ejecutaba "a la fuerza". Un ejemplo:

<?php
        $gatito= "Lo odio";
        if($gatito=="Lo amo"){
                include("condicionado-asi-que-si-no-es-verdad-no-me-incluyo.php");
        }else{
                require("igual-me-voy-a-incluir-bwahahaha.php");
        }
?>

En el output, veremos que se incluiría lo del require y no lo del include. Sin embargo, reitero, esto ya no funciona asi.
 

7. SESIÓN: TABLAS O ARRAYS

·  Uso de arrays

 

·  Tipos de declaraciones

 

·  Tipos de arrays

 

·  Funciones útiles para el uso de arrays

Arrays

Un array en PHP es realmente un mapa ordenado. Un mapa es un tipo de datos que asocia valores con claves. Este tipo es optimizado para varios usos diferentes; puede ser usado como una matriz real, una lista (vector), una tabla asociativa (una implementación de un mapa), diccionario, colección, pila, cola, y posiblemente más. Ya que los valores de un array pueden ser otros arrays, árboles y también son posibles arrays multidimensionales.

Una explicación sobre tales estructuras de datos está fuera del alcance de este manual, pero encontrará al menos un ejemplo de cada uno de ellos. Para más información, consulte la extensa literatura que existe sobre este amplio tema.

Sintaxis

Especificación con array()

Un array puede ser creado usando el constructor del lenguaje array(). Éste toma un cierto número de parejas clave => valor como argumentos.

array(
    clave  => valor,
    clave2 => valor2,
    clave3 => valor3,
    ...
)

La coma después del elemento del array es opcional y se puede omitir. Esto normalmente se hace para arrays de una sola línea, esto es, es preferible array(1, 2) que array(1, 2, ). Por otra parte, para arrays multilínea, la coma final se usa comnúnmente, ya que permite la adición sencilla de nuevos elementos al final.

A partir de PHP 5.4 también se puede usar la sintaxis de array corta, que reemplaza array() con [].

Ejemplo #1 Un array simple

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);
// a partir de PHP 5.4$array = [
    "foo" => "bar",
    "bar" => "foo",
];?>

La clave puede ser un integer o un string. El valor puede ser de cualquier tipo.

Además, los siguientes moldeados de tipo en la clave producirá:

• Strings que contienen integers válidos serán moldeados a el tipo integer. P.e.j. la clave "8" en realidad será almacenada como 8. Por otro lado "08" no será convertido, ya que no es un número integer decimal válido.
• Floats también serán moldeados en integers, lo que significa que la parte fraccionaria se elimina. P.e.j. la clave 8.7 en realidad será almacenada como 8.
• Bools son moldeados a integers, también, p.e.j. la clave true en realidad será almacenada como 1 y la clave false como 0.
• Null será moldeado a un string vacío, p.e.j. la clave null en realidad será almacenada como "".
• Arrays y objects no pueden ser usados como claves. Si lo hace, dará lugar a una advertencia: Illegal offset type.

Desde PHP 5.4, el acceso al índice de cadena se hace consistente. Como resultado, algunos valores de retorno pueden ser diferentes de versiones anteriores. A partir de PHP 5.4, los índices de cadena deberían ser un integer o un integer como string, de otro modo el resultado será una advertencia.

Ejemplo #2 String offset access example

<?php
$str = 'abc';
var_dump($str['1']);var_dump(isset($str['1']));
var_dump($str['1.0']);var_dump(isset($str['1.0']));
var_dump($str['x']);var_dump(isset($str['x']));
var_dump($str['1x']);var_dump(isset($str['1x']));?>

Muestra el ejemplo de arriba en PHP 5.3:

string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true)

Muestra el ejemplo de arriba en PHP 5.4:

string(1) "b"
bool(true)

Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)

Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)

Si varios elementos en la declaración del array usan la misma clave, sólo la última será usada y los demás son sobrescritos.

Ejemplo #3 Ejemplo de moldeado de tipo y sobrescritura

<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);var_dump($array);?>

El resultado del ejemplo sería:

array(1) {
  [1]=>
  string(1) "d"
}

Como todas las claves en el ejemplo anterior se convierten en 1, los valores serán sobrescritos en cada nuevo elemento y el último valor asignado "d" es el único que queda.

Los arrays PHP pueden contener claves integer y string al mismo tiempo ya que PHP no distingue entre arrays indexados y asociativos.

Ejemplo #4 Claves mixtas integer y string

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);var_dump($array);?>

El resultado del ejemplo sería:

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

La clave es opcional. Si no se especifica, PHP usará el incremento de la clave integer más grande utilizada anteriormente.

Ejemplo #5 Arrays indexados sin clave

<?php
$array = array("foo", "bar", "hallo", "world");var_dump($array);?>

El resultado del ejemplo sería:

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hallo"
  [3]=>
  string(5) "world"
}

Es posible especificar la clave sólo para algunos de los elementos y dejar por fuera a los demás:

Ejemplo #6 Claves no en todos los elementos

<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);var_dump($array);?>

El resultado del ejemplo sería:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Como se puede ver el último valor "d" se le asignó la clave 7. Esto es debido a que la mayor clave integer era 6.

Acceso a elementos de array con la sintaxis de corchete

Los elementos de array se pueden acceder utilizando la sintaxis array[key].

Ejemplo #7 Acceso a elementos de array

<?php
$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);
var_dump($array["foo"]);var_dump($array[42]);var_dump($array["multi"]["dimensional"]["array"]);?>

El resultado del ejemplo sería:

string(3) "bar"
int(24)
string(3) "foo"

A partir de PHP 5.4 es posible hacer referencia al array de el resultado de una llamada a la función o el método directamente. Antes sólo era posible utilizando una variable temporal.

Ejemplo #8 Hacer referencia al resultado array de funciones

<?phpfunction getArray() {
    return array(1, 2, 3);
}
// en PHP 5.4$secondElement = getArray()[1];
// anteriormente$tmp = getArray();$secondElement = $tmp[1];
// olist(, $secondElement) = getArray();?>

Nota:

Si intenta acceder a una clave del array que no se ha definido es lo mismo que el acceso a cualquier otra variable no definida: se emitirá un mensaje de error de nivel E_NOTICE, y el resultado será NULL.

Creación/modificación con sintaxis de corchete

Un array existente puede ser modificado al definir valores explícitamente en éste.

Esto se realiza mediante la asignación de valores al array, especificando la clave en corchetes. La clave también se puede omitir, resultando en un par de corchetes vacíos ([]).

    $arr[clave] = valor;
    $arr[] = valor;
    // clave puede ser un integer o string
    // valor puede ser cualquier valor de cualquier tipo

Si $arr aún no existe, se creará, así que esto es también una forma alternativa de crear un array. Sin embargo, esta práctica es desaconsejada ya que si $arr ya contiene algún valor (p.ej. un string de una variable de petición), entonces este valor estará en su lugar y [] puede significar realmente el operador de acceso a cadenas. Siempre es mejor inicializar variables mediante una asignación directa.

Para cambiar un valor determinado, se debe asignar un nuevo valor a ese elemento con su clave. Para quitar un par clave/valor, se debe llamar la función unset() en éste.

<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56;    // Esto es lo mismo que $arr[13] = 56;
                // en este punto de el script
$arr["x"] = 42; // Esto agrega un nuevo elemento a
                // el array con la clave "x"
                unset($arr[5]); // Esto elimina el elemento del array
unset($arr);    // Esto elimina el array completo?>

Nota:

Como se mencionó anteriormente, si no se especifica una clave, se toma el máximo de los índices integer existentes, y la nueva clave será ese valor máximo más 1 (aunque al menos 0). Si todavía no existen índices integer, la clave será 0 (cero).

Tenga en cuenta que la clave integer máxima utilizada para éste no es necesario que actualmente exista en el array. Ésta sólo debe haber existido en el array en algún momento desde la última vez que el array fué re-indexado. El siguiente ejemplo ilustra este comportamiento:

<?php// Crear un array simple.$array = array(1, 2, 3, 4, 5);print_r($array);
// Ahora elimina cada elemento, pero deja el mismo array intacto:foreach ($array as $i => $value) {
    unset($array[$i]);
}print_r($array);
// Agregar un elemento (note que la nueva clave es 5, en lugar de 0).$array[] = 6;print_r($array);
// Re-indexar:$array = array_values($array);$array[] = 7;print_r($array);?>

El resultado del ejemplo sería:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Funciones útiles

Hay un buen número de funciones útiles para trabajar con arrays. Véase la sección funciones de array.

Nota:

La función unset() permite remover claves de un array. Tenga en cuenta que el array no es re-indexado. Si se desea un verdadero comportamiento "eliminar y desplazar", el array puede ser re-indexado usando la función array_values().

<?php
$a = array(1 => 'uno', 2 => 'dos', 3 => 'tres');
unset($a[2]);/* producirá un array que se ha definido como
   $a = array(1 => 'uno', 3 => 'tres');
   y NO
   $a = array(1 => 'uno', 2 =>'tres');
*/
$b = array_values($a);// Ahora $b es array(0 => 'uno', 1 =>'tres')?>

La estructura de control foreach existe específicamente para arrays. Ésta provee una manera fácil de recorrer un array.

Recomendaciones sobre arrays y cosas a evitar

¿Por qué es incorrecto $foo[bar]?

Siempre deben usarse comillas alrededor de un índice de array tipo string literal. Por ejemplo, $foo['bar'] es correcto, mientras que $foo[bar] no lo es. ¿Pero por qué? Es común encontrar este tipo de sintaxis en scripts viejos:

<?php
$foo[bar] = 'enemy';
echo $foo[bar];// etc?>

Esto está mal, pero funciona. La razón es que este código tiene una constante indefinida (bar) en lugar de un valor string ('bar' - note las comillas). Puede que en el futuro PHP defina constantes que, desafortunadamente para tal tipo de código, tengan el mismo nombre. Funciona porque PHP automáticamente convierte una cadena pura (un string sin comillas que no corresponda con símbolo conocido alguno) en un string que contiene la cadena pura. Por ejemplo, si no se ha definido una constante llamada bar, entonces PHP reemplazará su valor por la cadena 'bar' y usará ésta última.

Nota: Esto no quiere decir que siempre haya que usar comillas en la clave. No use comillas con claves que sean constantes o variables, ya que en tal caso PHP no podrá interpretar sus valores.

<?php
error_reporting(E_ALL);ini_set('display_errors', true);ini_set('html_errors', false);// Array simple:$array = array(1, 2);$count = count($array);
for ($i = 0; $i < $count; $i++) {
    echo "\nRevisando $i: \n";
    echo "Mal: " . $array['$i'] . "\n";
    echo "Bien: " . $array[$i] . "\n";
    echo "Mal: {$array['$i']}\n";
    echo "Bien: {$array[$i]}\n";
}?>

El resultado del ejemplo sería:

Revisando 0:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mal:
Bien: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mal:
Bien: 1

Revisando 1:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mal:
Bien: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mal:
Bien: 2

Más ejemplos para demostrar este comportamiento:

<?php// Mostrar todos los erroreserror_reporting(E_ALL);
$arr = array('fruit' => 'apple', 'veggie' => 'carrot');
// Correctoprint $arr['fruit'];  // appleprint $arr['veggie']; // carrot

// Incorrecto. Esto funciona pero también genera un error de PHP de
// nivel E_NOTICE ya que no hay definida una constante llamada fruit
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...print $arr[fruit];    // apple

// Esto define una constante para demostrar lo que pasa. El valor 'veggie'
// es asignado a una constante llamada fruit.define('fruit', 'veggie');
// Note la diferencia ahoraprint $arr['fruit'];  // appleprint $arr[fruit];    // carrot

// Lo siguiente está bien ya que se encuentra al interior de una cadena. Las constantes no son procesadas al
// interior de cadenas, así que no se produce un error E_NOTICE aquíprint "Hello $arr[fruit]";      // Hello apple

// Con una excepción, los corchetes que rodean las matrices al
// interior de cadenas permiten el uso de constantesprint "Hello {$arr[fruit]}";    // Hello carrotprint "Hello {$arr['fruit']}";  // Hello apple

// Esto no funciona, resulta en un error de intérprete como:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Esto por supuesto se aplica también al uso de superglobales en cadenasprint "Hello $arr['fruit']";
print "Hello $_GET['foo']";
// La concatenación es otra opciónprint "Hello " . $arr['fruit']; // Hello apple?>

Cuando se habilita error_reporting para mostrar errores de nivel E_NOTICE (como por ejemplo definiendo el valor E_ALL), este tipo de usos serán inmediatamente visibles. Por omisión, error_reporting se encuentra configurado para no mostrarlos.

Tal y como se indica en la sección de sintaxis, lo que existe entre los corchetes cuadrados ('[' y ']') debe ser una expresión. Esto quiere decir que código como el siguiente funciona:

<?phpecho $arr[somefunc($bar)];?>

Este es un ejemplo del uso de un valor devuelto por una función como índice del array. PHP también conoce las constantes:

<?php
$error_descriptions[E_ERROR]   = "Un error fatal ha ocurrido";$error_descriptions[E_WARNING] = "PHP produjo una advertencia";$error_descriptions[E_NOTICE]  = "Esta es una noticia informal";?>

Note que E_ERROR es también un identificador válido, asi como bar en el primer ejemplo. Pero el último ejemplo es equivalente a escribir:

<?php
$error_descriptions[1] = "Un error fatal ha ocurrido";$error_descriptions[2] = "PHP produjo una advertencia";$error_descriptions[8] = "Esta es una noticia informal";?>

ya que E_ERROR es igual a 1, etc.

¿Entonces porqué está mal?

En algún momento en el futuro, puede que el equipo de PHP quiera usar otra constante o palabra clave, o una constante proveniente de otro código puede interferir. Por ejemplo, en este momento no puede usar las palabras empty y default de esta forma, ya que son palabras clave reservadas.

Nota: Reiterando, al interior de un valor string entre comillas dobles, es válido no rodear los índices de array con comillas, así que "$foo[bar]" es válido. Consulte los ejemplos anteriores para más detalles sobre el porqué, así como la sección sobre procesamiento de variables en cadenas.

Conversión a array

Para cualquiera de los tipos: integer, float, string, boolean y resource, convertir un valor a un array resulta en un array con un solo elemento, con índice 0, y el valor del escalar que fue convertido. En otras palabras, (array)$scalarValue es exactamente lo mismo que array($scalarValue).

Si convierte un object a un array, el resultado es un array cuyos elementos son las propiedades del object. Las claves son los nombres de las variables miembro, con algunas excepciones notables: las variables privadas tienen el nombre de la clase al comienzo del nombre de la variable; las variables protegidas tienen un caracter '*' al comienzo del nombre de la variable. Estos valores adicionados al inicio tienen bytes nulos a los lados. Esto puede resultar en algunos comportamientos inesperados:

<?php
class A {
    private $A; //  Este campo se convertirá en '\0A\0A'}

class B extends A {
    private $A; // Este campo se convertirá en '\0B\0A'
    public $AA; // Este campo se convertirá en 'AA'}
var_dump((array) new B());?>

En el ejemplo anterior parecerá que se tienen dos claves llamadas 'AA', aunque en realidad una de ellas se llama '\0A\0A'.

Si convierte un valor NULL a array, obtiene un array vacío.

Comparación

Es posible comparar arrays con la función array_diff() y mediante operadores de arrays.

Ejemplos

El tipo array en PHP es bastante versátil. Aquí hay algunos ejempos:

<?php// Esto:$a = array( 'color' => 'red',
            'taste' => 'sweet',
            'shape' => 'round',
            'name'  => 'apple',
            4        // la clave será 0
          );
$b = array('a', 'b', 'c');
// . . .es completamente equivalente a$a = array();$a['color'] = 'red';$a['taste'] = 'sweet';$a['shape'] = 'round';$a['name']  = 'apple';$a[]        = 4;        // la clave será 0
$b = array();$b[] = 'a';$b[] = 'b';$b[] = 'c';
// Después de que se ejecute el código, $a será el array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), y $b será el array
// array(0 => 'a', 1 => 'b', 2 => 'c'), o simplemente array('a', 'b', 'c').?>

Ejemplo #9 Uso de array()

<?php// Array como mapa de propiedades$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'lang'       => 'english',
              'short_tags' => true
            );
            // Keys estrictamente numéricas$array = array( 7,
                8,
                0,
                156,
                -10
              );// esto es lo mismo que array(0 => 7, 1 => 8, ...)
$switching = array(         10, // key = 0
                    5    =>  6,
                    3    =>  7,
                    'a'  =>  4,
                            11, // key = 6 (el índice entero máximo era 5)
                    '8'  =>  2, // key = 8 (integer!)
                    '02' => 77, // key = '02'
                    0    => 12  // el valor 10 será reemplazado por 12
                  );
                  // array vacío$empty = array();         ?>

Ejemplo #10 Colección

<?php
$colors = array('rojo', 'azul', 'verde', 'amarillo');

foreach ($colors as $color) {
    echo "¿Le gusta el $color?\n";
}
?>

El resultado del ejemplo sería:

¿Le gusta el rojo?
¿Le gusta el azul?
¿Le gusta el verde?
¿Le gusta el amarillo?

Modificar los valores del array directamente es posible a partir de PHP 5, pasándolos por referencia. Las versiones anteriores necesitan una solución alternativa:

Ejemplo #11 Cambiando elemento en el bucle

<?php// PHP 5foreach ($colors as &$color) {
    $color = strtoupper($color);
}
unset($color); /* se asegura de que escrituras subsiguientes a $color
no modifiquen el último elemento del arrays */

// Alternativa para versiones anterioresforeach ($colors as $key => $color) {
    $colors[$key] = strtoupper($color);
}
print_r($colors);?>

El resultado del ejemplo sería:

Array
(
    [0] => ROJO
    [1] => AZUL
    [2] => VERDE
    [3] => AMARILLO
)

Este ejemplo crea un array con base uno.

Ejemplo #12 Índice con base 1

<?php
$firstquarter  = array(1 => 'Enero', 'Febrero', 'Marzo');print_r($firstquarter);?>

El resultado del ejemplo sería:

Array
(
    [1] => 'Enero'
    [2] => 'Febrero'
    [3] => 'Marzo'
)

Ejemplo #13 Llenado de un array

<?php// llenar un array con todos los ítems de un directorio$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}closedir($handle);?>

Los Arrays son ordenados. El orden puede ser modificado usando varias funciones de ordenado. Vea la sección sobre funciones de arrays para más información. La función count() puede ser usada para contar el número de elementos en un array.

Ejemplo #14 Ordenado de un array

<?php
sort($files);print_r($files);?>

Dado que el valor de un array puede ser cualquier cosa, también puede ser otro array. De esta forma es posible crear arrays recursivas y multi-dimensionales.

Ejemplo #15 Arrays recursivos y multi-dimensionales

<?php
$fruits = array ( "fruits"  => array ( "a" => "orange",
                                       "b" => "banana",
                                       "c" => "apple"
                                     ),
                  "numbers" => array ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "holes"   => array (      "first",
                                       5 => "second",
                                            "third"
                                     )
                );
// Algunos ejemplos que hacen referencia a los valores del array anteriorecho $fruits["holes"][5];    // prints "second"echo $fruits["fruits"]["a"]; // prints "orange"unset($fruits["holes"][0]);  // remove "first"

// Crear una nueva array multi-dimensional$juices["apple"]["green"] = "good";?>

La asignación de arrays siempre involucra la copia de valores. Use el operador de referencia para copiar un array por referencia.

<?php
$arr1 = array(2, 3);$arr2 = $arr1;$arr2[] = 4; // $arr2 ha cambiado,
             // $arr1 sigue siendo array(2, 3)
            $arr3 = &$arr1;$arr3[] = 4; // ahora $arr1 y $arr3 son iguales?>

Objetos Cadenas

---

[edit] Last updated: Fri, 27 Apr 2012

 

add a note User Contributed Notes Arrays

php_net at mcdragonsoftware dot com 06-Apr-2012 05:55

If you're like me you've needed to use index paths (an array as the index for a multi-dimensional array) and dearly hoped that PHP had native support for it; probably even tried something like:

<?php
$TEST = array(
    array( 'A', 'B', 'C' ),
    array( 'X', 'Y', 'Z' ),
    array( '1', '2', '3' ),
);
$INDEX = array( 1, 1 );

echo $TEST[$INDEX];
?>

only to receive the Warning: "Illegal offset type...".

I spent the last 3 hours solving that problem, here is my 11 function solution: (these functions have been tested/verified in PHP 5.3, but not yet in PHP 4)

<?php

//// mda = Multi-Dimensional Array
function mcds_mda_get( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    foreach( (array)$PATH as $el ) {
        $SUB = &$SUB[$el];
    }
    return $SUB;
}

function mcds_mda_set( $ARRAY, $PATH, $value ) {
    $SUB = &$ARRAY;
    foreach( (array)$PATH as $el ) {
        $SUB = &$SUB[$el];
    }
    $SUB = $value;
    return $ARRAY;
}

function mcds_mda_add( $ARRAY, $PATH, $value ) {
    $SUB = &$ARRAY;
    foreach( (array)$PATH as $el ) {
        $SUB = &$SUB[$el];
    }
    $SUB = array_merge( (array)$SUB, (array)$value );
    return $ARRAY;
}

function mcds_mda_delete( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            unset($SUB[$el]);
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $ARRAY;
}

//// mdi = Multi-Dimensional Index (for use with mda)
function mcds_mdi_first( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $KEYS = array_keys( $SUB );
            $PATH[$i-1] = $KEYS[0];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

function mcds_mdi_prev( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $KEYS = array_keys( $SUB );
            $pos = max( array_search( $el, $KEYS ) -1, 0 );
            $PATH[$i-1] = $KEYS[$pos];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

function mcds_mdi_next( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $KEYS = array_keys( $SUB );
            $pos = min( array_search( $el, $KEYS ) +1, count($KEYS)-1 );
            $PATH[$i-1] = $KEYS[$pos];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

function mcds_mdi_last( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $KEYS = array_keys( $SUB );
            $PATH[$i-1] = $KEYS[count($KEYS)-1];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

function mcds_mdi_parent( $ARRAY, $PATH ) {
    unset($PATH[count($PATH)-1]);
    return $PATH;
}

function mcds_mdi_firstChild( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $SUB = &$SUB[$el];
            $KEYS = array_keys( $SUB );
            $PATH[$i] = $KEYS[0];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

function mcds_mdi_lastChild( $ARRAY, $PATH ) {
    $SUB = &$ARRAY;
    $i = 0;
    foreach( (array)$PATH as $el ) {
        $i++;
        if( $i == count($PATH) ) {
            $SUB = &$SUB[$el];
            $KEYS = array_keys( $SUB );
            $PATH[$i] = $KEYS[count($KEYS)-1];
        } else {
            $SUB = &$SUB[$el];
        }
    }
    return $PATH;
}

$TEST = array(
    array( 'A', 'B', 'C' ),
    array( 'X', 'Y', 'Z' ),
    array( '1', '2', '3' ),
);
$INDEX = array( 1, 1 );

$TEST = mcds_mda_set($TEST, $INDEX, "!Y" );
$TEST = mcds_mda_add($TEST, $INDEX, "Y2" );
$TEST = mcds_mda_add($TEST, $INDEX, array("Y3", "Y4") );
$TEST = mcds_mda_delete($TEST, array( 1, 0 ));
// $TEST = mcds_mda_get($TEST, $INDEX);
$TEST = mcds_mda_get($TEST, mcds_mdi_parent($TEST, $INDEX) );

echo "<pre>".print_r( $TEST, true )."</pre>";
?>

martijntje at martij