Laravel-Tutorial für Anfänger

Was ist Laravel?

Laravel ist ein Open-Source-Web-MVC-Framework für PHP. Laravel ist ein robustes Framework, das die einfache Entwicklung von PHP-Webanwendungen mit Funktionen wie einem modularen Paketsystem mit einem dedizierten Abhängigkeitsmanager, Zugriff auf relationale Datenbanken und anderen Dienstprogrammen für die Anwendungsbereitstellung und -wartung ermöglicht.

Laravel wurde von Taylor Otwell entwickelt. Seit seiner ersten Veröffentlichung im Juni 2011 (Version 1) hat es sich in der PHP-Framework-Branche der Webentwicklung stetig wachsender Beliebtheit erfreut. Ein Großteil dieser Popularität ist auf die vielen entwicklerfreundlichen Funktionen zurückzuführen, die es standardmäßig bietet.

Warum Laravel?

Meistens um 2000 PHP-Code war prozedural und konnte in Form von „Skripten“ gefunden werden, die ein Durcheinander von Spaghetti-Code enthielten. Selbst die einfachsten Seiten hatten keine Trennung von BedenkenSo konnte eine Anwendung schnell zu einem Wartungsalbtraum werden. Die Welt brauchte etwas Besseres. Hier kamen PHP Version 5 und verschiedene PHP-Frameworks ins Spiel, die versuchten, dringend benötigte Struktur und bessere Lösungen für diverse Probleme von Webanwendungen zu bieten.

Seitdem wurden zahlreiche Frameworks veröffentlicht, die den Weg für die heute gängigen Frameworks ebneten. Die drei führenden sind (unserer Meinung nach) Zend Framework, Symfony und natürlich Laravel. Obwohl alle drei Frameworks auf ähnlichen Prinzipien basieren und im Wesentlichen dieselben Probleme lösen sollen, liegen ihre Hauptunterschiede in der Implementierung. Jedes hat seine eigenen Besonderheiten bei der Problemlösung. Betrachtet man den Code der einzelnen Frameworks, erkennt man deutliche Unterschiede. Unserer Meinung nach ist Laravel das beste Framework.

Erfahren Sie hier mehr über Unterschied zwischen Laravel und CodeZünder.

So laden Sie Laravel mit Composer herunter und installieren es

Hinweis: Dieses Tutorial wurde für Laravel 5.8 geschrieben, die Konzepte von Routing, Controller, Request und Blade bleiben jedoch in den aktuellen Versionen unverändert. Die neueste Version (Stand 2026) ist Laravel 13 (veröffentlicht im März 2026), die PHP 8.3 oder höher benötigt, während Laravel 12 PHP 8.2 voraussetzt.

Hinweis: Es wird davon ausgegangen, dass Sie bereits eine Kopie von PHP auf Ihrem lokalen System installiert haben. Falls nicht, können Sie hier nachlesen, wie Sie es installieren. werden auf dieser Seite erläutert.

Composer ist sowohl ein Paket- als auch ein Abhängigkeitsmanager. Um es zu installieren, öffnen Sie ein Terminal und wechseln Sie per CD in ein neues Verzeichnis. Führen Sie diesen Befehl aus:

curl -Ss getcomposer.org/installer | php

Die Ergebnisse dieses Befehls sehen folgendermaßen aus:

Hinweis: Ausführlichere Anweisungen zur Einrichtung von Laravel finden Sie in der Laravel-Dokumentation. werden auf dieser Seite erläutert.

Sie sehen, wie das composer.phar-Skript heruntergeladen und kompiliert wird. Dieses Skript verwenden wir zur Installation von Laravel. Obwohl es zahlreiche Möglichkeiten gibt, eine neue Laravel-Anwendung einzurichten, verwenden wir hierfür das Laravel-Composer-Skript. Um dieses Skript zu installieren, führen Sie folgenden Befehl aus:

composer global require laravel/installer

Was etwa so aussehen wird:

Dadurch werden alle Framework-Dateien sowie alle benötigten Abhängigkeiten heruntergeladen und installiert. Die Pakete werden im Verzeichnis „vendor“ gespeichert. Nach dem Herunterladen und Installieren genügt folgender Befehl:

laravel new uploadApp

Die Ausgabe ähnelt der folgenden:

Composer installiert alle Pakete, die Laravel zum Ausführen benötigt. Dies kann einige Minuten dauern, also haben Sie Geduld. Führen Sie nach Abschluss der Installation den Befehl `ls -al` aus, um die installierten Pakete anzuzeigen.

Hier ist eine kurze Aufschlüsselung der Verzeichnisse in einer gängigen Laravel-Anwendung:

• app/ : Dies ist der Quellordner, in dem sich unser Anwendungscode befindet. Alle Controller, Richtlinien und Modelle befinden sich in diesem Ordner.
• Bootstrap/ : Enthält das Startskript der Anwendung und einige Klassenzuordnungsdateien.
• config/ : Enthält die Konfigurationsdateien der App. Diese werden normalerweise nicht direkt geändert, sondern basieren auf den Werten, die in der .env-Datei (Umgebungsdatei) im Stammverzeichnis der App festgelegt sind.
• Datenbank/ : Enthält die Datenbankdateien einschließlich Migrationen, Seeds und Testfabriken.
• öffentlich/ : Öffentlich zugänglicher Ordner, der die kompilierten Assets und natürlich eine index.php-Datei enthält.
• Ressourcen/: Enthält Frontend-Assets wie JavaSkriptdateien, Sprachdateien, CSS/SASS-Dateien und alle in der Anwendung verwendeten Vorlagen (sogenannte Blade-Vorlagen).
• Routen/ : Alle Routen der Anwendung befinden sich hier. Es gibt verschiedene Routenbereiche, wir konzentrieren uns jedoch auf die Datei web.php.
• Lagerung/ : Alle temporären Cache-Dateien, die von der Anwendung verwendet werden, Sitzungsdateien, kompilierte Ansichtsskripte und Protokolldateien.
• Tests/ : Enthält Testdateien für die Anwendung, wie z. B. Unit-Tests und Funktionstests.
• Verkäufer/ : Alle Abhängigkeitspakete wurden mit Composer installiert.

Nun erstellen wir den Rest der Anwendung und führen sie mit einem speziellen Artisan-Befehl aus (um uns die Installation und Konfiguration eines Webservers wie Apache oder nginx zu ersparen). Die Datei `.env` enthält alle Konfigurationswerte, die die Dateien im Verzeichnis `/config` zur Konfiguration der Anwendung verwenden.

Anwendungsdesign: Ein kurzer Überblick über unsere Anforderungen

In diesem Online-Laravel-Tutorial erstellen wir eine sehr einfache Anwendung, die nur zwei Dinge tut:

1. Datei-Uploads aus einem Webformular verarbeiten
2. Die zuvor hochgeladenen Dateien auf einer anderen Seite anzeigen.

Für dieses Projekt verwenden wir eine reine Schreibanwendung. Benutzer können also nur Dateien schreiben und die Liste der hochgeladenen Dateien einsehen. Die Anwendung ist sehr einfach gehalten, eignet sich aber hervorragend, um erste Erfahrungen mit Laravel zu sammeln. Aus Gründen der Übersichtlichkeit haben wir Datenbankmodellierung, Migrationen und Authentifizierung weggelassen. In einer realen Anwendung sollten Sie diese Aspekte jedoch unbedingt berücksichtigen.

Hier ist eine Liste der Komponenten, die wir benötigen, damit die Anwendung wie erwartet funktioniert:

• A Route Dadurch wird es der Außenwelt (Internet) ermöglicht, die Anwendung zu nutzen, und es wird der Endpunkt angegeben, der auf den Ort verweist, an dem die Logik zum Speichern der hochgeladenen Datei gespeichert ist.
• A Controller das den Ablauf von der Anfrage bis zur Antwort steuert.
• A Vorlage Damit werden eine Liste der zuvor hochgeladenen Dateien und das eigentliche Upload-Formular angezeigt.
• A Anforderung die der Controller zur Validierung der vom Webformular übergebenen Daten verwendet.

Was ist eine Route?

Eine Route in Laravel ist im Grunde ein Endpunkt, der durch einen URI definiert wird und als „Zeiger“ auf eine Funktion der Anwendung fungiert. Meistens verweist eine Route auf eine Methode eines Controllers und legt fest, welche HTTP-Methoden diese URI erreichen können. Eine Route muss aber nicht zwangsläufig eine Controller-Methode sein; sie kann die Ausführung der Anwendung auch einfach an eine definierte Closure oder anonyme Funktion weiterleiten.

Warum eine Route verwenden?

Routen werden in Dateien im Ordner /routes im Stammverzeichnis des Projekts gespeichert. Standardmäßig gibt es einige verschiedene Dateien, die den verschiedenen „Seiten“ der Anwendung entsprechen („Seiten“ stammt aus der hexagonalen Architekturmethodik). Dazu gehören:

• web.php: die öffentlich zugänglichen, browserbasierten Routen. Diese sind am häufigsten und werden vom Webbrowser aufgerufen. Sie laufen über die Web-Middleware-Gruppe und enthalten außerdem Funktionen für CSRF-Schutz (was dazu beiträgt, sich gegen formularbasierte böswillige Angriffe zu verteidigen) und enthalten im Allgemeinen einen gewissen „Zustand“ (damit meinen wir, dass sie Sitzungen nutzen).
• api.php: Routen, die einer API-Gruppe zugeordnet sind und daher standardmäßig die API-Middleware aktiviert haben. Diese Routen sind zustandslos und verwenden weder Sessions noch speicherübergreifenden Speicher (eine Anfrage teilt weder Daten noch Speicher mit anderen Anfragen; jede Anfrage ist in sich abgeschlossen).
• console.php: Diese Routen entsprechen benutzerdefinierten Artisan-Befehlen, die Sie für Ihre App erstellt haben.
• channels.php: Registriert Routen für die Ereignisübertragung.

Die wichtigste Datei, die Sie jetzt betrachten sollten, ist die browserspezifische Datei web.php. Standardmäßig ist bereits eine Route definiert, die Sie direkt beim Aufrufen des Web-Roots Ihrer Anwendung erreichen (das Web-Root befindet sich im öffentlichen Verzeichnis). Für die Funktion unserer Upload-Anwendung benötigen wir drei verschiedene Routen:

• /upload: Dies ist die URI der Hauptseite, auf der unser Webformular zum Hochladen von Dateien angezeigt wird.
• /process: Hier werden die vom Formular unter der URI /upload übermittelten Daten angezeigt (die „Aktion“ des Formulars).
• /list: Hiermit werden alle auf die Website hochgeladenen Dateien aufgelistet.

Hinweis: Der Endpunkt /list wäre möglicherweise nicht erforderlich, wenn wir die gesamte Logik zum Anzeigen des Upload-Formulars und der Dateiliste auf einer einzigen Seite unterbringen wollten; wir haben sie jedoch vorerst getrennt gehalten, um dem Thema noch etwas mehr Tiefe zu verleihen.

//inside routes/web.php
Route::get('/upload', 'UploadController@upload')->name('upload');
Route::get('/download', 'UploadController@download')->name('download');
Route::post('/process', 'UploadController@process')->name('process');
Route::get('/list', 'UploadController@list')->name('list');

In diesem Laravel-Framework-Tutorial listen wir jede gewünschte Route explizit in der Routendatei web.php auf und verwenden dabei eine der verfügbaren HTTP-spezifischen Anfragemethoden (get(), post(), put(), delete(), patch() oder options()). Eine detaillierte Beschreibung dieser Methoden finden Sie hier. fehlen uns die Worte. Diese Methoden legen fest, welche HTTP-Verben auf die jeweilige Route zugreifen dürfen. Soll eine Route mehrere HTTP-Verben akzeptieren (beispielsweise wenn eine Seite sowohl die initialen Daten anzeigt als auch Formulardaten sendet), können Sie die Methode `Route::any()` verwenden.

Das zweite Argument der Methoden `Route::get()` und `Route::post()` (sowie aller anderen HTTP-Verb-bezogenen Methoden der `Route`-Fassade) ist der Name eines bestimmten Controllers und die darin enthaltene Methode, die beim Aufruf des Endpunkts der Route mit der zulässigen HTTP-Anfrage (GET, POST, PATCH usw.) ausgeführt wird. Wir verwenden den `UploadController` für alle Routen und haben diese wie folgt spezifiziert:

Die letzte Methode, die wir für jede Route aufrufen, ist ihre `name()`-Funktion. Diese akzeptiert einen einzelnen String als Argument und dient dazu, einer bestimmten Route einen leicht zu merkenden Namen zu geben (in unseren Fällen `upload`, `process` und `list`). Es mag auf den ersten Blick nicht so sinnvoll erscheinen, jeder Route einen eigenen Namen zu geben, wenn… URL ist zwar genau gleich benannt, aber besonders praktisch ist es, wenn man eine bestimmte Route hat, wie z. B. /users/profile/dashboard/config, die man sich leichter als profile-admin oder user-config merken kann.

Eine Anmerkung zu Fassaden:

• Fassaden bieten eine „statische“ Schnittstelle zu Klassen, die im Service-Container der Anwendung verfügbar sind.
• Sie bieten eine knappe, einprägsame Syntax, die es Ihnen ermöglicht, die Funktionen von Laravel zu nutzen, ohne sich lange Klassennamen merken zu müssen, die manuell eingefügt oder konfiguriert werden müssen.

In den obigen Routendefinitionen verwenden wir die Route-Fassade, anstatt manuell ein neues Illuminate/Routing/Router-Objekt zu instanziieren und die entsprechenden Methoden dieses Objekts aufzurufen. Es handelt sich lediglich um eine Abkürzung, die Zeit spart.pingFassaden werden im Laravel-Framework häufig verwendet; Sie sollten sich daher näher damit vertraut machen. Die Dokumentation zu Fassaden finden Sie hier: werden auf dieser Seite erläutert.

Was ist ein Controller?

Ein Controller ist das „C“ in der „MVC“-Architektur (Model-View-Controller), auf der Laravel basiert. Die Aufgabe eines Controllers lässt sich auf diese einfache Definition reduzieren: Es empfängt die Anfrage vom Client und sendet eine Antwort an den Client zurück. Dies ist die grundlegendste Definition und gleichzeitig die Mindestanforderung an jeden Controller. Was dazwischen geschieht, wird allgemein als die „Aktion“ des Controllers (oder die „Implementierung der Route“) bezeichnet. Er dient als zweiter Einstiegspunkt zur Anwendung (der erste ist die Anfrage) für den Client, der die Anfrage-Payload (auf die wir später eingehen) an die Anwendung sendet und eine Antwort erwartet (z. B. eine Erfolgsseite, eine Weiterleitung, eine Fehlerseite oder eine andere HTTP-Antwort).

Ein Controller macht (im Prinzip) dasselbe wie eine Routendefinition, wobei eine anonyme Funktion als „Aktion“ festgelegt wird, wenn diese Route aufgerufen wird. Der Unterschied besteht darin, dass ein Controller die Trennung der Belange besser gewährleistet, während eine Route direkt im Code definiert wird. URL Definition, was im Grunde bedeutet, dass wir die der Route zugewiesene URI mit der Implementierung der Route oder dem Code verknüpfen, der ausgeführt wird, wenn diese Route aufgerufen wird.

Beispielsweise erreichen die folgenden beiden Codeteile dasselbe:

Beispiel Nr. 1: Definition und Implementierung der Route innerhalb eines einzelnen Methodenaufrufs (in der Routendatei web.php)

//inside routes/web.php
<?php
Route::get('/hello-world', function(Request $request) {
$name = $request->name;
return response()->make("<h1>Hello World! This is ".$name, 200);
});

Beispiel 2: Die Routendefinition befindet sich in routes/web.php, die Implementierung jedoch in der Klasse /app/Http/Controllers/HelloWorldController.

//inside routes/web.php
<?php

Route::get('/hello-world', 'HelloWorldController@index')->name('hello-world');

------------------------------------------------------------------------------------
//inside app/Http/Controllers/HelloWorldController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;

class HelloWorldController extends Controller
{
public function index(Request $request)
{
$name = $request->name;
return response()->make("<h1>Hello World! This is ".$name, 200);
}
}

Obwohl das Laravel-Beispiel Nr. 2 viel mehr Arbeit zu sein scheint (was es nicht ist, nur etwas mehr Code), sollten Sie sich die Vorteile ansehen, die wir erzielen, wenn wir unsere Aktionslogik für die gegebene „hello-world“-Route in einen Controller anstatt in die Routendefinition als Callback-Funktion einfügen:

1. Unsere Logik ist klar in eine eigene Klasse abgegrenzt (Trennung der Belange).
2. Unser Controller ist so konzipiert, dass er später erweitert werden kann, falls wir zusätzliche Funktionen benötigen. Angenommen, wir möchten eine „Goodbye-World“-Funktion hinzufügen. In diesem Fall würden wir den Controller in den allgemeineren Namen „HelloController“ umbenennen und anschließend zwei separate Methoden definieren. Hallo() und Verabschiedung(). Wir müssten auch zwei separate Routen definieren, die das abbilden /Hallo und / Auf Wiedersehen URIs verweisen auf die entsprechenden Methoden des Controllers. Dies ist vorteilhafter, als eine Routendatei mit für jede Route als Callback-Funktion definierten Implementierungen aufzublähen.
3. Laravel verfügt über die integrierte Fähigkeit, alle Routendefinitionen in der Anwendung zwischenzuspeichern, sodass die Zeit zum Auffinden einer bestimmten Route verkürzt wird (und die Anwendungsleistung erhöht wird). jedoch Sie können dies nur nutzen, wenn alle Ihre definierten Routen innerhalb der Anwendung mithilfe einer controllerspezifischen Zuordnung konfiguriert sind.pings (siehe Beispiel Nr. 2 oben).

Führen wir diesen Befehl aus, der einen neuen Controller für uns generiert.

// ...inside the project's root directory:
php artisan make:controller UploadController

Dieser Befehl erzeugt im Wesentlichen einen Stub für einen Controller namens „UploadController“ im Hauptverzeichnis der Controller unter /app/Http/Controllers/UploadController.php. Sie können die Datei gerne öffnen und einen Blick darauf werfen. Sie ist sehr einfach gehalten, da es sich lediglich um eine Platzhalterversion des Controllers mit dem korrekten Namespace-Pfad und den erforderlichen Klassen handelt, von denen er erbt.

Generieren der Anfrage

Bevor wir in diesem PHP-Laravel-Tutorial fortfahren und einige Änderungen am generierten Stub des UploadControllers vornehmen, ist es sinnvoller, zuerst die Request-Klasse zu erstellen. Der Grund dafür ist, dass die Controller-Methode, die die Anfrage verarbeitet, das Request-Objekt in ihrer Signatur typisieren muss, damit sie die eingehenden Formulardaten automatisch validieren kann (wie in der `rules()`-Methode festgelegt; dazu später mehr). Verwenden wir nun erneut den Artisan-Befehl, um unseren Request-Stub zu generieren:

php artisan make:request UploadFileRequest

Dieser Befehl erzeugt eine Datei namens UploadFileRequest im Verzeichnis app/Http/Requests/UploadFileRequest. Öffnen Sie die Datei und sehen Sie sich den Inhalt an. Sie werden feststellen, dass sie sehr einfach ist und nur zwei Methoden enthält: authorize() und rules().

Erstellen der Validierungslogik

Lassen Sie uns den Anfrage-Stub an die Bedürfnisse unserer Anwendung anpassen. Ändern Sie die Datei so, dass sie wie folgt aussieht:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class UploadFileRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize()
{
return true;
}

/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules()
{
return [
'fileName' => 'required|string',
'userFile' => 'required|file'
];
}
}

Es gibt nicht viele Änderungen, aber die Methode `authorize()` gibt nun `true` statt `false` zurück. Diese Methode entscheidet, ob die Anfrage an die Anwendung weitergeleitet wird. Ist sie auf `false` gesetzt, wird die Anfrage blockiert. Hier könnten Sie Autorisierungsprüfungen für den Benutzer oder andere Logik implementieren, die darüber entscheidet, ob die Anfrage an den Controller weitergeleitet werden darf. Aktuell geben wir hier einfach `true` zurück, damit alle Anwendungen die Anfrage nutzen können.

Die andere Methode, rules(), ist der Kern der Validierung. Die Idee ist einfach: Sie gibt ein Array zurück, das eine Reihe von Regeln in folgender Form enthält:

'formFieldName' => 'constraints this field has separated by pipe characters (|)'

Es gibt viele verschiedene Validierungsbeschränkungen, die von Laravel sofort unterstützt werden. Eine vollständige Liste finden Sie in der Online-Dokumentation. werden auf dieser Seite erläutertFür unsere Upload-Anwendung werden zwei Felder über eine POST-Anfrage aus einem Formular im Frontend übergeben. Der Parameter `fileName` muss im Formulartext enthalten sein (d. h. erforderlich) und dient als Dateiname, unter dem die Datei im Speicher abgelegt wird (dies geschieht im Controller; darauf gehen wir später ein). Wir legen außerdem fest, dass der Dateiname ein String sein muss, indem wir ein Pipe-Zeichen (|) und das Wort „string“ hinzufügen. Einschränkungen werden immer durch Pipes getrennt, sodass Sie zusätzliche Kriterien für das jeweilige Feld in einer einzigen Zeile angeben können.

Der zweite Parameter, userFile, ist die eigentliche Datei, die der Benutzer über ein Formular auf einer Webseite hochlädt. userFile ist ebenfalls erforderlich. sollen eine Datei sein. Hinweis: Wenn wir erwarten würden, dass die hochgeladene Datei ein Bild ist, würden wir die Bildbeschränkung verwenden, die die zulässigen Dateitypen auf gängige Bildformate (JPEG, PNG, BMP, GIF oder SVG) beschränkt. Da wir dem Benutzer jedoch das Hochladen beliebiger Dateitypen ermöglichen möchten, verwenden wir weiterhin die Dateivalidierungsbeschränkung.

Das ist im Wesentlichen alles, was das Anfrageobjekt beinhaltet. Seine Hauptaufgabe besteht darin, die zulässigen Kriterien (Einschränkungen) zu speichern, die die Parameter des Formulartextes erfüllen müssen, damit die Anwendung weiter ausgeführt werden kann. Außerdem ist zu beachten, dass die beiden Felder (userFile und fileName) auch im HTML-Code als Eingabefelder angegeben werden müssen (wobei der Feldname dem Namen im Anfrageobjekt entsprechen muss).

Sie fragen sich vielleicht: Hier werden die Merkmale dessen definiert, was eine Formularanfrage enthalten sollte, aber wo findet die eigentliche Überprüfung dieser Einschränkungen statt? Darauf gehen wir im nächsten Abschnitt ein.

Ändern des Controllers

Öffnen Sie app/Http/Controllers/UploadController und nehmen Sie die folgenden Änderungen vor:

<?php

namespace App\Http\Controllers;

use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Http\Request;
use App\Http\Requests\UploadFileRequest; //our new request class
use Illuminate\Support\Facades\Storage;

class UploadController extends Controller
{
/**
* This is the method that will simply list all the files uploaded by name and provide a
* link to each one so they may be downloaded
*
* @param $request : A standard form request object
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
* @throws BindingResolutionException
*/
public function list(Request $request)
{
$uploads = Storage::allFiles('uploads');

return view('list', ['files' => $uploads]);
}

/**
* @param $file
* @return \Symfony\Component\HttpFoundation\BinaryFileResponse
* @throws BindingResolutionException
*/
public function download($file)
{
return response()->download(storage_path('app/'.$file));
}

/**
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
* @throws BindingResolutionException
*/
public function upload()
{
return view('upload');
}

/**
* This method will handle the file uploads. Notice that the parameter's typehint
* is the exact request class we generated in the last step. There is a reason for this!
*
* @param $request : The special form request for our upload application
* @return array|\Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|null
* @throws BindingResolutionException
*/
public function process(UploadFileRequest $request)
{
//At this point, the parameters passed into the $request (from form) are
//valid--they satisfy each of the conditions inside the rules() method

$filename = $request->fileName; //parameters have already been validated
$file = $request->file('userFile'); //so we don't need any additional isset()

$extension = $file->getClientOriginalExtension(); //grab the file extension
$saveAs = $filename . "." . $extension; //filename to save file under

$file->storeAs('uploads', $saveAs, 'local'); //save the file to local folder

return response()->json(['success' => true]); //return a success message
}
}

Das Speichern der hochgeladenen Dateien auf der Festplatte ist also ein recht einfacher Ansatz. Hier eine detaillierte Beschreibung der oben genannten `process()`-Methode:

• Geben Sie in der Controller-Methode, die die Hauptfunktionalität ausführt, einen Typ-Hinweis für die Anfrageklasse an, damit wir die eingehenden Daten automatisch validieren können.
• Die Datei wird aus dem (nun validierten) Anfrageobjekt innerhalb der Controller-Methode extrahiert.
• Extrahieren Sie den Dateinamen aus der Anfrage.
• Generieren Sie den endgültigen Dateinamen, der zum Speichern der Datei verwendet wird. Die Methode getClientOriginalExtension() greift einfach auf die ursprüngliche Erweiterung der hochgeladenen Datei zurück.
• Speichern Sie die Datei mit der Methode „storeAs()“ im lokalen Dateisystem und übergeben Sie dabei den benannten Pfad im Verzeichnis /storage als erstes Argument und den Dateinamen, unter dem sie gespeichert werden soll, als zweites.
• Es wird eine JSON-Antwort zurückgegeben, die anzeigt, dass die Anfrage erfolgreich war.

Die Blade-Vorlage

Das letzte wichtige Puzzleteil ist die Blade-Vorlage, die den gesamten HTML-, CSS- und JavaSkript für unsere einfache Anwendung. Hier ist der Code; wir werden ihn später erklären.

<body>
<h1>Upload a file</h1>
<form id="uploadForm" name="uploadForm" action="{{route('process')}}" enctype="multipart/form-data">
@csrf
<label for="fileName">File Name:</label>
<input type="text" name="fileName" id="fileName" required /><br />
<label for="userFile">Select a File</label>
<input type="file" name="userFile" id="userFile" required />
<button type="submit" name="submit">Submit</button>
</form>
<h2 id="success" style="color:green;display:none">Successfully uploaded file</h2>
<h2 id="error" style="color:red;display:none">Error Submitting File</h2>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<script>
$('#uploadForm').on('submit', function(e) {
e.preventDefault();
var form = $(this);
var url = form.attr('action');
$.ajax({
url: url,
type: "POST",
data: new FormData(this),
processData: false,
contentType: false,
dataType: "JSON",
success: function(data) {
$("#fileName").val("");
$("#userFile").val("");
}
}).done(function() {
$('#success').css('display', 'block');
window.setTimeout(()=>($("#success").css('display', 'none')), 5000);
}).fail(function() {
$('#error').css('display', 'block');
window.setTimeout(()=>($("#error").css('display', 'none')), 5000);
});
});
</script>
</body>
</html>

Hier ist, was unser / Hochladen Seite sieht so aus:

Dies ist ein sehr typisches Beispiel für eine Blade-Datei, die ein HTML-Formular enthält und JavaSkript/jQuery zum Hinzufügen asynchroner Funktionalität (damit die Seite nicht neu geladen wird). Es gibt ein grundlegendes Ein Tag ohne method-Attribut (das wir gleich erklären werden) und mit einem ungewöhnlichen action-Attribut mit dem Wert {{route('process')}}. In Blade wird dies als … bezeichnet. Richtlinie. Eine Direktive ist lediglich ein anderer Name für eine Funktion; es handelt sich dabei um Funktionen, die speziell für Blade-Templates entwickelt wurden und verschiedene Operationen ausführen, die beim Erstellen von Webseiten und Webanwendungen üblich sind. Um alle nützlichen Funktionen von Blade besser zu verstehen, konsultieren Sie die Dokumentation. werden auf dieser Seite erläutertIm obigen Fall verwenden wir die Routendirektive, um eine zu generieren URL für unsere Formularübermittlung.

Denken Sie daran, dass wir unsere Routen zuvor in der web.php-Datei definiert und jeder einen leicht zu merkenden Namen gegeben haben. Die {{route()}}-Direktive akzeptiert den Namen einer Route, sucht ihn in der intern zwischengespeicherten Routenliste und generiert eine vollständige URL. URL Basierend auf der Definition dieser Route in der Datei web.php. Im ersten Fall legen wir fest, dass das Formular seine übermittelten Daten an /process senden soll. URL unserer Anwendung, die definiert ist als jetzt lesen Route.

Als Nächstes ist Ihnen vielleicht das @csrf-Tag direkt unter dem öffnenden Formular-Tag aufgefallen. In Blade erzeugt dieses Tag einen _token-Parameter im Formular, der innerhalb der Anwendung geprüft wird, bevor die Formulardaten verarbeitet werden dürfen. Dadurch wird sichergestellt, dass die Daten im Formular eine gültige Herkunft haben und Cross-Site-Request-Forgery-Angriffe verhindert werden. Weitere Informationen dazu finden Sie in der Dokumentation. docs.

Anschließend definieren wir unser Formular wie gewohnt; beachten Sie jedoch, dass die Namen unserer Formularparameter, userFile und fileName, die genau die gleiche Wie in unserem Anfrageobjekt definiert. Wenn wir für einen bestimmten, im Anfrageobjekt definierten Parameter ein Eingabefeld vergessen (oder ihn falsch geschrieben) haben, schlägt die Anfrage fehl und es wird ein Fehler zurückgegeben. Dadurch wird verhindert, dass die ursprüngliche Formularanfrage die Controller-Methode unter UploadController@process erreicht.

Probieren Sie es ruhig aus und laden Sie mithilfe dieses Formulars einige Dateien in die Anwendung hoch. Navigieren Sie anschließend zu /aufführen Seite, um den Inhalt des Upload-Ordners anzuzeigen. Die von Ihnen hochgeladenen Dateien werden in einer Tabelle aufgelistet:

The Bigger Picture

Lasst uns einen Schritt zurücktreten und betrachten, was wir in diesem Laravel-Tutorial gemacht haben.

Dieses Diagramm stellt die Anwendung in ihrem aktuellen Zustand dar (Details auf hoher Ebene wurden ausgelassen):

Sie sollten sich daran erinnern, dass das zu Beginn dieses Laravel-Tutorials erstellte Request-Objekt in seiner `rules`-Methode dieselben Parameter definieren sollte wie das Formular im Blade-Template (falls nicht, lesen Sie bitte den Abschnitt „Erstellen der Validierungslogik“ erneut). Der Benutzer füllt das Formular auf einer Webseite aus, die mit der Blade-Template-Engine gerendert wird, und sendet es ab. Der jQuery-Code im Template am Ende verhindert die Standardübermittlung (die automatisch auf eine separate Seite weiterleiten würde), erstellt eine Ajax-Anfrage, lädt die Formulardaten und die hochgeladene Datei in die Anfrage und sendet diese an die erste Schicht unserer Anwendung: die Anfrage.

Das Anfrageobjekt wird befüllt, indem die Parameter der `rules()`-Methode den übermittelten Formularparametern zugeordnet werden. Anschließend werden die Daten anhand jeder angegebenen Regel validiert. Sind alle Regeln erfüllt, wird die Anfrage an die entsprechende Controller-Methode weitergeleitet, die den in der Routendatei `web.php` definierten Werten entspricht. In diesem Fall ist es die `process()`-Methode des `UploadController`. Sobald der Controller erreicht ist, wissen wir bereits, dass die Anfrage die Validierung bestanden hat. Daher müssen wir nicht erneut prüfen, ob der angegebene Dateiname tatsächlich ein String ist oder der Parameter `userFile` einen Dateityp enthält. Wir können wie gewohnt fortfahren.

Die Controller-Methode liest die validierten Parameter aus dem Anfrageobjekt aus, generiert einen vollständigen Dateinamen durch Verkettung des übergebenen Parameters `fileName` mit der ursprünglichen Dateiendung der Benutzerdatei, speichert die Datei in einem Verzeichnis der Anwendung und gibt eine einfache JSON-kodierte Antwort zurück, die den Erfolg der Anfrage bestätigt. Die jQuery-Logik empfängt diese Antwort und führt weitere UI-bezogene Aufgaben aus, wie z. B. die Anzeige der Erfolgs- (oder Fehlermeldung) für 5 Sekunden, gefolgt vom Ausblenden, sowie das Löschen der vorherigen Formulareingaben. So weiß der Benutzer sicher, dass die Anfrage erfolgreich war und kann bei Bedarf eine weitere Datei hochladen.

Beachten Sie im obigen Diagramm, wo genau die Grenze zwischen Client und Server verläuft. Dieses Konzept ist absolut entscheidend für Ihr Verständnis und hilft Ihnen, zukünftige Probleme zu lösen, beispielsweise bei der gleichzeitigen Verarbeitung mehrerer asynchroner Anfragen. Die Trennung erfolgt direkt am Request-Objekt. Das Request-Objekt selbst kann als „Gateway“ zum Rest der Anwendung betrachtet werden. Es führt die erste Validierung und Registrierung der vom Webbrowser übermittelten Formularwerte durch. Sind diese gültig, werden sie an den Controller weitergeleitet. Alles davor findet im Frontend statt (der „Client“ bedeutet wörtlich „auf dem Computer des Benutzers“). Die Antwort wird von der Anwendung an den Client zurückgesendet, wo unser jQuery-Code geduldig auf deren Eintreffen wartet und nach Erhalt einige einfache UI-Aufgaben ausführt.

Wir haben auch viele wichtige, häufig gestellte Fragen behandelt. Interviewfragen zu Laravel und PHP sowohl für Berufseinsteiger als auch für erfahrene Kandidaten, den richtigen Job zu finden.

Häufig gestellte Fragen