8. Ejercicio práctico – Versión 3
Retomaremos el ejercicio que vimos anteriormente (versiones 1 y 2) y lo resolveremos con código PHP que emplea clases. Pondremos en práctica lo aprendido en los tres capítulos anteriores:
- una clase [readonly] (inmutable) para representar los datos de la administración tributaria;
- una interfaz, una clase abstracta que la implementa parcialmente y una clase derivada que la completa;
- un único tipo de excepción, [TaxException], para informar todos los errores de la aplicación;
- el atributo [#[\Override]] en todos los métodos que implementan un método de una interfaz o sobrescriben un método del padre.
8.1. Estructura de directorios de los scripts
La versión 3 se encuentra en la carpeta [scripts-console/tax/version-03]:
Cada clase o interfaz está en un archivo que lleva su nombre. Es una convención seguida universalmente en PHP (incluso la exige el estándar de carga automática PSR-4, que encontraremos con [Composer]).
8.2. La excepción [TaxException]
En la versión 3, cuando el constructor o un método de una clase encuentra un error, lanzará una excepción [TaxException]:
Comentarios
- Línea 6: la clase [TaxException] está en el espacio de nombres [Application]. Todas las clases e interfaces de la aplicación de cálculo del impuesto estarán en este espacio de nombres;
- línea 9: la clase [TaxException] extiende la clase predefinida de PHP [RuntimeException]. Como vimos en el capítulo sobre excepciones, una excepción se define principalmente por su tipo: es el tipo el que permite capturarla con una cláusula [catch (TaxException $ex)];
- Líneas 11–12: el curso de PHP 7 definía un constructor [__construct(string $message, int $code = 0)] que simplemente llamaba al constructor de la clase padre. Es innecesario: la clase hereda el constructor de [RuntimeException], que acepta un mensaje, un código de error y una posible excepción anterior. Usaremos este último parámetro para encapsular una excepción de bajo nivel (una [JsonException], por ejemplo) dentro de una [TaxException].
8.3. La clase [TaxAdminData]
En la versión 2, los datos de la administración tributaria se consolidaban:
- primero en un archivo JSON;
- luego, desde este archivo JSON, en un arreglo asociativo.
Habíamos señalado un defecto de esta solución: no hay garantía de que el arreglo asociativo contenga todas las claves esperadas ni de que los valores asociados sean números. En la versión 3, los datos de la administración tributaria siguen estando en el archivo [taxadmindata.json] pero con nombres de atributos diferentes, escritos según la convención camelCase para los nombres de atributos de clase:
En la versión 2, este archivo se usaba para inicializar un arreglo asociativo. En la versión 3, inicializará un objeto de la siguiente clase: [TaxAdminData]:
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 117 118 119 120 | |
Comentarios
- Línea 9: la clase es [readonly]: todos sus atributos son de solo lectura. Una vez creado, un objeto [TaxAdminData] ya no se puede modificar: puede compartirse sin riesgo entre todas las partes de la aplicación. También es [final]: no se puede derivar;
- líneas 12–24: dos constantes de clase privadas enumeran los nombres de los atributos esperados en los datos. A partir de PHP 8.3, una constante de clase puede tener tipo (aquí, [array]);
- líneas 27–43: el constructor utiliza la promoción de parámetros: cada parámetro se convierte en un atributo público con el mismo nombre y tipo. Los atributos tienen los mismos nombres que las claves del archivo JSON. Este es un punto importante que simplifica mucho la escritura del código, como veremos. Los tramos del impuesto son arreglos ([array]) y las constantes de cálculo son números reales ([float]). En PHP 7, los atributos no podían tener tipo (como se señaló en el curso de PHP 7); pueden tenerlo a partir de PHP 7.4;
- línea 27: el constructor es private; [new TaxAdminData(...)] no puede escribirse fuera de la clase. Un objeto [TaxAdminData] solo puede obtenerse mediante los métodos estáticos [fromJsonFile] y [fromArray], que verifican la validez de los datos. Esto garantiza que todo objeto [TaxAdminData] contenga datos válidos. En PHP, una clase solo puede tener un constructor. Los métodos estáticos que construyen un objeto, a veces llamados “constructores con nombre”, permiten varias formas de construir un objeto. El curso de PHP 7 usaba métodos de instancia [setFromJsonFile] llamados sobre un objeto vacío: [(new TaxAdminData())->setFromJsonFile(...)]. Esto es imposible con un objeto inmutable;
- líneas 47–67: el método [fromJsonFile] construye un objeto [TaxAdminData] a partir del archivo JSON cuyo nombre se le pasa. Su tipo de retorno, [self], se refiere a la propia clase;
- líneas 50–53: se lee el contenido del archivo. Si no es posible, se lanza una excepción [TaxException]. Esta excepción se propagará hasta el script principal;
- líneas 56–60: se decodifica el contenido del archivo, que es JSON. Con la opción [JSON_THROW_ON_ERROR] (PHP 7.3), la función [json_decode] lanza una excepción [JsonException] cuando el JSON no es válido, en lugar de devolver silenciosamente [null]. Observe el argumento con nombre [flags:], que evita tener que asignar un valor al tercer parámetro [depth] de [json_decode]. La excepción [JsonException] se encapsula dentro de una [TaxException]: el código que llama solo tiene que manejar un tipo de excepción, pero puede determinar la causa original mediante [$ex->getPrevious()];
- líneas 62–64: un archivo que contenga, por ejemplo, solo el número 12 es un JSON válido; hay que verificar que efectivamente se haya obtenido un arreglo;
- línea 66: el resto del trabajo se delega en el método [fromArray]. Este método es público: podrá usarse en una versión futura en la que los datos de la administración tributaria provengan de una base de datos;
- líneas 73–81: se verifica que las claves del arreglo [$data] sean exactamente los nombres esperados. [[...self::ARRAYS, ...self::CONSTANTS]] crea un arreglo con los elementos de ambos arreglos. La función [array_diff] devuelve los elementos del primer arreglo que no están en el segundo, y la función [array_first] (PHP 8.5) devuelve el primer elemento de un arreglo o [null] si el arreglo está vacío. Así se detecta una clave faltante seguida de una clave desconocida. Es el error más frecuente: un error tipográfico en el nombre de un atributo en el archivo [taxadmindata.json]. En el curso de PHP 7, el bucle [$this->$key = $value] creaba silenciosamente un atributo dinámico con el nombre incorrecto. Desde PHP 8.2, la creación de atributos dinámicos está obsoleta y está prohibida dentro de una clase [readonly];
- líneas 84–90: cada uno de los tres arreglos debe ser una lista no vacía (función [array_is_list], PHP 8.1) cuyos elementos sean todos números reales positivos o cero. La función [array_map] aplica el método [check] a cada elemento;
- líneas 92–95: los tres arreglos de tramos del impuesto deben tener el mismo tamaño;
- líneas 96–99: cada una de las constantes de cálculo debe ser un número real positivo o cero;
- línea 101: el arreglo [$values] usa como claves los nombres de los parámetros del constructor. El operador [...], aplicado a un arreglo con claves de tipo cadena, convierte cada elemento en un argumento con nombre (PHP 8.1): esta línea equivale a [new self(limits: $values["limits"], coeffR: $values["coeffR"], ...)]. Aquí es donde elegir nombres idénticos para las claves JSON y los atributos de la clase simplifica el código;
- líneas 105–113: el método [check] verifica si un valor [$value] de tipo desconocido ([mixed]) es un número positivo o cero. Según el contenido del archivo JSON, el valor leído puede ser un entero (1551), un número de punto flotante (1551.78), una cadena convertible en número ("1551"), una cadena no convertible ("xx"), un booleano... La función [is_numeric] devuelve [true] para una cadena que representa un número. El curso de PHP 7 realizaba esta verificación con una expresión regular y devolvía un objeto [stdClass] que indicaba si había ocurrido un error. Aquí, un error provoca una excepción y el método simplemente devuelve el número en forma de [float];
- línea 116: el método [__toString] devuelve la cadena JSON que contiene los atributos del objeto. La función [get_object_vars] devuelve un arreglo asociativo [attribute name => value].
8.3.1. ¿Por qué ya no hay getters ni setters?
El curso de PHP 7 declaraba los atributos como privados y escribía un getter y un setter para cada uno (26 métodos), generados automáticamente por el IDE NetBeans. Los setters eran “fluidos”: devolvían el objeto [$this], lo que permitía llamadas encadenadas como [$data->setLimits($limits)->setCoeffR($coeffR)].
Con PHP 8, este código ya no es necesario:
- los getters servían para leer atributos privados. Los atributos [readonly] pueden hacerse públicos sin riesgo, puesto que no se pueden modificar: escribimos [$taxAdminData->halfShareQfCeiling] en lugar de [$taxAdminData->getHalfShareQfCeiling()];
- los setters servían para inicializar el objeto y permitían validar los valores. Un objeto inmutable se inicializa de una vez por todas mediante su constructor, y la validación la realizan los métodos [fromJsonFile] y [fromArray];
- los atributos tipados garantizan el tipo de los valores. El curso de PHP 7 señalaba que la instrucción [$this->halfShareQfCeiling = 'abcd'] era posible: con atributos [float] y [declare(strict_types=1)], provoca un error [TypeError].
El script [test-taxadmindata.php] verifica el funcionamiento de la clase [TaxAdminData]:
Comentarios
- línea 14: construcción de un objeto [TaxAdminData] válido a partir del archivo [taxadmindata.json];
- línea 15: el objeto se inserta en una cadena: se llama a su método [__toString];
- línea 19: intento de modificar un atributo de solo lectura;
- línea 25: intento de usar el constructor privado;
- línea 31: el arreglo asociativo de datos válidos;
- líneas 32–47: un arreglo de funciones flecha, cada una de las cuales construye un objeto [TaxAdminData] a partir de datos no válidos. Los datos no válidos se obtienen modificando una copia del arreglo [$valid]. Al aplicar el operador [+] a dos arreglos, los elementos del arreglo de la izquierda tienen prioridad en caso de clave común. La función [array_diff_key] elimina del primer arreglo las claves presentes en el segundo;
- líneas 48–54: se ejecuta cada función y se muestra la excepción esperada;
- línea 56: una cadena numérica se acepta y se convierte en un número real.
Resultados:
- línea 2: la cadena JSON del objeto. Observe que los números reales sin parte decimal (1551.0) se escriben sin ella (1551) mediante la función [json_encode];
- líneas 4–5: los dos errores [Error] causados por modificar un atributo [readonly] y por llamar a un constructor privado. Son errores de programación, no errores de datos: no se convierten en [TaxException];
- líneas 6–12: se detectan todos los datos incorrectos, cada uno con un mensaje y un código de error diferentes;
- línea 13: la cadena "1551" se convirtió en un número de punto flotante.
8.4. La interfaz [InterfaceTax]
Definimos ahora la siguiente interfaz [InterfaceTax]: [InterfaceTax.php]:
Comentarios
- línea 8: la interfaz para el cálculo de impuestos. También está en el espacio de nombres [Application];
- línea 12: el método [getTaxAdminData] recuperará los datos de la administración tributaria en un objeto de tipo [TaxAdminData], que acabamos de presentar. Como estos datos pueden estar almacenados en un archivo, en una base de datos o incluso en la red, el método [getTaxAdminData] puede no lograr recuperarlos. En ese caso, lanzará una excepción de tipo [TaxException]. Es la forma estándar en la programación orientada a objetos de señalar un error encontrado en un método o en un constructor;
- línea 15: el método [calculateTax] calculará el impuesto de un contribuyente;
- línea 22: el método [executeBatchTaxes] calcula el impuesto de varios contribuyentes;
- [$taxPayersFileName] es el nombre del archivo de texto que contiene los datos de los contribuyentes;
- [$resultsFileName] es el nombre del archivo de texto que contiene los montos de impuesto de estos contribuyentes;
- [$errorsFileName] es el nombre del archivo de texto que contiene los errores encontrados durante el procesamiento de estos archivos.
El contenido del archivo de texto de los contribuyentes [taxpayersdata.txt] es el siguiente:
Observe que las líneas 5 y 8 contienen entradas incorrectas. Las otras once líneas corresponden a los once contribuyentes enumerados en la tabla de cifras oficiales.
8.5. La clase [Utilities]
Definimos también una clase llamada [Utilities] en un archivo llamado [Utilities.php]:
Comentarios
- Línea 9: la clase [Utilities] también se ubica en el espacio de nombres [Application]. Contiene únicamente métodos estáticos: no hay motivo para instanciarla ni derivarla. El curso de PHP 7 la declaraba abstracta para impedir su instanciación, lamentando que PHP se negara a declararla a la vez [final] y [abstract]. Esto sigue siendo así. La práctica actual es declararla [final] (no derivable) y darle un constructor privado (que no se puede instanciar desde el exterior);
- línea 16: el método [cutNewLineChar] elimina los caracteres de fin de línea del texto que se le pasa como parámetro. Es un método estático, es decir, se llamará de la forma [Utilities::cutNewLineChar($line)]. Su código es el mismo que el de la función del mismo nombre de la versión 2.
8.6. La clase abstracta [AbstractBaseTax]
La interfaz [InterfaceTax] será implementada por la siguiente clase abstracta [AbstractBaseTax] [AbstractBaseTax.php]:
Comentarios
- línea 9: la clase [AbstractBaseTax] implementa la interfaz [InterfaceTax];
- Línea 12: los datos de la administración tributaria se almacenarán en el atributo privado [$taxAdminData]. Su tipo, [?TaxAdminData], significa “un objeto [TaxAdminData] o el valor [null]”. Su valor inicial es [null];
- línea 16: el método [getTaxAdminData] de la interfaz. Todavía no sabemos cómo definirlo: hemos visto un caso en que los datos de la administración tributaria se recuperaban de un archivo JSON (versión 2). Veremos otro caso en que los datos se recuperarán de una base de datos. Corresponderá a las clases derivadas definir el contenido del método [getTaxAdminData]. Por lo tanto, el método se declara abstracto, lo que obliga a declarar abstracta la propia clase. Esta declaración es opcional: una clase abstracta que implementa una interfaz no está obligada a volver a declarar los métodos que no implementa. Sin embargo, hace el código más legible. El atributo [#[\Override]] (PHP 8.3) indica que el método pertenece a una interfaz o a una clase padre: si el nombre es incorrecto, PHP señala el error;
- Líneas 21–73: la función de cálculo del impuesto que ya vimos en las versiones 1 y 2. Sus parámetros han cambiado: la versión 2 recibía el arreglo asociativo [$taxAdminData] como primer parámetro, mientras que la versión 3 usa el atributo [$this->taxAdminData]. La primera diferencia entre estas dos soluciones es una diferencia en la visibilidad de los datos tributarios:
- en la versión 2, el arreglo asociativo [$taxAdminData] no tenía visibilidad global. Por lo tanto, se pasaba como parámetro a todas las funciones de cálculo del impuesto;
- en la versión 3, el atributo [$this->taxAdminData] es visible en todos los métodos de la clase. Por lo tanto, ya no se pasa como parámetro;
- una segunda diferencia proviene de que la versión 3 reemplaza las funciones por métodos de clase. Cada llamada a un método se realiza ahora mediante la expresión [$this->method(...)] (línea 31, línea 61);
- Línea 29: una tercera diferencia es que, cuando el método [calculateTax] comienza su trabajo, no sabe si el atributo [$taxAdminData] que necesita ha sido inicializado. De hecho, la clase no tiene ningún constructor que lo inicialice. Por lo tanto, le corresponde al método [calculateTax] hacerlo mediante el método [getTaxAdminData]. El operador [??=] (PHP 7.4) asigna el valor de la derecha a la variable de la izquierda solo si la variable es igual a [null]. La línea equivale a [if ($this->taxAdminData === null) { $this->taxAdminData = $this->getTaxAdminData(); }];
- Línea 38: los datos de la administración tributaria se leen directamente de los atributos públicos de solo lectura del objeto [TaxAdminData];
- Aparte de estas diferencias, el método de cálculo del impuesto sigue siendo el mismo que en las versiones anteriores.
Los métodos privados para calcular el impuesto son los siguientes:
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 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | |
Comentarios
- Líneas 80–83: la expresión [match] (PHP 8.0) es un mejor reemplazo de [if / else] de la versión 2. Compara el valor [$married] con los valores de sus ramas mediante el operador de igualdad [===] y devuelve el valor de la rama que coincide. Si ninguna rama coincide, lanza un error [UnhandledMatchError]: un estado civil distinto de “yes” o “no” no pasará inadvertido;
- líneas 100–102: las tablas de tramos del impuesto se copian en variables locales. En PHP, asignar una tabla crea una copia: la modificación de [$limits] en la línea 104 no afecta al atributo [readonly] del objeto [TaxAdminData] (lo cual, dicho sea de paso, sería un error);
- líneas 122–123: las funciones [min] y [max] reemplazan las dos funciones [if] de la versión 2: la deducción no puede exceder [tenPercentAllowanceMax] ni ser inferior a [tenPercentAllowanceMin];
- el resto del código es el mismo que en la versión 2, donde la expresión [$taxAdminData["COUPLE_DISCOUNT_CEILING"]] se ha convertido en [$this->taxAdminData->coupleDiscountCeiling]. Un error tipográfico en el nombre de un atributo ahora lo señala el editor [VS Code] (extensión [PHP Intelephense]) en cuanto se escribe el código, lo que no ocurría con un error tipográfico en una clave de arreglo.
El método [executeBatchTaxes] es el siguiente:
Comentarios del código
- Línea 185: el método recibe tres parámetros:
- [$taxPayersFileName]: el nombre del archivo de texto que contiene los datos de los contribuyentes. Cada línea de texto contiene los datos de un contribuyente con el siguiente formato: estado civil (yes/no), número de hijos, salario anual; por ejemplo, [yes,2,55555];
- [$resultsFileName]: el nombre del archivo de texto que contendrá los resultados. Cada línea de texto será la cadena JSON que representa los resultados de un contribuyente, por ejemplo, [{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}];
- [$errorsFileName]: el nombre del archivo de texto que contiene los errores, por ejemplo, [line [5] of the file [taxpayersdata.txt] is incorrect];
- línea 188: las variables de los tres archivos se inicializan en [false] (archivo no abierto). Esto permitirá determinar, en la cláusula [finally], qué archivos se han abierto;
- línea 190: como varias operaciones pueden lanzar una excepción, una estructura [try / finally] encierra todo el código del método;
- líneas 192–204: se abren los tres archivos. Se lanza una excepción en cuanto falla una operación de apertura, con un código de error distinto para cada caso;
- línea 210: las líneas del archivo [$data] se leen una por una en bloques de hasta 100 caracteres (todas las líneas tienen menos de 100 caracteres);
- línea 214: se utiliza el método estático [Utilities::cutNewLineChar] para eliminar los posibles caracteres de fin de línea;
- líneas 216–218: se ignoran las líneas vacías (por ejemplo, al final del archivo);
- línea 220: la línea se divide en la coma y se eliminan los espacios que rodean a cada campo. [trim(...)] es la sintaxis de los “first-class callables” (PHP 8.1): hace referencia a la propia función [trim], sin llamarla;
- línea 221: la línea debe tener exactamente tres campos. El curso de PHP 7 escribía directamente [list($married, $children, $salary) = explode(",", $line)]: con una línea que tenga solo dos campos, PHP 8 emite una advertencia “Undefined array key 2”;
- líneas 227–229: se verifica la validez de los tres elementos: el estado civil debe ser “yes” o “no”, y el número de hijos y el salario deben ser enteros positivos o cero (una secuencia de dígitos, expresión regular [/^\d+$/]). El tercer parámetro [true] de [in_array] exige una comparación estricta [===];
- líneas 232–236: no se lanza ninguna excepción si la línea no es válida; en su lugar, se escribe un mensaje de error en el archivo de texto [$errors], y el programa pasa a la línea siguiente;
- línea 238: si la línea leída es válida, se calcula el impuesto. El resultado se devuelve como un arreglo asociativo [tax, surcharge, discount, reduction, rate];
- línea 240: las claves [married, children, salary] se agregan al principio del resultado;
- línea 241: el resultado se escribe en el archivo de texto [$results] en forma de cadena JSON. La opción [JSON_THROW_ON_ERROR] hace que la función [json_encode] lance una excepción [JsonException] en lugar de devolver [false] si falla la codificación;
- líneas 244–246: al terminar de procesar el archivo [$data], se verifica el número de líneas erróneas encontradas. Si hay al menos una, se lanza una excepción;
- líneas 247–254: sea cual sea la manera en que termine la ejecución del método (normalmente o mediante una excepción), se ejecuta la cláusula [finally] : se cierran los archivos que se hayan abierto. El curso de PHP 7 usaba una estructura [try / catch / finally] cuya cláusula [catch] simplemente relanzaba la excepción. Esto es innecesario: una estructura [try / finally] sin [catch] permite que la excepción se propague después de que se haya ejecutado la cláusula [finally]. Además, el curso de PHP 7 cerraba los tres archivos sin verificar que se hubieran abierto: en PHP 8, [fclose(false)] provoca un error [TypeError].
8.7. La clase [TaxWithTaxAdminDataInJsonFile]
La clase abstracta [AbstractBaseTax] no implementa el método [getTaxAdminData] de la interfaz [InterfaceTax]. Por lo tanto, debemos definirlo en una clase derivada. Lo hacemos en la siguiente clase derivada, [TaxWithTaxAdminDataInJsonFile]:
Comentarios
- Línea 9: la clase [TaxWithTaxAdminDataInJsonFile] extiende la clase abstracta [AbstractBaseTax]. Debe definir el método [getTaxAdminData], que su clase padre no ha definido;
- Línea 12: el atributo [$taxAdminData] contendrá los datos de la administración tributaria. Es de solo lectura: lo inicializa el constructor de una vez por todas. Observe que la clase padre también tiene un atributo privado [$taxAdminData]: los dos atributos son distintos, ya que un atributo privado solo es visible dentro de la clase que lo declara;
- líneas 15–20: el constructor recibe como único parámetro el nombre del archivo JSON que contiene los datos del impuesto;
- línea 19: se crea un objeto de tipo [TaxAdminData] a partir del archivo JSON. Esta operación puede lanzar una excepción de tipo [TaxException]. Esta excepción se propagará hasta el script principal [main.php];
- Líneas 23–27: se proporciona un cuerpo para el método [getTaxAdminData], que la clase padre no había definido. Aquí basta con asegurarse de que el atributo [$this->taxAdminData] sea inicializado por el constructor.
8.8. El script [main.php]
Estas clases e interfaces son utilizadas por el siguiente script, [main.php]:
Comentarios
- línea 4: se exige el respeto estricto de los tipos de los parámetros de las funciones;
- línea 7: el script [main.php] también se ubica en el espacio de nombres [Application];
- líneas 10–15: se cargan los archivos de clases e interfaces que utiliza el script. Observe que aquí no hemos usado una instrucción [use] para declarar los nombres completos de las clases utilizadas por el script. Esto es innecesario porque el script y las clases están en el mismo espacio de nombres, [Application]. Observe también el orden de carga: una clase padre o una interfaz debe cargarse antes que la clase que deriva de ella o la implementa;
- líneas 18–21: los nombres de los archivos utilizados en el script. Estos nombres son relativos: los archivos se buscan en el directorio actual, aquel desde el cual se ejecuta el script;
- línea 25: se crea un objeto [TaxWithTaxAdminDataInJsonFile]. Esto puede lanzar una excepción si el archivo JSON falta o es incorrecto;
- línea 27: se llama al método [executeBatchTaxes], que calculará los impuestos de todos los contribuyentes del archivo [TAXPAYERSDATA_FILENAME]. Los resultados se escribirán en el archivo [RESULTS_FILENAME], y los posibles errores se escribirán en el archivo [ERRORS_FILENAME];
- líneas 28–31: si ocurre un error, se muestran el código y el mensaje de error. La expresión [{$ex->getCode()}] permite insertar el resultado de una llamada a un método en una cadena.
8.9. Resultados
Ejecute el script en un terminal abierto en la carpeta [version-03]:
Con el archivo de contribuyentes [taxpayersdata.txt] que se mostró arriba, se genera el siguiente archivo de errores [errors.txt]:
y el siguiente archivo de resultados, [results.txt]:
Los impuestos calculados para las once líneas correctas (2814, 1384, 0, 19884, 16782, 9200, 4230, 22986, 0, 64210, 42842) son los de las versiones 1 y 2.
8.10. Conclusión
La versión 3 tiene la misma funcionalidad que la versión 2, pero está mejor preparada para manejar errores: datos tributarios incompletos o incorrectos, líneas erróneas en el archivo de contribuyentes o archivos faltantes. Cada error se señala mediante una excepción [TaxException] que incluye un mensaje y un código específico.
Sin embargo, la clase [AbstractBaseTax] combina dos tipos de código: el cálculo del impuesto, por un lado, y la lectura y escritura de archivos, por otro. En los capítulos siguientes veremos cómo separar estas dos responsabilidades en capas distintas.