Comprender los modelos y las vistas en Laravel

Comprender los modelos y las vistas es esencial si quieres crear aplicaciones dinámicas basadas en datos con Laravel. Estos dos potentes componentes trabajan juntos para estructurar tus datos y mostrarlos con elegancia, tendiendo un puente entre la lógica de tu backend y el diseño del frontend.

Los modelos en Laravel sirven de enlace entre tu aplicación y tu base de datos, haciendo que el manejo de datos sea mucho más sencillo. Por otro lado, las vistas en Laravel gestionan la parte de la aplicación orientada al usuario.

En esta guía, exploraremos en profundidad los modelos y las vistas, descubriendo cómo agilizan las interacciones con la base de datos y transforman los datos brutos en impresionantes páginas web.

Empecemos.

¿Qué son los modelos en Laravel?

Los modelos en Laravel son el núcleo de la arquitectura MVC del framework, y gestionan cómo se utilizan y organizan los datos en toda tu aplicación.

Los modelos de Laravel representan tablas de tu base de datos, permitiéndote realizar operaciones esenciales -como consultar, actualizar y eliminar datos- mediantecódigo expresivo y legible por humanos.

Más allá de la interacción básica con la base de datos, los modelos de Laravel te permiten añadir lógica de negocio directamente a tus modelos, haciendo que tu código sea más modular y organizado.

¿Para qué sirve crear un modelo en Laravel?

Los modelos en Laravel son el centro neurálgico de la gestión y organización de los datos de tu aplicación, facilitando la interacción con tu base de datos sin esfuerzo.

He aquí por qué crear un modelo es tan valioso:

• Interacción directa con la base de datos: Los modelos tienden un puente entre las tablas de tu base de datos, permitiéndote recuperar, crear, actualizar y eliminar datos fácilmente sin escribir SQL sin procesar.
• Organización lógica de los datos: Cada modelo representa una tabla específica, como Usuario o Pedido, dando a tus datos una estructura clara y significativa que se ajusta a las necesidades de tu aplicación.
• Relaciones simplificadas: Los modelos te permiten definir relaciones, como «uno a muchos» o «muchos a muchos», que te permiten acceder a datos relacionados (como las publicaciones de un usuario) con un código mínimo.
• Seguridad de datos integrada: Los modelos incluyen funciones como la protección de asignación masiva y el reparto de atributos, lo que facilita el manejo seguro de los datos y evita vulnerabilidades comunes.

¿Cómo crear un modelo en Laravel?

Crear un modelo en Laravel implica unos cuantos pasos claros, cada uno de ellos manejado por comandos específicos y modificaciones de archivos.

He aquí cómo crear un modelo en Laravel, paso a paso, con código y explicaciones:

Paso 1: Utiliza el Mando Artesano

Para crear un modelo en Laravel, utiliza la herramienta de línea de comandos Artisan en tu terminal SSH con el siguiente comando:

php artisan make:model Post

Este comando genera un nuevo archivo de modelo. Estamos creando un modelo Post. Por defecto, el archivo modelo se crea en el directorio app/Modelos.

Paso 2: Definir las propiedades del modelo

Una vez creado el archivo modelo, puedes añadir propiedades para definir cómo interactúa con la base de datos.

Añade la siguiente línea de código en app/Models/Post.php que acabas de crear en el paso anterior.

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    // Add fillable properties
    protected $fillable = ['title', 'content', 'author'];

    // Specify the table name if it's different from 'posts'
    // protected $table = 'my_custom_table';
}

• Aquí, título, contenido y autor son campos que puede rellenar la aplicación.
• También puedes especificar nombres de tabla personalizados o añadir relaciones con otros modelos si es necesario.

Paso 3: Migración de la base de datos

Para crear la tabla real en la base de datos, genera un archivo de migración y define las columnas.

php artisan make:migration create_posts_table

Este comando crea un nuevo archivo de migración en la carpeta base de datos/migraciones.

Añade la siguiente línea de código dentro del nuevo archivo de migración en la base de datos/migraciones.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->string('author');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('posts');
    }
};

Este archivo de migración define la estructura de la tabla de puestos, incluidas sus columnas.

Cada campo especificado aquí (título, contenido, autor) corresponde a una columna de la base de datos. El método timestamps() añade automáticamente las columnas created_at y updated_at.

Después de definir la migración, ejecútala con

php artisan migrate

Hasta ahora, has creado un modelo básico en Laravel para gestionar registros de entradas en una tabla de base de datos de entradas.

Esto incluye definir el modelo (Post) y un archivo de migración para crear la tabla con columnas como título, contenido y autor.

Al ejecutar la migración con php artisan migrate se crea la tabla posts en la base de datos.

Paso 4: Utilizar modelos con Eloquent ORM

Después de configurar este modelo, puedes utilizar Eloquent ORM para interactuar con la base de datos, por ejemplo

// Create a new Post record
Post::create(['title' => 'First Post', 'content' => 'This is the content.', 'author' => 'Author Name']);

// Retrieve all posts
$posts = Post::all();

Con Eloquent ORM, puedes utilizar la interfaz de usuario para publicar registros en tu base de datos. Puedes acceder a ellos con Post::all() o buscar registros concretos por ID utilizando Post::find(1).

¿Qué son las Vistas en Laravel?

En Laravel, las vistas son como el front-end de tu aplicación. Muestran la información que genera tu aplicación.

Las vistas suelen escribirse en Blade, un motor de plantillas proporcionado por Laravel. Blade te permite crear plantillas HTML dinámicas y reutilizables. Puedes incrustar código PHP dentro de tu HTML para generar contenido dinámicamente.

Para utilizar una vista, normalmente la devuelves desde un controlador. El controlador recoge los datos necesarios y se los pasa a la vista, que a continuación renderiza el HTML con los datos dados. Esta separación del contenido ayuda a mantener tu código organizado y mantenible.

¿Para qué sirven las vistas en Laravel?

Las vistas en Laravel son la clave para que tus datos sean seguros y manejables. Las vistas de Laravel te permiten mantener tu código limpio, separado y organizado. He aquí por qué son esenciales:

• Visualización de contenidos sin esfuerzo: Las vistas son las plantillas que muestran los datos de tu aplicación, lo que facilita mostrar contenido dinámico en las páginas web sin saturar tu código backend.
• Separación de lógica y diseño: Las vistas mantienen tu HTML y CSS separados de tu lógica de negocio, lo que hace que tu código sea más limpio y fácil de mantener. Esta estructura también simplifica las actualizaciones, ya que la lógica y el diseño no se solapan.
• Diseños reutilizables: Puedes crear diseños reutilizables, como encabezados, pies de página y barras laterales, que aparecen en varias páginas con un diseño coherente, lo que te ahorra tiempo y esfuerzo.
• Experiencia de usuario dinámica: Al pasar datos a las vistas, puedes crear páginas interactivas y dinámicas que mejoren la experiencia del usuario, todo ello manteniendo tu código racionalizado.

¿Cómo crear una vista en Laravel?

Crear y renderizar vistas en Laravel es una tarea fundamental para las aplicaciones web. Aquí te explicamos cómo conseguirlo paso a paso, incluyendo ejemplos de código y explicaciones para cada parte:

Paso 1: Crear y renderizar vistas

Para crear una vista, coloca el archivo de plantilla HTML en el directorio resources/views.

Crea un nuevo archivo con extensión .blade.php. Esta extensión indica a Laravel que utilice el motor de plantillas Blade para analizar la vista.

En el archivo de la vista, añade las plantillas HTML, PHP y/o Blade que definen la estructura y el diseño de la página. Puedes utilizar marcadores de posición para el contenido dinámico.

Guarda el archivo de vista.

<!-- resources/views/greeting.blade.php -->
<h1>Step 1 output</h1>
<h1>Hello, world!</h1>

Para representar esta vista, utiliza el ayudante view() en un controlador o ruta:

// In a route (routes/web.php)
Route::get('/', function () {
    return view('welcome');
});

Salida

Paso 2: Directorios de vistas anidadas

Puedes organizar las vistas en subdirectorios para mantenerlas organizadas.

<!-- resources/views/posts/index.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>Posts</title>
</head>
<body>
    <h1>All Posts</h1>
</body>
</html>

Para representar una vista anidada, utiliza la notación de puntos:

// In a route (routes/web.php)
Route::get('/posts', function () {
    return view('posts.index');
});

La vista posts.index utiliza la notación con puntos para acceder al directorio anidado.

Paso 3: Crear la primera vista disponible

Utiliza View::first() para mostrar la primera vista disponible entre varias opciones.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/landing', function () {
    return View::first(['custom.landing', 'default.landing']);
});

Si existe resources/views/custom/landing.blade.php, carga esa vista. En caso contrario, volverá a resources/views/default/landing.blade.php.

Paso 4: Determinar si existe una vista

Comprueba si existe una vista antes de intentar representarla.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/check-view', function () {
    if (View::exists('posts.index')) {
        return view('posts.index');
    } else {
        return 'View does not exist';
    }
});

Paso 5: Pasar datos a las vistas

Puedes pasar datos directamente a una vista utilizando un array.

Route::get('/post', function () {
    $post = [
        'title' => 'My First Post',
        'content' => 'This is the content of my first post.',
    ];
    return view('posts.show', compact('post'));
});

Además, actualiza la vista en resources/views/posts/show.blade.php:

<!-- resources/views/posts/show.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>{{ $post['title'] }}</title>
</head>
<body>
    <h1>{{ $post['title'] }}</h1>
    <p>{{ $post['content'] }}</p>
</body>
</html>

Paso 6: Compartir datos con todas las vistas

Puedes compartir datos globalmente en tu aplicación con todas las vistas utilizando el método View::share().

use Illuminate\Support\Facades\View;

// In App\Providers\AppServiceProvider.php
public function boot()
{
    View::share('appName', 'My Laravel App');
}

Ahora para acceder a esta vista cualquier archivo de vista, puedes utilizar appName:

<!-- Example in any view file -->
<h1>Step 6 output</h1>
<h1>Welcome to {{ $appName }}</h1>

Salida

Utilizando este código, puedes construir y mostrar diferentes páginas en Laravel, organizar esas páginas de forma eficiente, gestionar las vistas que faltan y mostrar datos dinámicos en las páginas.

Esta estructura es fundamental para construir una aplicación web funcional, organizada y dinámica.

Consejos sobre el modelo Laravel

Aquí tienes algunos consejos esenciales sobre modelos Laravel que te ayudarán a construir aplicaciones seguras y mantenibles. Usando estas técnicas, puedes mantener tu código eficiente y seguro, asegurando un mejor control sobre tus modelos y datos.

¡Sumerjámonos en cada consejo!

1. Detectar y prevenir problemas N+1

El problema de la consulta N+1 se produce cuando se envían varias consultas a la base de datos para obtener datos relacionados, lo que provoca un rendimiento lento. Evítalo utilizando Eager Loading con el método with() de Laravel en tus consultas.

Esto acelera tus consultas al cargar los datos relacionados en una sola llamada, evitando retrasos en el rendimiento y llamadas innecesarias a la base de datos.

// Instead of this (causes N+1 issue)
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name;
}

// Use this (solves N+1 issue)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;
}

2. Evitar el acceso a atributos que faltan

Acceder a un atributo inexistente en un modelo puede provocar errores confusos. Utiliza $guarded o $fillable en tus modelos para controlar qué atributos son accesibles.

Al definir atributos $rellenables, te aseguras de que sólo se pueda acceder a estos campos especificados y asignarlos en masa, protegiendo tu modelo de datos inesperados.

class Post extends Model
{
    protected $fillable = ['title', 'content', 'author_id'];
}

3. Evitar el descarte silencioso de atributos

Laravel puede ignorar silenciosamente los atributos que no están en $fillable, causando confusión. Para evitarlo, activa guarded para los campos que quieras proteger y define estrictamente sólo lo que esté permitido.

Este enfoque ayuda a evitar que Laravel descarte atributos sin avisarte, manteniendo tus datos seguros y tu código claro.

class Post extends Model
{
    protected $guarded = ['id'];
}

4. Activar el modo estricto para los modelos

El modo estricto de Laravel garantiza que se produzcan errores por atributos no reconocidos, lo que hace que tu aplicación sea más segura. Activa el modo estricto en tu AppServiceProvider.

Con el modo estricto activado, Laravel te avisa cuando ocurre algo inesperado, lo que te ayuda a detectar los problemas a tiempo.

use Illuminate\Database\Eloquent\Model;

public function boot()
{
    Model::shouldBeStrict(true);
}

5. Utilizar UUID

Los UUID son identificadores únicos que hacen que los modelos sean más seguros, especialmente en las URL de cara al público. Añade el ayudante Str::uuid() para generar UUIDs.

Utilizar UUIDs oculta los identificadores numéricos de tu base de datos, haciendo que los datos de tu aplicación sean más seguros y más difíciles de predecir.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->uuid = (string) Str::uuid();
        });
    }
}

6. Utiliza UUID como clave primaria

Para una mayor seguridad, utiliza UUID como clave primaria. Anula $primaryKey y $keyType en el modelo y establece el incremento en false.

Utilizar UUID como claves primarias hace que tu base de datos sea menos predecible y mejora la seguridad al evitar que se adivinen ID secuenciales.

class Post extends Model
{
    protected $primaryKey = 'uuid';
    protected $keyType = 'string';
    public $incrementing = false;
}

7. Uso de los ULID

Los ULID son identificadores únicos alternativos que combinan la aleatoriedad con la ordenación secuencial. Puedes generar ULIDs con Str::ulid().

En palabras sencillas, los ULID ofrecen un ID único y ordenable que es estupendo para casos de uso que requieren ID ordenables pero seguros en la URL.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->ulid = (string) Str::ulid();
        });
    }
}

8. Cambiar el campo utilizado para el enlace del modelo de ruta

Por defecto, Laravel vincula modelos a rutas utilizando la clave primaria. Puedes cambiar esto para utilizar un UUID o cualquier otro campo anulando getRouteKeyName().

Este cambio hace que tus rutas sean más flexibles al permitirte utilizar campos únicos como uuid en lugar de ID numéricos, lo que añade claridad y seguridad.

class Post extends Model
{
    public function getRouteKeyName()
    {
        return 'uuid';
    }
}

9. Utilizar colecciones de modelos personalizados

Laravel te permite crear colecciones personalizadas para modelos específicos, lo que facilita la adición de métodos especializados para manejar grupos de modelos.

Con las colecciones personalizadas, puedes añadir métodos como published() que filtren los datos de tu colección, haciéndola más legible y cómoda.

use Illuminate\Database\Eloquent\Collection;

class PostCollection extends Collection
{
    public function published()
    {
        return $this->where('is_published', true);
    }
}

// In the Post model
class Post extends Model
{
    public function newCollection(array $models = [])
    {
        return new PostCollection($models);
    }
}

¿Usar modelos y vistas juntos en Laravel?

Construir aplicaciones web dinámicas requiere integrar los Modelos y las Vistas de Laravel. En esta parte aprenderemos a utilizar juntos Modelos y Vistas.

Vamos a desarrollar una aplicación básica que recupere y muestre artículos o productos de una base de datos.

Aquí tienes una guía paso a paso para hacerlo:

Paso 1: Configuración de la base de datos

En primer lugar, configura tu conexión a la base de datos en el archivo de entorno. Una vez configurada la base de datos, crea una tabla para almacenar tus productos. Utiliza el siguiente comando de Artisan para crear una tabla de productos:

php artisan make:migration create_products_table --create=products

A continuación, definiremos la migración. Para definir la migración, localiza el archivo de migración creado para la tabla productos. Encontrarás este archivo en base de datos/migraciones/, con un nombre similar a crear_tabla_productos. En nuestro caso, se llama 2024_11_12_125426_crear_tabla_productos.php.

Una vez localizado el archivo, ábrelo y define el esquema como se muestra a continuación:

public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description');
        $table->timestamps();
    });
}

Guarda el archivo y, a continuación, ejecuta la migración para crear la tabla de productos en la base de datos. Para ello, navega hasta el directorio raíz de tu proyecto y ejecuta el siguiente comando:

php artisan migrate

Paso 2: Crear un modelo de productos

En este paso, crearemos un modelo para los productos utilizando el siguiente comando de Artisan:

php artisan make:model Product

Una vez hecho esto, definiremos las propiedades rellenables. Podemos conseguirlo añadiendo la línea de código que compartimos a continuación en el archivo product.php situado en app/Models/Product.php.

Tendrás que añadirlo en la clase de producto, como se muestra en la captura de pantalla siguiente:

protected $fillable = ['name', 'description'];

Paso 3: Crear el controlador

Ahora crearemos el Controlador, que se utilizará para gestionar las solicitudes relacionadas con los productos. Tendrás que ejecutar el siguiente comando en el directorio raíz :

php artisan make:controller ProductController

Ahora tenemos que definir el Método Index añadiendo el siguiente bloque de código index bajo la ruta de archivo app/Http/Controllers/ProductController.php.

Añade el siguiente bloque de código a tu archivo ProductController.php. Tu ProductController.php sólo debe contener este código:

<?php

namespace App\Http\Controllers;

use App\Models\Product; // Import the Product model
use Illuminate\Http\Request;

class ProductController extends Controller
{
    // Define the index method
    public function index()
    {
        // Fetch all products from the database
        $products = Product::all();
        // Pass the products data to the view
        return view('products.index', compact('products'));
    }
}

Paso 4: Crear vista y diseño

En este paso, crearemos un directorio de productos y diseños en resources/views/.

Ahora crearemos un directorio de diseño bajo vistas, igual que hicimos para el directorio de productos.

A continuación, crearemos un archivo de vista llamado index.blade.php en resources/views/products/ con el siguiente bloque de código y lo guardaremos :

@extends('layouts.app')

@section('content')
    <h1>Our Products</h1>
    @foreach($products as $product)
        <div class="product">
            <h2>{{ $product->name }}</h2>
            <p>{{ $product->description }}</p>
        </div>
    @endforeach
@endsection

Ahora añadiremos el siguiente código en el directorio de diseño creando un nuevo archivo con el nombre app.blade.php y guardándolo .

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Laravel App</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}"> <!-- Link to your CSS -->
</head>
<body>
    <div class="container">
        @yield('content') <!-- This is where your content will be injected -->
    </div>
</body>
</html>

Paso 5: Definir rutas

Aquí abriremos el Archivo de Rutas en routes/web.php. Añadiremos la Ruta para el Índice de Productos compartida en el bloque de código siguiente:

use App\Http\Controllers\ProductController;
.
.
.
// Define route for products index
Route::get('/products', [ProductController::class, 'index']);

Seguir estos pasos te ha permitido mostrar con éxito productos de tu base de datos utilizando los modelos y vistas de Laravel. Este método mejora la experiencia del usuario a la vez que mantiene la organización de tu código proporcionando información dinámica en respuesta a las consultas del usuario.

Ahora debería mostrarse adecuadamente una lista de tus artículos en tu página de inicio cuando visites /productos. Hemos añadido los siguientes detalles de productos como muestra: puedes añadir tus productos para obtener el resultado esperado.

Palabras finales.

En esta guía, hemos explorado los conceptos esenciales de Modelos y Vistas en Laravel, ayudándote a comprender cómo se estructuran la gestión de datos y las interfaces de usuario dentro de este framework.

Hemos visto cómo los Modelos simplifican las interacciones con la base de datos y cómo las Vistas, utilizando el motor de plantillas Blade, permiten una presentación dinámica y flexible de los datos.

Utilizando estos conceptos, puedes crear aplicaciones que equilibren una potente funcionalidad de back-end con una experiencia de usuario receptiva.