Pagination ist eine gemeinsame Funktion in Webanwendungen. Fast jede Laravel -Anwendung, an der ich jemals gearbeitet habe
Aber was ist Pagination und warum benutzen wir es? Wie k?nnen wir Paginierung in unseren Laravel -Anwendungen implementieren? Und wie entscheiden wir, welche Pagierungsmethode verwendet werden soll?In diesem Artikel werden wir genau diese Fragen beantworten und untersuchen, wie Pagination in Laravel sowohl für Blade -Ansichten als auch für API -Endpunkte verwendet wird. Am Ende dieses Artikels sollten Sie sich sicher genug fühlen, um in Ihren eigenen Projekten eine Paginierung zu verwenden.
#Was ist Pagination?
Pagination ist eine Technik, mit der ein gro?er Datensatz in kleinere Stücke (oder Seiten) unterteilt wird. Sie k?nnen eine Teilmenge der Daten anstelle aller m?glichen Werte gleichzeitig anzeigen.
Stellen Sie sich beispielsweise vor, Sie h?tten eine Seite, die die Namen aller Benutzer in Ihrer Anwendung ausgibt. Wenn Sie Tausende von Benutzern h?tten, w?re es nicht praktisch, sie alle auf einer einzigen Seite anzuzeigen. Stattdessen k?nnen Sie auf jeder Seite Pagination verwenden, um eine Teilmenge der Benutzer (z.
Durch Verwendung von Pagination k?nnen Sie:
Verbesserung der Leistung Ihrer Anwendung - Da Sie gleichzeitig eine kleinere Teilmenge von Daten abrufen, müssen Sie weniger Daten aus der Datenbank abholen, sich verarbeiten und dann zurückgeben.
- Verbesserung der Benutzererfahrung - Es ist wahrscheinlich, dass der Benutzer immer nur an einer kleinen Teilmenge der Daten gleichzeitig interessiert ist (normalerweise auf den ersten Seiten, insbesondere wenn Filter und Suchbegriffe verwendet werden). Durch die Verwendung von Pagination k?nnen Sie vermeiden, Daten anzuzeigen, an denen der Benutzer nicht interessiert ist.
- Die Seitenladezeiten verbessern - Durch das Abrufen einer Teilmenge der Daten k?nnen Sie die Datenmenge reduzieren, die auf die Seite geladen werden müssen, wodurch die Lade- und JavaScript -Verarbeitungszeiten der Seite verbessert werden k?nnen.
- Pagination kann typischerweise in zwei verschiedene Typen aufgeteilt werden:
Offset -basierte Pagination - Dies ist die h?ufigste Art von Pagination, auf die Sie wahrscheinlich in Ihren Web -Apps sto?en, insbesondere in Benutzeroberfl?chen (UI). Dazu geh?ren eine Teilmenge von Daten aus der Datenbank basierend auf einem "Offset" und einer "Grenze". Zum Beispiel k?nnen Sie 10 Datens?tze ab dem 20. Datensatz abrufen, um die 3. Datenseite abzurufen.
- Cursor -basierte Pagination - Diese Art der Pagination beinhaltet das Abrufen einer Teilmenge von Daten basierend auf einem "Cursor". Der Cursor ist in der Regel eine eindeutige Kennung für einen Datensatz in der Datenbank. Zum Beispiel k?nnen Sie die n?chsten 10 Datens?tze aus dem Datensatz mit einer ID von 20 abrufen.
- Laravel bietet drei verschiedene Methoden zum pagierenden beredten Abfragen in Ihren Anwendungen:
-
paginate
- Verwendet eine Offset -basierte Pagination und holt die Gesamtzahl der Datens?tze im Datensatz ab. -
simplePaginate
- Verwendet eine Offset -basierte Pagination, holt aber nicht die Gesamtzahl der Datens?tze im Datensatz. -
cursorPaginate
- Verwendet Cursor -basierter Pagination und holt nicht die Gesamtzahl der Datens?tze im Datensatz.
Schauen wir uns jede dieser Methoden ausführlicher an.
#Die paginate
-Methode
verwenden
Mit der Methode paginate
k?nnen Sie eine Teilmenge von Daten aus der Datenbank basierend auf einem Offset und Grenzwert abrufen (wir werden uns sp?ter ansehen, wenn wir uns die zugrunde liegenden SQL -Abfragen ansehen).
Sie k?nnen die paginate
-Methode wie SO verwenden:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Ausführen des obigen Codes würde dazu führen, dass $users
eine Instanz von IlluminateContractsPaginationLengthAwarePaginator
ist, typischerweise ein IlluminatePaginationLengthAwarePaginator
Objekt. Diese Paginatorinstanz enth?lt alle Informationen, die Sie für die Anzeige der pagierten Daten in Ihrer Anwendung ben?tigen.
Die Methode paginate
kann die angeforderte Seitennummer automatisch basierend auf dem Parameter page
Abfrage in der URL ermitteln. Wenn Sie beispielsweise https://my-app.com/users?page=2
besucht haben, würde die paginate
-Methode die zweite Seite der Daten abrufen.
standardm??ig sind alle Paginierungsmethoden in Laravel standardm??ig 15 Datens?tze gleichzeitig abgerufen. Dies kann jedoch in einen anderen Wert ge?ndert werden (wir werden uns sp?ter ansehen, wie dies sp?ter geht).
#use paginate
mit Blade -Ansichten
Schauen wir uns an, wie die paginate
-Methode verwendet wird, wenn Daten in einer Klingenansicht rendern.
Stellen Sie sich vor, wir haben eine einfache Route, die die Benutzer aus der Datenbank in einem pagierten Format abruft und sie an eine Ansicht weitergibt:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
unsere resources/views/users/index.blade.php
Datei k?nnte ungef?hr so ??aussehen:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
Die resultierende Seite würde ungef?hr so ??aussehen:
Lassen Sie uns zusammenbrechen, was in der Klingeansicht passiert:
- Wir schauen jeden Benutzer durch, der im Feld
$users
(dasIlluminatePaginationLengthAwarePaginator
-Objekt) vorhanden ist und seinen Namen ausgibt. - nennen wir die
links
-Methode im$users
-Objekt. Dies ist eine wirklich praktische Methode, die einige HTML zurückgibt, die die Paginierungslinks (z. B. "vorher", "Next" und die Seitennummern anzeigen). Dies bedeutet
-Methode uns einen überblick über die Paginierungsdaten gibt. Wir k?nnen sehen, dass wir die 16. bis 30. Rekorde von insgesamt 50 Datens?tzen betrachten. Wir k?nnen auch sehen, dass wir auf der zweiten Seite sind und dass es insgesamt 4 Seiten gibt. paginate
-Methode das HTML -Stil mit dem Rückenwind -CSS zurückgibt. Wenn Sie etwas anderes als Rückenwind verwenden m?chten oder die Paginierungsverlinks selbst stylen m?chten, k?nnen Sie die Dokumentation zum Anpassen von Paginationsansichten überprüfen. links
In den API -Endpunkten paginate
sowie die -Methode in Blade -Ansichten verwenden Sie sie auch in den API -Endpunkten. Laravel erleichtert diesen Vorgang durch automatische Konvertierung der pagierten Daten in JSON. paginate
-Dendpunkt erstellen (indem wir die folgende Route zu unserer /api/users
-Datei hinzufügen), die die pagierten Benutzer im JSON -Format zurückgibt: routes/api.php
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();Zugriff auf den Endpunkt
würde eine JSON -Antwort zurückgeben, die dem folgenden ?hnlich ist
/api/users
data
Lassen Sie uns die JSON -Antwort aufschlüsseln:
-
current_page
- Die aktuelle Seite, auf der wir uns befinden. In diesem Fall sind wir auf der ersten Seite. -
data
- Die tats?chlichen Daten selbst, die zurückgegeben werden. In diesem Fall enth?lt es die ersten 15 Benutzer (verkürzt auf 3 für Kürze). -
first_page_url
- Die URL zur ersten Datenseite. -
from
- Die Startdatensatznummer der zurückgegebenen Daten. In diesem Fall ist es der erste Rekord. Wenn wir auf der zweiten Seite w?ren, w?re dies 16. -
last_page
- Die Gesamtzahl der Datenseiten. In diesem Fall gibt es 4 Seiten. -
last_page_url
- Die URL zur letzten Datenseite. -
links
- Ein Array von Links zu den verschiedenen Datenseiten. Dies umfasst die "vorherigen" und "n?chsten" Links sowie die Seitenzahlen. -
next_page_url
- Die URL zur n?chsten Datenseite. -
path
- Die Basis -URL des Endpunkts. -
per_page
- Die Anzahl der zurückgegebenen Datens?tze pro Seite. In diesem Fall ist es 15. -
prev_page_url
- Die URL zur vorherigen Datenseite. In diesem Fall ist esnull
, weil wir auf der ersten Seite sind. Wenn wir auf der zweiten Seite w?ren, w?re dies die URL zur ersten Seite. -
to
- Die Enddatensatznummer der zurückgegebenen Daten. In diesem Fall ist es der 15. Rekord. Wenn wir auf der zweiten Seite w?ren, w?re dies 30. -
total
- Die Gesamtzahl der Datens?tze im Datensatz. In diesem Fall gibt es 50 Datens?tze.
#Die zugrunde liegende SQL -Abfragen
Verwenden der paginate
-Methode in Laravel führt zu zwei SQL -Abfragen:
- Die erste Abfrage holt die Gesamtzahl der Datens?tze im Datensatz ab. Dies wird verwendet, um Informationen wie die Gesamtzahl der Seiten und die Gesamtzahl der Datens?tze zu bestimmen.
- Die zweite Abfrage holt die Teilmenge der Daten basierend auf den Offset- und Grenzwerten. Zum Beispiel k?nnte es die Benutzer abrufen, damit wir verarbeiten und zurückkehren k?nnen.
Wenn wir also die erste Seite von Benutzern (mit 15 Benutzern pro Seite) abrufen wollten, werden die folgenden SQL -Abfragen ausgeführt:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
und
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
In der zweiten Abfrage k?nnen wir sehen, dass der Wert limit
auf 15 gesetzt ist. Dies ist die Anzahl der Datens?tze, die pro Seite zurückgegeben werden.
Der Wert offset
wird wie folgt berechnet:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
Wenn wir also die dritte Seite der Benutzer holen wollten, wird der Wert offset
berechnet als:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });
Daher w?re der Wert offset
30 und wir würden die 31. bis 45. Datens?tze holen. Die Abfragen für die dritte Seite würden so aussehen:
<!-- Syntax highlighted by torchlight.dev -->{ "current_page": 1, "data": [ { "id": 1, "name": "Andy Runolfsson", "email": "teresa.wiegand@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 2, "name": "Rafael Cummings", "email": "odessa54@example.org", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 3, "name": "Reynold Lindgren", "email": "juwan.johns@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" } ], "first_page_url": "http://example.com/users?page=1", "from": 1, "last_page": 4, "last_page_url": "http://example.com/users?page=4", "links": [ { "url": null, "label": "« Previous", "active": false }, { "url": "http://example.com/users?page=1", "label": "1", "active": true }, { "url": "http://example.com/users?page=2", "label": "2", "active": false }, { "url": "http://example.com/users?page=3", "label": "3", "active": false }, { "url": "http://example.com/users?page=4", "label": "4", "active": false }, { "url": "http://example.com/users?page=5", "label": "5", "active": false }, { "url": "http://example.com/users?page=2", "label": "Next »", "active": false } ], "next_page_url": "http://example.com/users?page=2", "path": "http://example.com/users", "per_page": 15, "prev_page_url": null, "to": 15, "total": 50 }
und
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
#Die simplePaginate
-Methode
verwenden
Die simplePaginate
-Methode ist der paginate
-Methode jedoch sehr ?hnlich, jedoch mit einem Schlüsselunterschied. Die simplePaginate
-Methode holt nicht die Gesamtzahl der Datens?tze im Datensatz ab.
Wie wir gerade gesehen haben, erhalten wir, wenn wir die paginate
-Methode verwenden, auch Informationen über die Gesamtzahl der im Datensatz verfügbaren Datens?tze und Seiten. Wir k?nnen diese Informationen dann verwenden, um Dinge wie die Gesamtzahl der Seiten in der UI- oder API -Antwort anzuzeigen.
Wenn Sie diese Details jedoch nicht dem Benutzer (oder Entwickler, der die API verbraucht), k?nnen wir eine nicht ben?tigte Datenbankabfrage vermeiden (die die Gesamtzahl der Datens?tze z?hlt) mithilfe der Methode simplePaginate
.
Die simplePaginate
-Methode kann auf die gleiche Weise wie die paginate
-Methode verwendet werden:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Ausführen des obigen Code
$users
Im Gegensatz zu dem von der IlluminateContractsPaginationPaginator
-Methode zurückgegebenen IlluminatePaginationPaginator
-Objekt enth?lt das Objekt
IlluminatePaginationLengthAwarePaginator
#use paginate
mit Blade -Ansichten IlluminatePaginationPaginator
-Methode mit einer Klingenansicht verwenden k?nnen. Wir gehen davon aus
simplePaginate
Wir werden unsere Klingenansicht genauso erstellen wie zuvor:
simplePaginate
simplePaginate
Die resultierende Seite würde ungef?hr so ??aussehen:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });
Wie wir in diesem Beispiel sehen k?nnen, unterscheidet sich die Ausgabe von
von der Ausgabe, die wir bei der Verwendung der -Methode gesehen haben. Da die Methode die Gesamtzahl der Datens?tze nicht abrei?t, hat sie keinen Kontext der Gesamtzahl der Seiten oder Datens?tze, nur ob es eine n?chste Seite gibt oder nicht. Daher sehen wir nur die "vorherigen" und "n?chsten" Links in den Paginationslinks.
In den API -Endpunkten $users->links()
paginate
Sie k?nnen auch die simplePaginate
-Methode in den API -Endpunkten verwenden. Laravel konvertiert die pagierten Daten automatisch in JSON für Sie.
Erstellen wir einen simplePaginate
-Getriebe, der die pagierten Benutzer im JSON -Format zurücksetzt:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Wenn wir diese Route erreichen, erhalten wir eine JSON -Antwort ?hnlich wie folgt (ich habe das Feld data
auf nur 3 Datens?tze für die Kürze beschr?nkt):
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Wie wir sehen k?nnen, ist die JSON -Antwort der Antwort sehr ?hnlich, die wir bei der Verwendung der paginate
-Methode erhalten haben. Der Hauptunterschied besteht
last_page
#Die zugrunde liegende SQL -Abfragen last_page_url
links
Schauen wir uns die zugrunde liegenden SQL -Abfragen an, die bei Verwendung der total
-Methode ausgeführt werden.
Die
-Methode basiert immer noch auf den Werten und simplePaginate
, um die Teilmenge der Daten aus der Datenbank abzurufen. Die Abfrage wird jedoch nicht ausgeführt, um die Gesamtzahl der Datens?tze im Datensatz abzurufen.
Der Wert simplePaginate
wird weiterhin auf die gleiche Weise berechnet wie zuvor: limit
offset
-Werwert geringfügig unterschiedlich berechnet als die offset
-Methode. Es wird berechnet als:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
Dies liegt daran, dass die limit
-Methode einen weiteren Datensatz als den paginate
-Werte abrufen muss, um festzustellen, ob mehr Datens?tze abgerufen werden müssen. Angenommen, wir holen 15 Datens?tze pro Seite. Der Wert
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });
Wenn wir also die erste Seite von Benutzern (mit 15 Benutzern pro Seite) abrufen wollten, werden die folgenden SQL -Abfragen ausgeführt: simplePaginate
perPage
limit
Die Abfrage für die zweite Seite würde so aussehen:
#Die
<!-- Syntax highlighted by torchlight.dev -->{ "current_page": 1, "data": [ { "id": 1, "name": "Andy Runolfsson", "email": "teresa.wiegand@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 2, "name": "Rafael Cummings", "email": "odessa54@example.org", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 3, "name": "Reynold Lindgren", "email": "juwan.johns@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" } ], "first_page_url": "http://example.com/users?page=1", "from": 1, "last_page": 4, "last_page_url": "http://example.com/users?page=4", "links": [ { "url": null, "label": "« Previous", "active": false }, { "url": "http://example.com/users?page=1", "label": "1", "active": true }, { "url": "http://example.com/users?page=2", "label": "2", "active": false }, { "url": "http://example.com/users?page=3", "label": "3", "active": false }, { "url": "http://example.com/users?page=4", "label": "4", "active": false }, { "url": "http://example.com/users?page=5", "label": "5", "active": false }, { "url": "http://example.com/users?page=2", "label": "Next »", "active": false } ], "next_page_url": "http://example.com/users?page=2", "path": "http://example.com/users", "per_page": 15, "prev_page_url": null, "to": 15, "total": 50 }-Methode
verwenden
Bisher haben wir uns die Methoden<!-- Syntax highlighted by torchlight.dev -->select count(*) as aggregate from `users`und
angesehen, die beide eine offset-basierte Pagination verwenden. Wir werden uns jetzt die cursorPaginate
-Methode ansehen, die Cursor-basierte Pagination verwendet.
Als Heads-up scheint der Cursor-basierte Pagination ein wenig verwirrend zu sein, wenn Sie zum ersten Mal darauf sto?en. Machen Sie sich also keine Sorgen, wenn Sie es nicht sofort verstehen. Hoffentlich werden Sie am Ende dieses Artikels ein besseres Verst?ndnis dafür haben, wie es funktioniert. Ich werde am Ende dieses Artikels auch ein fantastisches Video hinterlassen, in dem der Cursor-basierte Pagination ausführlicher erkl?rt wird. paginate
simplePaginate
Mit einer offset-basierten Pagination verwenden wir die Werte cursorPaginate
und
Nehmen wir zum Beispiel an, wir machen eine Frage, um die ersten 15 Benutzer abzurufen. Wir gehen davon aus, dass die ID des 15. Benutzers 20 ist. Wenn wir die n?chsten 15 Benutzer abrufen m?chten, verwenden wir die ID des 15. Benutzers (20) als Cursor. Wir werden sagen "Die n?chsten 15 Benutzer mit einer ID von mehr als 20 abrufen".
Sie k?nnen manchmal Cursors sehen, die als "Token", "Keys", "Next", "vorher" und so weiter bezeichnet werden. Sie sind im Wesentlichen ein Verweis auf einen bestimmten Datensatz in der Datenbank. Wir werden uns die Struktur der Cursoren sp?ter in diesem Abschnitt ansehen, wenn wir uns die zugrunde liegenden SQL -Abfragen ansehen.
Mit Laravel k?nnen wir die Cursor-basierte Pagination mit der cursorPaginate
-Methode leicht verwenden:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Ausführen des obigen Codes würde dazu führen, dass das Feld $users
eine Instanz von IlluminateContractsPaginationCursorPaginator
ist, typischerweise ein IlluminatePaginationCursorPaginator
-Objekt. Diese Paginatorinstanz enth?lt alle Informationen, die Sie für die Anzeige der pagierten Daten in Ihrer Anwendung ben?tigen.
?hnlich wie bei der simplePaginate
-Methode f?rdert die cursorPaginate
-Methode nicht die Gesamtzahl der Datens?tze im Datensatz. Es kennt nur die aktuelle Datenseite und darüber, ob mehr Datens?tze abgerufen werden müssen. Daher sind wir uns nicht sofort der Gesamtzahl der Seiten oder Datens?tze bewusst.
#use cursorPaginate
mit Blade -Ansichten
Schauen wir uns an, wie Sie die cursorPaginate
-Methode verwenden, wenn Daten in einer Klingenansicht rendern. ?hnlich wie bei unseren früheren Beispielen werden wir annehmen, dass wir eine einfache Route haben, die die Benutzer aus der Datenbank in einem paginierten Format abrei?t und sie an eine Ansicht weitergibt:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Die Klingeansicht k?nnte ungef?hr so ??aussehen:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
Dies würde eine Seite ?hnlich wie folgt ausgeben:
Wie wir sehen k?nnen, ist die Ausgabe von cursorPaginate
nicht die Gesamtzahl der Datens?tze im Datensatz $users->links()
, da die Ausgabe von simplePaginate
bei der Verwendung der
cursorPaginate
#using
In den API -Endpunkten
Mit cursorPaginate
Laravel k?nnen Sie auch die Methode
/api/users
Erstellen wir einen
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });
data
Wenn wir diese Route erreichen, erhalten wir eine JSON -Antwort ?hnlich wie folgt (ich habe das Feld
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Wie wir sehen k?nnen, ?hnelt die JSON -Antwort den vorherigen Antworten, die wir gesehen haben, jedoch mit einigen kleinen Unterschieden. Da wir nicht die Gesamtzahl der Datens?tze abrufen, haben wir nicht die Felder last_page
, last_page_url
, links
oder total
in der Antwort. M?glicherweise haben Sie auch bemerkt, dass wir auch nicht die Felder from
und to
haben.
Stattdessen haben wir die Felder next_cursor
und prev_cursor
, die den Cursor für die n?chsten und vorherigen Datenseiten enthalten. Da wir auf der ersten Seite sind, sind die Felder prev_cursor
und prev_page_url
beide null
. Die Felder next_cursor
und next_page_url
sind jedoch festgelegt.
Das Feld next_cursor
ist eine base-64-codierte Zeichenfolge, die den Cursor für die n?chste Datenseite enth?lt. Wenn wir das Feld next_cursor
dekodieren, bekommen wir so etwas (für die Lesbarkeit versch?nert):
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Der Cursor enth?lt zwei separate Informationen:
-
users.id
- Die ID des letzten im Datensatzes abgerufenen Datensatzes. -
_pointsToNextItems
- Ein boolescher Wert, der uns zeigt, ob der Cursor auf die n?chste oder vorherige Elemente hinweist. Wenn der Werttrue
ist, bedeutet dies, dass der Cursor verwendet werden sollte, um den n?chsten Satz von Datens?tzen mit einer ID zu holen, die gr??er als derusers.id
-Werte ist. Wenn der Wertfalse
ist, bedeutet dies, dass der Cursor verwendet werden sollte, um den vorherigen Satz von Datens?tzen mit einer ID unter dem Wertusers.id
abzurufen.
Schauen wir uns an, wie die zweite Seite der Daten aussehen k?nnte (erneut verkürzt auf 3 Datens?tze für die Kürze):
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
k?nnen wir sehen, dass die Felder prev_cursor
und prev_page_url
jetzt festgelegt sind und die Felder next_cursor
und next_page_url
für die n?chste Datenseite mit dem Cursor aktualisiert wurden.
#Die zugrunde liegende SQL -Abfragen
Um ein besseres Verst?ndnis dafür zu bekommen, wie die Cursorpagination unter der Haube funktioniert, schauen wir uns die zugrunde liegenden SQL
cursorPaginate
Auf der ersten Datenseite (mit 15 Datens?tzen) würde die folgende SQL -Abfrage ausgeführt:
Wir k?nnen sehen, dass wir die ersten 16 Datens?tze aus der Tabelle
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });abrufen und sie in der Spalte
in aufsteigender Reihenfolge bestellen. ?hnlich wie bei der users
-Methode holen wir 16 Zeilen, weil wir feststellen m?chten, ob mehr Datens?tze zum Abrufen sind. id
simplePaginate
Stellen wir uns vor, wir navigieren dann mit dem folgenden Cursor zur n?chsten Seite der Elemente:
Wenn dieser Cursor dekodiert ist, erhalten wir das folgende JSON -Objekt:
<!-- Syntax highlighted by torchlight.dev -->{ "current_page": 1, "data": [ { "id": 1, "name": "Andy Runolfsson", "email": "teresa.wiegand@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 2, "name": "Rafael Cummings", "email": "odessa54@example.org", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 3, "name": "Reynold Lindgren", "email": "juwan.johns@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" } ], "first_page_url": "http://example.com/users?page=1", "from": 1, "last_page": 4, "last_page_url": "http://example.com/users?page=4", "links": [ { "url": null, "label": "« Previous", "active": false }, { "url": "http://example.com/users?page=1", "label": "1", "active": true }, { "url": "http://example.com/users?page=2", "label": "2", "active": false }, { "url": "http://example.com/users?page=3", "label": "3", "active": false }, { "url": "http://example.com/users?page=4", "label": "4", "active": false }, { "url": "http://example.com/users?page=5", "label": "5", "active": false }, { "url": "http://example.com/users?page=2", "label": "Next »", "active": false } ], "next_page_url": "http://example.com/users?page=2", "path": "http://example.com/users", "per_page": 15, "prev_page_url": null, "to": 15, "total": 50 }
Laravel wird dann die folgende SQL -Abfrage ausführen, um den n?chsten Satz von Datens?tzen abzurufen:
<!-- Syntax highlighted by torchlight.dev -->select count(*) as aggregate from `users`
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Wie wir sehen k?nnen, holen wir die n?chsten 16 Datens?tze aus der Tabelle users
mit einem id
gr??er als 15 (da 15 die letzte ID auf der vorherigen Seite war).
Nehmen wir nun an, dass die ID des ersten Benutzers auf Seite 2 16 ist. Wenn wir zurück zur ersten Datenseite der zweiten Seite navigieren, würde der folgende Cursor verwendet:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Wenn dies dekodiert ist, erhalten wir das folgende JSON -Objekt:
<!-- Syntax highlighted by torchlight.dev --><html> <head> <title>Paginate</title> <script src="https://cdn.tailwindcss.com"></script> </head> <body> <div class="max-w-5xl mx-auto py-8"> <h1 class="text-5xl">Paginate</h1> <ul class="py-4"> @foreach ($users as $user) <li class="py-1 border-b">{{ $user->name }}</li> @endforeach </ul> {{ $users->links() }} </div> </body> </html>
Wenn wir zur n?chsten Ergebnisse übergehen, wird der letzte abgerufene Datensatz als Cursor verwendet. Wenn wir zur vorherigen Ergebnisse zurückkehren, wird der erste abgerufene Datensatz als Cursor verwendet. Aus diesem Grund k?nnen wir sehen, dass der Wert users.id
im Cursor auf 16 eingestellt ist. Wir k?nnen auch sehen, dass der Wert _pointsToNextItems
auf false
festgelegt wird, da wir zu den vorherigen Elementen zurückkehren.
Infolgedessen würde die folgende SQL -Abfrage ausgeführt, um den vorherigen Satz von Datens?tzen zu holen:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('paginate', function () { return User::query()->paginate(); });
Wie wir sehen k?nnen, prüft die Einschr?nkung where
nun auf Datens?tze mit einem id
weniger als 16 (da 16 die erste ID auf Seite 2 war) und die Ergebnisse in absteigender Reihenfolge bestellt werden.
#Used API -Ressourcen mit Pagination
In unseren API -Beispielen haben wir bisher die paginierten Daten direkt vom Controller zurückgegeben. In einer realen Anwendung m?chten Sie jedoch wahrscheinlich die Daten verarbeiten, bevor Sie sie an den Benutzer zurückgeben. Dies kann alles aus dem Hinzufügen oder Entfernen von Feldern, dem Konvertieren von Datentypen oder sogar von der Umwandlung der Daten in ein anderes Format sein. Aus diesem Grund m?chten Sie wahrscheinlich API -Ressourcen verwenden, da sie eine M?glichkeit bieten, Ihre Daten konsequent zu transformieren, bevor sie diese zurückgeben.
MitLaravel k?nnen Sie API -Ressourcen neben Pagination verwenden. Schauen wir uns ein Beispiel dafür an, wie es geht.
Stellen Sie sich vor, wir haben eine AppHttpResourcesUserResource
API -Ressourcenklasse erstellt, die die Benutzerdaten vor der Rückgabe transformiert. Es k?nnte ungef?hr so ??aussehen:
<!-- Syntax highlighted by torchlight.dev -->{ "current_page": 1, "data": [ { "id": 1, "name": "Andy Runolfsson", "email": "teresa.wiegand@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 2, "name": "Rafael Cummings", "email": "odessa54@example.org", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" }, { "id": 3, "name": "Reynold Lindgren", "email": "juwan.johns@example.net", "email_verified_at": "2024-10-15T23:19:28.000000Z", "created_at": "2024-10-15T23:19:29.000000Z", "updated_at": "2024-10-15T23:19:29.000000Z" } ], "first_page_url": "http://example.com/users?page=1", "from": 1, "last_page": 4, "last_page_url": "http://example.com/users?page=4", "links": [ { "url": null, "label": "« Previous", "active": false }, { "url": "http://example.com/users?page=1", "label": "1", "active": true }, { "url": "http://example.com/users?page=2", "label": "2", "active": false }, { "url": "http://example.com/users?page=3", "label": "3", "active": false }, { "url": "http://example.com/users?page=4", "label": "4", "active": false }, { "url": "http://example.com/users?page=5", "label": "5", "active": false }, { "url": "http://example.com/users?page=2", "label": "Next »", "active": false } ], "next_page_url": "http://example.com/users?page=2", "path": "http://example.com/users", "per_page": 15, "prev_page_url": null, "to": 15, "total": 50 }
In der Methode toArray
definieren wir, dass wir, wenn wir einen Benutzer über diese Ressource verarbeiten, nur die Felder id
, name
und email
zurückgeben m?chten.
Erstellen wir nun einen einfachen /api/users
API -Endpunkt in unserer routes/api.php
-Datei, die die paginierten Benutzer mithilfe des AppHttpResourcesUserResource
:
<!-- Syntax highlighted by torchlight.dev -->select count(*) as aggregate from `users`
im obigen Code holen wir eine einzige Seite von Benutzern (nehmen wir an, es ist die erste Seite mit 15 Benutzern) aus der Datenbank. Wir übergeben dann das Feld $users
(das eine Instanz von IlluminatePaginationLengthAwarePaginator
) an die UserResource::collection
-Methode sein wird. Diese Methode transformiert die paginierten Daten mithilfe der AppHttpResourcesUserResource
, bevor sie an den Benutzer zurückgegeben wird.
Wenn wir auf den Endpunkt /api/users
klicken, erhalten wir eine JSON -Antwort ?hnlich wie folgt (ich habe das Feld data
auf nur 3 Datens?tze für die Kürze eingeschr?nkt):
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Wie wir im obigen JSON sehen k?nnen, erkennt Laravel, dass wir mit einem pagierten Datensatz arbeiten und die pagierten Daten wie zuvor in einem ?hnlichen Format zurückgeben. Diesmal enthalten die Benutzer im Feld data
jedoch nur die Felder id
, name
und email
, die wir in unserer API -Ressourcenklasse angegeben haben. Andere Felder (current_page
, from
, last_page
, links
, path
, per_page
, to
und total
) werden immer noch zurückgegeben, da sie Teil der paginierten Daten sind, aber sie wurden in einem meta
-Feld platziert. Es gibt auch ein links
Feld, das die Links first
, last
, prev
und next
enth?lt, zu den verschiedenen Datenseiten.
#changieren Sie den pro Seitenwert
Beim Erstellen von Ansichten mit paginierten Daten m?chten Sie dem Benutzer m?glicherweise erm?glichen, die Anzahl der pro Seite angezeigten Datens?tze zu ?ndern. Dies kann über ein Dropdown- oder Zahlen -Eingangsfeld geschehen.
laravel erleichtert die Anzahl der pro Seite angezeigten Datens?tze, indem ein perPage
-Parameter an die Methoden simplePaginate
, paginate
und cursorPaginate
übergeben wird. Mit diesem Parameter k?nnen Sie die Anzahl der Datens?tze angeben, die Sie pro Seite anzeigen m?chten.
Schauen wir uns ein einfaches Beispiel dafür an, wie Sie einen per_page
-Anterfrageparameter lesen und diese verwenden, um die Anzahl der pro Seite abgerufenen Datens?tze zu ?ndern:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; use Illuminate\Support\Facades\Route; Route::get('users', function () { $users = User::query()->paginate(); return view('users.index', [ 'users' => $users, ]); });
Im obigen Beispiel greifen wir den Wert des Parameters per_page
abfragen. Wenn der Wert nicht bereitgestellt wird, werden wir standardm??ig 10. Dann übergeben wir diesen Wert an den Parameter perPage
der Methode paginate
.
wir konnten dann auf diese verschiedenen URLs zugreifen:
-
https://my-app.com/users
- Zeigen Sie die erste Seite von Benutzern mit 10 Datens?tzen pro Seite an. -
https://my-app.com/users?per_page=5
- Zeigen Sie die erste Seite von Benutzern mit 5 Datens?tzen pro Seite an. -
https://my-app.com/users?per_page=5&page=2
- Zeigen Sie die zweite Seite von Benutzern mit 5 Datens?tzen pro Seite an. - und so weiter ...
#Wow, um zu entscheiden, welche Pagierungsmethode
verwendet werden sollNachdem wir uns die verschiedenen Arten von Pagination angesehen haben und wie sie in Laravel verwendet werden, werden wir diskutieren, wie Sie entscheiden k?nnen, welche dieser Ans?tze in Ihrer Anwendung verwendet werden sollen.
#do Sie ben?tigen die Seitennummer oder die Gesamtzahl der Datens?tze?
Wenn Sie einen UI- oder API -Endpunkt erstellen, bei dem die Gesamtzahl der Datens?tze oder Seiten angezeigt werden muss, ist die Methode paginate
wahrscheinlich eine vernünftige Wahl.
Wenn Sie keine von diesen ben?tigen, ist die simplePaginate
oder cursorPaginate
effizienter, da sie keine unn?tigen Abfragen ausführen, um die Gesamtzahl der Datens?tze zu z?hlen.
#do Sie müssen zu einer bestimmten Seite springen?
Wenn Sie in der Lage sein müssen, auf eine bestimmte Datenseite zu springen, ist eine offset-basierte Pagination besser geeignet. Da der Cursor -Pagination staatlich ist, basiert es auf der vorherigen Seite, um zu wissen, wohin Sie als n?chstes gehen sollen. Es ist also nicht so einfach, zu einer bestimmten Seite zu springen.
W?hrend Sie bei der Verwendung von Offset -Pagination die Seitennummer in der Anforderung (m?glicherweise als Abfrageparameter) übergeben und zu dieser Seite springen, ohne einen Kontext der vorherigen Seite zu haben.
#Wie gro? ist der Datensatz?
Aufgrund der Art und Weise, wie Datenbanken offset
Werte verarbeiten, wird die offsetbasierte Pagination mit zunehmendem Seitenzahl weniger effizient. Dies liegt daran, dass die Datenbank bei Verwendung eines Offsets immer noch alle Datens?tze bis zum Offset -Wert durchsuchen muss. Sie werden nur verworfen und in den Abfrageberichten nicht zurückgegeben.
Hier ist ein gro?artiger Artikel, in dem dies genauer erkl?rt: https://use-the-index-luke.com/no-cret.
Wenn die Gesamtmenge der Daten in der Datenbank w?chst und die Seitenzahl zunimmt, kann die offsetbasierte Pagination weniger effizient werden. In diesen F?llen ist die Cursor-basierte Pagination leistungsf?higer, insbesondere wenn das Cursorfeld indiziert ist, da die vorherigen Datens?tze nicht gelesen werden. Wenn Sie eine Paginierung gegen einen gro?en Datensatz verwenden, m?chten Sie sich m?glicherweise für die Cursorpagination über die Offset -Pagination entscheiden.
#iis Der Datensatz ?ndert sich wahrscheinlich oft?
Offset-basierte Pagination kann unter Problemen leiden, wenn der zugrunde liegende Datensatz zwischen Anforderungen ?ndert.
Schauen wir uns ein Beispiel an.
Nehmen wir an, wir haben die folgenden 10 Benutzer in unserer Datenbank:
- Benutzer 1
- Benutzer 2
- Benutzer 3
- Benutzer 4
- Benutzer 5
- Benutzer 6
- Benutzer 7
- Benutzer 8
- Benutzer 9
- Benutzer 10
Wir stellen eine Anfrage zum Abrufen der ersten Seite (5 Benutzer) und die folgenden Benutzer abrufen:
- Benutzer 1
- Benutzer 2
- Benutzer 3
- Benutzer 4
- Benutzer 5
Wenn wir zu Seite 2 navigieren, erwarten wir die Benutzer von 6 bis 10. Stellen wir uns jedoch vor, dass Benutzer 1 aus der Datenbank gel?scht wird, bevor wir Seite 2 laden (w?hrend wir noch Seite 1 anzeigen). Da die Seitengr??e 5 ist, würde die Abfrage zum Abrufen der n?chsten Seite so aussehen:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Dies bedeutet, dass wir die ersten 5 Datens?tze überspringen und die n?chsten abrufen 5.
Dies würde dazu führen, dass Seite 2 die folgenden Benutzer enthalten:
- Benutzer 7
- Benutzer 8
- Benutzer 9
- Benutzer 10
Wie wir sehen, fehlt Benutzer 6 in der Liste. Dies liegt daran, dass Benutzer 6 jetzt der 5. Datensatz in der Tabelle ist, also sind sie tats?chlich auf der ersten Seite.
Cursor-basierter Pagination hat dieses Problem nicht, da wir keine Datens?tze überspringen. Wir holen nur den n?chsten Satz von Datens?tzen, die auf einem Cursor basieren. Stellen wir uns vor, wir hatten im obigen Beispiel Cursor-basierte Pagination verwendet. Der Cursor für Seite 2 w?re die ID von Benutzer 5 (von dem wir annehmen, dass er 5 ist), da es der letzte Datensatz auf der ersten Seite war. Unsere Abfrage für Seite 2 kann also so aussehen:
<!-- Syntax highlighted by torchlight.dev -->use App\Models\User; $users = User::query()->paginate();
Ausführen der obigen Abfrage würde die Benutzer wie erwartet 6 bis 10 zurückgeben.
Dies sollte hoffentlich hervorheben, wie eine packungsbasierte Pagination problematisch werden kann, wenn die zugrunde liegenden Daten ge?ndert, hinzugefügt oder entfernt werden, w?hrend sie gelesen werden. Es wird weniger vorhersehbar und kann zu unerwarteten Ergebnissen führen.
#are Sie bauen eine API?
Es ist wichtig, sich daran zu erinnern, dass Sie nicht auf eine einzelne Art von Pagination in Ihrer Anwendung befestigt sind. An einigen Stellen kann die Offset -Pagination besser geeignet sein (m?glicherweise für UI -Zwecke), und in anderen kann die Cursorpagination effizienter sein (z. B. bei der Arbeit mit einem gro?en Datensatz). So k?nnen Sie je nach Anwendungsfall Paginationsmethoden in Ihrer Anwendung mischen und anpassen.
Wenn Sie jedoch eine API bauen, würde ich Ihnen sehr empfehlen, dass Sie konsistent sind und einen einzelnen Paginationsansatz für alle Ihre Endpunkte verwenden. Dies erleichtert Entwicklern zu verstehen, wie Sie Ihre API verwenden und Verwirrung vermeiden k?nnen.
Sie m?chten nicht, dass sie sich daran erinnern müssen, welche Endpunkte die Offset-Pagination verwenden und welche Cursor-Pagination verwenden.
Dies ist natürlich keine harte und schnelle Regel. Wenn Sie wirklich eine andere Paginierungsmethode in einem bestimmten Endpunkt verwenden müssen, dann fahren Sie fort. Stellen Sie jedoch nur sicher, dass Sie in der Dokumentation klar machen, dass Entwickler das Verst?ndnis erleichtert.
#Prefer ein Video stattdessen?
Wenn Sie eher ein visueller Lerner sind, sollten Sie sich dieses gro?artige Video von Aaron Francis ansehen, das den Unterschied zwischen Offset- und Cursor-basierter Pagination ausführlicher erkl?rt:
#Conclusion
In diesem Artikel haben wir uns die verschiedenen Arten der Pagination in Laravel und in der Art und Weise angesehen, wie sie verwendet werden. Wir haben uns auch ihre zugrunde liegenden SQL -Abfragen angesehen und wie man entscheidet, welche Pagination in Ihrer Anwendung verwendet werden soll.
Hoffentlich sollten Sie sich jetzt sicherer fühlen, wenn Sie Paginierung in Ihren Laravel -Anwendungen verwenden.
Das obige ist der detaillierte Inhalt vonEin Leitfaden zur Paginierung in Laravel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Hei?e KI -Werkzeuge

Undress AI Tool
Ausziehbilder kostenlos

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem v?llig kostenlosen KI-Gesichtstausch-Tool aus!

Hei?er Artikel

Hei?e Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Hei?e Themen





Um zwei PHP -Arrays zusammenzuführen und eindeutige Werte zu behalten, gibt es zwei Hauptmethoden. 1. Verwenden Sie für Index -Arrays oder nur Deduplizierung Array_merge und Array_unique -Kombinationen: Zuerst merge array_merge ($ array1, $ array2) und verwenden Sie dann Array_unique (), um sie endgültig zu erhalten, um ein neues Array zu erhalten, das alle eindeutigen Werte enth?lt. 2. Verwenden Sie für assoziative Arrays und m?chten im ersten Array Schlüsselwertepaare beibehalten: $ result = $ array1 $ array2, was sicherstellt, dass die Schlüssel im ersten Array vom zweiten Array nicht überschrieben werden. Diese beiden Methoden gelten für verschiedene Szenarien, je nachdem, ob der Schlüsselname beibehalten wird oder nur der Fokus liegt

Um die St?rke des Kennworts zu bestimmen, muss die regelm??ige und logische Verarbeitung kombiniert werden. Die grundlegenden Anforderungen umfassen: 1. Die L?nge betr?gt mindestens 8 Ziffern; 2. Enthaltende Kleinbuchstaben, Gro?buchstaben und Zahlen; 3.. Spezielle Charakterbeschr?nkungen k?nnen hinzugefügt werden; In Bezug auf fortgeschrittene Aspekte müssen eine kontinuierliche Vervielf?ltigung von Zeichen und inkrementelle/abnehmende Sequenzen vermieden werden, was eine PHP -Funktionserkennung erfordert. Gleichzeitig sollten Blacklists vorgestellt werden, um gemeinsame schwache Passw?rter wie Passwort und 123456 zu filtern. Schlie?lich wird empfohlen, die ZXCVBN -Bibliothek zu kombinieren, um die Bewertungsgenauigkeit zu verbessern.

Um PHP -Datei -Uploads sicher zu verarbeiten, müssen Sie die Quelle und die Type und die Eingabe des Dateinamens und des Pfades überprüfen, Serverbeschr?nkungen festlegen und Mediendateien zweimal verarbeiten. 1. überprüfen Sie die Upload -Quelle, um CSRF durch Token zu verhindern, und erkennen Sie den realen MIME -Typ über die Finfo_file mithilfe der Whitelist -Steuerung. 2. Benennen Sie die Datei in eine zuf?llige Zeichenfolge um und bestimmen Sie die Erweiterung, um sie gem?? dem Erkennungstyp in einem Verzeichnis ohne Web zu speichern. 3. Die PHP -Konfiguration begrenzt die Hochladengr??e und das tempor?re Verzeichnis Nginx/Apache verbietet den Zugriff auf das Upload -Verzeichnis. 4. Die GD -Bibliothek stellt die Bilder neu, um potenzielle b?swillige Daten zu l?schen.

H?ufige Probleme und L?sungen für den variablen PHP -Umfang umfassen: 1. Die globale Variable kann innerhalb der Funktion nicht zugegriffen werden, und sie muss bei der Verwendung des globalen Schlüsselworts oder Parameters übergeben werden. 2. Die statische Variable wird statisch deklariert und nur einmal initialisiert und der Wert wird zwischen mehreren Aufrufen beibehalten. 3.. Hyperglobale Variablen wie $ _get und $ _post k?nnen direkt in jedem Bereich verwendet werden, aber Sie müssen auf eine sichere Filterung achten. 4. Die anonymen Funktionen müssen über das Schlüsselwort verwenden, und wenn Sie externe Variablen ?ndern, müssen Sie eine Referenz übergeben. Das Beherrschen dieser Regeln kann dazu beitragen, Fehler zu vermeiden und die Code -Stabilit?t zu verbessern.

Es gibt drei g?ngige Methoden für den PHP -Kommentarcode: 1. Verwenden Sie // oder #, um eine Codezeile zu blockieren, und es wird empfohlen, // zu verwenden. 2. Verwenden Sie /.../, um Codebl?cke mit mehreren Zeilen zu wickeln, die nicht verschachtelt werden k?nnen, aber gekreuzt werden k?nnen. 3.. Kombinationskenntnisse Kommentare wie die Verwendung / if () {} / Um Logikbl?cke zu steuern oder um die Effizienz mit Editor -Verknüpfungsschlüssel zu verbessern, sollten Sie auf die Schlie?ung von Symbolen achten und das Verschachteln bei der Verwendung vermeiden.

Der Schlüssel zum Schreiben von PHP -Kommentaren liegt in der Kl?rung des Zwecks und der Spezifikationen. Kommentare sollten "Warum" und nicht "was getan" erkl?ren, um Redundanz oder zu Einfachheit zu vermeiden. 1. Verwenden Sie ein einheitliches Format wie Docblock (/*/) für Klassen- und Methodenbeschreibungen, um die Lesbarkeit und die Kompatibilit?t der Werkzeuge zu verbessern. 2. Betonen Sie die Gründe für die Logik, z. B. warum JS -Sprünge manuell ausgeben müssen. 3. Fügen Sie eine übersichtsbeschreibung vor komplexem Code hinzu, beschreiben Sie den Prozess in Schritten und helfen Sie, die Gesamtidee zu verstehen. V. Gute Anmerkungen k?nnen die Kommunikationskosten senken und die Effizienz der Code -Wartung verbessern.

AgneeratorinphpiSamemory-effizientes WaytoiterateOverlargedatasetsByyieldingValueatimeinsteadofReturningThemallatonce.1.GeneratorsusetheyieldKeywordtoproduktenvaluesonDemand, ReducingMemoryUsage.2.TheyareusefulforfulforfulfordlingBiglopploups, Lesebiglochen, Leselungen, Lesebigs, Leselung, oder

Es gibt zwei M?glichkeiten, ein Array in PHP zu erstellen: Verwenden Sie die Funktion array () oder verwenden Sie Klammern []. 1. Die Verwendung der Funktion array () ist eine traditionelle Art und Weise mit guter Kompatibilit?t. Definieren Sie Indexarrays wie $ fruits = Array ("Apple", "Banana", "Orange") und assoziative Arrays wie $ user = array ("name" => "John", "Age" => 25); 2. Die Verwendung [] ist eine einfachere M?glichkeit, seit Php5.4 wie $ Color zu unterstützen
