Argumentos con nombre en funciones, Valores por defecto y nullable en PHP

▶

Aquí quería mostrarte un poco sobre el uso de los argumentos con nombre en PHP, en caso de que no lo conozcas. Es en este tipo de situaciones donde se nota que PHP es un lenguaje con años encima. Algo similar ocurrió con Java cuando lo comparábamos con Kotlin. Apenas nació Kotlin, ya tenía características modernas que Java no tenía: por ejemplo, la gestión de null pointer exception y, justamente, los argumentos con nombre, que es de lo que quiero hablar aquí.

Enfoque clásico vs argumentos con nombre

Lo que vemos primero es el enfoque clásico de toda la vida, que podemos emplear prácticamente en cualquier lenguaje de programación. Se trata simplemente de definir una función —en este caso, una función estática— y pasarle una lista de parámetros:

public static function inscribe($book, $ordenId, $trace, $price,$user, $coupon, $payment,$visibility, $type,$affiliateUser)

La usamos:

  $codeMsj = Book::inscribe(
             $book,
             $orderId,
             $trace,
             $pricePayed,
             $user,
             $coupon,
             $payment,
             $visibility,
             $type,
             $affiliateUser
        );

Sí, ya sé que en Clean Code se dice que no deberíamos pasar más de tres o cuatro parámetros… pero bueno, son los que necesita mi función para funcionar, y no sé hacerlo de otra forma. Así que cada quien con lo suyo.

Problemas del enfoque clásico

¿A qué me refiero con esto? A que se presta a errores, como mezclar parámetros. Por ejemplo, pasar un valor equivocado al parámetro tipo, o asignar valores en desorden, generando confusión al leer la función.

Claro, hay un segundo consejo útil: declarar los tipos. Esto es opcional en PHP, pero altamente recomendable:

public static function inscribe(Book $book, string $ordenId, string $trace, $price, User $user, string $coupon, string $payment, string $visibility, string $type, AffiliateUser $affiliateUser)

Podrías, por ejemplo, definir que un parámetro puede ser un int o un string usando el pipe |. En este caso no aplica porque la función que estoy mostrando siempre espera un string, ya que se trata de una función para registrar un producto.

Tipos de datos

Para mí, una función bien declarada comienza por especificar los tipos de datos, siempre que sea posible. Incluso cuando no estés 100% seguro de qué datos se recibirán, puedes usar valores como null o declarar múltiples tipos:

public static function inscribe(Book $book, string $ordenId, string $trace, $price, User $user, ?string $coupon, string $payment, string $visibility, string $type, ?AffiliateUser $affiliateUser = null)

Y aquí es donde entra lo que quiero mostrarte: el uso de argumentos con nombre, que mejora mucho la claridad del código.

Sintaxis de los argumentos con nombre

Si vienes de un lenguaje moderno como Kotlin, esta característica te resultará familiar. En PHP, simplemente usas el nombre del argumento seguido de dos puntos : y luego el valor.

Por ejemplo, si el argumento se llama book, entonces lo llamarías así:

$codeMsj = Book::inscribe(
    book: $book,
    ordenId: $orderId,
    trace: $trace,
    price: $pricePayed,
    user: $user,
    coupon: $coupon,
    payment: $payment,
    visibility: $visibility,
    type: $type,
    affiliateUser: $affiliateUser
);

Esto hace que tu intención sea más clara y evita errores. Si, por ejemplo, lo escribes mal (boo en lugar de book), te dará un error inmediatamente. Además, puedes pasar los argumentos en el orden que quieras, siempre y cuando uses esta sintaxis.

Otra ventaja es que puedes asignar valores por defecto, como null, lo que también ayuda a evitar errores tipo null pointer exception:

?AffiliateUser $affiliateUser = null

Con los argumentos con nombre, puedes pasar tantos parámetros como necesites sin temor a equivocarte. Es una forma más clara, más segura y más mantenible de escribir funciones.