Een beginnershandleiding voor het maken en beheren van Django-slakken

Als webontwikkelaar is het optimaliseren van de gebruikerservaring van uw webapp cruciaal. Gebruik gebruiksvriendelijke URL's met slugs in Django om de gebruikerservaring en de zichtbaarheid van zoekmachines te verbeteren. Het maken van URL's met slugs is net zo eenvoudig als het schrijven van een functie, waardoor u beknopte en beschrijvende URL's kunt genereren die gemakkelijk te begrijpen zijn voor gebruikers en zoekmachines. Dit verbetert de bruikbaarheid en toegankelijkheid en verbetert de positie in zoekmachines.

De codevoorbeelden die in dit artikel worden gebruikt, zijn hierin te vinden GitHub-opslagplaats.

Een Django-project maken

Django biedt verschillende methoden om slugs te genereren en deze op uw website te gebruiken. Om verschillende manieren te illustreren om slugs te implementeren, zal deze tutorial je helpen bij het bouwen van een eenvoudige blog-webapplicatie.

Voordat u een Django-project opzet, creëer en activeer een virtuele omgeving om de nodige afhankelijkheden te installeren. Volg na het activeren van uw virtuele omgeving deze stappen om uw project in te stellen:

• Installeer Django met behulp van de pip-opdracht in uw opdrachtregel:

pip installeer django

• Maak een project aan met behulp van de django-admin nutsvoorziening. Deze tutorial zal gebruiken project_kern als de projectnaam.

django-admin startproject project_core .

• Maak een app met de naam recepten.

python manage.py startapp-recepten

• Voeg uw app toe aan de geïnstalleerde apps in uw project instelling.py bestand.

GEÏNSTALLEERDE_APPS = [
'...'
'recepten',
]

• Voer uw toepassing uit door de volgende opdracht in uw opdrachtregelprogramma te typen:

python manage.py runserver

• Navigeren naar http://127.0.0.1:8000/ in uw browser. Je zou deze pagina moeten zien:

• Configureer het URL-patroon in uw project URL.py bestand

van django.urls importeren pad, omvatten
urlpatronen = [
'...',
 pad('', erbij betrekken('recepten.urls'))
]

Een slak maken in Django

Om een ​​slug in Django te genereren, moet u een slug-veld in uw modellen opnemen. Volg deze stappen om een ​​slug te maken in Django.

Maak een model

In uw modellen.py bestand, maak een nieuw model en voeg een slug-veld toe. Hier is een voorbeeld:

klasRecept(modellen. Model):
 naam = modellen. CharField (max_length=225, blanco=Vals, null=Vals)
 ingrediënten = modellen. Tekstveld (leeg=Vals, null=Vals)
 instructies = modellen. Tekstveld (leeg=Vals, null=Vals)
 date_created = modellen. DatumTijdVeld (auto_now=WAAR)
 slak = modellen. Slakkenveld (null = WAAR, blanco=WAAR, uniek=WAAR)

In bovenstaand voorbeeld het model Recept bevat een veld met de naam naaktslak. De naaktslak veld heeft de attributen, nul En blanco ingesteld op WAAR.

Pas migraties toe op uw model

Nadat u een model hebt gemaakt, voert u de volgende opdracht uit in uw opdrachtregelprogramma om de tabel in uw database te maken:

python manage.py makemigrations && python manage.py migreren

De bovenstaande opdracht genereert eerst een migratiebestand en werkt vervolgens de database bij door de instructies in het migratiebestand uit te voeren.

Voeg gegevens toe aan uw database

Registreer uw model door het volgende in uw admin.py bestand:

van django.contrib importeren beheerder
van .modellen importeren Recept
admin.site.register (recept)

Open vervolgens uw opdrachtregelprogramma en maak een Super gebruiker voor uw beheerderspaneel door deze opdracht uit te voeren:

python manage.py createsuperuser

De bovenstaande opdracht leidt u door de stappen die in deze afbeelding worden weergegeven:

Na het aanmaken van een Super gebruiker, start je lokale server met de volgende opdracht:

python manage.py runserver

Zodra uw server start, moet u navigeren naar http://127.0.0.1:8000/admin/, log in met de gegevens waarmee je een Super gebruiker, en voeg handmatig enkele recepten toe aan uw database. Je moet op het slakkenveld letten.

Maak weergaven voor uw app

Open je weergaven.py bestand en maak twee weergaven voor uw app. De eerste weergave toont eenvoudig een overzicht van uw recepten, terwijl de tweede meer details over elk recept geeft. U kunt deze weergaven gebruiken in uw project:

van django.snelkoppelingen importeren render, krijg_object_of_404
van .modellen importeren Recept
# Lijstweergave voor recepten
defreceptenlijst(verzoek):
 recepten = Recept.objecten.all()
opbrengst renderen (verzoek, 'recepten/receptenlijst.html', {"recepten":recepten})
# Detailweergave voor elk recept
defrecept_detail(verzoek, recept_slak):
 recept = get_object_or_404(Recept, slug=recept_slug)
opbrengst renderen (verzoek, 'recepten/recept_detail.html', {'recept': recept})

In het bovenstaande codefragment is de receptenlijst view retourneert de lijst met alle recepten naar de sjabloon. Aan de andere kant, de recept_detail view retourneert een enkel recept naar de sjabloon. Deze weergave bevat een extra parameter genaamd recept_slak die wordt gebruikt om de slak voor een specifiek recept te krijgen.

Configureer URL-patronen voor uw weergaven

In uw app-directory (of recept map), maak een bestand met de naam URL.py om URL-paden voor uw app toe te voegen. Hier is een voorbeeld:

van django.urls importeren pad
van .keer bekeken importeren recept_lijst, recept_detail
urlpatronen = [
 pad('', receptenlijst, naam='recept-thuis'),
 pad('recept//', recept_detail, naam='recept_detail'),
]

In het bovenstaande codefragment introduceert het tweede pad de slug in de URL voor de pagina.

Maak sjablonen voor uw app

Maak sjablonen voor uw weergaven om de recepten in de browser weer te geven. Eén sjabloon zou voor de receptenlijst bekijken terwijl de andere voor de recept_detail weergave. Volg dit formaat om de slug in uw sjabloon te gebruiken, {% url 'view_name' recept.slug %}. Hier zijn twee voorbeelden die u in uw code kunt gebruiken:

 recepten/receptenlijst.html 
{% breidt 'base.html' uit %}
{% blokinhoud %}
<h1klas="mijn-5 tekstcentrum">Receptenh1>
<centrum>
<ulklas="lijst-groep w-75">
 {% voor recept in recepten %}
<liklas="lijst-groep-item mijn-3">
<h2klas="mb-3">
<Ahref="{% url 'recipe_detail' recept.slug %}">
 {{ recept.naam }}
A>
h2>
<Pklas="w-50">
 Ingrediënten: {{ recept.ingrediënten }}
P>
<Pklas="tekst gedempt">
 Gemaakt: {{ recept.date_created }}
P>
li>
 {% leeg %}
<liklas="lijst-groep-item">Geen recepten gevonden.li>
 {% endfor %}
ul>
centrum>
{% eindblok %}

De bovenstaande HTML-sjabloon geeft een overzicht van alle recepten in uw database en weergave Geen recepten gevonden als er geen recepten zijn. Het gebruikt Bootstrap-klassen voor styling. Je kunt leren hoe gebruik Bootstrap met Django. De bovenstaande sjabloon zou er als volgt uit moeten zien in de browser:

 recepten/recept_detail.html 
{% breidt 'base.html' uit %}
{% blokinhoud %}
<centrum>
<divklas="w-75">
<h1klas="mt-5mb-4">{{ recept.naam }}h1>
<h3>Ingrediëntenh3>
<P>{{ recept.ingrediënten }}P>
<h3>Instructiesh3>
<P>{{ recept.instructies }}P>
<Pklas="tekst gedempt">Gemaakt: {{ recept.date_created }}P>
div>
centrum>
{% eindblok %}

De bovenstaande HTML-sjabloon retourneert details over een specifiek recept. In de browser zou de bovenstaande pagina er als volgt uit moeten zien:

U zult merken dat de URL nu de slug bevat die u voor elk recept in uw database hebt toegevoegd. Als u niet begrijpt hoe het sjabloonsysteem werkt, moet u dit eerst leren sjabloonovererving in Django En Django's MVT-architectuur.

Genereer automatisch een slak in Django

Met slugs wil je ze eigenlijk automatisch genereren op basis van een veld in je model. Om dit te doen, moet u de redden() methode in uw model en geef uw eigen regels op voordat objecten in de database worden opgeslagen. Hier is een eenvoudig voorbeeld dat u aan uw modelklasse kunt toevoegen:

#slugify importeren
van django.template.defaultfilters importeren slakken
defredden(zelf, *args, **kwargs):
alsniet zelf.slak:
 self.slug = slugify (zelf.naam)
 super().save(*args, **kwargs)

De bovenstaande functie controleert eerst of er een slug bestaat voor het modelobject. Als er geen slak is, gebruikt het de slakken functie om er een te genereren uit het naamveld in het model. Na het overschrijven van de redden() methode, open je admin panel en voeg wat recepten toe. Deze keer hoef je het slakkenveld niet in te vullen, omdat het automatisch wordt ingevuld zodra je je recept opslaat.

Als u naar de detailpagina van uw nieuw toegevoegde recept navigeert, ziet u dat de URL de receptnaam als slug gebruikt.

Soms heb je meerdere recepten met dezelfde naam en dat veroorzaakt fouten in je slak. Je kunt dit oplossen door een uniek element aan je slak toe te voegen, zoals de aanmaakdatum. Hier is een eenvoudig voorbeeld:

self.slug = slugify (zelf.naam + "-" + str (zelf.datum_gemaakt))

Gebruik Slugs om de URL-ervaring te verbeteren

In tegenstelling tot de goede oude pk, bieden slugs veel voordelen, waaronder flexibiliteit en overdraagbaarheid, aangezien ze niet gebonden zijn aan specifieke URL-identifiers zoals de primaire sleutel. Als u uw databasestructuur wijzigt of uw gegevens migreert, kunt u dus nog steeds consistente URL's behouden. Slakken verbeteren ook de SEO-vriendelijkheid.