“Extract Params Into Class” como su nombre lo sugiere, es un patrón de refactoring muy común el cual sugiere extraer los parámetros de una función y añadirlos dentro de una clase mediante sus propiedades.

Veamos un simple ejemplo:

Lo habitual al crear una función

public function RegisterUser(
    string $name,
    string $lastName,
    string $email,
    string $streetAddress,
    int $streetNumber,
    string $state,
    string $country,
    int $zipCode
) {
    // ...
    // Here comes the implementation 
}

Refactorizando usando Extract Params Into Class

public function RegisterUser(
    User $user,
    Address $address
) {
    // ...
    // Here comes the implementation
}

class User
{
    private $name;
    private $lastName;
    private $email;

    public function  __constructor(
        string $name,
        string $lastName,
        string $email
    ) {
        $this->name = $name;
        $this->lastName = $lastName;
        $this->email = $email;
    }

    // ... semantic getters
}

class Address
{
    private $streetAddress;
    private $streetNumber;
    private $state;
    private $country;
    private $zipCode;

    public function  __constructor(
        string $streetAddress,
        int $streetNumber,
        string $state,
        string $country,
        int $zipCode
    ) {
        $this->streetAddress = $streetAddress;
        $this->streetNumber = $streetNumber;
        $this->state = $state;
        $this->country = $country;
        $this->zipCode = $zipCode;
    }

    // ... semantic getters
}

Consideraciones Finales

Particularmente, es uno de los patrones que uso cuando de refactoring se trata siempre que me encuentro frente una aplicación que fue implementada por alguien más.

O porque en muchos casos, cuando estamos implementando un requerimiento, vamos dejando un esqueleto previo donde debe ir cada cosa, sobre todo cuando se trata de cosas complejas.

Pero que al final, al tener una vista general de donde debe ir cada cosa, siempre encontramos una mejor forma de refactorizar y aquí es donde entra este patrón el cual nos puede ser de muchísima ayuda.

Es por esto que con el uso del patrón de refactoring “Extract Params Into Class” estaremos ante una implementación más limpia, aprovechando siempre la programación orientada a objetos.

A su vez, estaríamos contribuyendo hacia el uso de los principios de un código limpio (Clean Code), legible, fácil de entender y por supuesto siguiendo una arquitectura limpia (Clean Architecture).

Así que no me queda más que recomendarte que lo pongas en práctica en cada uno de tus desarrollos y verás como poco a poco iras añadiendo mas skills a tu carrera profesional.

Recuerda que si tienes alguna sugerencia o pregunta, no dudes en dejar tus comentarios al final del post.

Si te gustó este post, ayúdame a que pueda servirle a muchas más personas, compartiendo mis contenidos en tus redes sociales.

Espero que este post haya sido de gran ayuda para ti, y como siempre, cualquier inquietud o duda que tengas, puedes contactarme por cualquiera de las vías disponibles, o dejando tus comentarios al final de este post. También puedes sugerir que temas o post te gustaría leer a futuro.