Skip to content

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]:

version-03
├── AbstractBaseTax.php
├── errors.txt
├── InterfaceTax.php
├── main.php
├── results.txt
├── taxadmindata.json
├── TaxAdminData.php
├── TaxException.php
├── taxpayersdata.txt
├── TaxWithTaxAdminDataInJsonFile.php
├── test-taxadmindata.php
└── Utilities.php

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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// la excepción lanzada por las clases de la aplicación de cálculo del impuesto
class TaxException extends \RuntimeException
{
    // sin código: basta con el constructor heredado de [\RuntimeException]
    // __construct(string $message = "", int $code = 0, ?\Throwable $previous = null)
}

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:

{
    "limits": [9964, 27519, 73779, 156244, 0],
    "coeffR": [0, 0.14, 0.3, 0.41, 0.45],
    "coeffN": [0, 1394.96, 5798, 13913.69, 20163.45],
    "halfShareQfCeiling": 1551,
    "singleIncomeCeilingForReduction": 21037,
    "coupleIncomeCeilingForReduction": 42074,
    "halfShareReductionValue": 3797,
    "singleDiscountCeiling": 1196,
    "coupleDiscountCeiling": 1970,
    "coupleTaxCeilingForDiscount": 2627,
    "singleTaxCeilingForDiscount": 1595,
    "tenPercentAllowanceMax": 12502,
    "tenPercentAllowanceMin": 437
}

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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// los datos de la administración tributaria: un objeto inmutable
final readonly class TaxAdminData
{
    // los nombres de los arreglos y constantes esperados en los datos
    private const array ARRAYS = ["limits", "coeffR", "coeffN"];
    private const array CONSTANTS = [
        "halfShareQfCeiling",
        "singleIncomeCeilingForReduction",
        "coupleIncomeCeilingForReduction",
        "halfShareReductionValue",
        "singleDiscountCeiling",
        "coupleDiscountCeiling",
        "coupleTaxCeilingForDiscount",
        "singleTaxCeilingForDiscount",
        "tenPercentAllowanceMax",
        "tenPercentAllowanceMin",
    ];

    // constructor privado: hay que pasar por los métodos [from...]
    private function __construct(
        // tramos del impuesto
        public array $limits,
        public array $coeffR,
        public array $coeffN,
        // constantes de cálculo del impuesto
        public float $halfShareQfCeiling,
        public float $singleIncomeCeilingForReduction,
        public float $coupleIncomeCeilingForReduction,
        public float $halfShareReductionValue,
        public float $singleDiscountCeiling,
        public float $coupleDiscountCeiling,
        public float $coupleTaxCeilingForDiscount,
        public float $singleTaxCeilingForDiscount,
        public float $tenPercentAllowanceMax,
        public float $tenPercentAllowanceMin,
    ) {
    }

    // construcción a partir de un archivo JSON
    public static function fromJsonFile(string $taxAdminDataFilename): self
    {
        // recuperamos el contenido del archivo de datos de impuestos
        $fileContents = is_readable($taxAdminDataFilename) ? file_get_contents($taxAdminDataFilename) : false;
        // ¿error?
        if ($fileContents === false) {
            throw new TaxException("The data file [$taxAdminDataFilename] does not exist", 1);
        }
        // decodificamos el JSON en un arreglo asociativo
        try {
            $data = json_decode($fileContents, true, flags: JSON_THROW_ON_ERROR);
        } catch (\JsonException $ex) {
            throw new TaxException("The JSON data file [$taxAdminDataFilename] could not be processed correctly", 2, $ex);
        }
        // el JSON debe ser un objeto {...}
        if (!is_array($data)) {
            throw new TaxException("The JSON data file [$taxAdminDataFilename] does not contain a JSON object", 3);
        }
        // construcción del objeto a partir del arreglo asociativo
        return self::fromArray($data);
    }

    // construcción a partir de un arreglo asociativo [name => value]
    public static function fromArray(array $data): self
    {
        // las claves presentes deben ser exactamente las esperadas
        $expected = [...self::ARRAYS, ...self::CONSTANTS];
        $missing = array_first(array_diff($expected, array_keys($data)));
        if ($missing !== null) {
            throw new TaxException("The attribute [$missing] of [TaxAdminData] has not been initialized", 4);
        }
        $unknown = array_first(array_diff(array_keys($data), $expected));
        if ($unknown !== null) {
            throw new TaxException("The attribute [$unknown] does not exist in [TaxAdminData]", 5);
        }
        // verificamos y convertimos cada valor
        $values = [];
        foreach (self::ARRAYS as $key) {
            // un arreglo no vacío de reales >= 0
            if (!is_array($data[$key]) || !array_is_list($data[$key]) || count($data[$key]) === 0) {
                throw new TaxException("The value of attribute [$key] is invalid", 6);
            }
            $values[$key] = array_map(fn(mixed $value): float => self::check($key, $value), $data[$key]);
        }
        // los tres arreglos deben tener el mismo tamaño
        $size = count($values["limits"]);
        if (count($values["coeffR"]) !== $size || count($values["coeffN"]) !== $size) {
            throw new TaxException("The arrays [limits, coeffR, coeffN] do not have the same size", 7);
        }
        foreach (self::CONSTANTS as $key) {
            // un real >= 0
            $values[$key] = self::check($key, $data[$key]);
        }
        // construcción del objeto: las claves del arreglo se convierten en argumentos con nombre
        return new self(...$values);
    }

    // verifica que un valor sea un número real positivo o cero y lo devuelve como [float]
    private static function check(string $key, mixed $value): float
    {
        // aceptamos 1551, 1551.78, "1551" pero no "xx", true, null, -3...
        if ((is_int($value) || is_float($value) || (is_string($value) && is_numeric($value)))
            && (float) $value >= 0) {
            return (float) $value;
        }
        throw new TaxException("The value of attribute [$key] is invalid", 6);
    }

    // cadena JSON del objeto
    public function __toString(): string
    {
        return json_encode(get_object_vars($this), JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
    }
}

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]:

<?php

// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Application;

// inclusión de las clases
require_once __DIR__ . "/TaxException.php";
require_once __DIR__ . "/TaxAdminData.php";

// un objeto válido
$taxAdminData = TaxAdminData::fromJsonFile("taxadmindata.json");
print "$taxAdminData\n";
print "halfShareQfCeiling=" . $taxAdminData->halfShareQfCeiling . "\n";
// el objeto es inmutable
try {
    $taxAdminData->halfShareQfCeiling = 2000;
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}
// el constructor es privado
try {
    $taxAdminData = new TaxAdminData([], [], []);
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}

// datos incorrectos
$valid = json_decode(file_get_contents("taxadmindata.json"), true, flags: JSON_THROW_ON_ERROR);
$tests = [
    // archivo inexistente
    fn() => TaxAdminData::fromJsonFile("xx.json"),
    // archivo que no es JSON
    fn() => TaxAdminData::fromJsonFile("taxpayersdata.txt"),
    // clave faltante
    fn() => TaxAdminData::fromArray(array_diff_key($valid, ["halfShareQfCeiling" => 0])),
    // clave desconocida (error tipográfico)
    fn() => TaxAdminData::fromArray(["halfShareQFCeiling" => 1551] + $valid),
    // valor no numérico
    fn() => TaxAdminData::fromArray(["halfShareQfCeiling" => "xx"] + $valid),
    // valor negativo en un arreglo
    fn() => TaxAdminData::fromArray(["coeffR" => [0, 0.14, -0.3, 0.41, 0.45]] + $valid),
    // arreglos de tamaños diferentes
    fn() => TaxAdminData::fromArray(["limits" => [9964, 27519, 73779, 0]] + $valid),
];
foreach ($tests as $test) {
    try {
        $test();
    } catch (TaxException $ex) {
        print "TaxException no. {$ex->getCode()}: {$ex->getMessage()}\n";
    }
}
// un valor "1551" es aceptado y convertido a real
$taxAdminData = TaxAdminData::fromArray(["halfShareQfCeiling" => "1551"] + $valid);
var_dump($taxAdminData->halfShareQfCeiling);

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:

> php test-taxadmindata.php
{"limits":[9964,27519,73779,156244,0],"coeffR":[0,0.14,0.3,0.41,0.45],"coeffN":[0,1394.96,5798,13913.69,20163.45],"halfShareQfCeiling":1551,"singleIncomeCeilingForReduction":21037,"coupleIncomeCeilingForReduction":42074,"halfShareReductionValue":3797,"singleDiscountCeiling":1196,"coupleDiscountCeiling":1970,"coupleTaxCeilingForDiscount":2627,"singleTaxCeilingForDiscount":1595,"tenPercentAllowanceMax":12502,"tenPercentAllowanceMin":437}
halfShareQfCeiling=1551
Error: Cannot modify readonly property Application\TaxAdminData::$halfShareQfCeiling
Error: Call to private Application\TaxAdminData::__construct() from global scope
TaxException no. 1: The data file [xx.json] does not exist
TaxException no. 2: The JSON data file [taxpayersdata.txt] could not be processed correctly
TaxException no. 4: The attribute [halfShareQfCeiling] of [TaxAdminData] has not been initialized
TaxException no. 5: The attribute [halfShareQFCeiling] does not exist in [TaxAdminData]
TaxException no. 6: The value of attribute [halfShareQfCeiling] is invalid
TaxException no. 6: The value of attribute [coeffR] is invalid
TaxException no. 7: The arrays [limits, coeffR, coeffN] do not have the same size
float(1551)
  • 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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

interface InterfaceTax
{
    // recupera los datos de la administración tributaria usados para calcular el impuesto
    // puede lanzar la excepción TaxException
    public function getTaxAdminData(): TaxAdminData;

    // la interfaz sabe calcular un impuesto
    public function calculateTax(string $married, int $children, int $salary): array;

    // la interfaz sabe procesar datos en archivos de texto
    // $taxPayersFileName: archivo de datos de los contribuyentes en la forma estado civil, número de hijos, salario anual
    // $resultsFileName: archivo de resultados en la forma estado civil, número de hijos, salario anual, monto del impuesto...
    // $errorsFileName: archivo de los errores encontrados
    // puede lanzar la excepción TaxException
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void;
}

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:

yes,2,55555
yes,2,50000
yes,3,50000
no,2,100000
no,3x,100000
no,3,100000
yes,3,100000
yes,5,100000x
yes,5,100000
no,0,100000
yes,2,30000
no,0,200000
yes,3,200000

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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// una clase de funciones utilitarias: no puede instanciarse ni derivarse
final class Utilities
{
    // constructor privado: la clase no puede instanciarse
    private function __construct()
    {
    }

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

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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// una clase abstracta que implementa la interfaz [InterfaceTax]
abstract class AbstractBaseTax implements InterfaceTax
{
    // los datos de la administración tributaria
    private ?TaxAdminData $taxAdminData = null;

    // datos necesarios para calcular el impuesto: las clases derivadas saben dónde encontrarlos
    #[\Override]
    abstract public function getTaxAdminData(): TaxAdminData;

    // cálculo del impuesto
    // --------------------------------------------------------------------------
    #[\Override]
    public function calculateTax(string $married, int $children, int $salary): array
    {
        // $married: yes, no
        // $children: número de hijos
        // $salary: salario anual
        // $this->taxAdminData: datos de la administración tributaria
        //
        // recuperamos los datos de la administración tributaria si aún no se ha hecho
        $this->taxAdminData ??= $this->getTaxAdminData();
        // cálculo del impuesto con hijos
        $result1 = $this->calculateTax2($married, $children, $salary);
        $tax1 = $result1["tax"];
        // cálculo del impuesto sin hijos
        if ($children !== 0) {
            $result2 = $this->calculateTax2($married, 0, $salary);
            $tax2 = $result2["tax"];
            // aplicación del tope del cociente familiar
            $halfShareCeiling = $this->taxAdminData->halfShareQfCeiling;
            if ($children < 3) {
                // halfShareQfCeiling euros por los 2 primeros hijos
                $tax2 = $tax2 - $children * $halfShareCeiling;
            } else {
                // halfShareQfCeiling euros por los 2 primeros hijos, el doble por los siguientes
                $tax2 = $tax2 - 2 * $halfShareCeiling - ($children - 2) * 2 * $halfShareCeiling;
            }
        } else {
            $tax2 = $tax1;
            $result2 = $result1;
        }
        // tomamos el impuesto más alto con la tasa y el recargo correspondientes
        if ($tax1 > $tax2) {
            $tax = $tax1;
            $rate = $result1["rate"];
            $surcharge = $result1["surcharge"];
        } else {
            $surcharge = $tax2 - $tax1 + $result2["surcharge"];
            $tax = $tax2;
            $rate = $result2["rate"];
        }
        // cálculo de un posible descuento
        $discount = $this->getDiscount($married, $salary, $tax);
        $tax -= $discount;
        // cálculo de una posible reducción de impuesto
        $reduction = $this->getReduction($married, $salary, $children, $tax);
        $tax -= $reduction;
        // resultado
        return [
            "tax" => (int) floor($tax),
            "surcharge" => (int) $surcharge,
            "discount" => (int) $discount,
            "reduction" => (int) $reduction,
            "rate" => $rate,
        ];
    }

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:

    // --------------------------------------------------------------------------
    private function calculateTax2(string $married, int $children, float $salary): array
    {
        // número de partes
        $nbShares = match ($married) {
            "yes" => $children / 2 + 2,
            "no" => $children / 2 + 1,
        };
        // 1 parte por hijo a partir del tercero
        if ($children >= 3) {
            // media parte más por cada hijo a partir del tercero
            $nbShares += 0.5 * ($children - 2);
        }
        // ingreso gravable
        $taxableIncome = $this->getTaxableIncome($salary);
        // recargo
        $surcharge = floor($taxableIncome - 0.9 * $salary);
        // por problemas de redondeo
        if ($surcharge < 0) {
            $surcharge = 0;
        }
        // cociente familiar
        $quotient = $taxableIncome / $nbShares;
        // los tramos del impuesto (copias de los arreglos del objeto)
        $limits = $this->taxAdminData->limits;
        $coeffR = $this->taxAdminData->coeffR;
        $coeffN = $this->taxAdminData->coeffN;
        // se coloca al final del arreglo de límites para detener el bucle siguiente
        $limits[count($limits) - 1] = $quotient;
        // cálculo del impuesto
        $i = 0;
        while ($quotient > $limits[$i]) {
            $i++;
        }
        // ahora podemos calcular el impuesto
        $tax = floor($taxableIncome * $coeffR[$i] - $nbShares * $coeffN[$i]);
        // resultado
        return ["tax" => $tax, "surcharge" => $surcharge, "rate" => $coeffR[$i]];
    }

    // taxableIncome=annualSalary-allowance
    // la deducción tiene un mínimo y un máximo
    private function getTaxableIncome(float $salary): float
    {
        // deducción del 10% del salario, acotada por un mínimo y un máximo
        $allowance = 0.1 * $salary;
        $allowance = min($allowance, $this->taxAdminData->tenPercentAllowanceMax);
        $allowance = max($allowance, $this->taxAdminData->tenPercentAllowanceMin);
        // ingreso gravable
        $taxableIncome = $salary - $allowance;
        // resultado
        return floor($taxableIncome);
    }

    // calcula un posible descuento
    private function getDiscount(string $married, float $salary, float $taxes): float
    {
        // al inicio, un descuento nulo
        $discount = 0;
        // monto máximo de impuesto para obtener el descuento
        $taxCeilingForDiscount = $married === "yes"
            ? $this->taxAdminData->coupleTaxCeilingForDiscount
            : $this->taxAdminData->singleTaxCeilingForDiscount;
        if ($taxes < $taxCeilingForDiscount) {
            // monto máximo del descuento
            $discountCeiling = $married === "yes"
                ? $this->taxAdminData->coupleDiscountCeiling
                : $this->taxAdminData->singleDiscountCeiling;
            // descuento teórico
            $discount = $discountCeiling - 0.75 * $taxes;
            // el descuento no puede superar el monto del impuesto
            if ($discount > $taxes) {
                $discount = $taxes;
            }
            // ningún descuento < 0
            if ($discount < 0) {
                $discount = 0;
            }
        }
        // resultado
        return ceil($discount);
    }

    // calcula una posible reducción
    private function getReduction(string $married, float $salary, int $children, float $taxes): float
    {
        // el tope de ingresos para tener derecho a la reducción del 20%
        $incomeCeilingForReduction = $married === "yes"
            ? $this->taxAdminData->coupleIncomeCeilingForReduction
            : $this->taxAdminData->singleIncomeCeilingForReduction;
        $incomeCeilingForReduction += $children * $this->taxAdminData->halfShareReductionValue;
        if ($children > 2) {
            $incomeCeilingForReduction += ($children - 2) * $this->taxAdminData->halfShareReductionValue;
        }
        // ingreso gravable
        $taxableIncome = $this->getTaxableIncome($salary);
        // reducción
        $reduction = 0;
        if ($taxableIncome < $incomeCeilingForReduction) {
            // reducción del 20%
            $reduction = 0.2 * $taxes;
        }
        // resultado
        return ceil($reduction);
    }

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:

    // cálculo del impuesto en modo por lotes
    // --------------------------------------------------------------------------
    #[\Override]
    public function executeBatchTaxes(string $taxPayersFileName, string $resultsFileName, string $errorsFileName): void
    {
        // los tres archivos aún no están abiertos
        $errors = $results = $data = false;
        // pueden ocurrir bastantes errores en cuanto se manejan archivos
        try {
            // apertura del archivo de errores
            $errors = fopen($errorsFileName, "w");
            if ($errors === false) {
                throw new TaxException("Unable to create the errors file [$errorsFileName]", 10);
            }
            // apertura del archivo de resultados
            $results = fopen($resultsFileName, "w");
            if ($results === false) {
                throw new TaxException("Unable to create the results file [$resultsFileName]", 11);
            }
            // apertura del archivo de datos de los contribuyentes
            $data = is_readable($taxPayersFileName) ? fopen($taxPayersFileName, "r") : false;
            if ($data === false) {
                throw new TaxException("Unable to open the taxpayers' declarations [$taxPayersFileName] for reading", 12);
            }
            // procesamos la línea actual del archivo de datos de los contribuyentes
            // que tiene la forma estado civil, número de hijos, salario anual
            $num = 0;         // n.º de la línea actual
            $nbErrors = 0;    // número de errores encontrados
            while (($line = fgets($data, 100)) !== false) {
                // una línea más
                $num++;
                // eliminamos la posible marca de fin de línea
                $line = Utilities::cutNewLineChar($line);
                // ignoramos las líneas vacías
                if (trim($line) === "") {
                    continue;
                }
                // la línea debe tener 3 campos married,children,salary
                $fields = array_map(trim(...), explode(",", $line));
                $error = count($fields) !== 3;
                if (!$error) {
                    [$married, $children, $salary] = $fields;
                    // el estado civil debe ser yes o no
                    $married = strtolower($married);
                    // el número de hijos y el salario deben ser enteros positivos o cero
                    $error = !in_array($married, ["yes", "no"], true)
                        || !preg_match('/^\d+$/', $children)
                        || !preg_match('/^\d+$/', $salary);
                }
                // ¿error?
                if ($error) {
                    fputs($errors, "line [$num] of the file [$taxPayersFileName] is incorrect\n");
                    $nbErrors++;
                    continue;
                }
                // calculamos el impuesto
                $result = $this->calculateTax($married, (int) $children, (int) $salary);
                // escribimos el resultado en el archivo de resultados
                $result = ["married" => $married, "children" => (int) $children, "salary" => (int) $salary] + $result;
                fputs($results, json_encode($result, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR) . "\n");
            }
            // ¿errores?
            if ($nbErrors > 0) {
                throw new TaxException("There were $nbErrors incorrect line(s): see the file [$errorsFileName]", 15);
            }
        } finally {
            // cerramos los archivos que se abrieron
            foreach ([$data, $results, $errors] as $file) {
                if ($file !== false) {
                    fclose($file);
                }
            }
        }
    }

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]:

<?php

declare(strict_types=1);

// espacio de nombres
namespace Application;

// una clase que toma los datos de la administración tributaria de un archivo JSON
class TaxWithTaxAdminDataInJsonFile extends AbstractBaseTax
{
    // los datos de la administración tributaria
    private readonly TaxAdminData $taxAdminData;

    // el constructor
    public function __construct(string $jsonFileName)
    {
        // inicializamos $this->taxAdminData a partir del archivo JSON
        // puede lanzar una excepción TaxException
        $this->taxAdminData = TaxAdminData::fromJsonFile($jsonFileName);
    }

    // devuelve los datos usados para calcular el impuesto
    #[\Override]
    public function getTaxAdminData(): TaxAdminData
    {
        return $this->taxAdminData;
    }
}

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]:

<?php

// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Application;

// inclusión de las interfaces y clases
require_once __DIR__ . "/TaxException.php";
require_once __DIR__ . "/TaxAdminData.php";
require_once __DIR__ . "/Utilities.php";
require_once __DIR__ . "/InterfaceTax.php";
require_once __DIR__ . "/AbstractBaseTax.php";
require_once __DIR__ . "/TaxWithTaxAdminDataInJsonFile.php";

// definición de las constantes
const TAXPAYERSDATA_FILENAME = "taxpayersdata.txt";
const RESULTS_FILENAME = "results.txt";
const ERRORS_FILENAME = "errors.txt";
const TAXADMINDATA_FILENAME = "taxadmindata.json";

try {
    // creamos un objeto [TaxWithTaxAdminDataInJsonFile]
    $tax = new TaxWithTaxAdminDataInJsonFile(TAXADMINDATA_FILENAME);
    // ejecutamos el lote de impuestos
    $tax->executeBatchTaxes(TAXPAYERSDATA_FILENAME, RESULTS_FILENAME, ERRORS_FILENAME);
} catch (TaxException $ex) {
    // mostramos el error
    print "Error no. {$ex->getCode()}: {$ex->getMessage()}\n";
}
// fin
print "Done\n";

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]:

1
2
3
> php main.php
Error no. 15: There were 2 incorrect line(s): see the file [errors.txt]
Done

Con el archivo de contribuyentes [taxpayersdata.txt] que se mostró arriba, se genera el siguiente archivo de errores [errors.txt]:

line [5] of the file [taxpayersdata.txt] is incorrect
line [8] of the file [taxpayersdata.txt] is incorrect

y el siguiente archivo de resultados, [results.txt]:

{"married":"yes","children":2,"salary":55555,"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"yes","children":2,"salary":50000,"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}
{"married":"yes","children":3,"salary":50000,"tax":0,"surcharge":0,"discount":720,"reduction":0,"rate":0.14}
{"married":"no","children":2,"salary":100000,"tax":19884,"surcharge":4480,"discount":0,"reduction":0,"rate":0.41}
{"married":"no","children":3,"salary":100000,"tax":16782,"surcharge":7176,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":3,"salary":100000,"tax":9200,"surcharge":2180,"discount":0,"reduction":0,"rate":0.3}
{"married":"yes","children":5,"salary":100000,"tax":4230,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}
{"married":"no","children":0,"salary":100000,"tax":22986,"surcharge":0,"discount":0,"reduction":0,"rate":0.41}
{"married":"yes","children":2,"salary":30000,"tax":0,"surcharge":0,"discount":0,"reduction":0,"rate":0}
{"married":"no","children":0,"salary":200000,"tax":64210,"surcharge":7498,"discount":0,"reduction":0,"rate":0.45}
{"married":"yes","children":3,"salary":200000,"tax":42842,"surcharge":17283,"discount":0,"reduction":0,"rate":0.41}

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.