Vistas basadas en clases vs basadas en funciones: ¿cuál es mejor usar en Django?

Django …Todos conocemos la popularidad de este marco de Python en todo el mundo. Este marco ha hecho la vida más fácil para los desarrolladores. Se ha vuelto más fácil para los desarrolladores crear una aplicación web completa en Django. Si eres un desarrollador experimentado de Django, seguramente habrás estado al tanto del flujo del proyecto. Cómo se ejecutan las cosas en el repetitivo de Django y cómo se representan los datos para el usuario. 

Django trabaja en el concepto MVT. Trabajamos principalmente en dos tipos de vistas en él… vistas basadas en clases y vistas basadas en funciones. Si eres nuevo en el marco de Django, seguramente hayas estado usando FBV (Vistas basadas en funciones). 

Inicialmente, Django comenzó con las vistas basadas en funciones, pero luego Django agregó el concepto de vistas basadas en clases para evitar la redundancia de código en el modelo. Es un debate entre los desarrolladores cuál es mejor usar en Django… ¿vistas basadas en clases o vistas basadas en funciones? Hoy en este blog vamos a discutir este tema en profundidad para conocer los pros y los contras de ambas vistas. 

Puede realizar su tarea utilizando ambos. Algunas tareas se pueden implementar mejor utilizando CBV y algunas de ellas se pueden implementar en FBV. Las vistas de Django tienen principalmente tres requisitos…

• Son llamables. Puede escribir las vistas utilizando funciones basadas o basadas en clases. Mientras usa CBV, hereda el método as_view() que usa el método dispatch() para llamar al método apropiado según el verbo HTTP (obtener, publicar), etc.
• Como primer argumento posicional, las vistas de Django deberían aceptar HttpRequest.
• Debería devolver el HttpResponse

Ahora comparemos ambas vistas y veamos los pros y los contras de ambas.

1. Vistas basadas en funciones

Las vistas basadas en funciones son buenas para los principiantes. Es muy fácil de entender en comparación con las vistas basadas en clases. Inicialmente, cuando desea concentrarse en los fundamentos básicos, el uso de las vistas basadas en funciones brinda la ventaja de comprenderlo. Vamos a discutir algunos pros y contras de la misma. 

Ventajas:

• Fácil de leer, comprender e implementar.
• Flujo de código explícito
• Uso sencillo de decoradores.
• Bueno para la funcionalidad especializada.

Contras:

• Redundancia de código y difícil de ampliar
• La bifurcación condicional se usará para manejar los métodos HTTP.

Como hemos discutido, las vistas basadas en funciones son fáciles de entender, pero debido a la redundancia de código en un gran proyecto de Django, encontrará tipos de funciones similares en las vistas. Encontrará que un tipo de código similar se repite innecesariamente. 

Aquí hay un ejemplo de una vista basada en funciones…

def example_create_view(request, pk):
  template_name = 'form.html'
  form_class = FormExample
  
  form = form_class
  
  if request.method == 'POST':
    form = form_class(request.POST)
    if form.is_valid():
      form.save()
      return HttpResponseRedirect(reverse('list-view'))
  
  return render(request, template_name, {'form': form})

Todas las desventajas anteriores de los FBV no las encontrarás en las vistas basadas en clases. No tendrá que escribir el mismo código una y otra vez en su plantilla. 

2. Vistas basadas en clases

Las vistas basadas en clases son las alternativas de las vistas basadas en funciones. Se implementa en los proyectos como objetos Python en lugar de funciones. Las vistas basadas en clases no reemplazan las vistas basadas en funciones, pero tienen ciertas ventajas sobre las vistas basadas en funciones. Las vistas basadas en clases se encargan de las funcionalidades básicas, como eliminar un elemento o agregar un elemento. 

Usar la vista basada en clases no es fácil si eres un principiante. Tendrás que revisar la documentación y tendrás que estudiarla adecuadamente. Una vez que comprenda la vista basada en funciones en Django y sus conceptos sean claros, puede pasar a las vistas basadas en clases. Analicemos las vistas basadas en clases en detalle.

ventajas

• La ventaja más importante de la vista basada en clases es la herencia. En la vista basada en clases, puede heredar otra clase y puede modificarse para los diferentes casos de uso.
• Le ayuda a seguir el principio DRY. No tendrá que escribir el mismo código una y otra vez en su plantilla. La reutilización de código es posible en vistas basadas en clases.
• Puede ampliar las vistas basadas en clases y puede agregar más funcionalidades utilizando Mixins.
• Otra ventaja de usar una vista basada en clases es la estructuración del código. En las vistas basadas en clases, puede usar diferentes métodos de instancia de clase (en lugar de declaraciones de bifurcación condicional dentro de vistas basadas en funciones) para generar diferentes requests HTTP.
• Vistas genéricas basadas en clases incorporadas.

Contras

• Complejo de implementar y más difícil de leer.
• Flujo de código implícito.
• Se requiere una importación adicional o una anulación de método en los decoradores de vistas.

A continuación se muestra un ejemplo de una vista basada en clases…

class MyCreateView(View):
  template_name = 'form.html'
  form_class = MyForm
  
  def get(self, request, *args, **kwargs):
    form = self.form_class
    return render(request, template_name, {'form': form})
  
  def post(self, request, *args, **kwargs):
    form = self.form_class(request.POST)
    if form.is_valid():
      form.save()
      return HttpResonseRedirect(reverse('list-view'))
    else:
      return render(request, self.template_name, {'form': form})

Tenemos un poco de abstracción y el método as_view() está llamando a dispatch() para determinar qué método de clase debe ejecutarse, según la solicitud HTTP. as_view() le permite anular los atributos de clase en sus confs de URL. Puedes hacer algo como lo siguiente…

urlpatterns = [
    url(r'^new/$', MyCreateView.as_view(), name='original-create-view')
    url(r'^new_two/$', MyCreateView.as_view(template_name='other_form.html',
                    form_class='MyOtherForm'), name='modified-create-view')
  ]

Una vez que comience a usar las vistas genéricas basadas en clases de Django, podrá sobrescribir el método auxiliar como get_form_class y get_template_names. Puede insertar la lógica adicional en estos puntos en lugar de simplemente anular el atributo de clase. 

Uno de los buenos ejemplos de ello es…ModelFormMixin. El método form_valid se anula. Con el valor actualizado almacenado en self.object() se anula el método form_valid. 

3. Vista genérica basada en clases de Django

La creación de un nuevo objeto, el manejo de formularios, las vistas de lista, la paginación, las vistas de archivo, todas estas cosas son casos de uso común en una aplicación web. Viene en el núcleo de Django, puedes implementarlos desde el módulo django.views.generic. Las vistas genéricas basadas en clases son una excelente opción para realizar todas estas tareas. Acelera el proceso de desarrollo. 

Django proporciona un conjunto de vistas, mixins y vistas genéricas basadas en clases. Aprovechándolo puedes resolver las tareas más comunes en el desarrollo web. 

El objetivo principal no es reducir el modelo. Le evita escribir el mismo código una y otra vez. Modifique MyCreateView para heredar de django.views.generic.CreateView. 

from django.views.generic import CreateView 
class MyCreateView(CreateView):
    model = MyModel  
    form_class = MyForm

Podrías estar pensando que donde desaparece todo el código. La respuesta es que todo está en django.views.generic.CreateView. Obtiene una gran cantidad de funciones y accesos directos cuando hereda de CreateView. También compra una especie de ‘convención sobre configuración’. arreglo de estilo. Analicemos algunos detalles más…

Por defecto, la plantilla debe residir en /<nombre del modelo>/<nombre del modelo >_form.html. Puede cambiarlo configurando el atributo de clase template_name y template_name_suffix. 

• También necesitamos declarar los atributos model y form_class. Los métodos que hereda de CreateView se basan en ellos.
• Deberá declarar success_url como un atributo de clase en la vista o deberá especificar get_absolute_url() en el modelo. Esto es importante para la vista en su plantilla, de lo contrario, la vista no sabrá a dónde redirigir después de enviar un formulario correctamente.
• Defina los campos en su formulario o especifique el atributo de clase de campos en la vista. Aquí, en este ejemplo, puede optar por hacer lo último.

Mire el ejemplo dado a continuación para ver cómo se verá. 

from django import forms
from . models import MyModel 
class MyModelForm(forms.ModelForm):
  class Meta:
    model = MyModel
    fields = ['name', 'description']

Conclusión

Todavía es un debate entre los desarrolladores cuál es bueno para usar. ¿Vistas basadas en clases o vistas basadas en funciones? Hemos discutido los pros y los contras de ambos, pero depende totalmente del contexto y las necesidades. Hemos mencionado que las vistas basadas en clases no reemplazan las vistas basadas en funciones. En algunos casos, las vistas basadas en funciones son mejores y, en algunos casos, las vistas basadas en clases son mejores. 

En la implementación de la vista de lista, puede hacer que funcione subclasificando ListView y anulando los atributos. En un escenario donde necesita realizar la operación más compleja, manejar múltiples formularios a la vez, una vista basada en funciones será una mejor opción para usted.