Nie musisz kłopotać się tworzeniem ślimaków w Django. Zaimplementuj automatyczne generowanie ślimaków, aby zaoszczędzić czas i usprawnić przepływ pracy.

Jako programista internetowy optymalizacja doświadczenia użytkownika aplikacji internetowej ma kluczowe znaczenie. Aby poprawić doświadczenie użytkownika i widoczność w wyszukiwarkach, używaj przyjaznych dla użytkownika adresów URL ze ślimakami w Django. Tworzenie adresów URL za pomocą ślimaków jest tak proste, jak napisanie funkcji, co pozwala generować zwięzłe i opisowe adresy URL, które są łatwe do zrozumienia dla użytkowników i wyszukiwarek. Zwiększa to użyteczność i dostępność, jednocześnie poprawiając rankingi w wyszukiwarkach.

Przykłady kodu użyte w tym artykule można znaleźć w this Repozytorium GitHub.

Tworzenie projektu Django

Django zapewnia kilka metod generowania ślimaków i używania ich na twojej stronie internetowej. Aby zilustrować różne sposoby implementacji ślimaków, ten samouczek przeprowadzi Cię przez proces tworzenia prostej aplikacji internetowej dla blogów.

instagram viewer

Przed skonfigurowaniem projektu Django, stworzyć i aktywować środowisko wirtualne zainstalować niezbędne zależności. Po aktywowaniu środowiska wirtualnego wykonaj następujące kroki, aby skonfigurować projekt:

  • Zainstaluj Django za pomocą polecenia pip w wierszu poleceń: 
pip zainstaluj django
  • Utwórz projekt za pomocą django-admin pożytek. Ten samouczek będzie używany rdzeń_projektu jako nazwa projektu. 
django-admin startproject project_core .
  • Utwórz aplikację o nazwie przepisy. 
python Manage.py przepisy dotyczące aplikacji startowej
  • Dodaj swoją aplikację do zainstalowanych aplikacji w swoim projekcie ustawienie.py plik. 
ZAINSTALOWANE_APLIKACJE = [
'...'
„przepisy”,
]
  • Uruchom aplikację, wpisując następujące polecenie w narzędziu wiersza poleceń: 
python Manage.py serwer uruchomieniowy
  • Nawigować do http://127.0.0.1:8000/ w Twojej przeglądarce. Powinieneś zobaczyć tę stronę:
  • Skonfiguruj wzorzec adresu URL w swoim projekcie urls.py plik 
z django.adresy URL import ścieżka, zawiera
wzorce adresów URL = [
'...',
 ścieżka('', włączać(„przepisy.adresy URL”))
]

Tworzenie ślimaka w Django

Aby wygenerować ślimak w Django, musisz dołączyć pole ślimaka do swoich modeli. Wykonaj poniższe kroki, aby utworzyć ślimak w Django.

Utwórz model

W Twoim modele.py plik, utwórz nowy model i dołącz pole slug. Oto przykład:

klasaPrzepis(modele. Model):
 nazwa = modele. CharField (max_length=225, puste =FAŁSZ, zero=FAŁSZ)
 składniki = modele. TextField (puste =FAŁSZ, zero=FAŁSZ)
 instrukcje = modele. TextField (puste =FAŁSZ, zero=FAŁSZ)
 date_created = modele. DateTimeField (auto_now=PRAWDA)
 ślimak = modele. SlugField (null = PRAWDA, puste =PRAWDA, unikalny =PRAWDA)

W powyższym przykładzie model Przepis zawiera pole o nazwie ślimak. The ślimak pole ma atrybuty, zero I pusty Ustawić PRAWDA.

Zastosuj migracje do swojego modelu

Po utworzeniu modelu należy uruchomić następujące polecenie w narzędziu wiersza poleceń, aby utworzyć tabelę w bazie danych:

python manage.py makemigrations && python manage.py migracja

Powyższe polecenie najpierw wygeneruje plik migracji, a następnie zaktualizuje bazę danych, wykonując instrukcje zawarte w pliku migracji.

Dodaj dane do swojej bazy danych

Zarejestruj swój model, wpisując następujące informacje w swoim admin.py plik:

z django.contrib import Admin
z .modele import Przepis
admin.site.register (Przepis)

Następnie otwórz narzędzie wiersza poleceń i utwórz plik superużytkownik dla swojego panelu administracyjnego, uruchamiając to polecenie:

python manage.py tworzy superużytkownika

Powyższe polecenie przeprowadzi Cię przez kroki przedstawione na tym obrazku:

Po utworzeniu A superużytkownik, uruchom serwer lokalny za pomocą następującego polecenia:

python Manage.py serwer uruchomieniowy

Po uruchomieniu serwera należy przejść do http://127.0.0.1:8000/admin/, zaloguj się przy użyciu danych użytych do utworzenia superużytkowniki ręcznie dodaj niektóre przepisy do swojej bazy danych. Warto zwrócić uwagę na pole ślimaka.

Twórz widoki dla swojej aplikacji

Otwórz swoje wyświetlenia.py plik i utwórz dwa widoki dla swojej aplikacji. Pierwszy widok po prostu wyświetli przegląd twoich przepisów, podczas gdy drugi poda więcej szczegółów na temat każdego przepisu. Możesz użyć tych widoków w swoim projekcie:

z django.skróty import renderuj, pobierz_obiekt_or_404
z .modele import Przepis
# Widok listy przepisów
poklista_przepisów(wniosek):
 przepisy = Przepis.obiekty.all()
powrót renderować (prośba, „przepisy/lista_przepisów.html”, {„przepisy”:przepisy})
# Widok szczegółowy dla każdego przepisu
pokszczegóły_przepisu(prośba, przepis_slug):
 przepis = get_object_or_404(przepis, slug=recipe_slug)
powrót renderować (prośba, „przepisy/szczegóły_przepisu.html”, {'przepis': przepis})

W powyższym fragmencie kodu plik lista_przepisów view zwraca listę wszystkich przepisów do szablonu. Z drugiej strony, szczegóły_przepisu view zwraca pojedynczą recepturę do szablonu. Ten widok przyjmuje dodatkowy parametr o nazwie przepis_ślimaczek który służy do zdobycia ślimaka dla określonej receptury.

Skonfiguruj wzorce adresów URL dla swoich widoków

W katalogu aplikacji (lub przepis folder), utwórz plik o nazwie urls.py aby dodać ścieżki URL dla swojej aplikacji. Oto przykład:

z django.adresy URL import ścieżka
z .wyświetlenia import lista_przepisów, szczegóły_przepisów
wzorce adresów URL = [
 ścieżka('', lista_przepisów, nazwa=„przepis-dom”),
 ścieżka('przepis//', szczegóły_przepisu, nazwa=„szczegóły_przepisu”),
]

W powyższym fragmencie kodu druga ścieżka wprowadza ślimak do adresu URL strony.

Twórz szablony dla swojej aplikacji

Aby wyświetlić przepisy w przeglądarce, utwórz szablony dla swoich widoków. Jeden szablon powinien być dla lista_przepisów widok, podczas gdy drugi powinien być dla szczegóły_przepisu pogląd. Aby użyć ślimaka w swoim szablonie, postępuj zgodnie z tym formatem, {% url „view_name” przepis.slug %}. Oto dwa przykłady, których możesz użyć w swoim kodzie:

 przepisy/lista_przepisów.html 
{% rozszerza 'base.html' %}
{% zablokuj zawartość %}
<h1klasa=„centrum tekstowe my-5”>Przepisyh1>
<Centrum>
<ulklasa="lista-grupa w-75">
 {% dla przepisu w przepisach %}
<liklasa=„element-grupy-listy-my-3”>
<h2klasa="mb-3">
<Ahref=„{% url 'szczegóły_przepisu' przepis.slug %}”>
 {{ przepis.nazwa }}
A>
h2>
<Pklasa="w-50">
 Składniki: {{recipe.ingredients}}
P>
<Pklasa=„tekst wyciszony”>
 Utworzono: {{recipe.date_created }}
P>
li>
 {% pusty %}
<liklasa="element-grupy-listy">Nie znaleziono przepisów.li>
 {% koniec dla %}
ul>
Centrum>
{% blok końcowy %}

Powyższy szablon HTML wyświetli wszystkie przepisy w Twojej bazie danych i wyświetli je Nie znaleziono przepisów jeśli nie ma recepty. Używa klas Bootstrap do stylizacji. Możesz się tego nauczyć użyj Bootstrapa z Django. Powyższy szablon powinien wyglądać w przeglądarce tak:

 przepisy/szczegóły_przepisu.html 
{% rozszerza 'base.html' %}
{% zablokuj zawartość %}
<Centrum>
<dzklasa="w-75">
<h1klasa="mt-5 mb-4">{{ przepis.nazwa }}h1>
<h3>Składnikih3>
<P>{{ przepis. składniki }}P>
<h3>Instrukcjeh3>
<P>{{przepis.instrukcje}}P>
<Pklasa=„tekst wyciszony”>Utworzono: {{recipe.date_created }}P>
dz>
Centrum>
{% blok końcowy %}

Powyższy szablon HTML zwraca szczegółowe informacje o konkretnym przepisie. W przeglądarce powyższa strona powinna wyglądać tak:

Zauważysz, że adres URL zawiera teraz ślimak, który dodałeś do bazy danych dla każdego przepisu. Jeśli nie rozumiesz, jak działa system szablonów, powinieneś najpierw się tego nauczyć dziedziczenie szablonów w Django I Architektura MVT Django.

Automatycznie generuj ślimak w Django

W przypadku ślimaków tak naprawdę chcesz je automatycznie generować na podstawie pola w modelu. Aby to zrobić, musisz zmodyfikować plik ratować() w swoim modelu i określ własne reguły przed zapisaniem obiektów w bazie danych. Oto prosty przykład, który możesz dodać do swojej klasy modelu:

# spowolnienie importu
z django.template.defaultfilters import spowolnić
pokratować(ja, *argumenty, **kwargi):
Jeślinie ślimak:
 self.slug = spowolnienie (nazwa.własna)
 super().save(*args, **kwargs)

Powyższa funkcja najpierw sprawdza, czy istnieje ślimak dla obiektu modelu. Jeśli nie ma ślimaka, używa spowolnić funkcja do wygenerowania jednego z pola nazwy w modelu. Po zastąpieniu ratować() metodę, otwórz panel administracyjny i dodaj kilka przepisów. Tym razem nie musisz wypełniać pola ślimaka, ponieważ zostanie ono wypełnione automatycznie po zapisaniu przepisu.

Jeśli przejdziesz do strony szczegółów nowo dodanego przepisu, zobaczysz, że adres URL używa nazwy przepisu jako komunikatu.

Czasami będziesz mieć wiele przepisów o tej samej nazwie, co spowoduje błędy w twoim ślimaku. Możesz to naprawić, dodając do ślimaka unikalny element, taki jak data utworzenia. Oto prosty przykład:

self.slug = spowolnienie (self.name + "-" + str (self.date_created))

Użyj ślimaków, aby poprawić wrażenia z adresów URL

W przeciwieństwie do starego dobrego pkślimaki zapewniają wiele korzyści, w tym elastyczność i przenośność, ponieważ nie są powiązane z określonymi identyfikatorami adresów URL, takimi jak klucz podstawowy. Dlatego jeśli zmienisz strukturę bazy danych lub przeprowadzisz migrację danych, nadal możesz zachować spójne adresy URL. Ślimaki zwiększają również przyjazność dla SEO.