Cómo refactorizar una clase Validator en PHP

Contenido del curso

Introducción

Bases de un Framework

Refactorización

Acciones restantes

Estructura correcta de archivos

Seguridad

Flujo completo del sistema

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:26

Cómo refactorizar una clase Validator en PHP

Curso de PHP Avanzado

Clase 12 de 33

Clase 12 / 33

Recursos

Refactorizar una clase Validator en PHP significa reorganizar el código para que sea más legible, mantenible y escalable, sin alterar su funcionamiento. Si trabajas con validaciones en proyectos PHP y quieres que tu código crezca con orden, aquí verás cómo separar responsabilidades y mejorar la lectura línea por línea.

¿Por qué refactorizar el código de una clase Validator?

El código no es estático. Aunque tu clase funcione, eso no significa que esté lista para crecer. Cuando una línea es tan larga que necesitas hacer scroll horizontal para leerla completa, o cuando la indentación se vuelve un laberinto, ya tienes señales claras de que es momento de reorganizar.

¿Qué es refactorizar? Es mejorar la estructura interna del código sin cambiar su comportamiento externo. El resultado sigue siendo el mismo, pero el código queda más limpio.

En la clase Validator que tenemos como punto de partida, todo funciona: al hacer clic en registrar, las validaciones se activan y los mensajes aparecen. Pero leer cada regla cuesta esfuerzo. Ahí está el problema que vamos a resolver.

¿Cómo reducir la indentación extrayendo métodos?

La primera mejora es atacar la indentación excesiva. Cuando una condición tiene mucha lógica anidada, conviene extraerla a un método con un nombre que explique qué hace [00:46].

El proceso es directo:

Identifica el bloque de código que tiene demasiada sangría.
Córtalo y muévelo a un nuevo método con parámetros claros, por ejemplo el nombre del campo y su valor.
Reemplaza el bloque original por una llamada al nuevo método.

Con esto logras leer la línea completa sin scroll y el método principal queda mucho más corto. Que un método quede corto es buena señal: indica que su responsabilidad está acotada.

¿Cómo separar cada regla de validación en su propio método?

La segunda mejora apunta a la organización lógica. Cada regla de validación debe vivir en un método independiente. Así, cuando necesites modificar la regla required, sabes exactamente dónde tocar.

¿Qué orden conviene para los parámetros?

Un detalle pequeño pero importante: el orden de los parámetros facilita la lectura. Pasar primero el campo y luego el valor describe la intención casi como una frase en voz alta.

Dentro del nuevo método, por ejemplo validarReglaRequerida, retornas la condición que antes estaba enredada en el flujo principal. El código se vuelve plano, sin espacios extra, y termina con un punto y coma limpio [01:30].

¿Refactorizar significa que mi código estaba mal? No. Refactorizar es evolucionar el código para que sea más legible y para que tu yo del futuro lo entienda sin esfuerzo.

¿Cómo manejar el valor cero en una validación required?

Acá viene un detalle que muchos pasan por alto. Si pruebas la validación con el valor 0, el sistema responde que el título es obligatorio. ¿Por qué, si estás enviando un valor?

El problema está en cómo se evalúa la condición. PHP considera el 0 como un valor falso en comparaciones laxas, así que la regla required lo rechaza por error. La solución es ser más estricto en la comprobación.

La lógica corregida queda así:

Verifica si el valor es null o si no tiene ningún valor real.
Si se cumple esa condición, devuelve el mensaje de campo obligatorio.
Si no, retorna null para indicar que la validación pasó.

Con ese ajuste, el 0 se acepta como un valor válido y la regla cumple su propósito real: detectar ausencia de dato, no falsedad numérica [02:25].

¿Qué hacer cuando el proyecto crece más allá de los métodos?

Separar reglas en métodos es el primer nivel. Si tu proyecto crece, el siguiente paso natural es convertir cada regla en una clase independiente. Así trabaja Laravel: cada regla de validación vive en su propia clase, con su propia lógica y mensaje.

Mientras tanto, tu trabajo es claro:

Separa las responsabilidades dentro de la clase Validator.
Crea métodos adicionales para cada regla.
Mantén el método principal corto y enfocado en orquestar.

Refactorizar no es señal de que escribiste mal. Es la forma en que tu código madura junto a tu proyecto. ¿Tú cómo organizas tus validaciones en PHP? Cuéntame en los comentarios.

  public function hasError($name, $param, $field, $value): ?string
  {
    return match ($name) {
      'required' => $this->validateRequired($field, $value),
      'min' => $this->validateMinLength($field, $value, $param),
      'max' => $this->validateMaxLength($field, $value, $param),
      'url' => $this->validateUrl($field, $value),
      default => NULL
    };
  }

  public function validateRequired($field, $value): ?string
  {
    return ($value === NULL || $value === '') ? "$field is required." : NULL;
  }

  public function validateMaxLength($field, $value, $limit):?string
  {
    return strlen($value) > $limit ? "$field must not exceed $limit characters." : NULL;
  }

  public function validateMinLength($field, $value, $limit):?string
  {
    return strlen($value) < $limit ? "$field must be at least $limit characters." : NULL;
  }
  public function validateUrl($field, $value){
    return filter_var($value, FILTER_VALIDATE_URL) === FALSE ? "$field must be a valid URL" : NULL;
  }
```  public function hasError($name, $param, $field, $value): ?string  {    return match ($name) {      'required' => $this->validateRequired($field, $value),      'min' => $this->validateMinLength($field, $value, $param),      'max' => $this->validateMaxLength($field, $value, $param),      'url' => $this->validateUrl($field, $value),      default => NULL    };  }
&#x20; public function validateRequired($field, $value): ?string  {    return ($value === NULL || $value === '') ? "$field is required." : NULL;  }
&#x20; public function validateMaxLength($field, $value, $limit):?string  {    return strlen($value) > $limit ? "$field must not exceed $limit characters." : NULL;  }
&#x20; public function validateMinLength($field, $value, $limit):?string  {    return strlen($value) < $limit ? "$field must be at least $limit characters." : NULL;  }  public function validateUrl($field, $value){    return filter\_var($value, FILTER\_VALIDATE\_URL) === FALSE ? "$field must be a valid URL" : NULL;  }

  public function hasError($name, $param, $field, $value): ?string
  {
    return match ($name) {
      'required' => $this->validateRequired($field, $value),
      'min' => $this->validateMinLength($field, $value, $param),
      'max' => $this->validateMaxLength($field, $value, $param),
      'url' => $this->validateUrl($field, $value),
      default => NULL
    };
  }

  public function validateRequired($field, $value): ?string
  {
    return ($value === NULL || $value === '') ? "$field is required." : NULL;
  }

  public function validateMaxLength($field, $value, $limit):?string
  {
    return strlen($value) > $limit ? "$field must not exceed $limit characters." : NULL;
  }

  public function validateMinLength($field, $value, $limit):?string
  {
    return strlen($value) < $limit ? "$field must be at least $limit characters." : NULL;
  }
  public function validateUrl($field, $value){
    return filter_var($value, FILTER_VALIDATE_URL) === FALSE ? "$field must be a valid URL" : NULL;
  }
```  public function hasError($name, $param, $field, $value): ?string  {    return match ($name) {      'required' => $this->validateRequired($field, $value),      'min' => $this->validateMinLength($field, $value, $param),      'max' => $this->validateMaxLength($field, $value, $param),      'url' => $this->validateUrl($field, $value),      default => NULL    };  }
&#x20; public function validateRequired($field, $value): ?string  {    return ($value === NULL || $value === '') ? "$field is required." : NULL;  }
&#x20; public function validateMaxLength($field, $value, $limit):?string  {    return strlen($value) > $limit ? "$field must not exceed $limit characters." : NULL;  }
&#x20; public function validateMinLength($field, $value, $limit):?string  {    return strlen($value) < $limit ? "$field must be at least $limit characters." : NULL;  }  public function validateUrl($field, $value){    return filter\_var($value, FILTER\_VALIDATE\_URL) === FALSE ? "$field must be a valid URL" : NULL;  }

Introducción

Portafolio en PHP puro sin frameworks

Estructura web básica con PHP y Git

Vistas parciales en PHP sin repetir código

Menú moderno en PHP con Tailwind CSS

Menú activo dinámico con PHP y CSS

Front controller y rutas en PHP

Conexión a MySQL con PDO y consultas dinámicas en PHP

Bases de un Framework

Centralización de conexiones a bases de datos en PHP con PDO

Encadenamiento de métodos en PHP con PDO

Validación de formularios PHP con POST

Clase de validación reutilizable para formularios en PHP

Refactorización

Cómo refactorizar una clase Validator en PHP

Archivos sueltos a controladores en PHP

Conexión de rutas con controladores en PHP

Clase de rutas en PHP con GET y POST

Acciones restantes

Rota DELETE para eliminar registros no CRUD

Formulario de edición precargado desde base de datos

Actualizar registros con PUT en Laravel

Estructura correcta de archivos

Configuración de autocarga con Composer en proyectos PHP

Creación y uso de helpers en PHP para código más legible

Helpers PHP para config, DB y redireccionamiento

Seguridad

Primer middleware PHP para proteger rutas

Refactorización de middleware con clases e interfaces en PHP

Vista de inicio de sesión con PHP y control de acceso

Lógica real de login con base de datos

Cifrado de contraseñas y gestión de sesiones en PHP

Flujo completo del sistema

Separa la autenticación del controlador PHP

Redirección automática después de enviar formularios

Clase SessionManager para mensajes flash en PHP

Helper de errores reutilizable en PHP

Integración de funciones con sistema de sesiones en PHP

Sistema de redirecciones con mensajes en PHP

Middleware para proteger rutas de usuarios logueados en PHP

Cómo refactorizar una clase Validator en PHP