Django Form y DRF Serializer: Análisis comparativo de dos herramientas similares pero con diferencias

• 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'.

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.

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:

from django import forms

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

• DRF Serializer:

    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:

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

• DRF ModelSerializer:

    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.