Framework PHP

• Web oficial
• Documentación oficial

• Gestión de errores con Laravel
• Trabajando con bases de datos en Laravel
• Rutas en Laravel
• Controladores en Laravel
• Trabajando con vistas en Laravel
• Trabajando con formularios en Laravel
• Redirigir al usuario en Laravel
• Validación de información en Laravel
• Sesiones en Laravel
• Inyección implícita de modelos en Laravel
• Creando componentes con Artisan en Laravel
• Relaciones entre modelos
• Seeder
• Programación de tareas en Laravel
• Comandos en Laravel
• Crear un CRUD con Laravel
• Helpers de Laravel
• Convenciones utilizadas en Laravel

Para que Laravel funcione correctamente, el servidor web que lo correrá debe tener la siguiente versión de PHP y extensiones:

• PHP >= 8.2
• Ctype PHP Extension
• cURL PHP Extension
• DOM PHP Extension
• Fileinfo PHP Extension
• Filter PHP Extension
• Hash PHP Extension
• Mbstring PHP Extension
• OpenSSL PHP Extension
• PCRE PHP Extension
• PDO PHP Extension
• Session PHP Extension
• Tokenizer PHP Extension
• XML PHP Extension

Para instalar PHP y el resto de dependencias, existe el siguiente script:

/bin/bash -c "$(curl -fsSL https://php.new/install/linux/8.4)"

Descargamos el instalador de Laravel:

composer global require laravel/installer

Para crear un proyecto Laravel:

laravel new nombre-proyecto

Esto descargará los archivos necesarios y los guardará en el directorio desde el que ejecutemos el comando. Además, se iniciará un asistente para realizar una configuración básica de nuestro proyecto.

export PATH="~/.config/composer/vendor/bin:$PATH"

Si no queremos usar el instalador de Laravel, podemos usar solo composer:

composer create-project --prefer-dist laravel/laravel miproyecto

composer global update laravel/installer

Si estamos en Linux y tenemos Docker instalado, Laravel proporciona una herramienta llamada Sail que permite crear un entorno de ejecución para Laravel:

curl -s https://laravel.build/example-app | bash

Podemos sustituir example-app por el nombre que queramos (será el directorio donde descargará Laravel).

Entramos en el directorio y ejecutamos:

./vendor/bin/sail up

Sail es una aplicación para usar Laravel con Docker de forma sencilla:

• Servidor web en puerto 80
• Servidor Redis en puerto 6379
• Mailhog en puerto 1025 y 8025 (dashboard)
• Servidor MySQL en puerto 3306
• Meilisearch en puerto 7700
• Selenium

Si tenemos PHP y Composer instalados, podemos crear un proyecto Laravel con Composer:

composer create-project laravel/laravel example-app

Entramos en el directorio recién creado:

cd example-app

Arrancamos el servidor de desarrollo de Laravel:

php artisan serve

Tendremos disponible la aplicación desde http://localhost:8000

Hay dos formas de crear un nuevo proyecto en Laravel.

Utilizando Composer:

composer create-project laravel/laravel nombre-del-proyecto

composer create-project laravel/laravel nombre-del-proyecto "10.*"

Utilizando el instalador de Laravel:

laravel new nombre-del-proyecto

composer global require laravel/installer

Dentro del directorio creado, copiamos el archivo .env.example a .env

cp .env.example .env

Si vamos a usar una base de datos distinta a SQLite, lo configuramos también en el fichero .env:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nombre_db
DB_USERNAME=usuario_db
DB_PASSWORD=contraseña_db

Genera la clave de la aplicación:

php artisan key:generate

php artisan serve

Tendremos accesible la aplicación Laravel desde http://localhost:8000.

Al crear un proyecto Laravel, se crearán los siguientes directorios:

• app/: código de la aplicación. Modelos, controladores, comandos y el código personalizado.
• bootstrap/: ficheros que Laravel necesita cada vez que se ejecuta.
• database/: contiene las migraciones de base de datos (migrations), model factories y seeds. También se puede almacenar en él una base de datos SQLite.
• config/: ficheros de configuración.
• lang/: ficheros de idiomas.
• public/: directorio al que apunta el servidor web cuando sirve la aplicación. Contiene index.php, que es el front-controller. También contiene todo lo que se sirve públicamente como imágenes, hojas de estilo, scripts de JavaScript…
• resources/: vistas de Blade y otros assets.
• routes/: contiene la definición de las rutas del proyecto
• storage/: contiene logs, caché y otros ficheros generados por Laravel.
• tests/: contiene tests automatizados.
• vendor/: contiene las dependencias de Composer.

• composer.json dependencias requeridas por nuestro proyecto.
• En el fichero .env se definen las variables de entorno (este fichero debe figurar en el .gitignore para que no salga de nuestro entorno local).

Todo inicia con un archivo index.php. En Laravel, todo lo que sea público, es decir, todo lo que se pueda acceder desde una petición desde un navegador web, está en la carpeta public. Ahí encontraremos el archivo index.php.

En este fichero se controla el tiempo de ejecución del script, se cargan automáticamente las definiciones de las clases que instalamos por medio de Composer (dentro de la carpeta vendor) y se carga el “kernel” que es el que recibe la petición del usuario / navegador, la gestiona y envía la respuesta asociada. El kernel está en el fichero app/Http/Kernel.php. A su vez, hereda de vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php.

En el kernel se inicia el enrutador (router) que es el encargado de enviar la petición hacia las rutas.

Las rutas se encuentran en routes/. Lo normal es que trabajemos con el fichero web.php.

La ruta que hay en web.php gestiona la vista principal. Las vistas están en resources/views/. Los ficheros con las vistas siguen la nomenclatura nombre_vista.blade.php. Las vistas contienen el HTML, lo que devuelve Laravel al navegador web.

Configurar el servidor web para que sirva desde la carpeta public. Por ejemplo, en el caso de Nginx:

server {

    server_name localhost;
  
    index index.php index.html;
    root /var/www/html/mi-proyecto/public;

(...)

El servidor web debe poder escribir en los directorios storage y bootstrap/cache

En un proyecto de Laravel tendremos dos ficheros:

• .env: contiene las variables de entorno que usa Laravel. No se debe publicar.
• .env.example: es el que sí compartiremos porque es la base de la configuración de las variables de entorno.

APP_NAME=Laravel
APP_ENV=local
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost
...

Por ejemplo, en /config/app.php se cargan algunas variables de entorno como APP_NAME , APP_ENV…

Creación del esquema de las tablas..

Por defecto, se guardan en el directorio app/Models.

Podemos crear un modelo apoyándonos en artisan:

php artisan make:model Usuario --migration

Esto creará la clase Usuario en app/Models/Usuario.php con el código:

<?php
 
namespace App\Models;
 
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
 
class Usuario extends Model
{
    use HasFactory;
}

Además, como hemos indicado que queremos generar una migración de la base de datos (opción --migratio), también tendremos un fichero AAAA_MM_DD_HHMMSS_create_usuarios_table en database/migrations/ con el código:

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
class CreateUsuariosTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('usuarios', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('usuarios');
    }
}

Laravel se basa en un patrón de arquitectura del software llamado MVC, de Modelo-Vista-Controlador. Centrándonos en aplicaciones web, mantiene separado el código PHP del HTML.

Un controlador se encarga de manejar la lógica del negocio (crear, actualizar, mostrar, eliminar, realizar filtrados, etc).

Los controladores se ubican en app/Http/Controllers

Para crear un nuevo controlador, podemos hacerlo desde cero o utilizar Artisan:

php artisan make:controller ProductController

Esto creará un fichero llamado ProductController.php en app/Http/Controllers/ con el siguiente contenido rellenado por Laravel:

<?php
 
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
 
class ProductController extends Controller {
 
}

Vamos añadiendo acciones (métodos) al controlador:

    // ....
    public function index() 
    {
        return "This is the list of products";
    }

Podemos relacionar las rutas con los controladores, en lugar de tener funciones anónimas:

Route::get("products", "ProductController@index")->name("products.index");

Hemos asociado la ruta /products con la acción index del controlador ProductController.

Haríamos el resto de acciones:

    // ...
    public function create() 
    {
        return "This is the form to create a product from controller";
    }
 
    public function store() 
    {
        return "Product stored";
    }
 
    public function show($product) 
    {
        return "Showing the product with ID {$product}";
    }
 
    public function edit($product) 
    {
        return "Showing the form to edit the product with id {$product}";
    }
 
    public function update($product) 
    {
    // ...
    }
 
    public function destroy($product) 
    {
    // ...
    }

No es práctico devolver cadenas con el HTML directamente desde las rutas o controladores. Las vistas proporcionan una forma conveniente de organizar todo el HTML en ficheros separados. Las vistas separan el controlador / lógica de la aplicación de su presentación.

Se almacenan en resources/views/

Si, por organización, creamos las vistas en otros directorios dentro del “oficial”, para hacer referencia a ellas:

// ...
    return view('users.profile', $data);

Con esto indicamos que queremos el fichero profile.blade.app que está en resources/views/users/

El nombre de los ficheros con las vistas deben terminar en .blade.php.

• Laravel Views

Los ficheros con las vistas se almacenan en resources/views/. Podemos crear directorios dentro de ese directorio para organizar mejor nuestros ficheros. Por ejemplo resources/views/products/index.blade.php.

<!DOCTYPE html>
<html lang="es">
    <head>
        <meta charset="utf-8">
        <title>Título</title>
    </head>
    <body>
        <h1>Listado de productos</h1>
 
        <div class="table-responsive">
            <table class="table table-striped">
                <thead class="thead-light">
                    <tr>
                        <th>ID</th>
                        <th>Title</th>
                        <th>Description</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>1</td>
                        <td>Soap</td>
                        <td>Best soap ever</td>
                    </tr>
                    <tr>
                        <td>2</td>
                        <td>Shampoo</td>
                        <td>Best shampoo ever</td>
                    </tr>
                </tbody>
            </table>
        <div>
    </body>
</html>

Tanto desde un controlador como desde una ruta, podemos llamar a las vistas mediante el helper view:

Route::get("/", function() {
    return view("welcome");
})->name("main");

En caso de un controlador:

    // ...
    public function index() 
    {
        return view("index");
    }

Si la vista index.blade.php está dentro de una carpeta llamada “products”:

    // ...
    public function index() 
    {
        return view("products.index");
    }

Laravel utiliza un componente llamando Ignition, una página de error para aplicaciones Laravel.

Además de ver el error, podremos ver la traza hasta llegar a dicho error.

Hay un par de helpers que nos ayudan a la hora de depurar errores en Laravel:

• dd(): dump and die, muestra la información y detiene el script.
• dump(): muestra la información, pero no detiene el script.

Por ejemplo, queremos saber el valor de cierta variable sin detener el script:

dump($variable);

Proyectos open source hechos con este framework:

• Firefly III: gestor de finanzas personales
• Monica: Gestor de relaciones personales.
• Snipe-IT: Gestor de recursos y licencias TI
• https://gist.github.com/msurguy/8590765
• Top Laravel Interview Questions & Answers

Interfaz en línea de comandos incluida en Laravel diseñada para automatizar tareas comunes en el desarrollo de aplicaciones. Se usa para generar código, gestionar la base de datos, ejecutar pruebas y más.

Podremos ver todos los comandos que admite Artisan y una breve descripción de cada uno mediante:

php artisan

php artisan serve

Desde ese momento, tendremos accesible nuestro proyecto desde http://localhost:8080

php artisan serve --port=8000

Una de las variables que están definidas en el fichero .env es APP_KEY. Para generar un valor aleatorio:

php artisan key:generate

Para crear un nuevo modelo Eloquent:

php artisan make:model <NOMBRE_MODELO>

Si queremos que también genere la migración, le pasamos el argumento -m:

php artisan make:model <NOMBRE_MODELO> -m

También podemos generar de todo para un modelo:

php artisan make:model <NOMBRE_MODELO> -a

El comando anterior generará:

• Model (app/Models/)
• Migración (database/migrations/)
• Seeder (database/seeders/)
• Controlador y su recurso (7 rutas / métodos) para realizar un CRUD.
• Factory (database/factories)
• Policy

Para generar un controlador:

php artisan make:controller <NOMBRE_CONTROLADOR>

Si también queremos que se creen los métodos RESTful (para listar, editar, añadir y borrar), le pasamos la opción --resource:

php artisan make:controller <NOMBRE_CONTROLADOR> --resource

Si queremos crear un controlador y asociarlo a un modelo, utilizamos la opción --model:

php artisan make:controller <NOMBRE_CONTROLADOR> --model=<NOMBRE_MODELO>

php artisan migrate

php artisan migrate:rollback

php artisan migrate:fresh

Si también queremos que se ejecuten los seeders:

php artisan migrate:fresh --seed

php artisan db:seed

Si solo queremos que se ejecute cierto seeder, utilizamos la opción --class:

php artisan db:seed --class=UserSeeder

php artisan route:list

Para abrir la consola interactiva:

php artisan tinker

Borrar caché (por si hemos hecho muchos cambios y tenemos algún problema):

php artisan optimize:clear

Los comandos de Artisan que más usaremos serán los relacionados con migraciones de la base de datos y creación de componentes.

Para mostrar la ayuda de cualquier comando de artisan hay que añadir --help. Por ejemplo:

php artisan make:model --help

Para mostrar la información de un modelo:

php artisan model:show <NOMBRE_MODELO>

Por ejemplo:

$ php artisan model:show User

App\Models\User

  Table: users
  Connection: mysql
  Primary key: id
  Incrementing: Yes
  With: []
  WithCount: []
  Belongs to Many: []

  Attributes:
    id: int (auto-increment)
    name: string
    email: string
    meta: array (cast)
    created_at: Illuminate\Support\Carbon (cast: datetime)
    updated_at: Illuminate\Support\Carbon (cast: datetime)

  Relationships:
    posts(): HasMany(App\Models\Post)
      🔑 Foreign key: user_id
      🗝️ Owner key: id

  Methods:
    getEmailVerifiedAtAttribute()
    setPasswordAttribute($value)

php artisan serve

Si queremos poner la aplicación en modo mantenimiento:

php artisan down

Esto hará que Laravel devuelva un error 503. Útil si queremos hacer modificaciones y evitar que los usuarios se muevan por donde no deben

Si queremos “reactivarla” o sacarla del modo de mantenimiento:

php artisan up

Tinker es una consola de comandos con la que podremos interactuar con todas las clases y métodos de nuestra aplicación, una herramienta muy útil a la hora de realizar pruebas de funcionamiento.

php artisan tinker

A partir de ahí se abrirá una shell donde podremos ejecutar código PHP y funciones de Laravel. Por ejemplo, podemos usar los helpers de Laravel:

>>> \Str::plural('apple');
=> "people"
>>> \Str::random(5);
=> "IgRFW"

Si necesitamos generar la variable APP_KEY:

php artisan key:generate

Artisan añadirá al fichero .env la variable APP_KEY con un valor.

• Laravel Mix: gestión de dependencias para front-end, los assets (JavaScript y CSS). Necesita Node.js.

Para simplificar, se puede usar un pequeño servidor que viene con Laravel:

php artisan serve

Recomendación de plugins para el editor Sublime Text 3:

• Package Control: Necesario para instalar plugins o paquetes
• AdvancedNewFile: Para crear nuevos archivos fácilmente
• Blade Snippets: Para usar instrucciones de Blade en las vistas
• Bootstrap 4x Autocomplete: Sugerir componentes de Bootstrap 4 en las vistas
• DocBlockr: Crear bloques de comentarios fácilmente
• Emmet: Autocompletar etiquetas de HTML
• Laravel Blade AutoComplete: Autocomplete estructuras comunes en las vistas de Blade
• Laravel Blade Highlighter: Resalta el código con colores adecuados en las vistas
• Laravel Helper Completions: Sugerir el uso de helpers comunes en el código
• PHP Companion: Útil para importar definiciones de clases
• phpfmt: Útil para corregir el estilo del código PHP
• SideBarEnhacements: Para agregar opciones adicionales en la barra lateral
• SublimeCodeIntel: Para explorar y abrir fácilmente definiciones de clases y métodos en el proyecto
• SublimeLinter: Útil para detectar errores de sintaxis en el código
• SublimeLinter-php: El linter propio para detectar errores en código PHP

• Awesome Laravel: A curated list of awesome bookmarks, packages, tutorials, videos and other cool resources from the Laravel ecosystem.
• Documentación de Laravel