Laravel.

Laravel is a free, open-source PHP web framework built on the Model-View-Controller (MVC) pattern. It covers routing, database access and views in one package.

Its key features:

• Eloquent ORM maps each database table to a model class for database work.
• Blade is the templating engine for views.
• Artisan is the command-line tool that generates code and runs tasks.
• A routing system that maps URLs to controllers.
• Authentication and authorization.
• Database migrations and queue management.
• Event broadcasting and testing support.

Laravel favours convention over configuration, so following its folder layout and naming rules saves setup work.

Laravel's Model-View-Controller (MVC) architecture splits each request across three parts. Models handle data, views render output, and controllers connect the two.

• The model is an Eloquent class that holds data logic and talks to the database.
• The view is a Blade template that turns data into HTML.
• The controller receives the request, asks models for data and hands it to a view.

A request first matches a route, which calls a controller method. The controller reads or writes data through models and gets the results back. It then returns a view, and Laravel sends the rendered view as the response.

Because each layer has one job, you can change a template without touching queries. You can also test models and controllers on their own.

Composer is PHP's dependency manager, and Laravel uses it to install and autoload every package the app needs. You list dependencies in composer.json, and Composer records the exact installed versions in composer.lock.

composer install           # Install dependencies
composer update            # Update dependencies  
composer dump-autoload     # Regenerate PSR-4 autoload
composer require package   # Add new package

composer install reads the lock file, so every machine gets the same versions. composer update resolves newer versions and rewrites the lock file.

Composer also builds the PSR-4 autoloader, which loads a class such as App\Models\User from its file path without manual require calls. A new project usually starts with composer create-project laravel/laravel.

You define a route by mapping an HTTP verb and a URI to a closure or a controller method, in a file under routes/. The router has one method per verb, such as Route::get() and Route::post().

Web routes go in routes/web.php. They get the web middleware group, which adds sessions and protection against cross-site request forgery (CSRF). API routes go in routes/api.php. Current Laravel versions create that file only when you run php artisan install:api. Laravel adds the /api prefix to every route in it.

Route::get('/users', [UserController::class, 'index']);
Route::post('/users', [UserController::class, 'store']);
Route::put('/users/{id}', [UserController::class, 'update']);
Route::delete('/users/{id}', [UserController::class, 'destroy']);

// Resource route (creates all CRUD routes)
Route::resource('posts', PostController::class);

Route::resource() registers the full set of CRUD routes for a controller in one line. You can name a route with ->name() and list every route with php artisan route:list.

Route parameters are placeholders in a URI, written in braces, that capture segments of the URI and pass them to your closure or controller. Laravel passes them in order, so the arguments must follow the order of the placeholders.

// Required parameter
Route::get('/user/{id}', function ($id) {
    return "User ID: $id";
});

// Optional parameter
Route::get('/hello/{name?}', function ($name = 'Guest') {
    return "Hello, $name";
});

// Regular expression constraint
Route::get('/post/{id}', function ($id) {
    //
})->where('id', '[0-9]+');

A required parameter like {id} must be present. An optional parameter adds a ?, and its argument needs a default value.

A parameter matches one segment, so it stops at a slash unless a where() constraint allows one. The where() method adds a regular expression constraint, and a URI that fails it gets a 404. Routes are matched in the order they are registered, so each example here uses its own URI.

A resource controller has one method for each standard action on a resource, so a single Route::resource() line wires up all its CRUD routes. You generate one with the --resource flag.

// Generate: php artisan make:controller PostController --resource
// Route: Route::resource('posts', PostController::class);

The seven methods map to verbs and URIs like this:

• index() lists resources at GET /posts.
• create() shows the creation form at GET /posts/create.
• store() stores a new resource at POST /posts.
• show($id) displays one resource at GET /posts/{post}.
• edit($id) shows the edit form at GET /posts/{post}/edit.
• update($id) updates a resource at PUT /posts/{post} or PATCH.
• destroy($id) deletes a resource at DELETE /posts/{post}.

Each route also gets a name such as posts.index. For a JSON API, Route::apiResource() leaves out create and edit, since an API serves no HTML forms. Chain only() or except() to register a subset.

Eloquent is Laravel's object-relational mapper (ORM), which maps database tables to PHP classes. It follows the Active Record pattern. Each database table has a corresponding model class, and each model instance is one row.

Its main advantages:

• Simple, expressive syntax, such as User::where('active', 1)->get().
• Relationship management, such as hasMany.
• Automatic created_at and updated_at timestamps.
• Soft deletes, which hide a row instead of removing it.
• Query scopes, which are reusable query conditions.
• Accessors and mutators, which change a value when it is read or written.
• Model events, which run code when a model is saved.

The trade-off is speed. Eloquent builds a full model object for every row, while the query builder, called through DB::table(), returns plain rows. Large reports often run faster through it.