Es ist ein Memo, wenn CRUD mit Django schreibt. Ich habe den Inhalt, der zu mir passt, unter Bezugnahme auf verschiedene Websites extrahiert.
Lesen Sie vor der Entwicklung auch hier, in dem der grundlegende Ablauf und die Konzepte der Entwicklung mit Django zusammengefasst sind (obwohl dies etwas überschrieben ist).
Ich bin in einer Mac-Umgebung, also versuche ich es auf einem Mac, aber ich denke, es ist dasselbe unter Windows.
Python ist 3.6.1. Ich erstelle eine virtuelle Umgebung mit venv, die standardmäßig in Python 3.x enthalten ist, aber ich denke, es muss keine virtuelle Umgebung sein. Informationen zum Umgebungsbau finden Sie unter hier.
Das Ergebnis des Einfrierens der Pip ist wie folgt.
Django==1.11
django-bootstrap-form==3.2.1
PyMySQL==0.7.11
pytz==2017.2
Da Pytz enthalten ist, wenn Django enthalten ist, gibt es drei explizite Einträge: Django, Django-Bootstrap-Form und PyMySQL. Bitte bei Bedarf installieren.
pip install Django
pip install django-bootstrap-form
pip install PyMySQL
django-bootstrap-from ist ein Paket zum automatischen Generieren von Formularen im Bootstrap-Stil.
Django hat das Konzept von "Projekt" und "Anwendung". Es ist so, als würde man zuerst ein Projekt erstellen und dann eine Anwendung (im Folgenden als App bezeichnet) hinzufügen.
Es ist wie eine Visual Studio-Lösung und ein Visual Studio-Projekt. Wie Ara von ASP.NET MVC.
Jetzt erstellen wir ein Projekt. Hier erstellen wir ein Projekt namens jango_test.
django-admin.py startproject django_test
Nach Abschluss der Erstellung wird die folgende Dateistruktur generiert.
django_test/
manage.py
django_test/
__init__.py
settings.py
urls.py
wsgi.py
Direkt unter dem Projektverzeichnis befindet sich ein Verzeichnis mit demselben Namen wie das Projekt. Es gibt eine Einstellungsdatei, die allen Projekten in diesem gemeinsam ist (die zur Erklärung jedoch verwirrend ist). Die hier erläuterte Arbeit setzt in der Regel eine Arbeit direkt unter dem Projektverzeichnis voraus.
Ändern Sie nach dem Erstellen des Projekts die Einstellungen in settings.py.
Django verwendet standardmäßig SQLite. Da ich jedoch MySQL verwende, bearbeite ich DATABASES entsprechend.
django_test/settings.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'djangodb', #Umschreiben
'USER': 'root', #Umschreiben
'PASSWORD': 'root', #Umschreiben
'HOST': '',
'PORT': '',
}
}
Es versteht sich von selbst, dass Sie zuvor MySQL konfigurieren müssen.
Am Anfang habe ich PyMySQL installiert, um eine Verbindung mit MySQL herzustellen, aber ich kann es nicht alleine verwenden, also lade ich das Paket in das Projekt. Ich habe es am Anfang von settings.py geschrieben.
Es gab einen Artikel, der in manage.py geschrieben wurde, aber da er sich auf Einstellungen bezieht, habe ich ihn vorerst in settings.py geschrieben.
django_test/settings.py
import pymysql
pymysql.install_as_MySQLdb()
Beeilen Sie sich und bearbeiten Sie als weitere Einstellungselemente LANGUAGE_CODE und TIME_ZONE.
django_test/settings.py
LANGUAGE_CODE = 'ja'
TIME_ZONE = 'Asia/Tokyo'
Da die Installation der Datenbank abgeschlossen ist, werden wir hier einmal migrieren.
python manage.py migrate
Dadurch werden die Tabellen generiert, die für die Verwendung von Django in der angegebenen Datenbank erforderlich sind.
Lassen Sie uns nun den Entwicklungswebserver einmal starten und prüfen, ob der Django-Bildschirm korrekt angezeigt werden kann. Starten Sie es mit dem folgenden Befehl.
python manage.py runserver
Versuchen Sie nach Abschluss des Startvorgangs, auf die unten stehende URL zuzugreifen.
http://localhost:8000/
Es ist in Ordnung, wenn Sie etwas wie "Es hat funktioniert!" Sehen.
Nachdem Sie das Projekt festgelegt haben, erstellen wir eine App.
Hier erstellen wir eine App namens crud.
python manage.py startapp crud
Ein Verzeichnis namens crud wurde auf derselben Ebene wie das Arbeitsverzeichnis erstellt. Darunter werden app-bezogene Dateien generiert.
Es scheint, dass es nicht nur durch Generieren einer Anwendung verwendet werden kann, daher werde ich es zum Laden in das Projekt beschreiben. Die Einstellungen werden in settings.py vorgenommen. Laden Sie übrigens auch das Django-Bootstrap-Formular, das später verwendet wird.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
+ 'bootstrapform',
+ 'crud',
]
Django verwendet das MTV-Modell anstelle der MVC. Es ist jedoch nicht erforderlich, ein neues Konzept zu erlernen, da es sich nur um ein Image handelt, bei dem V von MVC in T (Emplate) und C von VMC in V (Ansicht) umbenannt wurde.
Erstellen Sie ein Mitgliedsmodell mit dem Bild des Speicherns von Mitgliedsinformationen. Beschreiben Sie Folgendes in models.py im Verzeichnis crud.
crud/models.py
from django.db import models
# Register your models here
class Member(models.Model):
name = models.CharField('Vollständiger Name', max_length=255)
email = models.CharField('E-Mail', max_length=255)
age = models.IntegerField('Alter', blank=True, default=0)
def __str__(self):
return self.name
Ich werde es nicht besonders erklären, aber ich denke, es liegt in dem Bereich, den ich mir vorstellen kann.
Generieren Sie nach dem Schreiben des Modells eine Migrationsdatei für die Tabellengenerierung, die das Modell enthält. Es ist zuerst ein sogenannter Code. Durch Ausführen von Make-Migrationen durch Angabe des Anwendungsnamens wird anscheinend eine Migrationsdatei erstellt, indem die Modelländerungen in der Zielanwendung gescannt werden.
python manage.py makemigrations crud
Es scheint, dass es mit vorhandenen Tabellen verwendet werden kann.
Führen Sie die Migration aus, wenn die Migrationsdatei generiert wird.
python manage.py migrate
In der aktuellen Entwicklung wird "Modell bearbeiten" ⇒ "Meke-Migration" ⇒ "Migrieren" wiederholt.
Mit Django können Sie von Anfang an auf die (Modell-) Verwaltungssite zugreifen, indem Sie http: // localhost: 8000 / admin besuchen. Da jedoch der Benutzer und das Kennwort für die Anmeldung an der Verwaltungssite nicht festgelegt sind, generieren und erhalten Sie diese zuerst.
Fügen Sie einen Benutzer mit dem folgenden Befehl hinzu.
python manage.py createsuperuser
Legen Sie ein geeignetes Passwort, eine E-Mail-Adresse usw. fest.
Wenn Sie sich an der Verwaltungssite anmelden, werden standardmäßig nur "Gruppe" und "Benutzer" als Verwaltungsziele angezeigt. Um Ihr eigenes Modell zu verwalten, müssen Sie admin.py im App-Verzeichnis die erforderliche Beschreibung hinzufügen.
crud/admin.py
from django.contrib import admin
from crud.models import Member
# Register your models here.
admin.site.register(Member)
Bitte aktualisieren Sie nach dem Hinzufügen der Beschreibung oder melden Sie sich erneut an, um die Änderungen zu überprüfen.
Wenn Sie Mitglieder auf der Administrationssite verwalten können, fügen Sie einige Datenzeilen für spätere Tests hinzu.
Zusätzlich hat Django eine Funktion zum Importieren von Daten namens firexure.
In der Reihenfolge von MVT möchte ich als nächstes mit Templete spielen, aber um die Struktur der Anwendung zu verstehen, setzen Sie zuerst View (entspricht Controller) und Routing. Dieses Mal werde ich es so einstellen, dass auf jede Funktion mit dem folgenden URL-Muster zugegriffen werden kann.
Jetzt schreiben wir zuerst View. Bevor ich jedoch eine bestimmte Funktion implementiere, möchte ich zunächst eine Methode implementieren, die nur eine Zeichenfolge zurückgibt, z. B. "Liste", "Bearbeiten", "Löschen", und die Zuordnung zwischen der URL und der Funktion überprüfen.
Der Grund, warum es kein "neues" gibt, ist, dass wie bei anderen Frameworks ein POST und eine ID bearbeitet werden und wenn es sich nur um einen POST handelt, wird er als Neuzugang beurteilt (da "edit" gemeinsam verwendet wird).
Die views.py unter Rohöl sollte folgendermaßen aussehen:
crud/views.py
from django.shortcuts import render
from django.http import HttpResponse
#Aufführen
def index(request):
return HttpResponse("Aufführen")
#Neu und bearbeiten
def edit(request, id=None):
return HttpResponse("Bearbeiten")
#Löschen
def delete(request, id=None):
return HttpResponse("Löschen")
#Details (Bonus)
def detail(request, id=None):
return HttpResponse("Einzelheiten")
Es ist nur ein Prozess, der eine Zeichenfolge zurückgibt.
Um das Routing in Django festzulegen, scheint es eine gute Praxis zu sein, urls.py im Anwendungsverzeichnis zu generieren, das Ruting in der Anwendung festzulegen und es dann in urls.py des gesamten Projekts aufzunehmen und festzulegen. ist.
Richten Sie das Routing gemäß den oben gezeigten URL- und Feature-Map-Regeln ein.
crud/urls.py
from django.conf.urls import url
from crud import views
urlpatterns = [
url(r'^members/$', views.index, name='index'),
url(r'^members/add/$', views.edit, name='add'),
url(r'^members/edit/(?P<id>\d+)/$', views.edit, name='edit'),
url(r'^members/delete/(?P<id>\d+)/$', views.delete, name='delete'),
url(r'^members/detail/(?P<id>\d+)/$', views.detail, name='detail'),
]
Routing ist
url(r'Kanonischer Ausdruck des URL-Musters', views.Entsprechende Methode von py, name='Routenname')
Das Format ist.
Die Beschreibung> r '' scheint zu bedeuten, dass Sonderzeichen in '' nicht maskiert werden. Der Routenname wird verwendet, wenn das Verbindungsziel in der Vorlage angegeben wird.
Fügen Sie urls.py in das App-Verzeichnis ein. Dies führt zu einer URL wie http: // localhost: 8000 / crud / members /.
urls.py
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^crud/', include('crud.urls', namespace='crud'))
]
Führen Sie nun runserver aus, greifen Sie auf jedes URL-Muster zu und sehen Sie, wie es funktioniert (ob die entsprechenden Zeichen angezeigt werden).
Ist dann die Implementierung in views.py, die vorübergehend implementiert wurde, diese Implementierung? Machen.
Beschreiben Sie index () wie folgt.
crud/views.py
from django.shortcuts import render
from django.http import HttpResponse
from crud.models import Member #hinzufügen
#Aufführen
def index(request):
members = Member.objects.all().order_by('id') #Wert erhalten
return render(request, 'members/index.html', {'members':members}) #Übergeben Sie einen Wert an die Vorlage
Ich erhalte einen Wert für Mitglieder und übergebe ihn mit dem Namen Mitglieder an members / index.html.
Erstellen Sie vor dem Erstellen von index.html auf der empfangenden Seite den gemeinsamen Teil auf jeder Seite als gemeinsame Vorlage (base.html). Da diesmal Bootstrap als CSS-Framework verwendet wird, werden das erforderliche CSS und JS aus dem CDN gelesen.
Erstellen Sie unter dem App-Verzeichnis (crud) ein Verzeichnis mit dem Namen Templates und speichern Sie es als base.html.
crud/templates/base.html
{% load staticfiles %}
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{% block title %}My books{% endblock %}</title>
<!-- Bootstrap -->
<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
{% block content %}
{{ content }}
{% endblock %}
</div>
<!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<!--Wo man js schreibt-->
{% block script %}
{% endblock %}
</body>
</html>
Damit ist die allgemeine Vorlage vervollständigt. Beschreiben Sie den Inhalt, der {%%} in der Vorlage entspricht, auf einer separaten Seite.
Jetzt erstellen wir eine separate Seite. Erstellen Sie ein Mitgliederverzeichnis unter dem zuvor erstellten Vorlagenverzeichnis und speichern Sie es als index.html darin.
Django scheint keine sehr strengen Einschränkungen für den Verzeichnisnamen zu haben, in dem Vorlagen gespeichert sind. In den Beispielen im Internet werden viele von ihnen als App-Namen bezeichnet (hier grob). Es scheint, dass es im offiziellen Tutorial dasselbe ist.
crud/templates/members/index.html
{% extends "base.html" %}
{% block title %}
Geplant, um eine Liste anzuzeigen
{% endblock title %}
{% block content %}
<h3>Listenanzeige</h3>
<a href="{% url 'crud:add' %}" class="btn btn-primary btn-sm">hinzufügen</a>
<table class="table table-striped table-bordered">
<thead>
<tr>
<th>ID</th>
<th>Vollständiger Name</th>
<th>E-Mail</th>
<th>Alter</th>
<th>Operation</th>
</tr>
</thead>
<tbody>
{% for member in members %}
<tr>
<td>{{ member.id }}</td>
<td><a href="{% url 'crud:detail' id=member.id %}">{{ member.name }}</a></td>
<td>{{ member.email }}</td>
<td>{{ member.age }}</td>
<td>
<a href="{% url 'crud:edit' id=member.id %}" class="btn btn-primary btn-sm">Bearbeiten</a>
<a href="{% url 'crud:delete' id=member.id %}" class="btn btn-primary btn-sm" id="btn_del">Löschen</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
<!--Setzen Sie hier Pagenation-->
{% endblock content %}
<!--Fügen Sie js ein-->
{% block script %}
{% endblock %}
Überprüfen Sie nach Abschluss jeder Implementierung, ob der Listenbildschirm korrekt angezeigt wird. Klicken Sie hier, um zu sehen, ob die Links "Registrieren", "Bearbeiten" und "Löschen" geeignet sind.
Als nächstes werden wir neue Funktionen zum Hinzufügen / Bearbeiten implementieren. Verwenden Sie die gleiche views.py und Vorlage für Neu und Bearbeiten. In Django scheint es üblich zu sein, Form- und ModelForm-Klassen zu verwenden, die automatisch Formulare (HTML-Informationen) generieren. Verwenden wir sie also.
Die Formularklasse scheint verwendet zu werden, um Formulare (z. B. Suche) ohne Modell zu erstellen.
Erstellen Sie nun forms.py im App-Verzeichnis und schreiben Sie wie folgt.
crud/forms.py
from django.forms import ModelForm
from crud.models import Member
class MemberForm(ModelForm):
class Meta:
model = Member
fields = ('name','email','age',)
Abgesehen von den Details verwende ich das Mitgliedermodell und verwende Name, E-Mail-Adresse und Alter! Ist es wie eine Erklärung?
crud/views.py
from django.shortcuts import render, get_object_or_404, redirect #hinzufügen
from django.http import HttpResponse
from crud.models import Member
from crud.forms import MemberForm #hinzufügen
#(Auszug)
#Neu und bearbeiten
def edit(request, id=None):
if id: #Wenn es eine ID gibt (beim Bearbeiten)
#Suche nach ID und Rückgabe von Ergebnissen oder 404-Fehler
member = get_object_or_404(Member, pk=id)
else: #Wenn es keine ID gibt (wenn neu)
#Mitglied erstellen
member = Member()
#Bei POST (wenn die Registrierungstaste gedrückt wird, ob neu oder bearbeitet)
if request.method == 'POST':
#Formular erstellen
form = MemberForm(request.POST, instance=member)
if form.is_valid(): #Speichern, wenn die Validierung in Ordnung ist
member = form.save(commit=False)
member.save()
return redirect('crud:index')
else: #Zum Zeitpunkt von GET (Formular generieren)
form = MemberForm(instance=member)
#Neuen / Bearbeitungsbildschirm anzeigen
return render(request, 'members/edit.html', dict(form=form, id=id))
Erstellen Sie einen Bildschirm (edit.html), der beim Neu- / Bearbeiten verwendet werden soll.
crud/templates/members/edit.html
{% extends "base.html" %}
{% load bootstrap %}
{% block title %}Mitgliederbearbeitung{% endblock title %}
{% block content %}
{% if id %}
<h3 class="page-header">Mitgliederbearbeitung</h3>
<form action="{% url 'crud:edit' id=id %}" method="post" class="form-horizontal" role="form">
{% else %}
<h3 class="page-header">Mitgliedsregistrierung</h3>
<form action="{% url 'crud:add' %}" method="post" class="form-horizontal" role="form">
{% endif %}
{% csrf_token %}
{{ form|bootstrap_horizontal }}
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10">
<button type="submit" class="btn btn-primary">Senden</button>
</div>
</div>
</form>
<a href="{% url 'crud:index' %}" class="btn btn-default btn-sm">Rückkehr</a>
{% endblock content %}
Es kann besser sein, den Titel durch bedingte Verzweigung zu ändern. Überprüfen Sie nun bitte den Betrieb.
Schließlich werden wir die Löschfunktion implementieren.
Ich werde es vorerst löschen. Ich bin wirklich wütend, wenn ich den Löschvorgang nicht in POST implementiere, aber das ist ein anderes Mal.
crud/views.py
def delete(request, id):
# return HttpResponse("Löschen")
member = get_object_or_404(Member, pk=id)
member.delete()
return redirect('crud:index')
Überprüfen Sie dies zumindest beim Löschen. Fügen Sie die folgende Beschreibung zu index.html hinzu. Es sollte kurz vor {% endblock content%} stehen.
members/index.html
{% block script %}
<script>
$(function(){
$("#btn_del").click(function(){
if(confirm("Möchten Sie es löschen?")){
//Verarbeitung ja (ohne etwas zu tun)
}else{
//Verarbeitung abbrechen
return false;
}
});
})
</script>
{% endblock %}
Es ist wirklich ein Bonus, aber lassen Sie uns einen detaillierten Bildschirm implementieren.
Wie beim Bearbeiten und Löschen erhält es die ID, sucht und übergibt das Ergebnis an die Vorlage.
views.py
#Einzelheiten
def detail(request, id=id):
member = get_object_or_404(Member, pk=id)
return render(request, 'members/detail.html', {'member':member})
Erweitern Sie das empfangene Mitglied. Ich denke, es ist besser, eine Tabelle zu erstellen, aber das ist nicht der Punkt, also zeigen Sie sie vorerst einfach an.
members/detail.html
{% extends "base.html" %}
{% load bootstrap %}
{% block title %}Mitgliederdetails{% endblock title %}
{% block content %}
<h3>Detaillierte Informationen der Mitglieder</h3>
<h5>Name</h5>
{{ member.name }}
<h5>E-Mail</h5>
{{ member.email }}
<h5>Alter</h5>
{{ member.age }}
<br>
<br>
<a href="{% url 'crud:index' %}" class="btn btn-default btn-sm">Rückkehr</a>
{% endblock content %}
Mit dem oben genannten habe ich versucht, die CRUD-Funktion zu implementieren.
Die Paginierung ist ein wesentlicher Bestandteil jeder Web-App. Außerdem bietet jedes Framework eine Möglichkeit, es einfacher zu machen. In Django scheint es üblich zu sein, LitView zu verwenden. Verwenden wir es also. ListView ist eine Art klassenbasierte Allzweckansicht, und es scheint sich um eine View-Klasse zu handeln, die Allzweckfunktionen für verschiedene Zwecke bereitstellt.
Sie können die Indexmethode neu schreiben, aber zum Vergleich die MemberList () -Klasse hinzufügen, ohne die Indexmethode zu ändern.
views.py
from django.views.generic import ListView #hinzufügen
#Aufführen
def index(request):
members = Member.objects.all().order_by('id') #Wert erhalten
return render(request, 'members/index.html', {'members':members}) #Übergeben Sie einen Wert an die Vorlage
#Liste (hinzugefügt für Seitennation)
class MemberList(ListView):
model = Member #Modell zu verwenden
context_object_name='members' #Objektnameneinstellung (Standard ist Objekt_Es wird eine Liste)
template_name='members/index.html' #Angeben einer Vorlagenseite
paginate_by = 1 #Anzahl der Seiten pro Seite
Bearbeiten Sie nach dem Hinzufügen das Routing, um MemberList () anstelle von Index ohne Paging zu verwenden.
urls.py
from django.conf.urls import url
from crud import views
urlpatterns = [
#url(r'^members/$', views.index, name='index'), #Auskommentieren
url(r'^members/$', views.MemberList.as_view(), name='index'), #hinzufügen
url(r'^members/add/$', views.edit, name='add'),
url(r'^members/edit/(?P<id>\d+)/$', views.edit, name='edit'),
url(r'^members/delete/(?P<id>\d+)/$', views.delete, name='delete'),
]
Zu diesem Zeitpunkt sollte nur eine Zeile angezeigt werden. (Ohne Vorwärts- / Rückwärtsfunktion).
Schreiben Sie HTML-Elemente für das Paging. Außerdem wird hier ein Klassenelement hinzugefügt, damit das Paging-Element von Bootstrap korrekt gerendert werden kann.
Fügen Sie den folgenden Inhalt in \ <! - Pagenation here-> in index.html ein.
members/index.html
<!--Pagenation (unten hinzugefügt)-->
{% if is_paginated %}
<ul class="pagination">
<!--Rückkehr<<Anzeigeverarbeitung-->
{% if page_obj.has_previous %}
<li><a href="?page={{ page_obj.previous_page_number }}">«</a></li>
{% else %}
<li class="disabled"><a href="#">«</a></li>
{% endif %}
<!--Seitenanzeige (wenn es viele gibt, ist eine separate Verarbeitung erforderlich) -->
{% for linkpage in page_obj.paginator.page_range %}
{% ifequal linkpage page_obj.number %}
<li class="active"><a href="#">{{ linkpage }}</a></li>
{% else %}
<li><a href="?page={{ linkpage }}">{{ linkpage }}</a></li>
{% endifequal %}
{% endfor %}
<!--Nächster>>Anzeigeverarbeitung-->
{% if page_obj.has_next %}
<li><a href="?page={{ page_obj.next_page_number }}">»</a></li>
{% else %}
<li class="disabled"><a href="#">»</a></li>
{% endif %}
</ul>
{% endif %}
Als nächstes werfen wir einen kurzen Blick auf die Validierung. Standardmäßig ist die im Modell festgelegte Spalte? Es scheint, dass die minimale Validierung (max_length usw.) gemäß den Informationen festgelegt wird. Es scheint auch, dass grundlegende Eingaben erforderlich sind.
Das ist nicht genug, also werde ich es hinzufügen. Der Zusatz scheint mit forms.py zu verwirren. Im folgenden Beispiel
Es ist wie es ist.
crud/forms.py
from django.forms import ModelForm
from crud.models import Member
from django import forms
import re
class MemberForm(ModelForm):
#Die im Modell definierten Bedingungen überschreiben? (Schreiben Sie vor der Beschreibung von Meta)
name = forms.CharField(required=False,max_length=8)
class Meta:
model = Member
fields = ('name','email','age',)
#Validierung jedes Elements
def clean_email(self):
email = self.cleaned_data['email']
#Aber vorerst
if re.match(r'.+@+',email) == None:
raise forms.ValidationError("Es ist keine E-Mail-Adresse.")
return email
Es scheint, dass die Validierung für jedes Element hinzugefügt werden kann, indem eine Methode namens clear_element name () definiert wird.
Die Bedeutung von> clear ~ scheint Daten zu bedeuten, die die grundlegende Validierung (clear) bestanden haben.
Ich hoffe, solche Dinge bald hinzuzufügen. Vorerst.
Recommended Posts