> * Django Form es una herramienta para validar datos de entrada HTML.
> * DRF Serializer es una herramienta para validar y transformar datos de API JSON.
> * Ambas herramientas tienen flujos muy similares para `is_valid()`, datos validados y manejo de errores.
> * ModelForm y ModelSerializer también comparten una estructura similar para la generación automática de campos basada en modelos y el guardado.

***

## Similitudes entre Django Form y DRF Serializer

Cuando utilizamos [[Django]], dos 'guardianes' nos brindan un gran apoyo (y a veces dolores de cabeza): el [[Django Form]] y el **Serializador de DRF ([[Django REST Framework]])**. Aquí hemos resumido sus similitudes.

Aunque operan en escenarios diferentes (páginas web vs. API), estos dos amigos comparten una función y estructura tan fundamentalmente similares que es sorprendente: 'validar de forma segura los datos externos para introducirlos internamente, y empaquetar elegantemente los datos internos para enviarlos al exterior'.

![Imagen simbólica de un serializador y un formulario](/media/whitedec/blog_img/bhqorJyY.webp)

***

## 1\. Comparación de Roles a Simple Vista

Para hacer una analogía sencilla, son como los 'agentes de seguridad y recepcionistas' en la entrada de un centro comercial.

*   **Django Form:** Opera principalmente en el mundo de las **páginas web HTML**. Verifica que los datos introducidos por el usuario en la ventana del navegador (Form Data) sean correctos y, si hay errores, muestra amablemente un mensaje en pantalla indicando "por favor, inténtelo de nuevo".
*   **DRF Serializer:** Trabaja principalmente en el mundo de las **API** que intercambian **JSON**. Transforma los datos JSON enviados por aplicaciones móviles o frontends (como React, Vue, etc.) en objetos Python y, a la inversa, empaqueta elegantemente (serializa) los datos de la base de datos en formato JSON.

| Función | Django Form (Centrado en páginas web) | DRF Serializer (Centrado en API) |
| --- | ---------------------- | ----------------------- |
| **Al ingresar (Input)** | Formulario HTML -> Diccionario Python (`cleaned_data`) | Cadena JSON -> Diccionario Python (`validated_data`) |
| **Validación de datos** | Llamada a `is_valid()` | Llamada a `is_valid()` |
| **Al salir (Output)** | Objeto Python -> Renderizado como etiquetas HTML (`<input>`) | Objeto Python -> Conversión a cadena JSON (serialización) |

***

## 2\. ¿Por qué son tan similares? Tres similitudes estructurales

Los desarrolladores de DRF se inspiraron en la excelente estructura de Django Form, utilizándola casi como referencia directa para crear los Serializers. Por eso, la estructura del código y su uso son sorprendentemente similares, como gemelos no idénticos.

### ① La forma de definir los campos es idéntica

La forma de especificar el formato de los datos que deben ingresar es exactamente la misma.

*   **Django Form:**

```python
from django import forms

class UserForm(forms.Form):
    username = forms.CharField(max_length=100)
    email = forms.EmailField()
    age = forms.IntegerField()
```

*   **DRF Serializer:**

```python
    from rest_framework import serializers

    class UserSerializer(serializers.Serializer):
        username = serializers.CharField(max_length=100)
        email = serializers.EmailField()
        age = serializers.IntegerField()
```

> Excepto por el cambio de `forms` a `serializers`, la lógica para declarar los campos es completamente idéntica.

### ② La validación y la forma de acceder a los datos son idénticas

El flujo del método para verificar la seguridad de los datos y acceder a los datos validados es consistente.

1.  **Validación de validez:** Ambos enfoques invocan `if form.is_valid():` o `if serializer.is_valid():` después de introducir los datos.
2.  **Acceso a datos validados:** Los datos limpios y validados se almacenan en un diccionario llamado `form.cleaned_data` para Form y `serializer.validated_data` para Serializer. Solo difieren ligeramente en el nombre, pero la funcionalidad es la misma.
3.  **Verificación de errores:** Si la validación falla, se proporcionan mensajes de error en formato de diccionario a través de `form.errors` o `serializer.errors` para indicar qué salió mal.

### ③ Integración con el Modelo (ModelForm vs ModelSerializer)

El núcleo de Django es la integración con la DB (Modelo). Ambas herramientas cuentan con clases 'comodín' que generan automáticamente campos basados en el modelo.

*   **Django ModelForm:**

```python
    class MyModelForm(forms.ModelForm):
        class Meta:
            model = MyModel
            fields = ['title', 'content']
```

*   **DRF ModelSerializer:**

```python
    class MyModelSerializer(serializers.ModelSerializer):
        class Meta:
            model = MyModel
            fields = ['title', 'content']
```

> La sintaxis para especificar qué modelo y qué campos usar, mediante la clase interna `Meta`, es sorprendentemente idéntica. Gracias a esto, al llamar al método `save()`, los datos se crean (`create`) o modifican (`update`) automáticamente en la base de datos de la misma manera.

***

## Para Concluir

*   **Django Form** actúa como un intérprete **entre HTML y Python**, encargándose de la validación de datos.
*   **DRF Serializer**, por su parte, es el intérprete **entre JSON y Python**, realizando también la validación de datos.

Si ya has trabajado con Django Form en el pasado, puedes considerar que DRF Serializer es, en más del 90%, un Form que maneja JSON en lugar de HTML. A la inversa, si te has familiarizado primero con Serializer, Form te resultará igualmente fácil de entender.

Sin embargo, creo que muchos ingenieros de backend, a pesar de que estas dos herramientas son bastante similares, se sienten cómodos con Serializer pero incómodos con Form, que fue la base de Serializer. Yo mismo me incluyo en ese grupo.

¿Alguna vez te has parado a pensar por qué surge esa sensación? En el próximo artículo, me gustaría hablar sobre las razones por las que Django Form, a pesar de ser similar a Serializer, genera una sensación de incomodidad cuanto más se usa.

Si este artículo te ha sido útil, ¡dale a 'me gusta'! y espera con interés el próximo.