Skip to content

3. Los fundamentos de PHP

3.1. La estructura de directorios de los scripts

Los scripts de este capítulo se encuentran en dos carpetas dentro de la carpeta [scripts-console] del código del curso:

php8-oct-2026
└── scripts-console
    ├── basics
    │   ├── phpinfo.php
    │   ├── basics-01.php
    │   ├── basics-02.php
    │   ├── ...
    │   ├── basics-17.php
    │   └── info.txt
    └── json
        ├── family.json
        ├── json-01.php
        ├── json-02.php
        └── json-03.php

Son scripts de “consola”: se ejecutan en un terminal con el comando [php script-name.php] y envían sus resultados a ese mismo terminal. Los scripts web, que ejecuta el servidor [Apache] de [Laragon] y que se muestran en un navegador, se tratarán más adelante.

3.2. Configuración de PHP

PHP viene preconfigurado mediante un archivo de texto llamado [php.ini]. Todos estos parámetros pueden modificarse mediante programación. La configuración de PHP influye mucho en la ejecución de los scripts. Por lo tanto, es importante comprenderla. El siguiente script, [phpinfo.php], permite hacerlo:

1
2
3
4
5
6
<?php

declare(strict_types=1);

// muestra la configuración de PHP
phpinfo();

Comentarios:

  • línea 3: esta línea aparecerá al principio de todos los scripts de este curso. La explicaremos en la sección sobre las conversiones de tipos;
  • línea 6: la función [phpinfo] muestra la configuración de PHP.

Abramos un terminal en la carpeta [scripts-console/basics] y ejecutemos el script. A continuación se muestra un extracto:

> php phpinfo.php
phpinfo()
PHP Version => 8.5.11
…
Server API => Command Line Interface
…
PHP API => 20250925
PHP Extension => 20250925
Zend Extension => 420250925
PHP Integer Size => 64 bits
Debug Build => no
Zend Memory Manager => enabled
IPv6 Support => enabled
…
display_errors => STDOUT => STDOUT
error_reporting => 30719 => 30719
memory_limit => 512M => 512M
max_execution_time => 0 => 0
…

La función [phpinfo] muestra aquí casi 1500 líneas de configuración. No las comentaremos porque la mayoría corresponde a usos avanzados de PHP. Destaquemos algunas:

  • [PHP Version]: la versión de PHP utilizada, en este caso 8.5;
  • [Server API]: la forma en que se inició PHP. [Command Line Interface] (CLI) designa al intérprete que se ejecuta en un terminal. Cuando PHP lo ejecuta el servidor [Apache], esta línea cambia y la configuración puede ser distinta;
  • [display_errors] y [error_reporting]: PHP muestra todos los errores, advertencias y avisos de obsolescencia. El valor 30719 corresponde a la constante [E_ALL] a partir de PHP 8.4. Esta es la configuración necesaria durante el aprendizaje: una advertencia casi siempre indica un error de programación.

Una línea importante de la salida completa es la línea [Loaded Configuration File]: indica qué archivo [php.ini] se utilizó para configurar el PHP que ejecuta sus scripts. Con [Laragon], es un archivo como [C:\laragon\bin\php\php-8.5.x-Win32-vs17-x64\php.ini]. También puede obtenerlo directamente con el comando [php --ini]. Si desea modificar la configuración de ejecución de PHP, este es el archivo que debe editar ([Laragon] da acceso a él desde su menú, en la sección [PHP > php.ini]). Este archivo contiene numerosos comentarios que explican la finalidad de los distintos parámetros.

3.3. Un primer ejemplo

3.3.1. El código

A continuación se presenta un programa [basics-01.php] que muestra las características básicas de PHP:

<?php

// verificación estricta de los tipos de los parámetros y resultados de las funciones
declare(strict_types=1);

// esto es un comentario
// variable usada sin haber sido declarada
$name = "dupont";
// una salida en pantalla
print "name=$name\n";
// un arreglo con elementos de tipos diferentes
$array = ["one", "two", 3, 4];
// su número de elementos
$n = count($array);
// un bucle
for ($i = 0; $i < $n; $i++) {
    print "array[$i]=$array[$i]\n";
}
// inicialización de 2 variables con el contenido de un arreglo
[$string1, $string2] = ["string1", "string2"];
// concatenación de las 2 cadenas
$string3 = $string1 . $string2;
// mostrar el resultado
print "[$string1,$string2,$string3]\n";
// uso de una función
display($string1);
// se puede conocer el tipo de una variable
displayType("n", $n);
displayType("string1", $string1);
displayType("array", $array);
// el tipo de una variable puede cambiar durante la ejecución
$n = "has changed";
displayType("n", $n);
// una función puede devolver un resultado
$res1 = f1(4);
print "res1=$res1\n";
// una función puede devolver un arreglo de valores
[$res1, $res2, $res3] = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// habríamos podido recuperar estos valores en un arreglo
$t = f2();
for ($i = 0; $i < count($t); $i++) {
    print "t[$i]=$t[$i]\n";
}
// algunas pruebas
for ($i = 0; $i < count($t); $i++) {
    // solo muestra las cadenas
    if (gettype($t[$i]) === "string") {
        print "t[$i]=$t[$i]\n";
    }
}
// operadores de comparación == y ===
if ("2" == 2) {
    print "with the == operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the == operator, the string 2 is not equal to the integer 2\n";
}
if ("2" === 2) {
    print "with the === operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the === operator, the string 2 is not equal to the integer 2\n";
}
// una comparación cuyo resultado cambió con PHP 8
if (0 == "abc") {
    print "with the == operator, the integer 0 is equal to the string abc\n";
} else {
    print "with the == operator, the integer 0 is not equal to the string abc\n";
}
// otras pruebas
for ($i = 0; $i < count($t); $i++) {
    // solo muestra los enteros > 10
    if (is_int($t[$i]) && $t[$i] > 10) {
        print "t[$i]=$t[$i]\n";
    }
}
// un bucle while
$t = [8, 5, 0, -2, 3, 4];
$i = 0;
$sum = 0;
while ($i < count($t) && $t[$i] > 0) {
    print "t[$i]=$t[$i]\n";
    $sum += $t[$i];   // $sum = $sum + $t[$i]
    $i++;             // $i = $i + 1
}
print "sum=$sum\n";

// fin del programa
exit;

//----------------------------------
function display(string $string): void
{
    // muestra $string
    print "string=$string\n";
}

//----------------------------------
function displayType(string $name, mixed $variable): void
{
    // muestra el tipo de $variable
    print "type[variable $" . $name . "]=" . gettype($variable) . "\n";
}

//----------------------------------
function f1(int $param): int
{
    // suma 10 a $param
    return $param + 10;
}

//----------------------------------
function f2(): array
{
    // devuelve 3 valores
    return ["one", 0, 100];
}

Los resultados:

> php basics-01.php
name=dupont
array[0]=one
array[1]=two
array[2]=3
array[3]=4
[string1,string2,string1string2]
string=string1
type[variable $n]=integer
type[variable $string1]=string
type[variable $array]=array
type[variable $n]=string
res1=14
(res1,res2,res3)=[one,0,100]
t[0]=one
t[1]=0
t[2]=100
t[0]=one
with the == operator, the string 2 is equal to the integer 2
with the === operator, the string 2 is not equal to the integer 2
with the == operator, the integer 0 is not equal to the string abc
t[2]=100
t[0]=8
t[1]=5
sum=13

Comentarios:

  • línea 4: indica a PHP que verifique estrictamente los tipos declarados de los parámetros y de los valores de retorno de las funciones. Volveremos sobre esto en la sección sobre los cambios de tipo. Por ahora, tenga en cuenta que todos los scripts de este curso comienzan así;
  • línea 8: en PHP las variables no se declaran. Tienen un tipo dinámico que puede cambiar con el tiempo. [$name] representa la variable con el identificador [name];
  • línea 10: para escribir en pantalla se puede usar la instrucción [print] o la instrucción [echo];
  • línea 12: la notación [[...]] sirve para definir un arreglo. La notación [$array[$i]] representa el elemento n.º [$i] del arreglo [$array], donde el primer elemento tiene el número 0. La notación más antigua [array("one", "two", 3, 4)] todavía se acepta, pero no la usaremos;
  • línea 14: la función [count($array)] devuelve el número de elementos del arreglo [$array];
  • líneas 16 a 18: un bucle. Como este bucle contiene una sola instrucción, las llaves son opcionales. En el resto de este documento, usaremos siempre llaves, sin importar el número de instrucciones;
  • línea 17: las cadenas se delimitan con comillas dobles " o comillas simples '. Dentro de las comillas dobles, las variables [$variable] se evalúan (también se dice que se “interpolan”), pero no dentro de las comillas simples;
  • línea 20: se pueden asignar los elementos de un arreglo a varias variables en una sola operación. Aquí, [$string1="string1"] y [$string2="string2"]. Esta sintaxis, llamada desestructuración, reemplaza a la función [list] de las versiones antiguas de PHP: [list($string1, $string2) = ...] todavía se acepta;
  • línea 22: el operador . (punto) es el operador de concatenación de cadenas;
  • líneas 91 a 95: la palabra clave [function] define una función. Una función puede definirse en cualquier parte del script, incluso después de haber sido utilizada. Aquí, [string $string] indica que el parámetro [$string] debe ser una cadena, y [: void] indica que la función no devuelve ningún resultado. Estas declaraciones de tipo son opcionales en PHP, pero las usaremos de manera sistemática: documentan el código y permiten que PHP (y el editor) detecten errores;
  • línea 98: el tipo [mixed] (PHP 8.0) significa “cualquier tipo”. El parámetro [$variable] puede aceptar un entero, una cadena, un arreglo, etc.;
  • línea 101: la función predefinida [gettype($variable)] devuelve una cadena que representa el tipo de [$variable]. Los resultados muestran que este tipo puede cambiar con el tiempo: [$n] es primero un entero y luego una cadena;
  • línea 105: una función devuelve un resultado mediante la instrucción [return]. El tipo de este resultado se declara después de los paréntesis: [: int]. El código que realiza la llamada puede ignorar o recuperar los resultados de una función;
  • línea 112: una función puede devolver varios valores agrupándolos en un arreglo;
  • líneas 53 a 62: el operador [===] realiza una comparación estricta de dos elementos: deben tener el mismo tipo y el mismo valor para ser iguales. El operador [] es menos estricto: dos elementos pueden ser iguales sin ser del mismo tipo. En ese caso, la comparación se realiza después de convertir ambos elementos al mismo tipo. Es bastante fácil “pasar por alto” estas conversiones implícitas y terminar con resultados inesperados, como descubrir que una condición es verdadera cuando se esperaba que fuera falsa. Para evitar esta trampa, usaremos de manera sistemática el operador de comparación [=] (y su negación, [!==]);
  • líneas 64 a 68: un ejemplo de estas conversiones implícitas. En PHP 7, la cadena “abc” se convertía en el número 0, ¡y la expresión [0 == "abc"] era verdadera! Desde PHP 8.0, al comparar un número con una cadena que no representa un número, el número se convierte en cadena y la expresión es falsa. El comportamiento de [] ha cambiado, por lo tanto, de una versión a otra: razón de más para preferir [=];
  • línea 72: la función [is_int] devuelve [true] si su parámetro es un entero. De manera similar, existen [is_string], [is_float], [is_bool], [is_array]… El operador [&&] es el AND lógico. También se pueden usar los operadores lógicos [||] (OR) y [!] (NOT). PHP también admite las palabras clave [and] y [or], pero su menor prioridad respecto de la asignación puede dar lugar a resultados inesperados: no las usaremos;
  • línea 80: un bucle [while]. Se detiene en cuanto la condición es falsa; en este caso, en cuanto se recorre el arreglo o se encuentra un elemento negativo o igual a cero;
  • línea 88: la instrucción [exit] detiene la ejecución del script. Las funciones que siguen no se ejecutan en ese punto, pero son reconocidas por todo el script.

Observe que el script no termina con la etiqueta de cierre [?>] del código PHP. No es indispensable. Además, en un contexto web puede causar problemas si va seguida de espacios o saltos de línea, que son difíciles de detectar porque no son visibles en un editor de texto. De hecho, la recomendación [PSR-12] especifica que debe omitirse en los archivos que solo contienen PHP. Por lo tanto, en el resto de este documento la omitiremos de forma sistemática.

Nota: en este documento usaremos la palabra clave [print] para mostrar texto en la consola. Otra forma de hacer lo mismo es usar la palabra clave [echo]. Existen diferencias sutiles entre estas dos palabras clave, pero en el contexto de este documento no habrá ninguna. Así que, si prefiere usar [echo], adelante.

3.3.2. Uso de VS Code

Para trabajar con los scripts del curso, abra la carpeta [php8-oct-2026] en [VS Code] (menú [File > Open Folder]). El árbol de archivos aparece en el explorador, en el lado izquierdo de la ventana. Para ejecutar un script:

  • abra un terminal integrado (menú [Terminal > New Terminal]). Se abre en la carpeta [php8-oct-2026];
  • navegue a la carpeta del script: [cd scripts-console/basics];
  • ejecute el script: [php basics-01.php]. Los resultados se muestran en el terminal. Como alternativa, en el explorador de archivos puede hacer clic con el botón derecho en la carpeta [basics] y seleccionar [Open in Integrated Terminal].

Si el comando [php] no se reconoce, significa que la carpeta de PHP no está incluida en el PATH de Windows: [Laragon] la agrega allí cuando se marca la opción correspondiente en su menú [Tools > Path]. El comando [php -v] debería mostrar la versión 8.5.

La extensión [PHP Intelephense] analiza el código mientras se escribe y señala los problemas con una línea ondulada bajo el código incorrecto. Al pasar el mouse sobre esta línea se muestra el mensaje. Todos los problemas del archivo se listan en el panel [Problems] (menú [View > Problems]). Entre las advertencias útiles se encuentran:

  • [Undefined variable]: se está usando una variable sin haberla inicializado. A menudo es un error tipográfico en el nombre de la variable;
  • [Undefined function]: se está llamando a una función que no existe; de nuevo, suele ser un error tipográfico;
  • [Expected type 'int'. Found 'string'.]: un parámetro real no tiene el tipo declarado por la función. Esta es una de las grandes ventajas de las declaraciones de tipo: el error se informa incluso antes de la ejecución;
  • [Expected 2 arguments. Found 1.]: el número de parámetros reales no coincide con la definición de la función.

Al pasar el mouse sobre el nombre de una función se muestra su firma (parámetros, tipos, valor de retorno) y su documentación, incluso para las funciones predefinidas de PHP. Para asegurarse de que [Intelephense] conozca las novedades recientes del lenguaje, revise la configuración de [VS Code] (menú [File > Preferences > Settings], busque “intelephense php version”) y verifique que la versión de PHP especificada sea la 8.5. Mientras aprende el lenguaje, se aconseja corregir todas las advertencias que se informen. Es una excelente manera de aprender.

[Intelephense] también puede formatear un archivo (clic con el botón derecho, [Format Document]) según las recomendaciones de codificación de [PSR-12]. Las PSR (PHP Standard Recommendations) son guías para producir código estándar, lo que facilita la interoperabilidad y el mantenimiento del código escrito por distintas personas. Las publica el [PHP-FIG] en el sitio web www.php-fig.org. Las recomendaciones [PSR-1] y [PSR-12] establecen las reglas para escribir código. Estas son las reglas de [PSR-1]:

Elemento
Regla
Constantes de clase
Las constantes de clase DEBEN escribirse en mayúsculas, con el carácter _ como separador.
Ej.: [const VAT_RATE]
Métodos
Los nombres de los métodos DEBEN escribirse en camelCase.
Ejemplo: [public function executeBatchTaxes()]
Propiedades
Los nombres de las propiedades DEBERÍAN escribirse de manera coherente dentro de una misma base de código, en StudlyCaps, camelCase o under_score.
Ejemplos: [$AnnualSalary], [$annualSalary], [$annual_salary]
Efectos secundarios
Un archivo DEBERÍA declarar nuevos símbolos (clases, funciones, constantes, etc.) sin ningún efecto secundario, o bien ejecutar código con efectos secundarios, pero NO DEBERÍA hacer ambas cosas.
Tipos
Los nombres de los tipos (clases, interfaces, etc.) DEBEN escribirse en StudlyCaps. Cada tipo está en su propio archivo y en un espacio de nombres con al menos un nivel.
Ejemplo: [class ScholarshipStudent]

La regla de los efectos secundarios establece que un archivo debe contener:

  • o bien declaraciones de tipos (clases, interfaces), funciones o constantes;
  • o bien código ejecutable sin declaraciones de nuevos tipos.

Para simplificar, los ejemplos de este capítulo no siguen esta regla: cada script es un único archivo que define sus funciones y las utiliza. Dividir el código en varios archivos resultaría demasiado engorroso para ejemplos básicos. En la aplicación presentada como hilo conductor de este documento, nos esforzaremos por seguir estas recomendaciones lo más fielmente posible una vez que esté escrita con clases.

3.4. Ámbito de las variables

3.4.1. Ejemplo 1

El script [basics-02.php] es el siguiente:

<?php

declare(strict_types=1);

// ámbito de las variables

function f1(): void
{
    // usamos la variable global $i
    global $i;
    $i++;
    $j = 10;
    print "f1[i,j]=[$i,$j]\n";
}

function f2(): void
{
    // usamos la variable global $i
    global $i;
    $i++;
    $j = 20;
    print "f2[i,j]=[$i,$j]\n";
}

function f3(): void
{
    // usamos una variable local $i
    $i = 4;
    $j = 30;
    print "f3[i,j]=[$i,$j]\n";
}

// pruebas
$i = 0;
$j = 0;  // estas dos variables son conocidas por una función f
// solo si esta declara explícitamente con la instrucción global
// que quiere usarlas
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";

Los resultados:

1
2
3
4
5
> php basics-02.php
f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[4,30]
test[i,j]=[2,0]

Comentarios:

  • Líneas 34 y 35: definen dos variables, [$i] y [$j], en el programa principal. Estas variables no son reconocidas dentro de las funciones. Así, en la línea 12, la variable [$j] de la función [f1] es una variable local de la función [f1] y es distinta de la variable [$j] del programa principal;
  • línea 10: una función puede acceder a una variable denominada [$variable] del programa principal mediante la palabra clave [global]. Aquí, la instrucción hace referencia a la variable global [$i] del programa principal;
  • línea 28: la función [f3] no ha declarado [$i] como global; su variable [$i] es una variable local, sin relación con la del programa principal.

No se recomienda el uso de [global] : una función que modifica variables globales es difícil de entender y de probar. Es preferible que una función reciba sus datos mediante sus parámetros y devuelva sus resultados mediante [return]. Esto es lo que haremos en el siguiente ejemplo.

3.4.2. Ejemplo 2

El script [basics-03.php] es el siguiente:

<?php

declare(strict_types=1);

// el ámbito de una variable es global a los bloques de código
$i = 0;
{
    $i = 4;
    $i++;
}
print "i=$i\n";

Los resultados:

> php basics-03.php
i=5

Comentarios:

En algunos lenguajes, una variable definida entre llaves tiene un ámbito limitado a esas llaves: no es accesible fuera de ellas. Los resultados anteriores muestran que en PHP no es así. La variable [$i] utilizada en la línea 8 dentro de las llaves es la misma que la utilizada en las líneas 6 y 11 fuera de ellas.

3.5. Cambios de tipo

Las variables de PHP no tienen un tipo fijo. El tipo puede cambiar en tiempo de ejecución según el valor asignado a la variable. En las operaciones que involucran datos de varios tipos, el intérprete de PHP realiza conversiones implícitas para llevar los operandos a un tipo común. Estas conversiones implícitas, si el desarrollador las desconoce, pueden ser fuente de errores difíciles de detectar. A continuación se presenta un script [basics-04.php] que muestra conversiones implícitas y explícitas. Comencemos con la primera parte:

<?php

// tipos estrictos al pasar parámetros
declare(strict_types=1);

// cambios implícitos de tipo
// tipo → bool
print "Conversion to a boolean------------------------------\n";
showBool("abcd", "abcd");
showBool("", "");
showBool("[1, 2, 3]", [1, 2, 3]);
showBool("[]", []);
showBool("null", null);
showBool("0.0", 0.0);
showBool("0", 0);
showBool("4.6", 4.6);
showBool("\"0\"", "0");

function showBool(string $prefix, mixed $var): void
{
    print "(bool) $prefix : ";
    // la conversión de $var a booleano se hace automáticamente en la siguiente prueba
    if ($var) {
        print "true";
    } else {
        print "false";
    }
    print "\n";
}

Comentarios:

  • línea 4: solicita la verificación estricta de los tipos de los parámetros de una función cuando se especifica el tipo (y del tipo de su valor de retorno). Explicaremos esta instrucción un poco más adelante;
  • línea 19: la función [showBool] tiene como finalidad mostrar la conversión implícita (automática) que realiza el intérprete de PHP cuando un valor de cualquier tipo debe convertirse en booleano (línea 23);
  • línea 19: el parámetro [$prefix] debe ser de tipo [string]. El parámetro [$var] es de tipo [mixed]: el parámetro real puede ser, por lo tanto, de cualquier tipo. La función [showBool] no devuelve ningún valor ([void]);
  • línea 23: en la instrucción [if ($var)], el valor de [$var] debe convertirse en booleano para poder evaluar [if] . Sorprendentemente, el intérprete de PHP devuelve un resultado para cualquier tipo de valor que se le proporcione;
  • líneas 9 a 17: el valor del parámetro de la función [showBool] será, sucesivamente:
    • línea 9: una cadena no vacía: resultado [true] (no se distingue entre mayúsculas y minúsculas, TRUE=true);
    • línea 10: una cadena vacía: resultado [false];
    • línea 11: un arreglo no vacío: resultado [true];
    • línea 12: un arreglo vacío: resultado [false];
    • línea 13: el valor [null] (sin valor): resultado [false];
    • línea 14: el número real 0: resultado [false];
    • línea 15: el entero 0: resultado [false];
    • línea 16: un número real (o entero) distinto de 0: resultado [true];
    • línea 17: una trampa: la cadena "0" se convierte en [false], mientras que cualquier otra cadena no vacía se convierte en [true].

Esto se muestra en las siguientes salidas de pantalla resultantes:

Conversion to a boolean------------------------------
(bool) abcd : true
(bool)  : false
(bool) [1, 2, 3] : true
(bool) [] : false
(bool) null : false
(bool) 0.0 : false
(bool) 0 : false
(bool) 4.6 : true
(bool) "0" : false

Continuemos con el código del script:

// cambios implícitos de tipo de cadena a un tipo numérico
// cadena → número
print "Conversion string to number------------------------------\n";
showNumber("12");
showNumber("45.67");
showNumber("12abcd");
try {
    showNumber("abcd");
} catch (TypeError $error) {
    print "(abcd): error [" . $error->getMessage() . "]\n";
}

function showNumber(string $var): void
{
    $number = $var + 1;
    var_dump($number);
    print "($var): $number\n";
}

Comentarios:

  • línea 43: la función [showNumber] acepta un parámetro de tipo [string] y no devuelve ningún resultado ([void]);
  • línea 45: este parámetro se utiliza en una operación aritmética, lo que obligará al intérprete de PHP a intentar convertir [$var] en un número:
    • línea 34: convertirá la cadena "12" en el entero 12;
    • línea 35: convertirá la cadena "45.67" en el número real 45.67;
    • línea 36: la cadena "12abcd" comienza con un número. PHP utiliza este número, 12, pero emite una advertencia;
    • línea 38: la cadena "abcd" no contiene números. En PHP 7 se convertía en 0 con una simple advertencia. Desde PHP 8.0, esta operación ya no es posible: PHP lanza un error de tipo [TypeError], que, si no se intercepta, terminaría el script;
  • líneas 37 a 41: la estructura [try { ... } catch (TypeError $error) { ... }] permite interceptar este error y continuar la ejecución. [$error->getMessage()] es el mensaje de error. Las excepciones se tratarán en un capítulo posterior; por ahora basta saber que el código del bloque [catch] se ejecuta cuando el código del bloque [try] provoca un error [TypeError].

Estos son los resultados de la ejecución:

Conversion string to number------------------------------
int(13)
(12): 13
float(46.67)
(45.67): 46.67

Warning: A non-numeric value encountered in .../php8-oct-2026/scripts-console/basics/basics-04.php on line 45
int(13)
(12abcd): 13
(abcd): error [Unsupported operand types: string + int]

La función [var_dump] muestra el tipo y el valor de su parámetro: int(13) es el entero 13, y float(46.67) es el número de punto flotante 46.67.

Observe que la instrucción [declare(strict_types=1)] no impidió que la cadena "12" se convirtiera en número. Este es un punto importante: el modo estricto se aplica únicamente al paso de parámetros a las funciones y a los resultados que estas devuelven. No afecta las conversiones realizadas por los operadores (+, ., ==…) ni por el [if]. Esto es lo que sí cambia:

  • sin [declare(strict_types=1)] (el llamado modo “coercitivo”), si una función espera un [int] y se le pasa la cadena “12”, PHP convierte la cadena en el entero 12;
  • con [declare(strict_types=1)] (modo estricto), la misma llamada produce un error [TypeError]. El parámetro real debe ser exactamente del tipo esperado. Hay una excepción: se acepta un [int] donde se espera un [float].

Esta instrucción debe ser la primera del archivo y solo se aplica a las llamadas a funciones realizadas dentro de ese archivo. La usaremos en todos los scripts: transforma las conversiones silenciosas, que son fuentes de errores, en errores informados. Veremos un ejemplo en la sección sobre el paso de parámetros.

Continuemos con el código del script con las conversiones explícitas de tipo:

// cambios explícitos de tipo
// a int
print "Explicit conversion to int------------------------------\n";
showInt("12.45");
showInt(67.8);
showInt(true);
showInt(null);

function showInt(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((int) $var);
}

Comentarios:

  • línea 58: la función [showInt] acepta un parámetro de cualquier tipo ([mixed]) y no devuelve ningún resultado. Convierte el parámetro [$var] en un entero (línea 63). En general, para convertir una variable de tipo [$var] al tipo T, se escribe [(T) $var], donde T puede ser: int, bool, float, string, array u object. Las notaciones (integer), (boolean), (double) y (binary) de las versiones antiguas de PHP son obsoletas: PHP 8.5 las señala como obsoletas. La sintaxis (real), en cambio, se eliminó a partir de PHP 8.0;
  • línea 53: convierte la cadena "12.45" en el entero 12;
  • línea 54: convierte el número de punto flotante 67.8 en el entero 67 (se pierde la parte decimal);
  • línea 55: convierte el booleano [true] en el entero 1 (el booleano [false] en el entero 0);
  • línea 56: convierte el valor [null] en el entero 0.

Esto es lo que muestran las salidas de pantalla:

1
2
3
4
5
6
7
8
9
Explicit conversion to int------------------------------
parameter: string(5) "12.45"
result of the conversion: int(12)
parameter: float(67.8)
result of the conversion: int(67)
parameter: bool(true)
result of the conversion: int(1)
parameter: NULL
result of the conversion: int(0)

Continuamos el análisis del script con la conversión explícita de valores al tipo [float]:

// a float
print "Explicit conversion to float------------------------------\n";
showFloat("12.45");
showFloat(67);
showFloat(true);
showFloat(null);

function showFloat(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((float) $var);
}

Comentarios:

  • línea 73: la función [showFloat] recibe un parámetro de cualquier tipo y no devuelve ningún resultado;
  • línea 78: el valor de este parámetro se convierte explícitamente en [float];
  • línea 68: la cadena "12.45" se convierte en el número real 12.45;
  • línea 69: el entero 67 se convierte en el número real 67;
  • línea 70: el valor booleano [true] se convierte en el número real 1 (el valor [false] se convierte en el número 0);
  • línea 71: el valor [null] se convierte en el número real 0.

Esto lo muestra la salida de pantalla:

1
2
3
4
5
6
7
8
9
Explicit conversion to float------------------------------
parameter: string(5) "12.45"
result of the conversion: float(12.45)
parameter: int(67)
result of the conversion: float(67)
parameter: bool(true)
result of the conversion: float(1)
parameter: NULL
result of the conversion: float(0)

Concluimos la presentación del script examinando las conversiones al tipo [string]:

// a string
print "Explicit conversion to string------------------------------\n";
showString(5);
showString(6.7);
showString(false);
showString(null);

function showString(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((string) $var);
}

Comentarios:

  • línea 88: la función [showString] recibe un parámetro de cualquier tipo y no devuelve ningún resultado;
  • línea 93: el valor del parámetro se convierte al tipo [string];
  • línea 83: el entero 5 se convertirá en la cadena "5";
  • línea 84: el número de punto flotante 6.7 se convertirá en la cadena "6.7";
  • línea 85: el booleano [false] se convertirá en una cadena vacía;
  • línea 86: el valor [null] se convertirá en una cadena vacía.

Estos son los resultados en pantalla:

1
2
3
4
5
6
7
8
9
Explicit conversion to string------------------------------
parameter: int(5)
result of the conversion: string(1) "5"
parameter: float(6.7)
result of the conversion: string(3) "6.7"
parameter: bool(false)
result of the conversion: string(0) ""
parameter: NULL
result of the conversion: string(0) ""

3.6. Arreglos

3.6.1. Arreglos estándar unidimensionales

Hay dos notaciones para los arreglos en PHP:

$array = ["one", 2, "three"];
$opposites = ["small" => "big", "beautiful" => "ugly", "expensive" => "cheap"];

El arreglo 1 se denomina arreglo (o lista), y el arreglo 2 se denomina diccionario o arreglo asociativo, cuyos elementos se escriben como clave => valor. La notación [$opposites["beautiful"]] hace referencia al valor asociado a la clave "beautiful". En este caso, es la cadena "ugly". El arreglo 1 es simplemente una variante del diccionario y podría escribirse así:

$array = [0 => "one", 1 => 2, 2 => "three"];

Esto nos da [$array[2]="three"]. En el fondo, solo existen diccionarios. En el caso de un arreglo clásico de n elementos, las claves son los enteros del intervalo [0,n-1].

El script [basics-05.php] muestra operaciones para manipular un arreglo de valores:

<?php

declare(strict_types=1);

// arreglos clásicos
// inicialización
$tab1 = [0, 1, 2, 3, 4, 5];
// recorrido - 1
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// recorrido - 2
print "tab1 has " . count($tab1) . " elements\n";
foreach ($tab1 as $key => $value) {
    print "tab1[$key]=$value\n";
}
// agregar elementos
$tab1[] = $i++;
$tab1[] = $i++;
// recorrido - 3
print "tab1 has " . count($tab1) . " elements\n";
$i = 0;
foreach ($tab1 as $element) {
    print "tab1[$i]=$element\n";
    $i++;
}
// eliminar el último elemento
array_pop($tab1);
// recorrido - 4
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// eliminar el primer elemento
array_shift($tab1);
// recorrido - 5
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// agregar al final del arreglo
array_push($tab1, -2);
// recorrido - 6
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// agregar al inicio del arreglo
array_unshift($tab1, -1);
// recorrido - 7
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// primer y último elemento (PHP 8.5)
print "first element: " . array_first($tab1) . ", last element: " . array_last($tab1) . "\n";

Los resultados:

> php basics-05.php
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 8 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=7
tab1 has 7 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 has 6 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 has 7 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 has 8 elements
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2
first element: -1, last element: -2

Comentarios:

  • línea 15: el arreglo se recorre con un [foreach]. Este elemento de sintaxis permite recorrer un diccionario (y, por lo tanto, un arreglo) con dos sintaxis distintas: [foreach ($dictionary as $key => $value)] y [foreach ($array as $value)]. La primera sintaxis devuelve un par (clave, valor) en cada iteración, mientras que la segunda devuelve solo el valor. El curso de PHP 7 usaba aquí la función [each], que ya era obsoleta en ese momento: se eliminó en PHP 8.0. [foreach] es la forma estándar de recorrer un arreglo;
  • línea 19: la notación [$array[] = value] agrega el elemento [value] como último elemento de [$array]. Aquí, [$i] es igual a 6 después del primer bucle [for]: se agrega 6 y luego 7;
  • línea 24: una iteración con la segunda sintaxis de [foreach];
  • línea 29: la función [array_pop($array)] elimina el último elemento de [$array];
  • línea 36: la función [array_shift($array)] elimina el primer elemento de [$array]. Los elementos restantes se renumeran a partir de 0;
  • línea 43: la función [array_push($array, value)] agrega [value] como último elemento de [$array];
  • línea 50: la función [array_unshift($array, value)] agrega [value] como primer elemento de [$array];
  • línea 57: las funciones [array_first] y [array_last], introducidas con PHP 8.5, devuelven el primer y el último elemento de un arreglo (o [null] si el arreglo está vacío).

3.6.2. El diccionario o arreglo asociativo

El script [basics-06.php] es el siguiente:

<?php

declare(strict_types=1);

// diccionarios
$spouses = ["Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => ""];
// recorrido - 1
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// ordenar el diccionario por clave
ksort($spouses);
// recorrido - 2
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// lista de las claves del diccionario
$keys = array_keys($spouses);
for ($i = 0; $i < count($keys); $i++) {
    print "keys[$i]=$keys[$i]\n";
}
// lista de los valores del diccionario
$values = array_values($spouses);
for ($i = 0; $i < count($values); $i++) {
    print "values[$i]=$values[$i]\n";
}
// ¿un arreglo clásico es una lista? ¿y un diccionario?
print "values is a list: " . var_export(array_is_list($values), true) . "\n";
print "spouses is a list: " . var_export(array_is_list($spouses), true) . "\n";
// búsqueda de una clave
exists($spouses, "Jacques");
exists($spouses, "Lucette");
exists($spouses, "Jean");
// valor por defecto si la clave no existe: operador ??
print "spouse of Lucette: " . ($spouses["Lucette"] ?? "unknown") . "\n";
// eliminar un par clave-valor
unset($spouses["Jean"]);
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// fin
exit;

function exists(array $spouses, string $husband): void
{
    // verifica si la clave $husband existe en el diccionario $spouses
    if (isset($spouses[$husband])) {
        print "The key [$husband] exists, associated with the value [$spouses[$husband]]\n";
    } else {
        print "The key [$husband] does not exist\n";
    }
}

Los resultados:

> php basics-06.php
Number of elements in the dictionary: 4
spouses[Pierre]=Gisèle
spouses[Paul]=Virginie
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle
keys[0]=Jacques
keys[1]=Jean
keys[2]=Paul
keys[3]=Pierre
values[0]=Lucette
values[1]=
values[2]=Virginie
values[3]=Gisèle
values is a list: true
spouses is a list: false
The key [Jacques] exists, associated with the value [Lucette]
The key [Lucette] does not exist
The key [Jean] exists, associated with the value []
spouse of Lucette: unknown
Number of elements in the dictionary: 3
spouses[Jacques]=Lucette
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle

Comentarios:

El código anterior aplica a un diccionario lo que vimos antes para un arreglo simple. Solo comentaremos las novedades:

  • línea 13: la función [ksort] (key sort) ordena un diccionario según el orden natural de las claves;
  • línea 19: la función [array_keys($dictionary)] devuelve la lista de las claves del diccionario como un arreglo;
  • línea 24: la función [array_values($dictionary)] devuelve la lista de los valores del diccionario como un arreglo;
  • línea 29: la función [array_is_list] (PHP 8.1) devuelve [true] si las claves del arreglo son 0, 1, 2… en ese orden, es decir, si el arreglo es una lista. La función [var_export] devuelve la representación en PHP de un valor (“true” o “false”);
  • línea 46: la función [exists] recibe un arreglo ([array]) y una cadena ([string]);
  • línea 49: la función [isset($variable)] devuelve [true] si la variable [$variable] existe y no tiene el valor [null]; de lo contrario, devuelve [false]. Aplicada a un elemento de un arreglo, determina si existe una clave. La función [array_key_exists($key, $array)] hace lo mismo, pero devuelve [true] incluso si el valor asociado a la clave es [null];
  • línea 36: el operador [??] (“fusión de nulos”) devuelve su operando izquierdo si existe y no es [null], y su operando derecho en caso contrario. Es una forma concisa de obtener un valor predeterminado para una clave inexistente, sin una advertencia;
  • línea 38: la función [unset($variable)] elimina la variable [$variable], que aquí es un elemento del diccionario.

3.6.3. Arreglos multidimensionales

El script [basics-07.php] es el siguiente:

<?php

declare(strict_types=1);

// arreglos multidimensionales clásicos
// inicialización
$multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]];
// recorrido
for ($i1 = 0; $i1 < count($multi); $i1++) {
    for ($i2 = 0; $i2 < count($multi[$i1]); $i2++) {
        print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
    }
}
// diccionarios multidimensionales
// inicialización
$multi = ["zero" => [0, 1, 2], "one" => [10, 11, 12, 13], "two" => [20, 21, 22, 23, 24]];
// recorrido
foreach ($multi as $key => $value) {
    for ($i2 = 0; $i2 < count($value); $i2++) {
        print "multi[$key][$i2]={$multi[$key][$i2]}\n";
    }
}

Resultados:

> php basics-07.php
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zero][0]=0
multi[zero][1]=1
multi[zero][2]=2
multi[one][0]=10
multi[one][1]=11
multi[one][2]=12
multi[one][3]=13
multi[two][0]=20
multi[two][1]=21
multi[two][2]=22
multi[two][3]=23
multi[two][4]=24

Comentarios:

  • línea 7: los elementos del arreglo [$multi] son a su vez arreglos;
  • línea 11: dentro de una cadena delimitada por comillas, la interpolación simple de [$multi[$i1][$i2]] no funciona: PHP evaluaría solamente [$multi[$i1]]. Por eso sacamos la expresión de la cadena y usamos la concatenación;
  • línea 16: el arreglo [$multi] se convierte en un diccionario (clave, valor) en el que cada valor es un arreglo;
  • línea 20: otra solución: dentro de una cadena delimitada por comillas, la notación [{$expression}] permite evaluar una expresión compleja. Volveremos sobre esto en la próxima sección.

3.7. Cadenas

3.7.1. Notación

El script [basics-08.php] es el siguiente:

<?php

declare(strict_types=1);

// notación de cadenas
$string1 = "one";
$string2 = 'one';
print "[$string1,$string2]\n";
// entre comillas simples, las variables no se evalúan
print '[$string1,$string2]' . "\n";
// la notación {$...} delimita la expresión a evaluar
$person = ["name" => "dupont", "age" => 34];
print "{$person['name']} is {$person['age']} years old\n";
// una cadena de varias líneas (heredoc)
$text = <<<END
    name: $string1
    age: {$person['age']}
    END;
print "$text\n";

Resultados:

1
2
3
4
5
6
> php basics-08.php
[one,one]
[$string1,$string2]
dupont is 34 years old
name: one
age: 34

Comentarios:

  • Líneas 6 y 7: una cadena puede delimitarse con comillas dobles o con comillas simples;
  • línea 8: cuando se delimita con comillas dobles, las variables se evalúan;
  • línea 10: entre comillas simples no se evalúan: la cadena se muestra tal cual. De manera similar, [\n] no representa aquí un salto de línea, de ahí la concatenación de ["\n"];
  • línea 13: la notación [{$...}] permite evaluar dentro de una cadena expresiones más complejas que una simple variable, en este caso, elementos de un diccionario. La notación [${variable}] de las versiones antiguas de PHP es obsoleta desde PHP 8.2: no debe usarse;
  • líneas 15 a 18: la sintaxis [heredoc] permite que una cadena abarque varias líneas. La cadena comienza después de [<<<END] y termina con el marcador [END] (el nombre es arbitrario). Las variables que contiene se evalúan como si estuvieran entre comillas dobles. A partir de PHP 7.3, el marcador de cierre puede estar sangrado: esa sangría se elimina entonces de todas las líneas de la cadena.

3.7.2. Comparación

El script [basics-09.php] es el siguiente:

<?php

// respeto estricto del tipo de los parámetros de las funciones
declare(strict_types=1);

// función de comparación
function compareStrings(string $string1, string $string2): void
{
    // compara string1 y string2
    if ($string1 === $string2) {
        print "[$string1] is equal to [$string2]\n";
    } else {
        print "[$string1] is different from [$string2]\n";
    }
}

// pruebas de comparación de cadenas
compareStrings("abcd", "abcd");
compareStrings("", "");
compareStrings("1", "");

// búsqueda de una subcadena (PHP 8)
$file = "taxpayersdata.txt";
print "[$file] contains [data]: " . var_export(str_contains($file, "data"), true) . "\n";
print "[$file] starts with [tax]: " . var_export(str_starts_with($file, "tax"), true) . "\n";
print "[$file] ends with [.json]: " . var_export(str_ends_with($file, ".json"), true) . "\n";
// posición de una subcadena
print "position of [data] in [$file]: " . strpos($file, "data") . "\n";
// longitud, mayúsculas
print "length of [$file]: " . strlen($file) . ", in uppercase: " . strtoupper($file) . "\n";
// cuidado: strlen cuenta bytes, mb_strlen cuenta caracteres
print "strlen(\"café\")=" . strlen("café") . ", mb_strlen(\"café\")=" . mb_strlen("café") . "\n";

Resultados:

> php basics-09.php
[abcd] is equal to [abcd]
[] is equal to []
[1] is different from []
[taxpayersdata.txt] contains [data]: true
[taxpayersdata.txt] starts with [tax]: true
[taxpayersdata.txt] ends with [.json]: false
position of [data] in [taxpayersdata.txt]: 9
length of [taxpayersdata.txt]: 17, in uppercase: TAXPAYERSDATA.TXT
strlen("café")=5, mb_strlen("café")=4

Comentarios:

  • línea 10: podríamos haber usado el comparador [] en lugar de [=]. Este último operador es más restrictivo, ya que exige que ambos operandos sean del mismo tipo. Observe que aquí podría haberse reemplazado por el operador [] dado que el tipo de ambos parámetros está fijado como [string]* en la firma de la función. Sin embargo, seguiremos usando *[=];
  • línea 24: la función [str_contains($string, $substring)] (PHP 8.0) devuelve [true] si [$substring] está presente en [$string];
  • línea 25: la función [str_starts_with] (PHP 8.0) verifica el comienzo de una cadena;
  • línea 26: la función [str_ends_with] (PHP 8.0) verifica el final de una cadena;
  • línea 28: la función [strpos($string, $substring)] devuelve la posición de [$substring] en [$string], donde el primer carácter tiene la posición 0, y [false] si la subcadena no está presente. Antes de PHP 8, la presencia de una subcadena se verificaba con [strpos(...) !== false], una notación engañosa, ya que la posición 0 se convierte en [false]: [str_contains] es mucho más legible;
  • línea 30: la función [strlen] devuelve la longitud de una cadena, y [strtoupper] la convierte a mayúsculas;
  • línea 32: [strlen] cuenta bytes, no caracteres. Los archivos del curso están codificados en UTF-8, donde un carácter con tilde ocupa dos bytes: “café” tiene 4 caracteres pero 5 bytes. Las funciones de la extensión [mbstring] (mb_strlen, mb_substr, mb_strtoupper…) operan sobre caracteres.

3.7.3. Relaciones entre cadenas y arreglos

El script [basics-10.php] es el siguiente:

<?php

declare(strict_types=1);

// de cadena a arreglo
$string = "1:2:3:4";
$tab = explode(":", $string);
// recorrido del arreglo
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
}
// de arreglo a cadena
$string2 = implode(":", $tab);
print "string2=$string2\n";
// agreguemos un campo vacío
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// recorrido del arreglo
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // ahora tenemos 5 elementos, el último vacío
// agreguemos de nuevo un campo vacío
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// recorrido del arreglo
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // ahora tenemos 6 elementos, los dos últimos vacíos

Resultados:

> php basics-10.php
tab has 4 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
string2=1:2:3:4
string=1:2:3:4:
tab has 5 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
string=1:2:3:4::
tab has 6 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

Comentarios:

  • línea 7: la función [explode($separator, $string)] obtiene los campos de [$string] separados por [$separator]. Así, [explode(":", $string)] obtiene los elementos de [$string]—que están separados por la cadena ":"—en forma de arreglo;
  • línea 14: la función [implode($separator, $array)] realiza la operación inversa de la función [explode]. Devuelve una cadena formada por los elementos de [$array] separados por [$separator];
  • línea 17: el operador [.=] agrega una cadena al final de otra. Los resultados muestran que un campo vacío al final de una cadena produce un elemento vacío en el arreglo devuelto por [explode].

3.7.4. Expresiones regulares

El script [basics-11.php] es el siguiente:

<?php

// tipo estricto para los parámetros de las funciones
declare(strict_types=1);

// expresiones regulares en php
// recuperar los diferentes campos de una cadena
// el patrón: una secuencia de dígitos rodeada de cualquier carácter
// solo queremos recuperar la secuencia de dígitos
$pattern = "/(\d+)/";
// comparamos la cadena con el patrón
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// el patrón: una secuencia de dígitos rodeada de cualquier carácter
// queremos la secuencia de dígitos así como los campos que la siguen y la preceden
$pattern = "/^(.*?)(\d+)(.*?)$/";
// comparamos la cadena con el patrón
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// el patrón - una fecha en formato dd/mm/aa
$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
comparePattern2String($pattern, "10/05/97");
comparePattern2String($pattern, "  04/04/01  ");
comparePattern2String($pattern, "5/1/01");

// el patrón - un número decimal
$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
comparePattern2String($pattern, "187.8");
comparePattern2String($pattern, "-0.6");
comparePattern2String($pattern, "4");
comparePattern2String($pattern, ".6");
comparePattern2String($pattern, "4.");
comparePattern2String($pattern, " + 4");

// fin
exit;

// --------------------------------------------------------------------------
function comparePattern2String(string $pattern, string $string): void
{
    // compara la cadena $string con el patrón $pattern
    // comparamos la cadena con el patrón
    $fields = [];
    $matches = preg_match($pattern, $string, $fields);
    // mostrar los resultados
    print "\nResults($pattern,$string)\n";
    if ($matches === 1) {
        for ($i = 0; $i < count($fields); $i++) {
            print "fields[$i]=$fields[$i]\n";
        }
    } else {
        print "The string [$string] does not match the pattern [$pattern]\n";
    }
}

Resultados:

> php basics-11.php

Results(/(\d+)/,xyz1234abcd)
fields[0]=1234
fields[1]=1234

Results(/(\d+)/,12 34)
fields[0]=12
fields[1]=12

Results(/(\d+)/,abcd)
The string [abcd] does not match the pattern [/(\d+)/]

Results(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
fields[0]=xyz1234abcd
fields[1]=xyz
fields[2]=1234
fields[3]=abcd

Results(/^(.*?)(\d+)(.*?)$/,12 34)
fields[0]=12 34
fields[1]=
fields[2]=12
fields[3]= 34

Results(/^(.*?)(\d+)(.*?)$/,abcd)
The string [abcd] does not match the pattern [/^(.*?)(\d+)(.*?)$/]

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
fields[0]=10/05/97
fields[1]=10
fields[2]=05
fields[3]=97

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
fields[0]=  04/04/01
fields[1]=04
fields[2]=04
fields[3]=01

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
The string [5/1/01] does not match the pattern [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
fields[0]=187.8
fields[1]=
fields[2]=187.8

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
fields[0]=-0.6
fields[1]=-
fields[2]=0.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
fields[0]=4
fields[1]=
fields[2]=4

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
fields[0]=.6
fields[1]=
fields[2]=.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
fields[0]=4.
fields[1]=
fields[2]=4.

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
fields[0]= + 4
fields[1]=+
fields[2]=4

Comentarios:

Aquí usamos expresiones regulares para extraer los distintos campos de una cadena. Las expresiones regulares permiten superar las limitaciones de la función [explode]. El principio consiste en comparar una cadena con otra cadena llamada patrón mediante la función [preg_match]: [$matches = preg_match($pattern, $string, $fields)] (línea 48). La función [preg_match] devuelve el entero 1 si el patrón se encuentra en la cadena, y 0 en caso contrario. Si se encuentra, [$fields[0]] representa la subcadena que corresponde al patrón. Además, si el patrón contiene subpatrones entre paréntesis, [$fields[1]] es la parte de [$string] que corresponde al primer subpatrón, [$fields[2]] es la parte de [$string] que corresponde al segundo subpatrón, y así sucesivamente. Volvamos al script:

  • línea 10: el patrón corresponde a una secuencia de uno o más (+) dígitos (\d) que aparece en cualquier lugar de una cadena. Además, el patrón define un subpatrón entre paréntesis;
  • línea 12: el patrón /(\d+)/ se compara con la cadena "xyz1234abcd". Vemos que la subcadena 1234 corresponde al patrón. Por lo tanto, [$fields[0]] es igual a "1234". Además, el patrón tiene un subpatrón entre paréntesis. Obtendremos [$fields[1]="1234"];
  • línea 13: el patrón /(\d+)/ se compara con la cadena "12 34". Vemos que las subcadenas 12 y 34 corresponden al patrón. La comparación se detiene en la primera subcadena que corresponde al patrón. Por lo tanto, tendremos [$fields[0]=12] y [$fields[1]=12];
  • línea 14: el patrón /(\d+)/ se compara con la cadena "abcd". No se encuentra ninguna coincidencia;
  • línea 51: [preg_match] devuelve un entero (y [false] si hay un error en el patrón): se compara estrictamente con 1.

Expliquemos los patrones utilizados en el resto del código:

$pattern = "/^(.*?)(\d+)(.*?)$/";

corresponde al inicio de la cadena (^), seguido de cero o más (*) caracteres arbitrarios (.), seguido de uno o más (+) dígitos, seguido de cero o más (*) caracteres arbitrarios (.). El patrón (.*) corresponde a cero o más caracteres cualesquiera. Un patrón así coincidirá con cualquier cadena. Así, en el patrón /^(.*)(\d+)(.*)$/, el primer subpatrón (.*) correspondería a todos los dígitos excepto el último, que es el único que queda para el subpatrón (\d+). El patrón (.*?)(\d+) corresponde a 0 o más caracteres cualesquiera hasta el siguiente subpatrón (?), que en este caso es \d+. Por lo tanto, los dígitos ya no son capturados por el patrón (.*). El patrón anterior corresponde así a [inicio de la cadena (^), una secuencia de caracteres cualesquiera (.*?), una secuencia de uno o más dígitos (\d+), una secuencia de caracteres cualesquiera (.*?), el final de la cadena ($)].

$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

corresponde a [inicio de la cadena (^), una secuencia de 0 o más espacios (\s*), 2 dígitos (\d\d), el carácter / (\/), 2 dígitos, /, 2 dígitos, una secuencia de 0 o más espacios (\s*), el final de la cadena ($)].

$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";

corresponde a [inicio de la cadena (^), 0 o más espacios (\s*), un signo + o - ([+-]) presente 0 o 1 vez (?), una secuencia de 0 o más espacios (\s*), 1 o más dígitos seguidos de un punto decimal seguido de cero o más dígitos (\d+\.\d*) o (|) un punto decimal (\.) seguido de uno o más dígitos (\d+) o (|) uno o más dígitos (\d+), una secuencia de 0 o más espacios (\s*)]. El curso de PHP 7 lo escribía como [+|-]: entre corchetes, el carácter | no tiene ningún significado especial, y este patrón también aceptaba el símbolo | antes de un número. [+-] es la notación correcta.

Nota: el término [space] en las expresiones regulares designa un conjunto de caracteres: espacio en blanco, salto de línea \n, tabulación \t, retorno de carro \r, avance de página \f…

3.8. Funciones

3.8.1. Modo de paso de parámetros

El script [basics-12.php] es el siguiente:

<?php

// cómo se pasan los parámetros a una función
// respeto estricto de los tipos de los parámetros
declare(strict_types=1);

function f(int &$i, int $j): void
{
    // $i se obtendrá por referencia
    // $j se obtendrá por valor
    $i++;
    $j++;
    print "f[i,j]=[$i,$j]\n";
}

// pruebas
$i = 0;
$j = 0;
// $i y $j se pasan a la función f
f($i, $j);
print "test[i,j]=[$i,$j]\n";

Resultados:

1
2
3
> php basics-12.php
f[i,j]=[1,1]
test[i,j]=[1,0]

Comentarios:

El código anterior muestra las dos formas de pasar parámetros a una función. Consideremos el siguiente ejemplo:

1
2
3
4
5
6
7
8
9
function f(int &$a, int $b): void
{
    …
}

// programa principal
$i = 10;
$j = 20;
f($i, $j);
  • línea 1: define los parámetros formales [$a] y [$b] de la función [f]. Esta función procesa estos dos parámetros formales;
  • línea 9: llama a la función [f] con dos parámetros reales, [$i] y [$j]. Las relaciones entre los parámetros formales ([$a], [$b]) y los parámetros reales ([$i], [$j]) quedan definidas por las líneas 1 y 9:
    • [&$a]: el símbolo & indica que el parámetro formal [$a] tomará el valor de la dirección del parámetro real [$i]. En otras palabras, [$a] y [$i] son dos referencias a la misma ubicación de memoria. Manipular el parámetro formal [$a] equivale a manipular el parámetro real [$i]. Esto lo demuestra la ejecución del código. Este modo de paso es adecuado para los parámetros de salida. Se denomina “paso por referencia”;
    • [$b]: el parámetro formal [$b] tomará el valor del parámetro real [$j]. Es el paso por valor. Los parámetros formal y real son dos variables distintas. Manipular el parámetro formal [$b] no tiene ningún efecto sobre el parámetro real [$j]. Esto lo demuestra la ejecución del código. Este modo de paso es adecuado para los parámetros de entrada.

Consideremos la función [swap], que acepta dos parámetros formales: [$a] y [$b]. La función intercambia los valores de estos dos parámetros. Así, al llamar a [swap($i, $j)], el código que realiza la llamada espera que los valores de los dos parámetros reales se intercambien. Se trata, por lo tanto, de parámetros de salida (se modifican). Escribiremos entonces:

1
2
3
4
function swap(mixed &$a, mixed &$b): void
{
    [$a, $b] = [$b, $a];
}

Nota: podría pensarse que el paso por referencia también es adecuado para grandes conjuntos de datos, arreglos y diccionarios, para evitar copiarlos. Esto es innecesario: en realidad, PHP copia un arreglo pasado por valor solo si la función lo modifica. Por lo tanto, el paso por referencia debe reservarse para los parámetros de salida.

El siguiente script, [basics-13.php], muestra ejemplos adicionales:

<?php

// cómo se pasan los parámetros
// sin declare(strict_types=1) en este script: estamos en modo "coercitivo"

function f(&$i, $j)
{
    // $i se obtendrá por referencia
    // $j se obtendrá por valor
    $i++;
    $j++;
    print "f[i,j]=[$i,$j]\n";
}

function g(int &$i, int $j): void
{
    // $i se obtendrá por referencia
    // $j se obtendrá por valor
    $i++;
    $j++;
    print "g[i,j]=[$i,$j]\n";
}

// pruebas
$i = 0;
$j = 0;
// $i y $j se pasan a la función f
f($i, $j);
print "test[i,j]=[$i,$j]\n";
// $i y $j se pasan a la función g
g($i, $j);
print "test[i,j]=[$i,$j]\n";
// pasamos parámetros float a f
$a = 5.0;
$b = 6.2;
f($a, $b);
print "test[a,b]=[$a,$b]\n";
// pasamos parámetros float a g
$a = 5.0;
$b = 6.0;
g($a, $b);
print "test[a,b]=[$a,$b]\n";

Comentarios:

  • línea 4: a diferencia de todos los demás scripts de este curso, este script no incluye la instrucción [declare(strict_types=1)]: PHP funciona en modo “coercitivo”;
  • líneas 6 a 13: la función [f] tratada en el párrafo anterior, pero con los parámetros sin tipo;
  • líneas 15 a 22: la función [g] hace lo mismo que la función [f], pero se especifican los tipos de los parámetros esperados. Espera dos parámetros de tipo [int]. Queremos ver qué ocurre cuando el parámetro real que se pasa a la función no tiene el tipo que esta espera;
  • líneas 25 y 26: [$i] y [$j] son dos enteros;
  • línea 28: llamada a la función [f] con parámetros del tipo esperado;
  • línea 31: llamada a la función [g] con parámetros del tipo esperado;
  • líneas 34 y 35: las variables [$a] y [$b] son de tipo [float];
  • línea 36: llamada a la función [f] con parámetros de tipo [float];
  • líneas 39 a 41: llamada a la función [g] con parámetros de tipo [float], que no es el tipo esperado.

Resultados:

1
2
3
4
5
6
7
8
9
> php basics-13.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]
g[i,j]=[6,7]
test[a,b]=[6,6]
  • La función [f], cuyos parámetros no tienen tipo, aceptó los dos parámetros de tipo [float] y los procesó de la siguiente manera: [$i] es 6.0 (se muestra como 6), y [$j] es 7.2;
  • la función [g] aceptó ambos parámetros de tipo [float] pero los convirtió al tipo [int]. Esto se puede ver en la variable [$a], pasada por referencia, que pasó a ser el entero 6.

Los números de punto flotante 5.0 y 6.0 no tienen parte decimal: convertirlos en enteros no produce ninguna pérdida de información. ¿Qué ocurriría con el número de punto flotante 5.3? En PHP 7 se convertía silenciosamente en el entero 5. Desde PHP 8.1, esta conversión, que pierde información, está marcada como obsoleta (deprecated): se convertirá en un error en una versión futura de PHP.

Ahora hagamos lo mismo en modo estricto. El script [basics-13b.php] es idéntico al script [basics-13.php] salvo que comienza con la instrucción:

declare(strict_types=1);

Esta instrucción especifica que se deben respetar los tipos de los parámetros formales. Si no se respetan, se informa un error. Los resultados de la ejecución son entonces:

> php basics-13b.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]

Fatal error: Uncaught TypeError: g(): Argument #1 ($i) must be of type int, float given, called in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 42 and defined in .../php8-oct-2026/scripts-console/basics/basics-13b.php:16
Stack trace:
#0 .../php8-oct-2026/scripts-console/basics/basics-13b.php(42): g(5.0, 6.0)
#1 {main}
  thrown in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 16

El intérprete de PHP lanzó un error [TypeError] para indicar que el primer parámetro pasado a la función [g] era de un tipo incorrecto: g(): Argument #1 ($i) must be of type int; float was provided. El mensaje indica el número de línea de la llamada errónea (42) y el de la definición de la función (16). Como este error no se captura (no hay [try / catch]), el script termina. Se recomienda ser estricto con los tipos de los parámetros siempre que sea posible para detectar errores en las llamadas a funciones: por eso todos los scripts del curso comienzan con [declare(strict_types=1)].

3.8.2. Parámetros de las funciones en PHP 8

PHP 8 ha mejorado considerablemente la declaración y la llamada de funciones. El script [basics-14.php] muestra estas novedades:

<?php

// parámetros de funciones en PHP 8
declare(strict_types=1);

// 1 - parámetros con valor por defecto
function greeting(string $name, string $phrase = "Hello", bool $uppercase = false): string
{
    $message = "$phrase $name";
    return $uppercase ? strtoupper($message) : $message;
}

print greeting("Pierre") . "\n";
print greeting("Pierre", "Good evening") . "\n";
// 2 - argumentos con nombre (PHP 8.0): se puede omitir un parámetro y darlos en cualquier orden
print greeting("Pierre", uppercase: true) . "\n";
print greeting(uppercase: true, phrase: "Hi", name: "Paul") . "\n";
// las funciones predefinidas también aceptan argumentos con nombre
print str_pad(string: "7", length: 3, pad_string: "0", pad_type: STR_PAD_LEFT) . "\n";

// 3 - tipo unión (PHP 8.0): el parámetro puede ser de uno de los tipos listados
function double(int|float $number): int|float
{
    return 2 * $number;
}

var_dump(double(4));
var_dump(double(4.5));

// 4 - tipo anulable: ?string equivale a string|null
function length(?string $string): int
{
    // el operador ?? devuelve su operando derecho si el operando izquierdo es null
    return strlen($string ?? "");
}

print "length(\"abc\")=" . length("abc") . ", length(null)=" . length(null) . "\n";

// 5 - tipo mixed (PHP 8.0) y expresión match (PHP 8.0)
function describe(mixed $value): string
{
    // match compara con === y devuelve un valor
    return match (true) {
        is_int($value), is_float($value) => "the number $value",
        is_string($value) => "the string [$value]",
        is_bool($value) => "the boolean " . ($value ? "true" : "false"),
        is_array($value) => "an array of " . count($value) . " element(s)",
        default => "a value of type " . get_debug_type($value),
    };
}

foreach ([12, 3.5, "abc", false, [1, 2], null] as $value) {
    print describe($value) . "\n";
}

// match sobre un valor
$children = 3;
$shares = match ($children) {
    0 => 0.0,
    1, 2 => $children * 0.5,
    default => 1 + ($children - 2) * 1.0,
};
print "$children child(ren) bring $shares share(s)\n";

// 6 - número variable de parámetros (variádicos) y el operador ... (spread)
function sum(int|float ...$numbers): int|float
{
    // $numbers es un arreglo
    return array_sum($numbers);
}

print "sum()=" . sum() . "\n";
print "sum(1, 2, 3)=" . sum(1, 2, 3) . "\n";
$values = [10, 20, 30.5];
// el arreglo se "expande" en parámetros reales
print "sum(...\$values)=" . sum(...$values) . "\n";
// el operador ... también permite fusionar arreglos
$all = [0, ...$values, 40];
print "all=[" . implode(",", $all) . "]\n";

Resultados:

> php basics-14.php
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
007
int(8)
float(9)
length("abc")=3, length(null)=0
the number 12
the number 3.5
the string [abc]
the boolean false
an array of 2 element(s)
a value of type null
3 child(ren) bring 2 share(s)
sum()=0
sum(1, 2, 3)=6
sum(...$values)=60.5
all=[0,10,20,30.5,40]

Comentarios:

  • línea 7: los parámetros [$phrase] y [$uppercase] tienen valores predeterminados. Se pueden omitir al llamar a la función (línea 13), en cuyo caso toman sus valores predeterminados;
  • línea 10: el operador ternario [condition ? value1 : value2] devuelve [value1] si la condición es verdadera, y [value2] en caso contrario;
  • línea 16: argumentos con nombre (PHP 8.0). El parámetro real va precedido del nombre del parámetro formal seguido de dos puntos (:). Esto permite asignar un valor al tercer parámetro sin especificar el segundo, que conserva su valor predeterminado;
  • línea 17: con los argumentos con nombre, el orden de los parámetros ya no importa. Esto mejora la legibilidad del código: [uppercase: true] es más descriptivo que un [true] aislado;
  • línea 19: las funciones predefinidas de PHP también aceptan argumentos con nombre. Sus nombres son los indicados en la documentación de php.net;
  • línea 22: el tipo unión [int|float] (PHP 8.0) indica que el parámetro puede ser un [int] o un [float]. Lo mismo se aplica al resultado;
  • línea 31: el tipo [?string] es un tipo que admite nulos (nullable): el parámetro es una cadena o el valor [null]. Es una notación abreviada de [string|null]. Nota: en PHP 7 se solía escribir [string $string = null] para obtener el mismo efecto. Esta notación (“nullable implícito”) está obsoleta desde PHP 8.4: se debe escribir [?string $string = null];
  • línea 34: el operador [??], que ya hemos visto: si [$string] es igual a [null], se utiliza la cadena vacía. De hecho, desde PHP 8.1, pasar [null] a un parámetro que no admite nulos de una función predefinida, como [strlen(null)] aquí, está obsoleto;
  • línea 40: el parámetro de tipo [mixed] acepta cualquier valor, incluido [null];
  • líneas 43–49: la expresión [match] (PHP 8.0). Compara el valor entre paréntesis con los valores a la izquierda de las flechas => y devuelve el valor a la derecha de la primera flecha para la cual la comparación es verdadera. Con [match (true)], las condiciones se escriben a la izquierda: la primera condición verdadera tiene prioridad. Se pueden separar varios valores con comas (línea 44). [default] cubre todos los demás casos;
  • línea 48: la función [get_debug_type] (PHP 8.0) devuelve el nombre del tipo de un valor tal como se escribe en el código: int, float, string, null o el nombre de clase de un objeto. [gettype], en cambio, devolvía nombres históricos como integer o double;
  • líneas 58–62: [match] aplicado a un valor. Aquí, la variable [$children] se compara con los valores 0, luego 1 y luego 2; en caso contrario, se aplica el caso [default]. A diferencia de la instrucción [switch], a la que [match] reemplaza en la práctica, la comparación se realiza con [===], [match] es una expresión que devuelve un valor y no hay que preocuparse por la instrucción [break]. Si ninguna rama es adecuada y no hay *[default]*, *[match] lanza un error *[UnhandledMatchError] ;
  • línea 66: [int|float ...$numbers] es un parámetro variádico: la función acepta cualquier cantidad de parámetros reales (incluso ninguno), que PHP reúne en el arreglo [$numbers]. Un parámetro variádico es siempre el último;
  • línea 76: el operador [...] (spread) colocado antes de un arreglo en una llamada “despliega” el arreglo: sus elementos se convierten en los parámetros reales de la función. [sum(...$values)] equivale a [sum(10, 20, 30.5)];
  • línea 78: el mismo operador permite insertar los elementos de un arreglo en otro arreglo.

3.8.3. Resultados devueltos por una función

El script [basics-15.php] es el siguiente:

<?php

// tipos en modo estricto
declare(strict_types=1);

// resultados devueltos por una función
// una función puede devolver varios valores en un arreglo
[$res1, $res2, $res3] = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++) {
    print "f1: res[$i]=$res[$i]\n";
}
// un arreglo asociativo también puede "desestructurarse"
["min" => $min, "max" => $max] = minMax([4, -2, 17, 8]);
print "minMax: [min=$min,max=$max]\n";

// una función puede devolver un objeto
$res = f2(10);
print "f2: [$res->res1,$res->res2,$res->res3]\n";
// ¿qué tipo de objeto?
print "kind of object: ";
var_dump($res);

// hacemos lo mismo con la función f3
$res = f3(10);
print "f3: [$res->res1,$res->res2,$res->res3]\n";
// ¿qué tipo de objeto?
print "kind of object: ";
var_dump($res);

// una función puede devolver un objeto o null
$res = f4(10);
// el operador nullsafe ?-> devuelve null en lugar de provocar un error si $res es null
print "f4(10): res1=" . ($res?->res1 ?? "none") . "\n";
$res = f4(-10);
print "f4(-10): res1=" . ($res?->res1 ?? "none") . "\n";

// fin
exit;

// función f1
function f1(int $value): array
{
    // devuelve un arreglo ($value+1,$value+2,$value+3)
    return [$value + 1, $value + 2, $value + 3];
}

// función minMax
function minMax(array $numbers): array
{
    // devuelve un arreglo asociativo
    return ["min" => min($numbers), "max" => max($numbers)];
}

// función f2
function f2(int $value): object
{
    // devuelve un objeto ($value+1,$value+2,$value+3)
    // obtenido transformando un arreglo asociativo en objeto
    return (object) ["res1" => $value + 1, "res2" => $value + 2, "res3" => $value + 3];
}

// función f3 - hace lo mismo que la función f2
function f3(int $value): object
{
    // devuelve un objeto ($value+1,$value+2,$value+3)
    $res = new stdClass();
    $res->res1 = $value + 1;
    $res->res2 = $value + 2;
    $res->res3 = $value + 3;
    // devuelve el objeto
    return $res;
}

// función f4 - devuelve un objeto si $value es positivo, null en caso contrario
function f4(int $value): ?object
{
    return $value >= 0 ? f3($value) : null;
}

Resultados:

> php basics-15.php
[11,12,13]
f1: res[0]=11
f1: res[1]=12
f1: res[2]=13
minMax: [min=-2,max=17]
f2: [11,12,13]
kind of object: object(stdClass)#1 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f3: [11,12,13]
kind of object: object(stdClass)#2 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f4(10): res1=11
f4(-10): res1=none

Comentarios:

  • El programa anterior muestra que una función de PHP puede devolver un conjunto de resultados en lugar de uno solo, en forma de arreglo o de objeto. El concepto de objeto se explica en un capítulo posterior;
  • líneas 43–47: la función [f1] devuelve varios valores en forma de arreglo ([array]);
  • línea 8: el arreglo devuelto se desempaqueta en tres variables;
  • línea 15: la desestructuración también funciona con un arreglo asociativo: para cada variable se especifica la clave del valor que se debe recuperar. La función [minMax] devuelve un diccionario (línea 53). Las funciones predefinidas [min] y [max] devuelven el menor y el mayor elemento de un arreglo;
  • líneas 57–62: la función [f2] devuelve varios valores en forma de objeto ([object]). Lo hace convirtiendo un arreglo asociativo en un objeto mediante el operador [(object)]: cada clave del arreglo se convierte en una propiedad del objeto;
  • líneas 65–74: la función [f3] hace lo mismo que la función [f2], pero crea explícitamente un objeto de tipo [stdClass] (línea 68) y luego le agrega propiedades. El atributo A de un objeto O se denota [$O->A];
  • línea 23: la función [var_dump] da acceso al tipo del objeto y a su contenido. En los resultados vemos que el objeto es de tipo [stdClass], que su propiedad [res1] es de tipo entero y tiene el valor 11, etc. El número #1 o #2 que sigue al tipo es un número interno del objeto;
  • línea 77: el tipo de resultado [?object] indica que la función [f4] devuelve un objeto o [null];
  • líneas 35–37: el operador null-safe [?->] (PHP 8.0). Si [$res] es igual a [null], la expresión [$res?->res1] es igual a [null] en lugar de causar un error; el operador [??] reemplaza entonces [null] por “ninguno”. Aquí, el operador [??] bastaría por sí solo, ya que no señala la ausencia de la propiedad. El operador [?->] resultará especialmente útil con los objetos y sus métodos: [$client?->getAddress()?->getCity()].

Nota: el curso de PHP 7 incluía una función que escribía [$res->res1 = ...] sin haber creado el objeto [$res]. PHP 7 creaba entonces un objeto [stdClass] de forma predeterminada con una simple advertencia. A partir de PHP 8.0, esto es un error fatal (Attempt to assign property on null): siempre se debe crear un objeto antes de utilizarlo.

3.8.4. Las funciones también son valores

En PHP, una función se puede almacenar en una variable, pasar como parámetro a otra función o devolver como resultado. El script [basics-17.php] muestra las diferentes formas de escribir y utilizar estas funciones:

<?php

// las funciones también son valores
declare(strict_types=1);

$numbers = [4, -2, 17, 8, -5];

// 1 - una función anónima asignada a una variable
$square = function (int $x): int {
    return $x * $x;
};
print "square(5)=" . $square(5) . "\n";

// 2 - una función anónima pasada como parámetro a una función predefinida
// array_map aplica la función a cada elemento del arreglo
$squares = array_map($square, $numbers);
print "squares=[" . implode(",", $squares) . "]\n";

// 3 - una función anónima que usa una variable externa: la palabra clave use
$threshold = 5;
$large = array_filter($numbers, function (int $x) use ($threshold): bool {
    return $x > $threshold;
});
print "numbers > $threshold: [" . implode(",", $large) . "]\n";

// 4 - la función flecha (PHP 7.4): una sola expresión, variables externas capturadas automáticamente
$positives = array_filter($numbers, fn(int $x): bool => $x >= 0);
print "positives=[" . implode(",", $positives) . "]\n";
// ordenar con una función de comparación: el operador <=> devuelve -1, 0 o 1
$sorted = $numbers;
usort($sorted, fn(int $a, int $b): int => $b <=> $a);
print "descending sort=[" . implode(",", $sorted) . "]\n";

// 5 - búsqueda en un arreglo (PHP 8.4)
print "first negative: " . array_find($numbers, fn(int $x): bool => $x < 0) . "\n";
print "at least one > 10: " . var_export(array_any($numbers, fn(int $x): bool => $x > 10), true) . "\n";
print "all > -10: " . var_export(array_all($numbers, fn(int $x): bool => $x > -10), true) . "\n";

// 6 - la sintaxis de callable de primera clase (PHP 8.1): functionName(...)
$uppercase = strtoupper(...);
print $uppercase("hello") . "\n";
$names = ["dupont", "durand", "martin"];
print "names=[" . implode(",", array_map(ucfirst(...), $names)) . "]\n";

// 7 - el operador pipe |> (PHP 8.5): el resultado de la izquierda se pasa a la función de la derecha
$result = "  Hello everybody out there  "
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s): string => str_replace(" ", "-", $s));
print "result=[$result]\n";
// equivalente sin el operador pipe
$result = str_replace(" ", "-", strtolower(trim("  Hello everybody out there  ")));
print "result=[$result]\n";

Resultados:

> php basics-17.php
square(5)=25
squares=[16,4,289,64,25]
numbers > 5: [17,8]
positives=[4,17,8]
descending sort=[17,8,4,-2,-5]
first negative: -2
at least one > 10: true
all > -10: true
HELLO
names=[Dupont,Durand,Martin]
result=[hello-everybody-out-there]
result=[hello-everybody-out-there]

Comentarios:

  • líneas 9–11: se asigna una función anónima (sin nombre) a la variable [$square]. Observe el punto y coma al final: es una asignación;
  • línea 12: la función se llama a través de la variable;
  • línea 16: la función predefinida [array_map] aplica la función pasada como primer parámetro a cada elemento del arreglo pasado como segundo parámetro y devuelve el arreglo de resultados;
  • líneas 21–23: la función predefinida [array_filter] devuelve los elementos del arreglo para los cuales la función pasada como segundo parámetro devuelve [true]. Una función anónima no conoce las variables del código circundante: la palabra clave [use ($threshold)] le da acceso a la variable [$threshold]. Observe que [array_filter] conserva las claves de los elementos seleccionados; esto no tiene efecto aquí porque [implode] utiliza solo los valores;
  • línea 27: una función flecha (PHP 7.4): [fn(parameters) => expression]. Contiene una sola expresión, cuyo valor es el resultado de la función. Tiene acceso de lectura automático a las variables del código circundante: no hace falta [use]. Es la forma más concisa de escribir funciones pequeñas que se pasan como parámetros;
  • línea 31: la función [usort] ordena un arreglo mediante una función de comparación que recibe dos elementos, [$a] y [$b], y devuelve un número negativo, cero o un número positivo, según que [$a] deba colocarse antes de, en el mismo rango que o después de [$b]. El operador [<=>] (“nave espacial”, spaceship) devuelve exactamente -1, 0 o 1. Al escribir [$b <=> $a] en lugar de [$a <=> $b], se obtiene un orden descendente. Observe que [usort] modifica el arreglo que se le pasa (paso por referencia): por lo tanto, hemos ordenado una copia ([$sorted]) del arreglo [$numbers];
  • línea 35: las funciones [array_find], [array_any] y [array_all] se introdujeron con PHP 8.4. [array_find] devuelve el primer elemento para el cual la función devuelve [true] (o [null] si no hay ninguno), [array_any] devuelve [true] si al menos un elemento cumple la condición, y [array_all] si todos la cumplen;
  • línea 40: sintaxis de callable de primera clase (PHP 8.1): [functionName(...)], con tres puntos entre los paréntesis, no llama a la función sino que devuelve la función misma como un objeto [Closure]. Luego se puede utilizar como una función anónima;
  • línea 43: la función predefinida [ucfirst] (primera letra en mayúscula) se pasa a [array_map];
  • líneas 46–49: el operador pipe [|>] (PHP 8.5). La expresión [value |> function] llama a la función con el valor como único parámetro. Las llamadas se encadenan de izquierda a derecha, en el orden en que se leen: los espacios iniciales y finales se eliminan con [trim], el texto se convierte a minúsculas con [strtolower] y luego los espacios se reemplazan por guiones. Una función flecha utilizada con [|>] debe ir entre paréntesis;
  • línea 52: lo mismo sin el operador pipe. Las funciones se anidan y se leen de adentro hacia afuera, en el orden inverso al de ejecución.

3.9. Archivos de texto

El script [basics-16.php] es el siguiente:

<?php

// respeto estricto del tipo de los parámetros de las funciones
declare(strict_types=1);

// procesamiento secuencial de un archivo de texto
// es un conjunto de líneas de la forma login:pwd:uid:gid:info:dir:shell
// cada línea se coloca en un diccionario en la forma login => [uid, gid, info, dir, shell]
// definimos el nombre del archivo
$INFO = "info.txt";
// lo abrimos para creación
$file = fopen($INFO, "w");
if ($file === false) {
    print "Error opening the file $INFO for writing\n";
    exit;
}
// generamos contenido arbitrario
for ($i = 0; $i < 100; $i++) {
    fputs($file, "login$i:pwd$i:uid$i:gid$i:info$i:dir$i:shell$i\n");
}
// cerramos el archivo
fclose($file);

// lo procesamos - fgets conserva la marca de fin de línea
// esto evita obtener una cadena vacía al leer una línea en blanco
// lo abrimos para lectura
$file = fopen($INFO, "r");
if ($file === false) {
    print "Error opening the file $INFO for reading\n";
    exit;
}

// el diccionario de información
$dict = [];
// las líneas tienen menos de 1000 caracteres
// la lectura de la línea se detiene en la marca de fin de línea
// o en la marca de fin de archivo
while (($line = fgets($file, 1000)) !== false) {
    // eliminamos la marca de fin de línea si existe
    $line = cutNewLineChar($line);
    // colocamos la línea en un arreglo
    $info = explode(":", $line);
    // recuperamos el login
    $login = array_shift($info);
    // ignoramos el pwd
    array_shift($info);
    // creamos una entrada en el diccionario
    $dict[$login] = $info;
}
// lo cerramos
fclose($file);

// uso del diccionario
displayInfo($dict, "login10");
displayInfo($dict, "X");

// otra forma de leer un archivo de texto: la función file
$lines = file($INFO, FILE_IGNORE_NEW_LINES);
print "the file $INFO has " . count($lines) . " lines, the last one is [" . array_last($lines) . "]\n";

// fin
exit;

// --------------------------------------------------------------------------
function displayInfo(array $dict, string $key): void
{
    // muestra el valor asociado a key en el diccionario $dict si existe
    if (isset($dict[$key])) {
        // el valor existe - ¿es un arreglo?
        $value = $dict[$key];
        if (is_array($value)) {
            print "[$key," . implode(":", $value) . "]\n";
        } else {
            // $value no es un arreglo
            print "[$key,$value]\n";
        }
    } else {
        // $key no es una clave del diccionario $dict
        print "the key [$key] does not exist\n";
    }
}

// --------------------------------------------------------------------------
function cutNewLineChar(string $line): string
{
    // eliminamos la marca de fin de línea de $line si existe
    // (\n en Unix, \r\n en Windows)
    return rtrim($line, "\r\n");
}

El archivo [info.txt] creado por el script:

1
2
3
4
5
6
login0:pwd0:uid0:gid0:info0:dir0:shell0
login1:pwd1:uid1:gid1:info1:dir1:shell1
login2:pwd2:uid2:gid2:info2:dir2:shell2
…
login98:pwd98:uid98:gid98:info98:dir98:shell98
login99:pwd99:uid99:gid99:info99:dir99:shell99

Los resultados:

1
2
3
4
> php basics-16.php
[login10,uid10:gid10:info10:dir10:shell10]
the key [X] does not exist
the file info.txt has 100 lines, the last one is [login99:pwd99:uid99:gid99:info99:dir99:shell99]

Comentarios:

  • línea 12: [fopen(file_name, "w")] abre el archivo [file_name] en modo de escritura (w=write). Si el archivo no existe, se crea. Si existe, se vacía. El archivo se crea en el directorio actual, aquel desde el que se ejecutó el script. Si la creación falla, [fopen] emite una advertencia y devuelve el valor [false];
  • línea 13: el resultado de [fopen] se prueba comparándolo estrictamente con [false];
  • línea 19: [fputs($file, $string)] escribe [$string] en el archivo [$file]. Aquí, la cadena termina con el marcador de fin de línea [\n];
  • línea 22: [fclose($file)] cierra el archivo [$file];
  • línea 27: [fopen(file_name, "r")] abre el archivo [file_name] en modo de lectura (r=read). Si la apertura del archivo falla (por ejemplo, si el archivo no existe), [fopen] devuelve el valor [false];
  • línea 34: el diccionario se inicializa vacío antes de llenarlo. PHP crearía el arreglo en la primera asignación de [$dict[$login] = ...], pero si el archivo estuviera vacío, la variable no existiría y su uso provocaría una advertencia;
  • línea 38: [fgets($file, 1000)] lee la siguiente línea del archivo, limitada a 1,000 caracteres. La operación [while (($line = fgets($file, 1000)) !== false) {...}] consta de dos operaciones sucesivas: 1) [$line = fgets(...)] y 2) [while ($line !== false)]. Después de leer el último carácter del archivo, la función [fgets] devuelve el valor [false], y el bucle [while] se detiene. Aquí, la función [fgets] intenta leer hasta 1,000 caracteres pero se detiene en cuanto encuentra un carácter de fin de línea. Como todas las líneas tienen aquí menos de 1,000 caracteres, [fgets] lee una línea de texto, incluido el carácter de fin de línea. El curso de PHP 7 escribía [while ($line = fgets($file, 1000))]: el bucle se habría detenido prematuramente ante una última línea reducida a "0", sin carácter de fin de línea, porque la cadena "0" se convierte en [false]. La comparación estricta [!== false] evita esta trampa;
  • línea 40: la función [cutNewLineChar] elimina los caracteres de fin de línea, si los hay;
  • línea 44: la función [array_shift($array)] elimina el primer elemento de [$array] y lo devuelve como resultado;
  • línea 46: aquí ignoramos el resultado devuelto por [array_shift];
  • línea 58: otra forma de leer un archivo de texto. La función [file] devuelve un arreglo que contiene todas las líneas del archivo. Con la opción [FILE_IGNORE_NEW_LINES], se eliminan los caracteres de fin de línea. Es más simple que el bucle con [fgets], pero todo el archivo se carga en memoria: para un archivo muy grande, es preferible leer línea por línea;
  • línea 71: la función [is_array($variable)] devuelve [true] si [$variable] es un arreglo, y [false] en caso contrario;
  • línea 84: el carácter de fin de línea es la cadena "\r\n" en los sistemas Windows y "\n" en los sistemas Unix. La función [rtrim($string, $characters)] elimina todos los caracteres presentes en [$characters], en este caso \r y \n, del final de [$string]. Sin un segundo parámetro, [rtrim] elimina todos los “espacios” (espacios en blanco, tabulaciones, saltos de línea, etc.); la función [trim] hace lo mismo en ambos extremos de la cadena.

3.10. Codificación y decodificación de JSON

La carpeta [scripts-console/json] contiene los scripts de esta sección:

1
2
3
4
5
json
├── family.json
├── json-01.php
├── json-02.php
└── json-03.php

La codificación y decodificación de JSON (JavaScript Object Notation) es algo que utilizaremos ampliamente en el ejercicio que sirve de hilo conductor de este documento. Los scripts [json-01.php, json-02.php, json-03.php] explican lo que se necesita saber para el resto del documento.

El script [json-01.php] es el siguiente:

<?php

declare(strict_types=1);

$array1 = ["lastName" => "séléné", "firstName" => "bénédicte", "age" => 34];
// codificación JSON del arreglo array1 con caracteres Unicode escapados
print "JSON encoding of the array array1 with escaped Unicode characters\n";
$json1 = json_encode($array1);
print "json1=$json1\n";
// codificación JSON del arreglo array1 con caracteres Unicode sin escapar
print "JSON encoding of the array array1 with unescaped Unicode characters\n";
$json2 = json_encode($array1, JSON_UNESCAPED_UNICODE);
print "json2=$json2\n";
// decodificación JSON a un arreglo asociativo
print "JSON decoding of json2 into an associative array\n";
$array2 = json_decode($json2, true);
var_dump($array2);
foreach ($array2 as $key => $value) {
    print "$key:$value\n";
}
// decodificación JSON a un objeto
print "JSON decoding of json2 into a stdClass object\n";
$object2 = json_decode($json2);
var_dump($object2);
print "firstName=$object2->firstName\n";
print "lastName=$object2->lastName\n";
print "age=$object2->age\n";

Resultados:

> php json-01.php
JSON encoding of the array array1 with escaped Unicode characters
json1={"lastName":"s\u00e9l\u00e9n\u00e9","firstName":"b\u00e9n\u00e9dicte","age":34}
JSON encoding of the array array1 with unescaped Unicode characters
json2={"lastName":"séléné","firstName":"bénédicte","age":34}
JSON decoding of json2 into an associative array
array(3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
lastName:séléné
firstName:bénédicte
age:34
JSON decoding of json2 into a stdClass object
object(stdClass)#1 (3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
firstName=bénédicte
lastName=séléné
age=34

Comentarios:

  • línea 8: la función [json_encode] convierte su parámetro en una cadena JSON. En la cadena resultante, el carácter acentuado é ha sido reemplazado por su código Unicode, que comienza con \u;
  • línea 12: repetimos el mismo proceso, esta vez especificando que los caracteres Unicode deben conservarse tal cual. La cadena JSON resultante es mucho más legible;
  • líneas 16–20: realizamos la operación inversa. Convertimos la cadena JSON en un arreglo asociativo: este es el papel del segundo parámetro, [true], de [json_decode]. Los resultados muestran que efectivamente hemos obtenido un arreglo asociativo;
  • líneas 23–27: sin el parámetro [true], [json_decode] convierte la cadena JSON en un objeto de tipo [stdClass]. El atributo A de un objeto O se denota [$O->A].

Los arreglos de varios niveles se pueden codificar como JSON, como muestra el siguiente script [json-02.php]:

<?php

declare(strict_types=1);

$array = [
    "lastName" => "séléné", "firstName" => "bénédicte", "age" => 34,
    "husband" => ["lastName" => "icariù", "firstName" => "ignacio", "age" => 35],
    "children" => [
        ["firstName" => "angèle", "age" => 8],
        ["firstName" => "andré", "age" => 2],
    ],
];
// codificación JSON del arreglo de varios niveles
print "JSON encoding of a multi-level array\n";
$json = json_encode($array, JSON_UNESCAPED_UNICODE);
print "json=$json\n";
// la misma codificación, presentada de forma legible
print "JSON encoding with the JSON_PRETTY_PRINT option\n";
print json_encode($array["husband"], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";

Resultados:

1
2
3
4
5
6
7
8
9
> php json-02.php
JSON encoding of a multi-level array
json={"lastName":"séléné","firstName":"bénédicte","age":34,"husband":{"lastName":"icariù","firstName":"ignacio","age":35},"children":[{"firstName":"angèle","age":8},{"firstName":"andré","age":2}]}
JSON encoding with the JSON_PRETTY_PRINT option
{
    "lastName": "icariù",
    "firstName": "ignacio",
    "age": 35
}

Comentarios:

En la cadena JSON:

  • los arreglos no asociativos (listas) se encierran entre corchetes [] ;
  • los arreglos asociativos se encierran entre llaves {} .

línea 19: las opciones de [json_encode] se combinan mediante el operador | (OR binario). La opción [JSON_PRETTY_PRINT] produce una cadena JSON con sangría en varias líneas, lo que la hace más legible.

El script [json-03.php] muestra cómo procesar el siguiente archivo JSON [family.json]:

{
    "wife": {
        "lastName": "séléné",
        "firstName": "bénédicte",
        "age": 34
    },
    "husband": {
        "lastName": "icariù",
        "firstName": "ignacio",
        "age": 35
    },
    "children": [
        {
            "firstName": "angèle",
            "age": 8
        },
        {
            "firstName": "andré",
            "age": 2
        }
    ]
}

El script [json-03.php] es el siguiente:

<?php

declare(strict_types=1);

// lectura del archivo JSON
$json = file_get_contents("family.json");
// ¿el contenido leído es JSON válido? (PHP 8.3)
if ($json === false || !json_validate($json)) {
    print "The file [family.json] is missing or does not contain valid JSON\n";
    exit;
}
// decodificación JSON a un objeto
$family1 = json_decode($json);
print "----family1\n";
var_dump($family1);
// decodificación JSON a un arreglo asociativo
print "----family2\n";
$family2 = json_decode($json, true);
var_dump($family2);

Comentarios:

  • línea 6: la función [file_get_contents] lee el contenido del archivo llamado [family.json] y lo almacena en la variable [$json]. Devuelve [false] si la operación de lectura falla;
  • línea 8: la función [json_validate] (PHP 8.3) devuelve [true] si la cadena pasada como parámetro es un JSON válido. Antes era necesario decodificar la cadena y luego llamar a la función [json_last_error];
  • líneas 13–19: la cadena se decodifica luego en un objeto y después en un arreglo asociativo.

Resultados:

> php json-03.php
----family1
object(stdClass)#2 (3) {
  ["wife"]=>
  object(stdClass)#1 (3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  object(stdClass)#3 (3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    object(stdClass)#4 (2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    object(stdClass)#5 (2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
----family2
array(3) {
  ["wife"]=>
  array(3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  array(3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    array(2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    array(2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
  • La primera parte de los resultados muestra el objeto resultante de la decodificación del archivo JSON [family.json]: los objetos JSON se han convertido en objetos [stdClass] y la lista JSON de hijos se ha convertido en un arreglo de PHP;
  • la segunda parte muestra el arreglo asociativo resultante de la misma decodificación: todos los objetos JSON se han convertido en arreglos asociativos.