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:
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:
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:
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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | |
Los resultados:
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:
Los resultados:
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:
Los resultados:
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:
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:
Continuemos con el código del script:
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:
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:
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:
Continuamos el análisis del script con la conversión explícita de valores al tipo [float]:
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:
Concluimos la presentación del script examinando las conversiones al tipo [string]:
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:
3.6. Arreglos
3.6.1. Arreglos estándar unidimensionales
Hay dos notaciones para los arreglos en PHP:
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í:
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:
Los resultados:
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:
Los resultados:
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:
Resultados:
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:
Resultados:
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:
Resultados:
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:
Resultados:
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:
Resultados:
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:
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 ($)].
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 ($)].
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:
Resultados:
Comentarios:
El código anterior muestra las dos formas de pasar parámetros a una función. Consideremos el siguiente ejemplo:
- 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:
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:
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:
- 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:
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:
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:
Resultados:
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
integerodouble; - 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:
Resultados:
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:
Resultados:
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:
El archivo [info.txt] creado por el script:
Los resultados:
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:
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:
Resultados:
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]:
Resultados:
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]:
El script [json-03.php] es el siguiente:
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:
- 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.