{"id":55711,"date":"2022-11-07T12:04:35","date_gmt":"2022-11-07T11:04:35","guid":{"rendered":"https:\/\/kinsta.com\/de\/?p=55711&post_type=knowledgebase&preview_id=55711"},"modified":"2025-10-01T20:17:08","modified_gmt":"2025-10-01T19:17:08","slug":"inertia-js","status":"publish","type":"post","link":"https:\/\/kinsta.com\/de\/blog\/inertia-js\/","title":{"rendered":"Der ultimative Leitfaden zu Inertia.js"},"content":{"rendered":"

Single-Page-Applikationen (SPAs) sind zur modernen Art der Erstellung von Webanwendungen geworden, und Inertia.js ist ein f\u00fchrendes Tool, mit dem Entwickler SPAs sowohl mit clientseitigem als auch mit serverseitigem Rendering erstellen k\u00f6nnen.<\/p>\n

In diesem Artikel werden wir uns ansehen, wie Inertia die Erstellung von SPAs zu einem Kinderspiel macht und wie es viele andere Probleme f\u00fcr Entwickler l\u00f6st. Au\u00dferdem gehen wir auf die wichtigsten Funktionen des Tools ein.<\/p>\n

Doch bevor wir beginnen, m\u00fcssen wir zun\u00e4chst sicherstellen, dass wir verstehen, wie server- und clientseitige Anwendungen funktionieren.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Was ist Serverseitiges Rendering?<\/h2>\n

Serverseitiges Rendering (SSR) bedeutet, dass eine Anwendung Webseiteninhalte auf dem Server und nicht im Browser darstellen kann. Wenn ein\/e Nutzer\/in versucht, example.com<\/strong> zu besuchen, stellt der Browser eine Anfrage an den Server, um alle notwendigen Informationen f\u00fcr die Anzeige dieser speziellen Webseite zu erhalten, und der Server antwortet sofort, indem er dem Browser eine vollst\u00e4ndig gerenderte Seite liefert.<\/p>\n

Suchmaschinen greifen ein und indizieren die vom Server gelieferten Informationen, bevor sie den Browser erreichen; dies wird als Suchmaschinenoptimierung (SEO) bezeichnet. Der Browser l\u00f6st dann die JavaScript-Inhalte auf, und die Webseite wird dem Nutzer angezeigt.<\/p>\n

\"Ein
Anzeige von Inhalten, die auf der Serverseite gerendert werden.<\/figcaption><\/figure>\n

Das Problem mit dem SSR-Ansatz ist, dass es lange dauert, bis eine vollst\u00e4ndig gerenderte Seite vom Server geladen ist, was kein angenehmes Nutzererlebnis bietet. Aus diesem Grund ziehen Entwickler\/innen SPAs und clientseitiges Rendering in Betracht.<\/p>\n\n

Was ist Clientside Rendering?<\/h2>\n

Beim clientseitigen Rendering erh\u00e4lt der Browser alles, was er zum Rendern der Webseite braucht, von der Client-Seite, anstatt eine vollst\u00e4ndig gerenderte Seite vom Server zu erhalten. Wenn die Seite geladen ist, sendet der Browser keine weiteren Anfragen an den Server, wodurch das Surferlebnis extrem schnell wird.<\/p>\n

\"Ein
Anzeige von Inhalten, die auf der Client-Seite gerendert werden.<\/figcaption><\/figure>\n

Das clientseitige Rendering hat zur Entwicklung von SPAs beigetragen und das Web revolutioniert. Du kannst eine Website erstellen, bei der die Seite nicht neu geladen werden muss, egal wie viele Links du anklickst. Das macht es f\u00fcr die Nutzer\/innen einfach, durch die Website zu navigieren.<\/p>\n

Obwohl SPAs fantastisch sind, birgt dieser Ansatz eine Menge Komplexit\u00e4t und Probleme, die wir heute behandeln werden. Inertia l\u00f6st die meisten dieser Probleme, indem es serverseitige Frameworks effektiv einsetzt. Es kombiniert die besten Eigenschaften von server- und clientseitigen Anwendungen.<\/p>\n

Was ist Inertia.js?<\/h2>\n

Inertia ist kein JavaScript-Framework<\/a>. Es handelt sich vielmehr um eine Strategie oder Technik zur Entwicklung von SPAs. Sie erm\u00f6glicht es dem Entwickler, aktuelle serverseitige Frameworks zu nutzen, um eine moderne SPA zu entwickeln, ohne die damit verbundene Komplexit\u00e4t.<\/p>\n

Inertia wurde entwickelt, um die Frameworks, die du bereits verwendest, zu erg\u00e4nzen und nicht zu ersetzen. Betrachte es als einen hilfreichen Verb\u00fcndeten, der dir hilft, Aufgaben schneller und effizienter zu erledigen. Es unterst\u00fctzt derzeit drei Frontend-Frameworks (Vue, React und Svelte) f\u00fcr das Rendering auf der Client-Seite und zwei Backend-Frameworks (Laravel und Rails) f\u00fcr das Rendering auf der Server-Seite.<\/p>\n

F\u00fcr die meisten Laravel-Entwicklerinnen und -Entwickler<\/a> ist Inertia eine der zuverl\u00e4ssigsten Techniken f\u00fcr den Aufbau von SPAs, da sie damit sowohl Frontend- als auch Backend-Frameworks verbinden k\u00f6nnen.<\/p>\n

Wie funktioniert Inertia.js?<\/h2>\n

Inertia \u00e4hnelt dem Vue Router, da es dir erlaubt, zwischen Seiten zu wechseln, ohne die gesamte Seite neu laden zu m\u00fcssen. Allerdings arbeitet Inertia synchron mit deinem serverseitigen Framework. Dies ist mit Link<\/code> m\u00f6glich, einem Wrapper f\u00fcr das Standard-Anker-Tag. Wenn ein Link<\/code> angeklickt wird, f\u00e4ngt Inertia das Klickereignis ab und sendet eine XHR-Anfrage an den Server. Der Server erkennt, dass es sich um eine Inertia-Anfrage handelt und gibt eine JSON-Antwort zur\u00fcck. Diese Antwort enth\u00e4lt den Namen und die Daten der JavaScript-Komponente, woraufhin Inertia auf magische Weise nicht ben\u00f6tigte Komponenten entfernt und durch diejenigen ersetzt, die f\u00fcr den Besuch der neuen Seite erforderlich sind, und den Verlaufsstatus aktualisiert.<\/p>\n

Ein tiefer Einblick in die Funktionsweise von Inertia.js<\/h3>\n

Wenn ein Besucher example.com<\/strong> zum ersten Mal besucht, f\u00fchrt der Browser eine normale Ganzseitenanfrage durch und der Server gibt eine vollst\u00e4ndige HTML-Antwort zur\u00fcck, als ob Inertia nicht existieren w\u00fcrde. Diese HTML-Antwort enth\u00e4lt alle Website-Assets (CSS, JavaScript), aber auch ein zus\u00e4tzliches Asset f\u00fcr Inertia, n\u00e4mlich das Stammverzeichnis div<\/code> mit dem data-page<\/code> -Attribut, das JSON-Daten f\u00fcr die Ausgangsseite enth\u00e4lt. Inertia nutzt diese JSON-Daten dann, um das Frontend-Framework zu starten und die Startseite anzuzeigen.<\/p>\n

\"Das
Inertia.js: Antwort auf den ersten Seitenbesuch.<\/figcaption><\/figure>\n

Sobald die App hochgefahren ist, wird jede Route, die der Nutzer innerhalb der gleichen Domain mit Link<\/code> besucht, eine XHR-Anfrage mit dem X-Inertia<\/code> Header sein. Dieser teilt dem Server mit, dass es sich um eine Inertia-Anfrage handelt.<\/p>\n

Die R\u00fcckmeldung erfolgt als JSON-Antwort mit dem Seiteninhalt und nicht als vollst\u00e4ndige HTML-Antwort wie beim ersten Besuch.<\/p>\n

\"Das
Inertia.js: Nachfolgende Antwort auf den Besuch der Route.<\/figcaption><\/figure>\n

Welche Probleme l\u00f6st Inertia.js?<\/h2>\n

Inertia l\u00f6st eine Vielzahl von Problemen f\u00fcr Webentwickler. Das Ziel bei der Entwicklung von Inertia war es, schnelle und effektive L\u00f6sungen f\u00fcr all die komplexen Probleme zu finden, die mit der Entwicklung einer SPA einhergehen.<\/p>\n

SPA-Komplexit\u00e4t<\/h3>\n

Wenn Entwickler\/innen eine SPA ohne Inertia entwickeln w\u00fcrden, m\u00fcssten sie REST- oder GraphQL-APIs erstellen und diese mit einer Art Authentifizierungsmethode sch\u00fctzen, was unter anderem die Erstellung eines Frontend-Statusverwaltungssystems erfordern w\u00fcrde.<\/p>\n

Inertia wurde entwickelt, um Entwicklern dabei zu helfen, ihre serverseitigen Anwendungen, die vollst\u00e4ndig auf dem Backend-Server laufen, in eine einseitige JavaScript-Anwendung umzuwandeln, ohne dabei all die Komplexit\u00e4t zu durchlaufen, die mit der Entwicklung von SPAs verbunden ist.<\/p>\n

Die Erstellung einer SPA mit Inertia ist \u00e4hnlich wie die Erstellung einer serverseitig gerenderten Anwendung. Du erstellst Controller, f\u00fchrst Datenbankabfragen f\u00fcr die ben\u00f6tigten Daten durch und gibst die Ergebnisse dann an die Views zur\u00fcck.<\/p>\n

Der Schl\u00fcssel dazu ist, dass die Views JavaScript-Komponenten sind. Das bedeutet, dass du die Daten von deinem Server abrufst und Inertia dann mit dem Frontend-Framework zusammenarbeitet, um die Seite mit den Daten als JavaScript-Datei anzuzeigen, sodass keine APIs erstellt werden m\u00fcssen.<\/p>\n

Authentifizierung<\/h3>\n

Da Inertia die Anwendung mit Daten und Antworten aus dem Backend f\u00fcttert, verwendet es einfach das Authentifizierungssystem, das du auf der Serverseite hast. Das bedeutet, dass du dich nicht um die clientseitige Authentifizierung k\u00fcmmern musst – du hast stattdessen ein sitzungsbasiertes Authentifizierungssystem, das mit deinem serverseitigen Authentifizierungssystem synchronisiert wird.<\/p>\n

SEO-Bedenken<\/h3>\n

Wie bereits beim serverseitigen Rendering erl\u00e4utert, fangen Suchmaschinen die Serverantwort an den Browser ab, um den HTML-Inhalt der Webseite zu indizieren. Im Falle einer SPA werden Suchmaschinen es schwer haben, den Inhalt der Seite zu identifizieren, da der Server entweder mit JavaScript-Komponenten oder JSON-Daten antwortet.<\/p>\n

Inertia hat dieses Problem gel\u00f6st, indem es die Funktion des serverseitigen Renderings (SSR)<\/a> eingef\u00fchrt hat, die du zu deiner Anwendung hinzuf\u00fcgen kannst. Inertia nutzt die Node.js-Umgebung als Ausl\u00f6ser, um die JSON-Datenantwort in HTML umzuwandeln.<\/p>\n

Um das besser zu veranschaulichen, stell dir vor, dass Inertia zwischen dem Server und dem Browser sitzt und beobachtet. Wenn der Server eine Inertia-Anfrage erh\u00e4lt und eine JSON-Antwort zur\u00fcckschickt, erkennt Inertia die Existenz eines Node.js-Servers, wandelt die JSON-Antwort in HTML um und schickt sie zur\u00fcck, so dass Suchmaschinen die Seite indizieren k\u00f6nnen, als ob die App keine SPA w\u00e4re.<\/p>\n

Inertia bietet auch eine Head<\/code> Komponente, mit der du einen Titel und Metadaten zu deiner Seite hinzuf\u00fcgen kannst:<\/p>\n

\n<script setup>\nimport { Head } from '@inertiajs\/inertia-vue3'\n<\/script>\n\n<template>\n  <Head>\n    <title>Page Title<\/title>\n    <meta name=\"description\" content=\"Page Description" \/>\n  <\/Head>\n<\/template>\n<\/code><\/pre>\n
Hier ist ein weiteres Beispiel aus der Online-Dokumentation von Inertia<\/a>:<\/p>\n
\n\/\/ Layout.vue\n\nimport { Head } from '@inertiajs\/inertia-vue3'\n\n<Head>\n  <title>My app<\/title>\n  <meta head-key=\"description\" name=\"description\" content=\"This is the default description\" \/>\n  <link rel=\"icon\" type=\"image\/svg+xml\" href=\"\/favicon.svg\" \/>\n<\/Head>\n\n\/\/ About.vue\n\nimport { Head } from '@inertiajs\/inertia-vue3'\n\n<Head>\n  <title>About - My app<\/title>\n  <meta head-key=\"description\" name=\"description\" content=\"This is a page specific description\" \/>\n<\/Head>\n<\/code><\/pre>\n
Formulare und Form Helper<\/h3>\n
Es ist m\u00f6glich, mit Inertia eine Standardformularanfrage zu stellen. Dabei wird jedoch eine ganze Seite aktualisiert.<\/p>\n
Inertia erm\u00f6glicht es den Nutzern, Formularanfragen mit Inertia zu stellen, wodurch die Seite nicht mehr aktualisiert werden muss. Sobald das Formular mit Inertia abgeschickt wurde, wird es serverseitig verarbeitet, so dass du den Nutzer wieder auf dieselbe Seite (oder eine ganz andere Seite) zur\u00fcckleiten kannst.<\/p>\n
Inertia macht uns das Leben bei der Erstellung und \u00dcbermittlung von Formularen leichter. Hier ist ein Beispiel daf\u00fcr, wie du es mit der Vue.js 3 Composition API verwenden kannst:<\/p>\n
\n<script setup>\n  import { useForm } from \"@inertiajs\/inertia-vue3\";\n\n  const form = useForm({\n    email: null,\n    password: null,\n  });\n<\/script>\n\n<template>\n  <form @submit.prevent=\"form.post('kinsta\/login')\">\n    \n    <input type=\"text\" v-model=\"form.email\" \/>\n    \n    <input type=\"password\" v-model=\"form.password\" \/>\n    \n    <button type=\"submit\">Login<\/button>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
Du kannst das Formular mit GET<\/code>, POST<\/code>, PUT<\/code>, PATCH<\/code> und DELETE<\/code> abschicken.<\/p>\n
\n<script setup>\n  import { useForm } from \"@inertiajs\/inertia-vue3\";\n\n  const form = useForm({\n    email: null,\n    password: null,\n  });\n\n  const submit = () => {\n    form.post(\"kinsta\/login\");\n  };\n<\/script>\n\n<template>\n  <form @submit.prevent=\"submit()\">\n    \n    <input type=\"text\" v-model=\"form.email\" \/>\n    \n    <input type=\"password\" v-model=\"form.password\" \/>\n    \n    <button type=\"submit\">Login<\/button>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
Die Formularhilfe von Inertia bietet auch einige hilfreiche Eigenschaften, wie z. B. die Eigenschaft processing<\/code>, die sich in true<\/code> verwandelt, sobald das Formular verarbeitet wird. Damit kannst du die Schaltfl\u00e4chen zum Absenden deaktivieren, w\u00e4hrend das Formular verarbeitet wird, um Mehrfach\u00fcbermittlungen zu verhindern:<\/p>\n
\n<button type=\"submit\" :disabled=\"form.processing\">Submit<\/button>\n<\/code><\/pre>\n
Du kannst auch preserveState<\/code>, preserveScroll<\/code> und Event-Callbacks mit dem Formular verwenden, die hilfreich sind, wenn du dem Formular zus\u00e4tzliche Optionen hinzuf\u00fcgst:<\/p>\n
\nform.post('kinsta\/login, {\n  preserveScroll: true,\n  onSuccess: () => form.reset('password'),\n})\n<\/code><\/pre>\n
Den Status mit Inertia.js speichern<\/h3>\n
Angenommen, ein Nutzer f\u00fcllt ein Formular auf deiner Website aus und beschlie\u00dft, zu einer anderen Seite zu navigieren, bevor er es absendet. Wenn er auf die Formularseite zur\u00fcckkehrt, werden die Eingaben des Nutzers zur\u00fcckgesetzt.<\/p>\n
Zum Gl\u00fcck gibt es in Inertia die Funktion useRemember<\/code>, mit der du die Formulareingaben des Nutzers im Verlaufsstatus speichern und bei der Navigation im Verlauf wiederherstellen kannst.<\/p>\n
Du kannst diese Funktion nutzen, indem du sie aus Inertia importierst und auf dein Formular anwendest:<\/p>\n
\nimport { useRemember } from '@inertiajs\/inertia-vue3'\n\nexport default {\n  setup() {\n    const form = useRemember({\n        first_name: null,\n        last_name: null,\n    })\n\n    return { form }\n  },\n}\n<\/code><\/pre>\n
Wenn du eine Seite mit vielen Formularen hast, die die Funktion useRemember<\/code> nutzen, muss jede Komponente einen eindeutigen Schl\u00fcssel haben, damit Inertia wei\u00df, welche Daten in jeder Komponente wiederhergestellt werden m\u00fcssen:<\/p>\n
\nconst form = useRemember({\n        first_name: null,\n        last_name: null,\n    }, 'Users\/Create')\n<\/code><\/pre>\n
Wir brauchen die Funktion useRemember<\/code> nicht zu verwenden, wenn wir die Formularhilfe von Inertia nutzen. Inertia merkt sich den Status der Formulareingabe automatisch, so dass wir nur einen eindeutigen Bezeichner angeben m\u00fcssen:<\/p>\n
\nimport { useForm } from '@inertiajs\/inertia-vue3'\n\nconst form = useForm('CreateUser', data)\n<\/code><\/pre>\n
Das Sch\u00f6ne an dieser Funktion ist, dass du dir alle Daten in deiner Anwendung manuell merken kannst. Dies kann auch n\u00fctzlich sein, um Daten von einer tief verschachtelten Komponente an die Hauptkomponente weiterzugeben:<\/p>\n
\nimport { Inertia } from '@inertiajs\/inertia'\n\n\/\/ DeeplyNestedComponent.vue\nInertia.remember(data, 'my-key')\n\n\/\/ MainComponent.vue\nlet data = Inertia.restore('my-key')\n<\/code><\/pre>\n
Dateiuploads<\/h3>\n
Inertia erkennt, ob das Formular Dateien enth\u00e4lt und wandelt in diesem Fall die Anfragedaten in das formData<\/code> Objekt um, das immer ben\u00f6tigt wird. Wenn du also ein Formular hast, das einen Namen und einen Avatar enth\u00e4lt, wird Inertia das Formular als multipart\/form-data<\/code> behandeln.<\/p>\n
Validierung und Fehler<\/h3>\n
Wenn ein Benutzer ein Formular mit falschen Werten absendet und es zur Validierung an den Server geschickt wird, kehrt der Benutzer mit einem Blitz von Validierungsfehlern in der Sitzung zur Formularseite zur\u00fcck. Inertia f\u00e4ngt Fehler aus der Sitzung ab und speichert sie als Seitenrequisiten.<\/p>\n
Da Requisiten reaktiv sind, erscheinen sie, wenn die Formular\u00fcbermittlung abgeschlossen ist. Damit Inertia das Vorhandensein von Fehlern erkennen kann, beh\u00e4lt es page.props.errors<\/code> im Auge.<\/p>\n
Sobald es Fehler gefunden hat, liefert es einen onError()<\/code> Callback anstelle von onSuccess()<\/code>.<\/p>\n
Hier ist ein Beispiel mit Vue 3, das dir hilft, das Konzept zu verstehen:<\/p>\n
\nconst submit = () => {\n    form.post(\"kinsta\/login\", {\n        onError: () => {\n            return \"Hi! , the server returned an error and Inertia saved it as a prop. Do as you like with me\"\n        },\n        onSuccess: () => {\n            return \"Wohoo!!\"\n        }\n    }\n    );\n  };\n<\/code><\/pre>\n
Die Anzeige von Fehlern ist so einfach, wie sie als Requisiten zu definieren und bedingt in deinem HTML anzuzeigen:<\/p>\n
\n<script setup>\n  defineProps({\n    errors: Object,\n  });\n\n\/\/\n<\/script>\n\n<template>\n  <form @submit.prevent=\"submit()\">\n    \/\/\n    <div v-if=\"errors.email\">{{ errors.email }}<\/div>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
Wenn du Inertia verwendest, brauchst du dir keine Gedanken \u00fcber alte Eingabedaten im Falle von Fehlern zu machen. Sobald Inertia erkennt, dass der Nutzer auf die Seite mit den Fehlern weitergeleitet wurde, beh\u00e4lt es automatisch den alten Zustand der Komponente f\u00fcr POST<\/code>, PUT<\/code>, PATCH<\/code> und DELETE<\/code> bei.<\/p>\n
Partielle Reloads mit Inertia.js<\/h3>\n
Die partielle Reload-Funktion von Inertia ist einfach hervorragend, da sie nur eine ausgew\u00e4hlte Komponente auf der Seite neu l\u00e4dt, anstatt den gesamten Datensatz erneut vom Server zu holen. Das hebt die Optimierung deiner Anwendung auf die n\u00e4chste Stufe. Du kannst auch den folgenden Link besuchen, um mehr dar\u00fcber zu erfahren, wie du die Leistung deiner Laravel-Anwendung optimierst<\/a>.<\/p>\n
Teilweise Neuladungen k\u00f6nnen mit der Eigenschaft only<\/code> von Inertia durchgef\u00fchrt werden:<\/p>\n
\nimport { Inertia } from '@inertiajs\/inertia'\n\nInertia.visit(url, {\n  only: ['users'],\n})\n<\/code><\/pre>\n
Externe Weiterleitungen mit Inertia.js<\/h3>\n
Das Subdomain-Routing oder die externe Weiterleitung ist eine der frustrierendsten Herausforderungen bei SPAs. Es ist unvern\u00fcnftig zu erwarten, dass deine Anwendung eine Single-Page-Anwendung bleibt, w\u00e4hrend sie gleichzeitig eine andere Domain besucht.<\/p>\n
Es kann notwendig sein, eine Inertia-Anfrage auf eine externe Website oder sogar auf einen anderen Endpunkt in deiner Anwendung umzuleiten, der nicht zu Inertia geh\u00f6rt. Dies ist durch einen serverseitig initiierten window.location<\/code> Besuch m\u00f6glich:<\/p>\n
\nreturn Inertia::location($url);\n<\/code><\/pre>\n
Wenn du beim Testen die Konsole \u00f6ffnest, wirst du feststellen, dass sie 409 conflict<\/code> zur\u00fcckgibt. Diese Antwort enth\u00e4lt die URL im X-Inertia-Location<\/code> Header, die Inertia auf der Client-Seite erkennt und den Besuch automatisch durchf\u00fchrt.<\/p>\n
Wie man mit Inertia.js arbeitet<\/h2>\n
Die Arbeit mit Inertia ist \u00e4hnlich wie die Arbeit an einer serverseitigen Anwendung, mit dem Unterschied, dass es sich um eine vollst\u00e4ndig reaktive Single-Page-Anwendung handelt. Du solltest in der Lage sein, deine Routes zu definieren, Controller anzupassen und eine View zur\u00fcckzugeben, die Inertia an dein Frontend-Framework sendet.<\/p>\n
Laravel-Routen und Inertia.js<\/h3>\n
Laravel-Routing ist etwas, auf das du bei der Entwicklung deiner Anwendung nicht verzichten solltest. Es erm\u00f6glicht dir, schnell die komplexesten Routen zu erstellen, und es gibt viele kostenlose und kostenpflichtige Laravel-Ressourcen<\/a>, mit denen du mehr \u00fcber Laravel und die Funktionsweise von Routing lernen kannst.<\/p>\n
Das Sch\u00f6ne daran ist, dass du keinen Vue Router oder React Router brauchst, um einfaches Client-seitiges Routing durchzuf\u00fchren, denn Inertia hat sein eigenes Routing-System, das mit Laravel-Routing funktioniert. Wenn der Job keine Backend-Daten ben\u00f6tigt, kannst du den Router-Helper verwenden, um direkt zu einer Komponente zu routen.<\/p>\n
\nRoute::inertia('\/home', 'HomeComponent');\n<\/code><\/pre>\n
\npublic function index()\n    {\n    return Inertia::render('Users\/Index', [\n        'users' => User::all();\n        'create_url' => URL::route('users.create'),\n    ]);\n}\n<\/code><\/pre>\n
Bevor wir weitermachen, m\u00f6chten wir dir DevKinsta<\/a> vorstellen, ein leistungsstarkes Tool f\u00fcr Entwickler, Designer und Agenturen, mit dem sie ein- und mehrseitige WordPress-Webanwendungen erstellen k\u00f6nnen. Gl\u00fccklicherweise kann WordPress mit dem Corcel-Paket<\/a> in Laravel integriert werden. Wenn du eine Laravel-App mit WordPress-Integration entwickelst, solltest du dir das Kinsta APM-Tool<\/a> f\u00fcr eine hervorragende Leistungs\u00fcberwachung ansehen.<\/p>\n
Umleitungen<\/h3>\n
Du solltest den Nutzer immer auf den richtigen Pfad umleiten, der der urspr\u00fcnglichen Anfrage entspricht. Wenn ein Nutzer z. B. den Endpunkt store<\/code> ansteuert, um einen Beitrag einzureichen, solltest du den Kunden zum Endpunkt GET<\/code> umleiten, vielleicht zur Beitragsroute.<\/p>\n
\npublic function store()\n{\n    Post::create(\n        Request::validate([\n            'title' => ['required'],\n            'body' => ['required'],\n        ])\n    );\n\n    \/\/ redirect the user to the posts show page\n    return Redirect::route('posts.show');\n}\n<\/code><\/pre>\n
Nachteile der Verwendung von Inertia.js<\/h2>\n
Bisher haben wir uns auf die verschiedenen Vorteile von Inertia konzentriert. Doch wie jedes andere Tool hat auch Inertia Nachteile.<\/p>\n