Home / Questions / 258616
Accepted
Julio Cesar
Asked: 2020-04-26 20:22:52 +0800 CST 2020-04-26 20:22:52 +0800 CST

reverse vs reverse_lazy? django

  • 772

I have a doubt and which is better reverseor reverse_lazy?, I saw somewhere that it was better reverse_lazyand that it is better to use it reverse_lazyin everything, because it is a function that is executed at runtime and should not be validated during Django loading. and that reversethere is a possibility that it is not validated in execution, something like that....

I mean that for example instead of using in the method get_success_url, reverseit is better to use reverse_lazysince it is better. (As explained above.)

def get_success_url(self):
    return reverse_lazy('pages:pages')

Practically that reverse_lazyalmost completely replaces reverse(well not so exaggerated) Well I hope I make myself understood.

But I still can't understand very well what is the difference between reverseand reverse_lazyand which is better. Also, how exactly does each one work?

Thanks in advance for your answers!

python

1 Answers

  1. Best Answer

    As part of the Django application, somewhere there must be a file that the documentation calls "URLConf", but in your case it will have whatever name you decide to give it (usually it will be called something urls.py like that, and there can be several of these, but there will be one "master" that imports the rest).

    This file contains a variable urlpatternsthat is a list of mappings between urls and the methods that must be executed to serve those urls. For example, things like:

    urlpatterns = [
    path('articles/<int:year>/', view=views.year_archive, name="archive"),
    # ...etc
]

    When Django has read that file, it knows that a request to the route articles/2019/must be converted to an execution of views.year_archive(), passing it 2019 as a parameter. It also associates the name "archive" with that view.

    Well, when you use reverse("archive", kwargs={"year": 2019})you are asking Django to tell you what would be the route that would cause the execution of the view "archive" with parameter year=2019(it would be the route "/articles/2019/").

    If when you run reverse()Django it had already read your urls.py, it will already have the information to respond to you, since it already knows that the name "archive" has been associated with the path /articles/<int:year>/.

    But since in Python everything is dynamic, it is possible that at the moment you execute reverse("archive", ...)the file urls.pyit has not yet been loaded (although it will be loaded later, it depends on the order in which the import, the include, etc. are done). Then the attempt to use reverse("archive", ...)will fail as the name "archive"is not yet associated with any route.

    That's when it reverse_lazy()can be useful. When you use reverse()the result it is a string (the reverse URL you wanted), but when you use reverse_lazy()the result it is a function, which will be called at the end, once all the config files have been loaded and the response is about to be sent to the client . By then the name will be known "archive"and the function reverse_lazy()you can use reverse()to generate your response.

    I don't have much experience with Django and I can't tell you which of the two is "better". From what I've read it seems that people in general use reverse()and if they run into an error, they change it to reverse_lazy(). I'm not sure why it's not better to use directly reverse_lazy()everywhere to save yourself trouble, except for the fact that the latter involves an extra call to another function, which may have a bit of a performance hit, but I think this effect is negligible . The fact is that apparently reverse_lazy()it is used very little, although I could not tell you why.

    • 7