Aprende Laravel 6: guía práctica paso a paso

Jon Vadillo Romero

Este libro está a la venta en http://leanpub.com/aprende-laravel

Esta versión se publicó en 2020-01-19

Este es un libro de Leanpub. Leanpub anima a los autores y publicadoras con el proceso de
publicación. Lean Publishing es el acto de publicar un libro en progreso usando herramientas
sencillas y muchas iteraciones para obtener feedback del lector hasta conseguir tener el libro
adecuado.

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0

International License
Este libro está dedicado a todas las personas que de una forma u otra ayudan a mantener y mejorar el
ecosistema actual de aprendizaje. Desde los más expertos que comparten su conocimiento para que el
resto de personas podamos seguir aprendiendo sin encontrar barrereas hasta a los más principiantes
que con su motivación por aprender hacen que el resto sintamos que compartir y enseñar merece la
pena.
Índice general

Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Prerequisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
¿Qué es Laravel? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Características principales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Ecosistema Laravel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Preparar el entorno de desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Tu primera aplicación en 8 pasos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Paso 1 - Crea tu primer proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Paso 2 - Configura el proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Paso 3 - Crear un Router . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Paso 4 - Crear una vista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Paso 5 - Crear un Controlador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Paso 6 - Configurar la base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Paso 7 - Crear la Migración (Migration) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Paso 8 - Crear un Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Bonus - Opciones (flags) de Artisan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Práctica 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Práctica 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Level up: Laravel nivel intermedio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Borrado de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Práctica 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Formularios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Práctica 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Construir layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Práctica 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Asignar nombres a las rutas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Utilizar Bootstrap en tu proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Relaciones One-to-Many . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Consejo: cómo añadir columnas a modelo existente . . . . . . . . . . . . . . . . . . . . . . . . 31
Generar datos de prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Práctica 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
ÍNDICE GENERAL

Práctica 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Práctica 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Autenticación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Práctica 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Manejo de sesiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Práctica 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Próximos pasos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Introducción
Es importante que antes de comenzar a leer este libro, comprendas dos cosas fundamentales acerca
del mismo:

• Este libro no pretende ser una extensa guía de referencia que profundice en cada uno de los
aspectos de Laravel. Su objetivo es el de mostrarte los aspectos más importantes de Laravel y
enseñarte paso a paso y de forma práctica a desarrollar aplicaciones web.
• El libro está en constante mejora y actualización. Toda contribución es bienvenida, ya sea en
forma de corrección de errores, sugerencias sobre el contenido, difusión entre conocidos o redes
sociales o cualquier otro tipo de colaboración que se te pueda ocurrir. Puedes hacerlo de forma
sencilla escribiendo un mensaje directo en Twitter a @JonVadillo.

Prerequisitos
Para seguir esta guía únicamente necesitarás conocimientos básicos/medios de PHP y motivación
para aprender. Si todavía no dispones de estos conocimientos, puedes utilizar el material gratuito
disponible en http://jonvadillo.com/learn para comenzar tu aprendizaje.
Cualquier editor de texto te servirá también para programar. No obstante, te recomiendo PhpStorm
de JetBrains, el cual considero sin duda alguna uno de los editores para PHP más potentes en la
actualidad.
¡Comencemos!

¿Qué es Laravel?
Tal y como dice la guía oficial, Laravel es un framework de desarrollo de aplicaciones web con
una sintaxis elegante que nos permitirá desarrollar aplicaciones web de forma rápida y segura.
El objetivo de Laravel es permitir a los desarrolladores crear aplicaciones web robustas y profesio-
nales, de forma ágil y con una estructura adecuada. Laravel facilita la implentación de cualquier
funcionalidad que toda aplicación profesional pueda necesitar (interacción con bases de datos,
seguridad, servicios web, etc.).
En este libro aprenderás a crear aplicaciones web con Laravel desde cero, desde lo más básico
hasta funcionalidades más complejas que incluyan aspectos como la seguridad o control de acceso.
Introducción 2

Características principales
Algunas de las características de Laravel son:

• Sistema intuitivo de rutas.

• Motor de plantillas Blade para la generación de interfaces de usuario de forma flexible.
• Soporte para cualquier base de datos mediante Eloquent ORM.
• Uso de la arquitectura MVC.
• Dispone de multitud de componentes capaces de resolver las problemáticas más comunes del
desarrollo de aplicaciones web.
• Una grande comunidad de desarrolladores y expertos.

Ecosistema Laravel
Es importante conocer bien los actores principales del ecosistema Laravel:

• Router: recibe todas las peticiones y las envía al controlador adecuado (también puede ejecutar
algún middleware específico antes de llamar al controlador).
• Controladores (Controllers): contienen toda la lógica para reaccionar a las peticiones entran-
tes.
• Vistas (Views): contienen el código HTML y separan la presentación de la lógica de la
aplicación (controlador).
• Modelos (Models): se utilizan para interactuar con la base de datos y aplicar la lógica de
negocio.

Laravel diagram
Introducción 3

Tal y como muestra la imagen anterior, el flujo de una petición en una aplicación de Laravel sería
el siguiente:

1. El punto de entrada de todas las peticiones es el archivo public/index.php el cual se encargará

de lanzar una instancia de nuestra aplicación Laravel.
2. La petición se envía al router, el cual la reenvía al controlador correspondiente.
3. El controlador atiende la petición y realiza las acciones correspondientes (por ejemplo, puede
interactuar con la base de datos para cargar o almacenar información).
4. Por último, el controlador genera la vista correspondiente y se la envía al cliente.
 Preparar el entorno de desarrollo
Puedes lanzar una aplicación desarrollada con Laravel en cualquier máquina o servidor con
Apache¹/Nginx, PHP² y Composer³. Para facilitar la creación del entorno de desarrollo, utilizaremos
Laravel Homestead⁴. Homestead es una Vagrant box que provee de un entorno de desarrollo con
todo el software necesario: PHP, servidor web, base de datos, gestor de dependencias, etc.
No obstante, si te sientes más cómodo utilizando tu propio servidor o entorno de desarrollo, puedes
hacerlo perfectamente siempre que cumplas con los requerimientos citados.
En esta sección veremos paso a paso como preparar nuestro entorno de desarrollo con Homestead.

1. Instalar VirtualBox 6.x

Descarga VirtualBox desde la página web oficial www.virtualbox.org⁵ e instálalo en tu ordenador.

También puedes utilizar VMWare, Parallels o Hyper-V en lugar de Virtual Box.

2. Instalar Vagrant.

Descarga e instala Vagrant tal y como lo indica la documentación de la página web oficial
https://www.vagrantup.com⁶.

3. Añadir laravel/homestead box a tu instalación de Vagrant

Una Vagrant box es una imagen base utilizada para clonar de forma rápida y sencilla una máquina
virtual. Ejecuta el siguiente comando para descargar e instalar la Vagrant box the Larabel y así poder
utilizarla para crear tantos entornos como quieras.

1 vagrant box add laravel/homestead

Puedes comprobar que se ha añadido correctamente utilizando el comando vagrant box list.

4. Instalar Homestead

Clona el repositorio oficial de Homestead en un directorio. Como recomendación, puedes clonarlo

en una carpeta llamada Homestead en la raíz de tu sistema, y utilizar esta máquina virtual para
todos tus proyectos de Laravel.
¹https://httpd.apache.org/
²https://www.php.net/
³https://getcomposer.org/
⁴https://github.com/laravel/homestead
⁵https://www.virtualbox.org/
⁶(https://www.vagrantup.com/downloads.html)
 Preparar el entorno de desarrollo 5

1 git clone https://github.com/laravel/homestead.git ~/Homestead

5. Crea el archivo de configuración Homestead.yaml

Ejecuta el comando init.sh en un terminal dentro del directorio donde clonaste Homestead. Este
comando creará el archivo de configuración Homestead.yaml.

1 // Mac / Linux...
2 bash init.sh
3
4 // Windows...
5 init.bat

El archivo Homestead.yaml creado tendrá el siguiente aspecto:

1 ip: "192.168.10.10"
2 memory: 2048
3 cpus: 2
4 provider: virtualbox
5
6 authorize: ~/.ssh/id_rsa.pub
7
8 keys:
9 - ~/.ssh/id_rsa
10
11 folders:
12 - map: ~/code
13 to: /home/vagrant/code
14
15 sites:
16 - map: homestead.test
17 to: /home/vagrant/code/public
18
19 databases:
20 - homestead

6. Genera las claves ssh

Si no dispones de unas clasves ssh en el sistema necesitarás generarlas desde un terminal. Para saber
si ya dispones de ellas, intanta encontrar el directorio .ssh en tu sistema operativo (normalmente
suele encontrarse en C:UsersUSER_NAME en Windows y el el directorio raíz ∼ en Linux/Mac ) y
busca dos archivos llamados id_rsa y id_rsa.pub. Si los has encontrado, puedes saltarte este paso.
En caso contrario, lanza el siguiente comando desde la consola:
 Preparar el entorno de desarrollo 6

1 ssh-keygen -t rsa -C "[email protected]"

El script te realizará algunas preguntas, simplemente pulsa ENTER y te creará los archivos id_rsa
y id_rsa.pub en un directorio con nombre .ssh.

7. Configurar Homestead

En esta instalación no tendrás que tocar el archivo Vagrantfile (probablemente estés familiarizado
con él ya que es típicamente el utilizado para configurar el entorno). Homestead delega la
configuración en el archivo Homestead.yaml, por lo que a continuación te mostraremos las opciones
más importantes que tendrás que configurar:

• ssh keys: el fichero de configuración Homestead.yaml tendrá la configuración realizada co-

rrectamente tanto para Mac como Linux. Si estás utilizando Windows, modifica los siguientes
valores:

1 authorize: c:/Users/USER_NAME/.ssh/id_rsa.pub
2
3 keys:
4 - c:/Users/USER_NAME/.ssh/id_rsa

• Shared folders: en este apartado se indican los directorios de la máquina local que se
mantendrán sincronizados con la máquina virtual creada. Modifica el valor de ‘map’ y
escribe la carpeta de tu proyecto (p.ej. /Users/USER_NAME/dev/my-project en Linux/Mac o
c:/dev/my-project en Windows).

1 folders:
2 - map: ~/code/project1
3 to: /home/vagrant/project1
4
5 - map: ~/code/project2
6 to: /home/vagrant/project2

• Sites: La propiedad sites permite mapear fácilmente un dominio con un directorio de nuestro
entorno virtual. De este forma podremos utilizar el dominio indicado para acceder a nuestra
aplicación desde el navegador:
 Preparar el entorno de desarrollo 7

1 sites:
2 - map: homestead.test
3 to: /home/vagrant/project1/public
4 - map: miapp.test
5 to: /home/vagrant/project2/public

8. Configurar el archivo local hosts

Es probable que vayas a utilizar el entorno virtual creado para múltiples proyectos o aplicaciones, por
lo que necesitarás añadir los dominios indicados en el anterior apartado de ‘sites’ al archivo hosts
de tu ordenador. De esta forma puedes redirigir las peticiones a dominios concretos a aplicaciones
de tu entorno virtual Homestead.
Modifica el archivo hosts (lo encontrarás en /etc/hosts en Mac/Linux y en C:\Windows\System32\drivers\etc\hos
en Windows):

1 192.168.10.10 homestead.test
2 192.168.10.10 miapp.test

Para evitar otro tipo de problemas, la recomendación general es utilizar dominios de tipo “.localhost”,
“.invalid”, “.test”, or “.example”.

9. Arrancar y prueba el entorno creado

Una vez ya tenemos Homestead configurado y el archivo hosts modificado, ya podemos ir al

directorio Homestead y ejecutar el siguiente comando para arranchar la máquina virtual (la primera
vez tardará más tiempo al tener que realizar la preparación del entorno):

1 vagrant up

Puedes acceder mediante SSH a tu máquina virtual:

1 vagrant ssh

¡Enhorabuena! Ya estás preparado para comenzar a crear tu primera aplicación web con Laravel.
Puedes detener la máquina virtual con el comando vagrant halt.
 Tu primera aplicación en 8 pasos
Ahora que ya tenemos nuestro entorno de desarrollo preparado, crearemos una aplicación web con
Laravel paso por paso. Al finalizar los 8 pasos que encontrarás en este capítulo, obtendremos como
resultado una revista online a la que hemos llamado RevistApp. Esta aplicación mostrará los artículos
de una revista almacenados en una base de datos. ¿Comenzamos ya?

Paso 1 - Crea tu primer proyecto

Accede a tu máquina virtual utilizando el comando vagrant ssh y ejecuta el siguiente comando
para crear un nuevo proyecto:

1 composer create-project --prefer-dist laravel/laravel revistapp

Si recibes un error, probablemente sea porque todavía no tienes Composer instalado en tu máquina
virtual. Para ello, ejecuta el siguiente comando:

1 composer global require laravel/installer

Una vez instalado vuelve a ejecutar el comando create-project de Composer. Este comando
inicializará un nuevo proyecto creado en el directorio revistapp. Puedes acceder a la aplicación
entrando a http://homestead.test (o el dominio que hayas indicado en la configuración) desde tu
navegador favorito.
De forma alternativa también puedes utilizar el comando laravel new que también creará un nuevo
proyecto de Laravel en la carpeta especificada:

1 laravel new revistapp

Puedes entrar a ver los archivos que se han creado en la nueva carpeta del proyecto. A partir de
ahora siempre trabajaremos dentro de este directorio.

Paso 2 - Configura el proyecto

Generar la clave de la aplicación (Application Key)

Laravel utiliza una clave para securizar tu aplicación. La clave de aplicación es un string de 32
caracteres utilizado para encriptar datos como la sesión de usuario. Cuando se instala Laravel
utilizando Composer o el instalador de Laravel, la clave se genera automáticamente, por lo que no
es necesario hacer nada. Comprueba que existe un valor para APP_KEY en el fichero de configuración
.env. En caso de no tener una clave generada, créala utilizando el siguiente comando:
 Tu primera aplicación en 8 pasos 9

1 php artisan key:generate

Establecer los permisos de directorio

Homestead realiza este paso por nosotros, por lo que si estás utilizando Homestead los permisos
deberían estar correctamente establecidos. Si no estás utilizando Homestead o quieres desplegar tu
aplicación en un servidor, no olvides establecer permisos de escritura para el servidor web en los
directorios storage y bootstrap/cache.

Paso 3 - Crear un Router

Cada vez que un usuario hace una petición a una de las rutas de la aplicación, Laravel trata la petición
mediante un Router definido en el directorio routes, el cual será el encargado de direccionar la
petición a un Controlador. Las rutas accesibles para navegadores estarán definidas en el archivo
routes/web.php y aquellas accesibles para servicios web (webservices) estarán definidas en el
archivo routes/api.php. A continuación se muestra un ejemplo:

1 Route::get('/articulos', function () {
2 return '¡Vamos a leer unos articulos!';
3 });

El código anterior muestra cómo se define una ruta básica. En este caso, cuando el usuario realice
una petición sobre /articulos, nuestra aplicación enviará una respuesta al usuario con el string
‘¡Vamos a leer unos articulos!’.
Aparte de ejecutar las acciones definidas para cada ruta, Laravel ejecutará el middlewere específico
en función del Router utilizado (por ejemplo, el middlewere relacionado con las peticiones web
proveerá de funcionalidades como el estado de la sesión o la protección CSRF⁷.

Ver las rutas creadas

Artisan incluye un comando para mostrar todas las rutas de una aplicación de forma rápida. Basta
con ejecutar el siguiente comando en la consola:

1 php artisan route:list

Devolver un JSON

También es posible devolver un JSON. Laravel convertirá automáticamente cualquier array a JSON:

⁷https://es.wikipedia.org/wiki/Cross-site_request_forgery
 Tu primera aplicación en 8 pasos 10

1 Route::get('/articulos', function () {
2 return ['foo' => 'bar'];
3 });

Parámetros en la ruta

Una URL puede contener información de nuestro interés. Laravel permite acceder a esta información
de forma sencilla utilizando los parámetros de ruta:

1 Route::get('articulos/{id}', function ($id) {

2 return 'Vas a leer el artículo: '.$id;
3 });

Los parámetros de ruta vienen definidos entre llaves {} y se inyectan automáticamente en las
callbacks. Es posible utilizar más de un parámetro de ruta:

1 Route::get('articulos/{id}/user/{name}', function ($id, $name) {

2 // Tu código aquí.
3 });

Acceder a la información de la petición

También es posible acceder a la información enviada en la petición. Por ejemplo, el siguiente código
devolverá el valor enviado para el parámetro ‘fecha’ de la URL /articulos?fecha=hoy:

1 Route::get('/articulos', function () {
2 $date = request('fecha');
3 return $date;
4 });

Paso 4 - Crear una vista

Definiendo una vista sencilla

Las vistas contienen el HTML que sirve nuestra aplicación a los usuarios. Se almacenan en el
directorio resources/views de nuestro proyecto.
 Tu primera aplicación en 8 pasos 11

1 <!-- vista almacenada en resources/views/articulos.blade.php -->

2 <html>
3 <body>
4 <h1>¡Vamos a leer unos artículos!</h1>
5 </body>
6 </html>

Devolver una vista

Cargar y devolver una vista al usuario es tan sencillo como utilizar la función global (helper) view():

1 Route::get('/articulos', function () {
2 return view('articulos');
3 });

Acceder a datos desde la vista

Laravel utiliza el motor de plantillas Blade⁸ por defecto. Un motor de plantillas permite crear vistas
empleando código HTML junto con código específico del motor empleado. De esta forma podremos
mostrar información almacenada en variables, crear condiciones if/else, estructuras repetitivas, etc.
En Blade mostrar datos almacenados en variables es muy sencillo:

1 <html>
2 <body>
3 <h1>Vamos a leer al escritor {{ $nombre }}</h1>
4 </ul>
5 </body>
6 </html>

Tal y como se puede ver en el ejemplo anterior, basta con escribir el nombre de la variable entre
llaves {{ }}.
También es posible iterar por los datos de una colección o array. El siguiente ejemplo muestra como
iterar por un array de strings de forma rápida:

⁸https://laravel.com/docs/6.x/blade
 Tu primera aplicación en 8 pasos 12

1 <!-- Vista almacenada en resources/views/articulos.blade.php -->

2 <html>
3 <body>
4 <h1>Vamos a leer al escritor {{ $nombre }}</h1>
5 <h2>Estos son sus últimos artículos:</h2>
6 <ul>
7 @foreach ($articulos as $articulo)
8 <li>{{ $articulo }}</li>
9 @endforeach
10 </ul>
11 </body>
12 </html>

Para que la vista pueda acceder a los datos, es necesario proporcionárselos en la llamada al método
view():

1 Route::get('/articulos', function () {
2 $articulos = array('Primero', 'Segundo','Tercero', 'Último');
3 return view('articulos', [
4 'nombre' => 'Ane Aranceta',
5 'articulos' => $articulos
6 ]);
7 });

Los datos se le pasarán como un array de tipo clave-valor.

El motor de plantillas Blade permite el uso de todo tipo de estructuras:

1 @for ($i = 0; $i < 10; $i++)

2 El valor actual es {{ $i }}
3 @endfor
4
5 @foreach ($users as $user)
6 <p>El usuario: {{ $user->id }}</p>
7 @endforeach
8
9 @forelse($users as $user)
10 <li>{{ $user->name }}</li>
11 @empty
12 <p>No users</p>
13 @endforelse
14
15 @while (true)
 Tu primera aplicación en 8 pasos 13

16 <p>Eso es un bucle infinito.</p>

17 @endwhile
18
19 @if (count($articulos) === 1)
20 Hay un artículo.
21 @elseif (count($articulos) > 1)
22 Hay varios artículos.
23 @else
24 No hay ninguno.
25 @endif
26
27 @unless (Auth::check())
28 No estas autenticado.
29 @endunless

Puedes encontrar toda la información acerca de Blade en la documentación oficial⁹.

Paso 5 - Crear un Controlador

Los controladores contienen la lógica para atender las peticiones recibidas. En otras palabras,
un Controlador es una clase que agrupa el comportamiento de todas las peticiones relacionadas
con una misma entidad. Por ejemplo, el ArticuloController será el encargado de definir el
comportamiento de acciones como: creación de un artículo, modificación de un artóculo, búsqueda
de artículos, etc.

Creando un Controller

Existen dos formas de crear un controlador:

• Crear manualmente una clase que extienda de la clase Controller de Laravel dentro del
directorio app/Http/Controllers.
• Utilizar el comando de Artisan make:controller. Artisan es una herramienta que nos provee
Laravel para interactuar con la aplicación y ejecutar instrucciones.

En este caso escogeremos la segunda opción y ejecutaremos el siguiente comando:

1 php artisan make:controller ArticuloController

De este modo Laravel creará automáticamente el controlador:.

⁹https://laravel.com/docs/6.x/blade
 Tu primera aplicación en 8 pasos 14

1 <?php
2
3 namespace App\Http\Controllers;
4
5 use App\Http\Controllers\Controller;
6 use App\User;
7
8 class ArticuloController extends Controller
9 {
10 /**
11 * Show the profile for the given user.
12 *
13 * @param int $id
14 * @return View
15 */
16 public function show($id)
17 {
18 return view('show', ['articulo' => 'Mi primer artículo de Laravel');
19 }
20 }

Añadiendo --resource al comando anterior, Artisan añadirá al controlador creado los siete métodos
más comunes: index(), create(), store(), show(), edit(), update(), destroy().

Enrutar el Controlador

El siguiente paso es añadir al Router la llamada a los métodos del Controlador.

1 Route::get('articulos/', 'ArticuloController@index');
2 Route::get('articulos/{id}', 'ArticuloController@show');
3 Route::get('articulos/{id}/create', 'ArticuloController@create');
4 Route::post('articulos/', 'ArticuloController@store');

De esta forma direccionaremos las peticiones a los métodos de los controladores.

Paso 6 - Configurar la base de datos

Es muy difícil de imaginar una aplicación web que no haga uso de una base de datos para almacenar
la información. A continuación veremos como preparar la base de datos para nuestra aplicación.
 Tu primera aplicación en 8 pasos 15

Configuración de la base de datos

El fichero .env de Laravel contiene la configuración relacionada con la aplicación y el entorno, como
por ejemplo la configuración de la base de datos. Abre el fichero .env con un editor y modifica las
siguientes credenciales de la base de datos:

1 DB_CONNECTION=mysql
2 DB_HOST=127.0.0.1
3 DB_PORT=3306
4 DB_DATABASE=nombre de la base de datos(revistapp)
5 DB_USERNAME=nombre de usuario de la base de datos(root)
6 DB_PASSWORD=contraseña del usuario(root)

Todas estas variables de configuración serán referenciadas desde el archivo de configuración

database.php.

Creación de la base de datos

Accede al cliente de MySQL como root:

1 mysql -u root

Crea la base de datos si no está creada:

1 CREATE DATABASE revistapp;

Paso 7 - Crear la Migración (Migration)

Las Migraciones (Migrations) se utilizan para construir el esquema de la base de datos. Ejecuta
el siguiente comando de Artisan para crear una nueva Migración para una tabla que llamaremos
“articulos”.

1 php artisan make:migration create_articulos_table --create=articulos

Laravel creará una nueva migración automáticamente en el directorio database/migrations.

 Tu primera aplicación en 8 pasos 16

1 <?php
2
3 use Illuminate\Support\Facades\Schema;
4 use Illuminate\Database\Schema\Blueprint;
5 use Illuminate\Database\Migrations\Migration;
6
7 class CreateArticulosTable extends Migration
8
9 {
10 /**
11 * Run the migrations.
12 *
13 * @return void
14 */
15 public function up()
16 {
17 Schema::create('articulos', function (Blueprint $table) {
18 $table->increments('id');
19 $table->string('titulo');
20 $table->text('contenido');
21 $table->timestamps();
22 });
23 }
24
25
26
27 /**
28 * Reverse the migrations.
29 *
30 * @return void
31 */
32 public function down()
33 {
34 Schema::dropIfExists('articulos');
35 }
36 }

Tal y como puedes deducir del código anterior, una migración contiene 2 métodos:

• up(): se utiliza para crear nuevas tablas, columnas o índices a la base de datos.
• down(): se utiliza para revertir operaciones realizadas por el método up().

Existen una gran variedad de tipos de columnas disponibles para definir las tablas. Puedes
 Tu primera aplicación en 8 pasos 17

encontrarlas en la documentación oficial¹⁰.

Para ejecutar las migraciones simplemente ejecuta el comando migrate de Artisan:

1 php artisan migrate

Crear usuario de base de datos

Es recomendable utilizar un usuario de base de datos diferente a root. Para ello, desde MySQL
ejecuta lo siguiente:

1 CREATE USER 'nombre_usuario'@'localhost' IDENTIFIED BY 'tu_contrasena';

El comando anterior crea el usuario con la contraseña indicada. El siguiente paso es otorgar permisos
al usuario:

1 GRANT ALL PRIVILEGES ON * . * TO 'nombre_usuario'@'localhost';

Para que los cambios surjan efecto ejecuta lo siguiente:

1 FLUSH PRIVILEGES;

No olvides actualizar los datos de acceso a base de datos en el fichero de configuración .env.

Paso 8 - Crear un Modelo

Laravel incluye por defecto Eloquent ORM, el cual hace de la interacción con la base de datos una
tarea fácil.Tal y como dice la documentación oficial:

Each database table has a corresponding “Model” which is used to interact with that table.
Models allow you to query for data in your tables, as well as insert new records into the
table.

En otras palabras, cada tabla de la base de datos corresponde a un Modelo, el cual permite ejecutar
operaciones sobre esa tabla (insertar o leer registros por ejemplo).

Creando un Modelo

Vamos a crear un Modelo:

¹⁰https://laravel.com/docs/4.2/schema#adding-columns
 Tu primera aplicación en 8 pasos 18

1 php artisan make:model Articulo

El comando anterior ha creado una clase llamada Articulo en el directorio app (es el directorio por
defecto para los modelos de Eloquent).

1 <?php
2
3 namespace App;
4
5 use Illuminate\Database\Eloquent\Model;
6
7 class Articulo extends Model
8 {
9 //
10 }

Por defecto un modelo de Eloquent almacena los registros en una tabla con el mismo nombre pero
en plural. En este caso, Articulo interactuará con la tabla llamada ‘articulos’.

Recuperando datos de la base de datos

Los modelos de Eloquent se utilizan para recuperar información de las tablas relacionadas con el
modelo. Proporcionan métodos como los siguientes:

1 // Recupera todos los modelos

2 $articulos = App\Articulo::all();
3
4 // Recupera un modelo a partir de su clave
5 $articulo = App\Articulo::find(1);
6
7 // Recupera el primer modelo que cumpla con los criterios indicados
8 $articulos = App\Articulo::where('active', 1)->first();
9
10 // Recupera los modelos que cumplan con los criterios indicados y de la forma indica\
11 da:
12 $articulos = App\Articulo::where('active', 1)
13 ->orderBy('titulo', 'desc')
14 ->take(10)
15 ->get();
16
17 // Iterar sobre los resultados:
18 foreach ($articulos as $articulo) {
19 echo $articulo->titulo;
20 }
 Tu primera aplicación en 8 pasos 19

Insertar, actualizar y borrar modelos

El siguiente controlador contiene toda la lógica para insertar, actualizar y borrar modelos:

1 <?php
2
3 namespace App\Http\Controllers;
4
5 use App\Articulo;
6 use Illuminate\Http\Request;
7 use Redirect;
8
9 class ArticuloController extends Controller
10 {
11
12 /**
13 * Create a new articulo instance.
14 *
15 * @param Request $request
16 * @return Response
17 */
18 public function store(Request $request)
19 {
20 // Validar la petición...
21
22 $articulo = new Articulo;
23
24 $articulo->titulo = request('titulo');
25
26 $articulo->save();
27 }
28
29 /**
30 * Update the specified resource in storage.
31 *
32 */
33 public function update(Request $request, $id)
34 {
35 $articulo = App\Articulo::find(1);
36
37 $articulo->titulo = request('titulo');
38 $articulo->contenido = request('contenido');
39
 Tu primera aplicación en 8 pasos 20

40 $articulo->save();
41 }
42
43 /**
44 * Remove the specified resource from storage.
45 *
46 */
47 public function destroy($id)
48 {
49 // Encuentra el artículo por ID y lo elimina
50 $articulo = App\Articulo::find($id);
51 $articulo->delete();
52
53 // Alternativa
54 App\Articulo::destroy($id);
55
56 //Borrar modelos por consulta (borra todos los que encuentre en la consulta)
57 Articulo::where('id',$id)->delete();
58 }
59
60 }

Laravel proporciona alternativas para realizar operaciones más complejas, como creaciones en
“masa” o crear un modelo solo si no existe:

1 // Retrieve flight by name, or create it if it doesn't exist...

2 $articulo = App\Articulo::firstOrCreate(['name' => 'Laptop']);

Puedes encontrar todas las posibilidades en la documentación oficial¹¹.

Tinker: un potente REPL para Laravel

Tinker es un potente REPL¹² o consola interactiva que viene por defecto en Laravel. Resulta muy
útil durante el desarrollo ya que permite interactuar con nuestra aplicación Laravel y probar cantidad
de cosas: eventos, acceso a datos, etc.
Para iniciar Tinker hay que ejecutar el siguiente comando:

1 php artisan tinker

A partir de ese momento se puede comenzar a interactuar con nuestra aplicación, como muestra el
ejemplo a continuación:
¹¹https://laravel.com/docs/6.x/eloquent
¹²https://es.wikipedia.org/wiki/REPL
 Tu primera aplicación en 8 pasos 21

1 >>> $articulo = new App\Articulo

2 => App\Articulo {#3014}
3 >>> $articulo->titulo="AA";
4 => "AA"
5 >>> $articulo->contenido="BBBB";
6 => "BBBB"
7 >>> $articulo
8 => App\Articulo {#3014
9 titulo: "Articulo numero 2",
10 contenido: "Lorem ipsum...",
11 }
12 >>> $articulos->save();
13 >>> \App\Articulo::count();
14 => 2
15 >>> $articulos = App\Articulo::all();
16 => Illuminate\Database\Eloquent\Collection {#3035
17 all: [
18 App\Articulo {#3036
19 id: 1,
20 titulo: "Articulo numero 1",
21 contenido: "Lorem ipsum...",
22 created_at: null,
23 updated_at: null,
24 },
25 App\Articulo {#3046
26 id: 2,
27 titulo: "Articulo numero 2",
28 contenido: "Lorem ipsum...",
29 created_at: "2019-12-15 15:32:04",
30 updated_at: "2019-12-15 15:32:04",
31 },
32 ],
33 }

Para salir se ejecuta el comando exit.

Bonus - Opciones (flags) de Artisan

Existen opciones muy útiles para generar archivos relacionados con los modelos. El siguiente ejemplo
crea un modelo junto con su controlador y migración utilizando un único comando:
 Tu primera aplicación en 8 pasos 22

1 php artisan make:model Articulo -mcr

• -m indica la creación de una migración

• -c indica la creación de un controlador
• -r indica que el controlador creado será “resourceful” (incializado con los métodos).

Práctica 1
Crea una aplicación Laravel que muestre un listado de artículos de la base de datos.

Práctica 2
Añade a la aplicación anterior una nueva vista que muestre el detalle de un artículo. Se accederá
desde la vista del listado de artículos.
 Level up: Laravel nivel intermedio
Borrado de registros
El borrado de registros es un tema que suele traer complicaciones, debido a que desde una página
HTML solo es posible enviar peticiones GET y POST (desde formularios). Por lo tanto, las alternativas
son las siguientes:

• Crear una ruta GET específica para el borrado. Por ejemplo: /removeArticulo/{id}
• Hacer la petición utilizando AJAx y especificando en la llamada el tipo de método: 'type':
'DELETE'
• Emular la llamada DELETE mediante el campo oculto _method. Para ello podemos utilizar los
helpers o directivas de Laravel en un formulario para notificar que se trata de una petición de
tipo DELETE:

1 <form method="POST">
2 {{ csrf_field()}}
3 {{ method_field("DELETE")}}
4 <!-- ... -->
5 </form>

A partir de Laravel 5.6, se pueden utilizar las siguientes directivas de Blade:

1 <form method="POST">
2 @csrf
3 @method("DELETE")
4 <!-- ... -->
5 </form>

Práctica 3
Añade la posibilidad de eliminar artículos mediante un enlace o botón en cada uno de los registros
mostrados.
 Level up: Laravel nivel intermedio 24

Formularios
Los formularios HTML son la forma más habitual de recoger datos introducidos por los usuarios y
enviarlos a la aplicación.
Para este cometido necesitaremos crear dos nuevas rutas en nuestro Router: una para mostrar al
usuario el formulario de recogida de datos y otra para recibir y tratar los datos introducidos por el
usuario.

1 Route::get('articulos/create', 'ArticuloController@create');
2 Route::post('articulos/', 'ArticuloController@store');

De igual forma que hemos necesitado dos nuevas rutas, también necesitaremos dos nuevos métodos
en nuestro Controller:

1 class ArticuloController extends Controller

2 {
3 /**
4 * Show the form to create a new articulo.
5 *
6 * @return Response
7 */
8 public function create()
9 {
10 return view('create');
11 }
12
13 /**
14 * Store a new articulo.
15 *
16 * @param Request $request
17 * @return Response
18 */
19 public function store(Request $request)
20 {
21 // Validate the Articulo
22
23 // Create the articulo
24 $articulo = new Articulo();
25
26 $articulo->titulo = request('titulo');
27 $articulo->contenido = request('contenido');
 Level up: Laravel nivel intermedio 25

28
29 $articulo->save();
30
31 return redirect('/articulos');
32 }
33 }

El último paso es crear la vista que contenga el formulario HTML y que será mostrada al usuario al
invocar el método create() del controlador:

1 <!-- Vista almacenada en resources/views/create.blade.php -->

2 <html>
3 <body>
4 <h1>Let's write a new articulo:</h1>
5 <form action="/articulos/create" method="POST">
6 <div>
7 <label for="titulo">Name:</label>
8 <input type="text" id="titulo" name="titulo">
9 </div>
10 <div>
11 <label for="contenido">Text:</label>
12 <textarea id="contenido" name="contenido"></textarea>
13 </div>
14 <div>
15 <input type="submit" value="Submit">
16 </div>
17 </form>
18 </body>
19 </html>

Práctica 4
Añade la posibilidad de añadir nuevos artículos mediante un formulario ubicado en una nueva vista.

Construir layouts
Las aplicaciones siempre contienen varias parte de la interfaz que son comunes en todas las páginas
(la cabecera, menú de navegación, footer, etc.). Blade permite el uso de Layouts, los cuales permiten
de forma muy sencilla compartir entre distintas vistas las partes que tienen en común y así evitar
repetir lo mismo múltiples veces. La idea consiste en separar en un archivo distinto la parte común
 Level up: Laravel nivel intermedio 26

de nuestras vistas y especificar en ella las zonas que albergarán los contenidos específicos de cada
vista (lo que no es común).
Empecemos por definir un layout básico:

1 <html>
2 <head>
3 <title>App Name - @yield('titulo')</title>
4 </head>
5 <body>
6 <div class="container">
7 @yield('content')
8 </div>
9 <div class="big-footer">
10 @yield('footer')
11 </div>
12 </body>
13 </html>

La directiva @yield se utiliza para especificar el lugar donde se mostrarán los contenidos de cada
sección.
Ahora crearemos la vista concreta que especificará el contenido a introducir en el layout. Es por esto
que decimos que la vista extiende (extends) del layout, es decir, la vista heredará toda la estructura
definida en el layout y sobreescribirá las partes concretas que defina (las secciones).

1 @extends('layouts.master')
2
3 @section('titulo', 'Page Title')
4
5 @section('content')
6 <h1>Hello World!</h1>
7 <p>This is my body content.</p>
8 @endsection
9
10 @section('footer')
11 <p>Built by @JonVadillo.</p>
12 @endsection

@section indica la sección del padre donde será introducido el contenido especificado entre las
etiquetas @section y @endsection.

Práctica 5
Crea un layout que englobe la parte común que contienen todas las vistas de la aplicación.
 Level up: Laravel nivel intermedio 27

Asignar nombres a las rutas

Una práctica muy habitual es asignar nombres a las rutas, lo cual es realmente sencillo:

1 Route::get('articulos/', 'ArticuloController@index')->name('articulos.index');
2 Route::get('articulos/create', 'ArticuloController@index')->name('articulos.create');
3 Route::get('articulos/{id}', 'ArticuloController@show')->name('articulos.show');

Como se puede deducir del ejemplo anterior, utlizamos el método name() para definir el nombre que
queremos establecer para cada ruta.
De este modo, podremos cargar las rutas utilizando el método global route():

1 // Generar una url

2 $url = route('articulos.index');
3
4 // Redireccionando a una ruta:
5 return redirect()->route('articulos.show');

En ocasiones necesitaremos indicar al método route los parámetros que necesitará insertar:

1 Route::get('articulos/{id}', function ($id) {

2 //
3 })->name('articulos.show');
4
5 $url = route('articulos.show', ['id' => 12);
6 // /articulos/12

Es posible comprobar las todas las rutas y sus nombres mediante el comande Artisan php artisan
route:list.

Utilizar Bootstrap en tu proyecto

A diferencia de versiones anteriores, en su versión 6, Laravel no incluye por defecto las dependencias
necesarias para Bootstrap. Por lo tanto, tendremos 3 opciones para utilizar Bootstrap:

a. Referenciar las dependecias JS y CSS utilizando BootstrapCDN (enlaces disponibles en la

documentación oficial¹³)
b. Descargar las dependecias (enlace¹⁴) e incluirlas manualmente en las carpetas /public/css y
/public/js.
¹³https://getbootstrap.com/docs/4.4/getting-started/introduction/
¹⁴https://getbootstrap.com/docs/4.4/getting-started/download/
 Level up: Laravel nivel intermedio 28

c. Utilizar Laravel Mix para compilar nuestros archivos JS y CSS.

A continuación describiremos los pasos a seguir para incluir Bootstrap mediante la última opción
descrita.

1. Instalar el paquete Laravel/UI mediante composer.

1 composer require laravel/ui

2. Añadir bootstrap a nuestro proyecto

1 php artisan ui bootstrap

3. Instalar las dependencias

1 npm install

En ocasiones puede haber problemas si la máquina virtual se ejecuta en un host con Windows 10,
por lo que en ese caso lanzar:

1 npm install --no-bin-links

4. Compilar el código JS y CSS mediante Webpack:

1 npm run dev

5. Incluir los ficheros generados (public/js/app.js y public/css/app.css) en

nuestras vistas, utilizando el método helper asset():

1 <html>
2 <head>
3 <meta charset="utf-8">
4 <title>Mi aplicación</title>
5 <link href="{{ asset('css/app.css') }}" rel="stylesheet" type="text/css" />
6 </head>
7 <body>
8 <h1>Bienvenido a mi app</h1>
9 <div class="content">
10 @yield('content')
11 </div>
12 <script src="{{ asset('js/app.js') }}" type="text/js"></script>
13 </body>
14 </html>

El método asset() generará una URL a nuestros recursos en la carpeta public/. Si cambiamos la
ubicación de nuestros recursos lo tendremos que especificar en la variable ASSET_URL del fichero
.env.
 Level up: Laravel nivel intermedio 29

Relaciones One-to-Many

Definir una relación

Las relaciones en Eloquent ORM se definen como métodos. Supongamos que tenemos dos entidades,
User y Articulo. Podríamos decir que un User tiene (‘has’) varios Articulo o que un Articulo
pertenece a (‘belongs to’) un User. Por lo tanto, podemos definir la relación en cualquiera de los dos
modelos, incluso en los dos.

1 class User extends Model

2 {
3 /**
4 * Get the articulos records associated with the user.
5 */
6 public function articulos()
7 {
8 return $this->hasMany('App\Articulo');
9 }
10 }

1 class Articulo extends Model

2 {
3 /**
4 * Get the user record associated with the articulo.
5 */
6 public function user()
7 {
8 return $this->belongsTo('App\User');
9 }
10 }

#### Acceder a los modelos de una relación

El acceso se podrá hacer como propiedades del propio modelo, es decir, mediante $user->articulos
o $articulo->user. Esto es gracias a que Eloquent utiliza lo que conocemos como ‘dynamic
properties’ y acceder a los métodos de las relaciones como si fuesen propiedades:
 Level up: Laravel nivel intermedio 30

1 $user = App\User::find(1); // Ejecuta la sentencia: select * from users where id = 1

2
3 $user_articulos = $user->articulos; // Ejecutara la sentencia: select * from articul\
4 os where user_id = 1
5
6 foreach ($user_articulos as $articulo) {
7 //
8 }

En el ejemplo anterior, la variable $user_articulos contiene una colección de objetos de la clase

Articulo.

Claves foráneas (Foreign keys)

Por defecto, si no indicamos lo contrario, Eloquent utilizará como foreign key el nombre del modelo
que contiene la colección añadiendo el sufijo '_id'. Es decir, en el caso anterior la tabla de Articulo
deberá contener una columna llamada 'user_id'.

1 public function up()

2 {
3 Schema::create('articulos', function (Blueprint $table) {
4 $table->bigIncrements('id');
5 $table->unsignedBigInteger('user_id');
6 $table->string('titulo');
7 $table->text('contenido');
8 $table->timestamps();
9 });
10 }
11 }

Crear la restricción de las claves foráneas en la Base de Datos

Laravel también permite la creación de las restricciones de claves foráneas a nivel de base de datos.
De esta forma podemos asegurarnos la integridad referencial en nuestra base de datos relacional. El
siguiente ejemplo muestra cómo hacerlo de forma sencilla:

1 Schema::table('articulos', function (Blueprint $table) {

2 $table->unsignedBigInteger('user_id');
3
4 $table->foreign('user_id')->references('id')->on('users');
5 });
 Level up: Laravel nivel intermedio 31

Además, en función de la base de datos utilizada, también podemos especificar qué acciones llevar
a cabo cuando borremos un registro cuyo ID es utilizado como FK en otros registros. Siguiendo el
ejemplo anterior, cuando eliminemos un usuario, podremos especificar el comportamiento de la base
de datos:

• Indicando que también se eliminen automáticamente todos sus artículos (conocido como
‘borrado en cascada’).
• Impidiendo que se realice el borrado del usuario si tiene artículos asociados (evitando así una
inconsistencia referencial).
• Actualizar el valor user_id a NULL en los artículos que tengan como FK el usuario que será
eliminado.

Para ello utilizaremos el método onDelete:

1 $table->foreign('user_id')
2 ->references('id')->on('users')
3 ->onDelete('cascade');
4
5 // O por ejemplo:
6 $table->foreign('user_id')
7 ->references('id')->on('users')
8 ->onDelete('set null');

Consejo: cómo añadir columnas a modelo existente

Existen dos escenarios posibles en los cuales queremos realizar cambios sobre modelos existentes:

• Estamos desarrollando una nueva aplicación y no nos importa borrar los datos existentes.
• Tenemos una aplicación en uso y queremos añadir columnas sin perder ningún registro.

En el primer caso, es suficiente con modificar la migración de la tabla correspondiente y ejecutar el

comando:

1 php artisan migrate:fresh

Este comando eliminará todas las tablas de la base de datos y volverá a crearlas desde cero.
Para el segundo caso (modificar una tabla sin perder datos), lo recomendable es crear una nueva
migración y ejecutar el comando php artisan migrate para lanzar los cambios. Normalmente se
incluyen los cambios en el propio nombre de la migración, por ejemplo:
 Level up: Laravel nivel intermedio 32

1 php artisan migrate:make add_category_to_articulos --table="articulos"

1 public function up()

2 {
3 Schema::table('articulos', function($table)
4 {
5 $table->string('category');
6 });
7 }
8 /**
9 * Reverse the migrations.
10 *
11 * @return void
12 */
13 public function down()
14 {
15 Schema::table('articulos', function ($table) {
16 $table->dropColumn('category');
17 });
18 }
19 }

Generar datos de prueba

Laravel incluye un mecanismo llamado Seeder que sirve para rellenar la base de datos con datos
de prueba. Por defecto nos incluye la clase DatabaseSeeder en la que podemos incluir el código que
genere los datos de prueba:

1 class DatabaseSeeder extends Seeder

2 {
3 /**
4 * Seed the application's database.
5 *
6 * @return void
7 */
8 public function run()
9 {
10 $faker = Faker\Factory::create();
11
12 for($i=0;$i<10;$i++){
13 DB::table('articulos')->insert([
 Level up: Laravel nivel intermedio 33

14 'titulo' => $faker->realText(50,2),

15 'contenido' => $faker->realText(400,2)
16 ]);
17 }
18 }
19 }

Una vez creado nuestro Seeder es probable que necesites regenerar el fichero autoload.php:

1 composer dump-autoload

Por último, sólo nos quedaría lanzar el proceso de ‘seeding’:

1 php artisan db:seed

Si lo que quieres es lanzar el proceso de creación de base de datos y el de seeding a la vez, puedes
utilizar el siguiente comando:

1 php artisan migrate:fresh --seed

Generar Seeders específicos

Es recomendable crear un seeder específico por cada entidad. Para ello, puedes utilizar el siguiente
comando:
php artisan make:seeder UsersTableSeeder
Por último, tendrás que modificar la clase DatabaseSeeder para que lance nuestros Seeders:

1 **
2 * Run the database seeds.
3 *
4 * @return void
5 */
6 public function run()
7 {
8 $this->call([
9 UsersTableSeeder::class,
10 PostsTableSeeder::class,
11 CommentsTableSeeder::class,
12 ]);
13 }
 Level up: Laravel nivel intermedio 34

Práctica 6
La vista de detalle de artículo mostrará los comentarios del artículo e incluirá la posibilidad de añadir
nuevos comentarios.

Práctica 7
Asigna nombres a las rutas y utilízalos desde los controladores y vistas de la aplicación.

Práctica 8
Añade estilo a la aplicación mediante Bootstrap 4.

Autenticación
La autenticación es una funcionalidad presente en la gran mayoría de aplicaciones. Básicamente se
trata de asegurar que un usuario es quién dice ser mediante un control de acceso a la aplicación.
Laravel 6 nos trae de serie los elementos necesarios para implementar la autenticación en nuestras
aplicaciones y no tener que preocuparnos de hacer todas las tareas por nosotros mismos (login,
registro, recuperación de contraseña, validación de usuario, etc.).
En concreto necesitaremos lo siguiente:

• Generar las vistas (login, registro, etc.), rutas y sus respectivas implementaciones.
• Especificar las partes de nuestra web (rutas) que queramos proteger.

Paso 1: Crear la estructura necesaria

El primer paso es instalar el paquete de laravel/ui mediante Composer:

1 composer require laravel/ui

Este paquete nos permitirá generar de forma automática todo lo relacionado con la interfaz de
usuario: vistas, rutas y un nuevo controlador llamado HomeController. Para ello utilizaremos el
siguiente comando:

1 php artisan ui:auth

Puesto que las vistas autogeneradas utilizan bootstrap, debemos o bien añadir manualmente
bootstrap al layout generado app.blade.php:
 Level up: Laravel nivel intermedio 35

1 <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/\

2 bootstrap.min.css" integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWP\
3 GFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
4
5 <script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3\
6 o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymou\
7 s"></script>
8 <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.\
9 js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b\
10 4Q" crossorigin="anonymous"></script>
11 <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" in\
12 tegrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" cr\
13 ossorigin="anonymous"></script>

o indicar la opción bootstrap al ejecutar el comando artisan:

1 php artisan ui bootstrap --auth

Si te fijas bien, el router web.php incluye dos nuevas líneas:

1 Auth::routes();
2
3 Route::get('/home', 'HomeController@index')->name('home');

La primera genera de forma automática las rutas necesarias para el proceso de autenticación (prueba
a acceder a /login o /register para comprobarlo). Las vistas que se cargan son las autogeneradas
en resources/views/auth (también se ha creado un layout).
La segunda es simplemente un nuevo controlador autogenerado como ejemplo. Si intentas acceder
a la ruta creada /home verás como la aplicación nos lleva a la página de login. Esto es porque
el controlador HomeController está definido como ‘seguro’ y solo usuarios autenticados podrán
acceder.
¡Felicidades! Ya tienes la estructura básica de la aplicación creada. Puedes probar a registrar nuevos
usuarios y realizar las acciones de login o logout con ellos.

Paso 2: Configuración básica

Una de las cosas que tendrás que configurar es la ruta a la que se envía al usuario tras autenticarse.
Esto puede especificarse mediante la variable HOME del archivo RouteServiceProvider:

1 public const HOME = '/home';

Laravel utiliza por defecto el campo email para identificar a los usuarios. Puedes cambiar esto
creando un método username() en el controlador LoginController.
 Level up: Laravel nivel intermedio 36

1 public function username()

2 {
3 return 'username';
4 }

Otro aspecto que podremos configurar es la ruta a la que enviaremos al usuario cuando intente acce-
der a una ruta protegida sin autenticarse. Por defecto Laravel le enviará a /login, pero podemos cam-
biar esto modificando el método redirectTo() del archivo app/Http/Middleware/Authenticate.php:

1 protected function redirectTo($request)

2 {
3 return route('login');
4 }

Paso 3: Securizar rutas

Indicaremos las rutas que queramos proteger directamente en nuestro ruter web.php:

1 Route::get('profile', function () {
2 // Solo podrán acceder usuarios autenticados.
3 })->middleware('auth');

También podremos indicarlo directamente en el constructor de un controlador de la siguiente forma:

1 public function __construct()

2 {
3 $this->middleware('auth');
4 }

Paso 4: Conseguir el usuario autenticado

Existen distintas formas de acceder al objeto del usuario autenticado. Desde cualquier punto de la
aplicación podremos acceder utilizado la facade Auth:
 Level up: Laravel nivel intermedio 37

1 use Illuminate\Support\Facades\Auth;
2
3 // Conseguir el usuario autenticado:
4 $user = Auth::user();
5
6 // Conseguir el ID del usuario autenticado:
7 $id = Auth::id();

También podremos conseguirlo desde cualquier petición:

1 public function update(Request $request)

2 {
3 $request->user(); // devuelve una instancia del usuario autenticado.
4 }

Para comprobar si un usuario está autenticado, podemos emplear el método check():

1 use Illuminate\Support\Facades\Auth;
2
3 if (Auth::check()) {
4 // El usuario está autenticado.
5 }

Práctica 9
• Añade las funciones de login, registro y logout a la aplicación.
• Protege la ruta empleada para escribir un nuevo artículo (solo usuarios autenticados podrán
acceder).
• La opción de borrar un artículo únicamente estará visible para usuarios autenticados.
• Muestra los comentarios de los artículos únicamente a usuarios autenticados. A los usuarios
no identificados muéstrales un mensaje con un enlace a la página de login.

Manejo de sesiones
HTTP es un protocolo sin estado (stateless), es decir, no guarda ninguna información sobre
conexiones anteriores. Esto quiere decir que nuestra aplicación no tiene “memoria”, y cada petición
realizada por un usuario es nueva para la aplicación. Las sesiones permiten afrontar este problema,
ya que son un mecanismo para almacenar información entre las peticiones que realiza un usuario al
navegar por nuestra aplicación. Laravel implementa las sesiones de forma que su uso es muy sencillo
para los desarrolladores.
 Level up: Laravel nivel intermedio 38

Configuración

Laravel soporta el manejo de sesiones con distintos backends (bases de datos, ficheros, etc.). Esta
configuración se indica en el fichero config/session.php, en le que podemos indicar el driver a
utilizar (“file”, “cookie”, “database”, “apc”, “memcached”, “redis”, “dynamodb” o “array”). La opción
utilizada por defecto es “cookie”, la cual es suficiente para la mayoría de aplicaciones.
Más información sobre la configuración en la documentación oficial¹⁵.

Uso de las sesiones

Existen dos formas principales de acceder a la inforamación de la sesión de usuario:

- El helper global session

1 // Obtener un valor de la sesión

2 $value = session('key');
3
4 // Podemos indicar un valor por defecto
5 $value = session('key', 'default');
6
7 // Para almacenar un valor, le pasamos un Array:
8 session(['key' => 'value']);

- Mediante la instancia Request (inyectada en los métodos de nuestros controladores)

1 public function show(Request $request, $id)

2 {
3 $value = $request->session()->get('key');
4
5 // También es posible indicar un valor por defecto si no existe ninguno:
6 $value = $request->session()->get('key', 'default');
7
8 // Almacenar un valor
9 $request->session()->put('key', 'value');
10
11 // Recuperar un valor y eliminarlo de la sesión
12 $value = $request->session()->pull('key', 'default');
13 }

Práctica 10
Añade las siguientes funcionalidades a la aplicación:
¹⁵https://laravel.com/docs/6.x/session
Level up: Laravel nivel intermedio 39

• Guardar en sesión los artículos leídos: cuando un usuario entre a ver un artículo, se almacenará
en sesión que ya lo ha leído.
• Guardar en sesión los artículos favoritos de un usuario: el usuario podrá hacer click en un
enlace/botón que guarde en sesión ese artículo como favorito.

Los artículos marcados como favoritos se podrán distinguir visualmente (mediante un icono, texto
en negrita o similar). Igualmente, los artículos leídos se mostrarán también de forma especial.
Próximos pasos
Si has llegado a este punto, te doy mi más sincera enhorabuena. Ya eres capaz de crear aplicaciones
web profesionales con uno de los frameworks más potentes de la actualidad como Laravel. Si algo
puedo asegurarte, es que el desarrollo de aplicaciones web es un bonito camino en el que nunca
dejarás de aprender y siempre tendrás nuevas cosas por explorar. En el punto en el que te encuentras
ahora mismo, son muchas las opciones por las que puedes decantarte y que dependerán únicamente
de lo que te motive aprender. Algunas ideas son:

• Aprender JavaScript para dar potenciar en tus aplicaciones las interacciones con el usuario. Si
ya conoces este lenguaje, quizá sea una buena oportunidad para aprender potentes frameworks
como Vue.js¹⁶, React¹⁷ o Angular¹⁸.
• Explorar nuevas bases de datos, como por ejemplo las no relacionales. Algunas por las que
puedes empezar son MongoDB¹⁹, Redis²⁰ o Cassandra²¹.
• Adentrarte en el ecosistema Laravel aprendiendo Vapor²², Envoyer²³ o Forge²⁴.
• Explorar nuevas formas de autenticación con Passport²⁵ o Socialite²⁶.
• Ampliar tu conocimiento de otros lenguajes de programación como Python mediante el libro
gratuito Aprende Python: desde cero a experto²⁷.

Recuerda, lo único que necesitas saber es que tú puedes aprender cualquier cosa.

¹⁶https://vuejs.org/
¹⁷https://es.reactjs.org/
¹⁸https://angular.io/
¹⁹https://www.mongodb.com/es
²⁰https://redis.io/
²¹http://cassandra.apache.org/
²²https://vapor.laravel.com/
²³https://envoyer.io/
²⁴https://forge.laravel.com/
²⁵https://laravel.com/docs/6.x/passport
²⁶https://laravel.com/docs/6.x/socialite
²⁷https://leanpub.com/aprende-python/