1- Instalar Laravel

  Instalar Laravel

Ejecuta en tu terminal (Linux/macOS) o CMD/PowerShell (Windows):

bash

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

Reemplaza nombre-del-proyecto con el nombre de tu aplicación.

---

3. Entrar al directorio del proyecto

bash

cd nombre-del-proyecto

---

4. Configurar el entorno

• Copia el archivo .env.example y renómbralo a .env:

  bash

  cp .env.example .env

• Genera la clave de la aplicación:

  bash

  php artisan key:generate

• Configura la base de datos en .env:

  ini

  DB_CONNECTION=mysql
  DB_HOST=127.0.0.1
  DB_PORT=3306
  DB_DATABASE=nombre_basedatos
  DB_USERNAME=usuario
  DB_PASSWORD=contraseña

---

5. Ejecutar migraciones (opcional)

Si necesitas tablas en la base de datos:

bash

php artisan migrate

---

6. Iniciar el servidor de desarrollo

bash

php artisan serve

Esto iniciará un servidor en http://localhost:8000.

---

7. Abrir en el navegador

Visita:

text

http://localhost:8000

---

Pasos adicionales (opcionales)

• Instalar herramientas frontend (Vite, Bootstrap, etc.):

  bash

  npm install && npm run dev

• Crear autenticación:

  bash

  composer require laravel/breeze --dev
  php artisan breeze:install
  npm install && npm run dev
  php artisan migrate

• Personalizar rutas en routes/web.php.

Convenciones de Nomenclatura en Laravel

Aquí te explico las convenciones más comunes para nombrar elementos en Laravel, con ejemplos claros:

1. Modelos

• Singular y en PascalCase (primera letra mayúscula)

• Corresponden a una tabla en la base de datos

• Ejemplo: User, Post, ProductCategory

php

// app/Models/User.php
class User extends Model
{
    // ...
}

2. Tablas de Base de Datos

• Plural y en snake_case (minúsculas con guiones bajos)

• Corresponden al modelo en singular

• Ejemplo: users, posts, product_categories

php

// En una migración
Schema::create('users', function (Blueprint $table) {
    $table->id();
    // ...
});

3. Controladores

• Singular con sufijo Controller y en PascalCase

• Para recursos, puedes usar NombreResourceController

• Ejemplo: UserController, PostController, ProductCategoryController

php

// app/Http/Controllers/UserController.php
class UserController extends Controller
{
    // ...
}

4. Variables en General

• camelCase (primera letra minúscula, palabras siguientes con mayúscula inicial)

• Ejemplo: $userName, $totalAmount, $isActive

5. Variables de Modelo (una instancia)

• Singular y en camelCase

• Representa una sola entidad/registro

• Ejemplo: $user, $post, $productCategory

php

$user = User::find(1); // Una sola instancia de User

6. Variables de Modelo (múltiples instancias)

• Plural y en camelCase

• Representa una colección de entidades/registros

• Ejemplo: $users, $posts, $productCategories

php

$users = User::all(); // Colección de usuarios

 Rutas en Laravel: Explicación y Ejemplos

Las rutas en Laravel son el mecanismo que permite definir cómo responde tu aplicación a las solicitudes HTTP entrantes. Todas las rutas de Laravel se definen en los archivos dentro del directorio routes/.

Tipos básicos de rutas

Usando compact()

El método compact() te permite pasar variables y arrays a las vistas convirtiendo los nombres de variables en un array asociativo.

php-compact

// En el controlador
public function index()
{
    $titulo = "Página de Inicio";
    $usuarios = ['Ana', 'Carlos', 'María'];
    
    return view('vista', compact('titulo', 'usuarios'));
}

// En la vista (vista.blade.php)
<h1>{{ $titulo }}</h1>
<ul>
    @foreach($usuarios as $usuario)
        <li>{{ $usuario }}</li>
    @endforeach
</ul>

usando with() en lugar de compact():

php-with

// En el controlador
public function index()
{
    $titulo = "Página de Inicio";
    $usuarios = ['Ana', 'Carlos', 'María'];
    
    // Usando with() para pasar cada variable individualmente
    return view('vista')
           ->with('titulo', $titulo)
           ->with('usuarios', $usuarios);
}

// En la vista (vista.blade.php) - Esto permanece igual
<h1>{{ $titulo }}</h1>
<ul>
    @foreach($usuarios as $usuario)
        <li>{{ $usuario }}</li>
    @endforeach
</ul>

Explicación:

1. Método with() encadenado: Pasa cada variable por separado encadenando múltiples llamadas a with()

2. Método with() con array: Alternativamente puedes pasar todas las variables en un array asociativo (opción comentada)

Pasando un Array desde las Rutas

Puedes pasar datos directamente desde las rutas usando un array como segundo parámetro:

php

// En routes/web.php
Route::get('/ejemplo', function () {
    return view('ejemplo', [
        'nombre' => 'Ejemplo Ruta',
        'valores' => [1, 2, 3, 4, 5]
    ]);
});

// En la vista (ejemplo.blade.php)
<h2>{{ $nombre }}</h2>
Suma de valores: {{ array_sum($valores) }}

Combinando métodos

También puedes combinar estos métodos según tus necesidades:

php

public function show($id)
{
    $usuario = User::find($id);
    $roles = ['admin', 'editor', 'usuario'];
    
    return view('perfil')
           ->with('usuario', $usuario)
           ->compact('roles');
}

Todos estos métodos son equivalentes en funcionalidad, la elección depende de tus preferencias de estilo de código.

Aquí tienes el ejemplo modificado definiendo el array fuera y pasando solo el nombre de la variable:

php

// En routes/web.php
Route::get('/ejemplo', function () {
    $datos = [
        'nombre' => 'Ejemplo Ruta',
        'valores' => [1, 2, 3, 4, 5]
    ];
    
    // Opción 1: Pasar el array completo usando compact
    return view('ejemplo', compact('datos'));
    
    // Opción 2: Pasar el array usando with
    // return view('ejemplo')->with('datos', $datos);
});

// En la vista (ejemplo.blade.php)
<h2>{{ $datos['nombre'] }}</h2>
Suma de valores: {{ array_sum($datos['valores']) }}

Otra alternativa más limpia sería usar el operador de propagación de PHP:

php

// En routes/web.php
Route::get('/ejemplo', function () {
    $datos = [
        'nombre' => 'Ejemplo Ruta',
        'valores' => [1, 2, 3, 4, 5]
    ];
    
    return view('ejemplo', [...$datos]);
});

// En la vista (ejemplo.blade.php) - Ahora las variables están en el scope directamente
<h2>{{ $nombre }}</h2>
Suma de valores: {{ array_sum($valores) }}

php

$datosEjemplo = [
    'nombre' => 'Ejemplo Ruta',
    'valores' => [1, 2, 3, 4, 5],
];

Route::get('/ejemplo', function () use ($datosEjemplo) { // Usa 'use' para heredar la variable
    return view('ejemplo', ['datos' => $datosEjemplo]);
});

1. Ejemplo usando with()

php

// En routes/web.php
$datosEjemplo = [
    'nombre' => 'Ejemplo Ruta',
    'valores' => [1, 2, 3, 4, 5],
];

Route::get('/ejemplo', function () use ($datosEjemplo) {
    // Opción con with() - Pasa los datos individualmente
    return view('ejemplo')->with('datos', $datosEjemplo);
});

2. Ejemplo usando compact()

php

// En routes/web.php
$datosEjemplo = [
    'nombre' => 'Ejemplo Ruta',
    'valores' => [1, 2, 3, 4, 5],
];

Route::get('/ejemplo', function () use ($datosEjemplo) {
    // Opción con compact() - Pasa el array automáticamente
    return view('ejemplo', compact('datosEjemplo'));
});

Nota:

Esta última forma con el operador ... (disponible en PHP 7.4+) es particularmente elegante ya que:

1. Define el array en una variable

2. Lo expande al pasarlo a la vista

3. Permite acceder a las claves del array como variables directas en la vista

Cómo Pasar Datos con Redirect en Laravel

En Laravel, hay varias formas de pasar datos cuando haces un redirect. Aquí te muestro los métodos más comunes:

1. Usando with() para datos de sesión flash

php

// En tu controlador o ruta
return redirect('/ruta-destino')->with('key', 'value');

Ejemplo completo:

php

public function store(Request $request)
{
    // Lógica de guardado...
    
    return redirect('/dashboard')
           ->with('success', 'Registro creado exitosamente!')
           ->with('warning', 'Por favor complete su perfil');
}

En la vista destino (usando Blade):

php

@if(session('success'))
    <div class="alert alert-success">
        {{ session('success') }}
    </div>
@endif

@if(session('warning'))
    <div class="alert alert-warning">
        {{ session('warning') }}
    </div>
@endif

2. Pasando un array de datos

php

return redirect('/ruta-destino')->with([
    'status' => 'success',
    'message' => 'Operación completada'
]);

3. Redireccionar con datos en la URL (para datos no sensibles)

php

return redirect('/ruta-destino?status=success&id=123');

public function store(Request $request)
{
    // 1. Validación de datos

    // 4. Redirección con mensaje de éxito
    return redirect()->route('usuarios.show', $usuario->id)
                    ->with('success', 'Usuario creado exitosamente!');
}

Variaciones Comunes

Redirección a la vista anterior

php

return back()->with('status', 'Registro creado con éxito');

Redirección con datos flash adicionales

php

return redirect('dashboard')
       ->with('success', 'Usuario creado')
       ->with('stats', [
           'total' => User::count(),
           'nuevos' => User::whereDate('created_at', today())->count()
       ]);

Redirección después de almacenar archivos

php

public function store(Request $request)
{
    $path = $request->file('avatar')->store('avatars');
    
    // Guardar el path en la base de datos...
    
    return redirect('perfil')
           ->with('success', 'Avatar subido correctamente')
           ->with('avatar_path', $path);
}

Buenas Prácticas

1. Validación: Siempre valida los datos antes de almacenarlos

2. Mensajes flash: Proporciona feedback al usuario sobre el resultado

3. Seguridad: Nunca pases datos sensibles en la URL

4. Nombres de rutas: Usa rutas con nombre (route()) en lugar de paths directos

5. Manejo de errores: Usa withErrors() para mostrar errores de validación

1. Rutas básicas

php

Route::get('/saludo', function () {
    return '¡Hola Mundo!';
});

Cuando se visita /saludo en el navegador, se mostrará "¡Hola Mundo!".

2. Rutas con parámetros

php

Route::get('/usuario/{id}', function ($id) {
    return 'Usuario '.$id;
});

Esta ruta capturará el ID de la URL y lo pasará a la función.

3. Rutas con parámetros opcionales

php

Route::get('/post/{titulo?}', function ($titulo = 'Título por defecto') {
    return $titulo;
});

El parámetro titulo es opcional y tiene un valor por defecto.

4. Rutas con restricciones

php

Route::get('/user/{id}', function ($id) {
    // Solo se ejecutará si {id} es numérico
})->where('id', '[0-9]+');

5. Rutas con nombre

php

Route::get('/perfil', function () {
    // ...
})->name('perfil');

Aquí te explico las diferentes formas de enviar datos desde un controlador a una vista en Laravel:

1. Usando el método with()

php

return view('vista')->with('variable', $valor);
// O también:
return view('vista')->with(['key1' => $valor1, 'key2' => $valor2]);

2. Pasando un array directamente a view()

php

return view('vista', ['nombre' => $valor]);
// Alternativa:
return view('vista', compact('variable'));

3. Usando la función compact()

php

$data1 = "valor1";
$data2 = "valor2";
return view('vista', compact('data1', 'data2'));

4. Método withVariable() (Magic method)

php

return view('vista')->withNombre($nombre)->withEdad($edad);

5. Usando view()->share() (Para datos globales)

php

// En un service provider
view()->share('key', 'value');

6. Usando View::make()

php

return View::make('vista', ['dato' => $valor]);

📌 Ejemplo completo:

php

public function index()
{
    $users = User::all();
    $title = "Listado de usuarios";
    
    // Puedes usar cualquiera de estas formas:
    return view('users.index', compact('users', 'title'));
    // ó
    return view('users.index')->with(compact('users', 'title'));
    // ó
    return view('users.index', ['users' => $users, 'title' => $title]);
}

En la vista accedes así:

php

<h1>{{ $title }}</h1>
@foreach($users as $user)
    {{ $user->name }}
@endforeach

Controladores en Laravel

Los controladores en Laravel son una parte fundamental de la arquitectura MVC (Modelo-Vista-Controlador) y sirven como intermediarios entre las rutas y la lógica de tu aplicación.

¿Qué son los controladores?

Los controladores son clases PHP que organizan la lógica relacionada con las peticiones HTTP. En lugar de poner toda tu lógica en los archivos de rutas, los controladores te permiten organizarla en clases separadas.

Creación de un controlador

Puedes crear un controlador usando Artisan:

bash

php artisan make:controller NombreController

Esto creará un archivo en app/Http/Controllers/NombreController.php.

Estructura básica

Un controlador típico se ve así:

php

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Models\User;

class UserController extends Controller
{
    /**
     * Mostrar una lista de usuarios.
     */
    public function index()
    {
        $users = User::all();
        return view('users.index', ['users' => $users]);
    }

    /**
     * Mostrar el formulario para crear un nuevo usuario.
     */
    public function create()
    {
        return view('users.create');
    }

    /**
     * Almacenar un nuevo usuario en la base de datos.
     */
    public function store(Request $request)
    {
        // Validación y almacenamiento
    }

    // Otros métodos...
}

Tipos de controladores

1. Controladores de recursos (Resource Controllers): Manejan todas las operaciones CRUD típicas.

   bash

   php artisan make:controller PhotoController --resource

   Esto genera automáticamente métodos para index, create, store, show, edit, update y destroy.

2. Controladores de API: Similar a los resource pero sin los métodos create y edit (que son para vistas HTML).

   bash

   php artisan make:controller API/PhotoController --api

3. Controladores simples: Contienen los métodos que tú defines.

Uso en rutas

Puedes asignar controladores a rutas:

php

// Ruta básica
Route::get('/user', [UserController::class, 'index']);

// Resource controller
Route::resource('photos', PhotoController::class);

// API resource controller
Route::apiResource('photos', PhotoController::class);

Inyección de dependencias

Laravel permite la inyección automática de dependencias en los métodos del controlador:

php

public function store(Request $request)
{
    // $request ya está inyectado
    $name = $request->input('name');
}

Buenas prácticas

1. Mantén los controladores delgados (mínima lógica)

2. Mueve la lógica de negocio a servicios o modelos

3. Usa la validación de solicitudes (Request Validation)

4. Sigue las convenciones de nombres (singular para recursos)

5. Considera usar Form Requests para validaciones complejas

Los controladores son una parte esencial para organizar tu aplicación Laravel de manera limpia y mantenible.

Verificar el contenido de un Request en Laravel

En Laravel hay varias formas de inspeccionar el contenido de un $request. Aquí te muestro diferentes alternativas:

1. Ver todo el contenido del Request

php

// Muestra todo el contenido y detiene la ejecución (más para desarrollo)
dd($request->all());

// Alternativa que no detiene la ejecución
dump($request->all());

// Ver como array PHP
var_dump($request->all());

// Ver en el log (útil en producción)
\Log::debug($request->all());

2. Verificar inputs específicos

php

// Verificar si un campo existe en el request
if ($request->has('nombre_campo')) {
    // El campo está presente (puede estar vacío)
}

// Verificar si un campo existe y no está vacío
if ($request->filled('nombre_campo')) {
    // El campo está presente y no está vacío
}

// Obtener el valor de un campo específico
$valor = $request->input('nombre_campo');

// Ver un campo específico con dd
dd($request->input('nombre_campo'));

// Ver varios campos específicos
dd($request->only(['campo1', 'campo2']));

3. Ver información adicional del Request

php

// Ver todos los headers
dd($request->headers->all());

// Ver el método HTTP (GET, POST, etc.)
dd($request->method());

// Ver la URL completa
dd($request->fullUrl());

// Ver los archivos subidos
dd($request->allFiles());

4. Alternativas para desarrollo

php

// Usar el helper ray() si usas la librería spatie/ray
ray($request->all());

// Mostrar en formato JSON (útil para APIs)
return response()->json($request->all());

Para desarrollo, dd() o dump() son muy útiles, pero para producción es mejor usar el log (\Log::debug()) o implementar un sistema de monitoreo más robusto.

 Características principales de Blade

1. Sintaxis Limpia
   Blade usa directivas (@directiva) que se compilan a código PHP puro, pero son más fáciles de leer y escribir.
   Ejemplo:

   php

   @if($user->isAdmin())
       <p>Eres administrador</p>
   @else
       <p>Eres usuario normal</p>
   @endif

2. Herencia de Layouts
   Permite definir plantillas base (layouts) que pueden ser extendidas por otras vistas, evitando repetir código (como headers/footers).

   • Ejemplo de layout (resources/views/layouts/app.blade.php):

     php-Herencia de Layouts-Laravel

     <html>
         <head><title>@yield('title')</title></head>
         <body>
             @section('sidebar') Contenido del sidebar @show
             <div class="container">
                 @yield('content')
             </div>
         </body>
     </html>

   • Extender el layout:

     php

     @extends('layouts.app')
     @section('title', 'Página de inicio')
     @section('content')
         <h1>Contenido principal</h1>
     @endsection

3. Inclusión de Subvistas
   Usa @include para reutilizar componentes:

   php

   @include('shared.header')

4. Mostrar Datos
   Escapa automáticamente variables para prevenir XSS:

   php

   <p>{{ $user->name }}</p>  <!-- Escapado -->
   <p>{!! $rawHtml !!}</p>  <!-- Sin escapar (usar con cuidado) -->

5. Bucles y Condicionales
   Similar a PHP pero más legible:

   php-Laravel

   @foreach($users as $user)
       <p>{{ $user->email }}</p>
   @endforeach
   
   @for($i = 0; $i < 10; $i++)
       {{ $i }}
   @endfor

6. Componentes y Slots
   Ideal para elementos reutilizables (ej. alertas, cards):

   php

   <!-- resources/views/components/alert.blade.php -->
   <div class="alert alert-{{ $type }}">
       {{ $slot }}  <!-- Contenido dinámico -->
   </div>
   
   <!-- Uso -->
   <x-alert type="success">
       ¡Operación exitosa!
   </x-alert>

7. Stacks y Push
   Para agregar CSS/JS específicos en layouts:

   php

   @push('scripts')
       <script src="/js/custom.js"></script>
   @endpush
   
   <!-- En el layout -->
   @stack('scripts')

8. Directivas Personalizadas
   Puedes crear tus propias directivas con Blade::directive():

   php

   // En AppServiceProvider::boot()
   Blade::directive('datetime', function ($expression) {
       return "<?php echo ($expression)->format('d/m/Y H:i'); ?>";
   });
   
   <!-- Uso -->
   @datetime($post->created_at)

---

Ventajas de Blade

• Seguridad: Escapa variables automáticamente.

• Rendimiento: Las vistas son compiladas a código PHP y cacheadas.

• Legibilidad: Sintaxis más clara que PHP puro en HTML.

---

Ejemplo Completo

php-Laravel

<!-- resources/views/welcome.blade.php -->
@extends('layouts.app')

@section('title', 'Inicio')

@section('content')
    <h1>Bienvenido, {{ Auth::user()->name }}</h1>
    @include('partials.notification')
    <ul>
        @foreach($items as $item)
            <li>{{ $item->name }}</li>
        @endforeach
    </ul>
@endsection

1. @yield

• ¿Qué hace?
  Define un "hueco" en una plantilla maestra (layout) que será rellenado por otras vistas.

• Ejemplo:

  html-Laravel

  <!-- layout.blade.php (plantilla maestra) -->
  <head>
      <title>@yield('title')</title> <!-- Aquí irá el título -->
  </head>

  html

  <!-- vista_hija.blade.php -->
  @extends('layout')
  @section('title', 'Página de inicio') <!-- Rellena el hueco -->

---

2. @section + @endsection

• ¿Qué hace?
  Define un bloque de contenido que puede ser inyectado en @yield o usado con @parent (para añadir contenido a una sección existente).

• Ejemplo:

  html-Laravel

  <!-- layout.blade.php -->
  <body>
      @yield('content') <!-- Aquí irá el contenido -->
  </body>

  html-Laravel

  <!-- vista_hija.blade.php -->
  @section('content')
      <p>Este es el contenido principal.</p>
  @endsection

---

3. @stack + @push

• ¿Qué hace?
  @stack define un lugar donde se apilarán múltiples bloques de contenido (como scripts o estilos), y @push añade contenido a esa pila.

• Ejemplo:

  html

  <!-- layout.blade.php -->
  <head>
      @stack('scripts') <!-- Aquí se acumularán los scripts -->
  </head>

  html

  <!-- vista_hija.blade.php -->
  @push('scripts')
      <script>alert('Hola!');</script>
  @endpush

---

4. <x-slot> (en componentes)

• ¿Qué hace?
  Permite pasar bloques de HTML a componentes de Blade. Es como un @section pero para componentes.

• Ejemplo:

  html-Laravel

  <!-- Componente 'alert.blade.php' -->
  <div class="alert">
      {{ $slot }} <!-- Aquí va el contenido por defecto -->
      <x-slot name="extra">Contenido extra</x-slot>
  </div>

  html-Laravel

  <!-- Uso del componente -->
  <x-alert>
      Este es el contenido principal.
      <x-slot name="extra">Más info...</x-slot>
  </x-alert>

---

Resumen rápido:

• @yield: "Hueco" en el layout.

• @section: Bloque de contenido para rellenar el hueco.

• @stack/@push: Para acumular cosas (como scripts).

• <x-slot>: Bloques de HTML en componentes.

Migraciones en Laravel

Las migraciones en Laravel son como un sistema de control de versiones para tu base de datos. Permiten definir y modificar la estructura de la base de datos de forma programática y colaborativa.

Conceptos clave

1. Qué son: Archivos PHP que describen cambios en la estructura de la base de datos (crear tablas, añadir columnas, etc.)

2. Para qué sirven:

   • Mantener un historial de cambios en la estructura de la BD

   • Compartir fácilmente cambios de estructura entre equipos

   • Deshacer cambios si es necesario

   • Mantener sincronizados los entornos de desarrollo

Comandos básicos

php

// Crear una nueva migración
php artisan make:migration create_nombre_table

// Ejecutar migraciones pendientes
php artisan migrate

// Revertir la última migración
php artisan migrate:rollback

// Revertir todas las migraciones
php artisan migrate:reset

// Revertir y volver a ejecutar
php artisan migrate:refresh

// Ver estado de las migraciones
php artisan migrate:status

Estructura de una migración

Una migración típica tiene dos métodos principales:

php

public function up()
{
    // Código para aplicar la migración
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('content');
        $table->timestamps(); // created_at y updated_at
    });
}

public function down()
{
    // Código para revertir la migración
    Schema::dropIfExists('posts');
}

Tipos comunes de columnas

php

$table->string('name');           // VARCHAR
$table->text('description');      // TEXT
$table->integer('quantity');      // INTEGER
$table->bigInteger('votes');      // BIGINT
$table->boolean('active');        // BOOLEAN
$table->dateTime('created_at');   // DATETIME
$table->decimal('amount');        // DECIMAL
$table->float('price');           // FLOAT
$table->json('options');          // JSON

Modificaciones de tablas

Para modificar una tabla existente:

php

Schema::table('users', function (Blueprint $table) {
    $table->string('email')->unique(); // Añadir columna
    $table->dropColumn('votes');      // Eliminar columna
    $table->renameColumn('from', 'to'); // Renombrar
});

Buenas prácticas

1. Cada migración debería representar un cambio lógico único

2. Usar nombres descriptivos para las migraciones

3. Siempre implementar el método down() para poder revertir

4. Ejecutar migraciones en producción con precaución (hacer backups)

Las migraciones son una herramienta poderosa que facilita el trabajo en equipo y el despliegue de aplicaciones Laravel

Modelos y Migraciones en Laravel: Guía Completa

En Laravel, los modelos y las migraciones son esenciales para interactuar con la base de datos. A continuación, te explico cómo usarlos eficientemente, incluyendo comandos clave como rollback, refresh y fresh.

---

1. Modelos en Laravel

Los modelos representan tablas en la base de datos y permiten interactuar con ellas usando Eloquent ORM.

Crear un Modelo

bash

php artisan make:model Product -m

📌 Explicación:

• -m crea automáticamente una migración asociada al modelo.

Estructura básica de un Modelo

php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $table = 'products'; // Nombre de la tabla (opcional si sigue convención)
    protected $fillable = ['name', 'price']; // Campos asignables masivamente
    protected $guarded = ['id']; // Campos protegidos (no asignables)
}

📌 Uso común:

• $fillable: Permite asignación masiva (ej: Product::create($request->all())).

• $guarded: Campos que no se pueden asignar masivamente.

---

2. Migraciones en Laravel

Las migraciones son como "control de versiones" para tu base de datos. Definen la estructura de las tablas.

Crear una Migración

bash

php artisan make:migration create_products_table

📌 Ubicación: database/migrations/XXXX_XX_XX_create_products_table.php

Estructura de una Migración

php

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

class CreateProductsTable extends Migration
{
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id(); // Auto-incremental ID
            $table->string('name');
            $table->decimal('price', 8, 2);
            $table->timestamps(); // created_at y updated_at
        });
    }

    public function down()
    {
        Schema::dropIfExists('products'); // Elimina la tabla al hacer rollback
    }
}

📌 Tipos de columnas comunes:

• string() → VARCHAR.

• integer() → INT.

• text() → TEXT.

• boolean() → TINYINT(1).

• timestamps() → Agrega created_at y updated_at.

---

3. Comandos Artisan para Migraciones

Comando	Explicación
php artisan migrate	Ejecuta migraciones pendientes.
php artisan migrate:rollback	Deshace la última migración.
php artisan migrate:rollback --step=3	Deshace las últimas 3 migraciones.
php artisan migrate:refresh	Rollback + migrate (recrea tablas).
php artisan migrate:fresh	Elimina todas las tablas y vuelve a migrar (sin rollback).
php artisan migrate:status	Muestra el estado de las migraciones.

📌 ¿Cuándo usar refresh vs fresh?

• refresh: Útil si tienes seeders y quieres reinsertar datos.

• fresh: Más rápido, pero borra todo sin ejecutar down().

---

4. Relaciones entre Modelos

Laravel permite definir relaciones fácilmente:

Ejemplo: Un Producto pertenece a una Categoría

php

// En el modelo Product
public function category()
{
    return $this->belongsTo(Category::class);
}

// En el modelo Category
public function products()
{
    return $this->hasMany(Product::class);
}

📌 Tipos de relaciones comunes:

• hasOne() → Uno a uno.

• hasMany() → Uno a muchos.

• belongsTo() → Inversa de hasMany.

• belongsToMany() → Muchos a muchos (con tabla pivote).

---

5. Seeders (Datos de Prueba)

Genera datos falsos para testing:

Crear un Seeder

bash

php artisan make:seeder ProductSeeder

Ejemplo de Seeder

php

use App\Models\Product;
use Illuminate\Database\Seeder;

class ProductSeeder extends Seeder
{
    public function run()
    {
        Product::factory()->count(50)->create(); // Usando Factory
        // O manualmente:
        Product::create(['name' => 'Laptop', 'price' => 999.99]);
    }
}

📌 Ejecutar Seeders:

bash

php artisan db:seed --class=ProductSeeder
# O para ejecutar todos:
php artisan db:seed

---

Conclusión

• Modelos: Gestionan datos y relaciones con Eloquent.

• Migraciones: Controlan la estructura de la base de datos.

• Comandos clave: migrate, rollback, refresh, fresh.

• Seeders: Poblar la base de datos con datos de prueba

Laravel Tinker: Comandos y Ejemplos Prácticos

Laravel Tinker es una potente herramienta REPL (Read-Eval-Print Loop) que te permite interactuar con tu aplicación Laravel directamente desde la terminal. Es ideal para probar rápidamente código, depurar y manipular datos.

1. Iniciar Tinker

bash

php artisan tinker

---

2. Comandos Básicos

A. Manipulación de Modelos

Comando	Descripción	Ejemplo
all()	Obtener todos los registros	App\Models\User::all()
find()	Buscar por ID	App\Models\User::find(1)
where()	Consulta con condición	App\Models\User::where('age', '>', 18)->get()
first()	Primer registro	App\Models\User::first()
count()	Contar registros	App\Models\User::count()
create()	Crear nuevo registro	App\Models\User::create(['name' => 'Juan', 'email' => 'juan@example.com'])
save()	Guardar cambios	$user = User::find(1); $user->name = 'Pedro'; $user->save()
delete()	Eliminar registro	User::find(1)->delete()

B. Relaciones entre Modelos

php

// Obtener posts de un usuario
$user = App\Models\User::find(1);
$user->posts;

// Obtener autor de un post
$post = App\Models\Post::first();
$post->user;

C. Ejecutar Funciones y Helpers

php

// Generar hash de contraseña
bcrypt('mi-contraseña');

// Generar URL
url('/dashboard');

// Configuración
config('app.name');

---

3. Ejemplos Prácticos

Ejemplo 1: Crear y Actualizar Usuario

php

// Crear usuario
$user = new App\Models\User;
$user->name = 'Carlos';
$user->email = 'carlos@example.com';
$user->password = bcrypt('secret');
$user->save();

// Actualizar usuario
$user = App\Models\User::find(1);
$user->name = 'Carlos Actualizado';
$user->save();

Ejemplo 2: Consultas Avanzadas

php

// Usuarios con más de 10 posts
App\Models\User::has('posts', '>', 10)->get();

// Posts ordenados por fecha
App\Models\Post::orderBy('created_at', 'desc')->take(5)->get();

Ejemplo 3: Usar Factories

php

// Crear 5 usuarios falsos
App\Models\User::factory()->count(5)->create();

// Crear post con usuario asociado
$user = App\Models\User::first();
$user->posts()->create(['title' => 'Nuevo post']);

---

4. Comandos Útiles Adicionales

Comando	Descripción
exit o quit	Salir de Tinker
clear	Limpiar la pantalla
dump($var)	Mostrar variable con formato
\Log::info('mensaje')	Escribir en logs
cache()->put('key', 'value', 60)	Guardar en caché
cache()->get('key')	Obtener de caché

---

5. Consejos de Productividad

1. Autocompletado: Presiona Tab para autocompletar nombres de clases y métodos.

2. Historial: Usa las flechas ↑ y ↓ para navegar por el historial.

3. Multilínea: Presiona Shift + Enter para escribir código en múltiples líneas.

4. Reutilizar variables: Asigna resultados a variables para usarlos después ($users = User::all()).

---

6. Salir de Tinker

php

exit
// o
quit

🔹 Tinker es tu mejor aliado para:
✔ Probar consultas Eloquent rápidamente
✔ Depurar relaciones entre modelos
✔ Generar datos de prueba

1. Del Controlador a la Vista

El controlador envía datos a la vista usando el método view() junto con un array asociativo.

Ejemplo:

Controlador (TaskController.php)

php-Laravel

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TaskController extends Controller
{
    public function index()
    {
        // Datos que queremos pasar a la vista (ej: lista de tareas)
        $tasks = [
            'Lavar los platos',
            'Hacer la compra',
            'Estudiar Laravel'
        ];

        // Pasamos las tareas a la vista 'tasks.index'
        return view('tasks.index', ['tasks' => $tasks]);
    }
}

Vista (resources/views/tasks/index.blade.php)

html-Laravel

<!DOCTYPE html>
<html>
<head>
    <title>Lista de Tareas</title>
</head>
<body>
    <h1>Mis Tareas</h1>
    <ul>
        @foreach($tasks as $task)
            <li>{{ $task }}</li>
        @endforeach
    </ul>
</body>
</html>

Resultado en el navegador:

text-Laravel

Mis Tareas
- Lavar los platos
- Hacer la compra
- Estudiar Laravel

---

2. De la Vista al Controlador (Formulario)

Para enviar datos desde la vista al controlador (ej: añadir una nueva tarea), usamos un formulario y recibimos los datos con $request.

Ejemplo:

Vista (resources/views/tasks/index.blade.php)

html-Laravel

<!-- Añadimos un formulario para nuevas tareas -->
<form action="{{ route('tasks.store') }}" method="POST">
    @csrf <!-- Token de seguridad -->
    <input type="text" name="task" placeholder="Nueva tarea">
    <button type="submit">Guardar</button>
</form>

Ruta (routes/web.php)

php-Laravel

use App\Http\Controllers\TaskController;

Route::get('/tasks', [TaskController::class, 'index'])->name('tasks.index');
Route::post('/tasks', [TaskController::class, 'store'])->name('tasks.store');

Controlador (TaskController.php)

php-Laravel

public function store(Request $request)
{
    // Obtenemos la tarea enviada desde el formulario
    $newTask = $request->input('task');

    // Aquí podríamos guardarla en una base de datos, etc.
    return redirect()->route('tasks.index')->with('success', 'Tarea añadida!');
}

---

Resumen

✅ Controlador → Vista:

• El controlador pasa datos con return view('vista', ['clave' => $valor]).

• La vista los recibe como variables (ej: $tasks).

✅ Vista → Controlador:

• La vista envía datos mediante un formulario (POST/GET).

• El controlador los recibe con $request->input('nombre_campo').

¡Así de fácil! 😊 Con esto ya puedes enviar y recibir datos básicos en Laravel.

Componentes en Blade con Slots (Laravel)

Los componentes en Blade permiten crear elementos reutilizables. Los slots son espacios dentro del componente que pueden ser llenados con contenido personalizado cuando se usa el componente. Vamos a adaptar nuestro ejemplo de tareas.

1. Crear un componente simple (card)

Componente (resources/views/components/card.blade.php)

html-Laravel

<div style="border: 1px solid #ccc; padding: 10px; margin: 10px;">
    <h2>{{ $title }}</h2>
    
    <div class="content">
        {{ $slot }}
    </div>
    
    @isset($footer)
        <div class="footer">
            {{ $footer }}
        </div>
    @endisset
</div>

2. Modificar la vista para usar componentes

Vista actualizada (resources/views/tareas/index.blade.php)

html-Laravel

@extends('layouts.app')

@section('title', 'Lista de Tareas')

@section('content')
    <x-card title="Gestión de Tareas">
        <form method="POST" action="{{ route('tareas.store') }}">
            @csrf
            <input type="text" name="nombre" placeholder="Nueva tarea" required>
            <button type="submit">Agregar</button>
        </form>

        <ul>
            @foreach($tareas as $tarea)
                <li>{{ $tarea->nombre }}</li>
            @endforeach
        </ul>

        <x-slot name="footer">
            Total: {{ count($tareas) }} tareas
        </x-slot>
    </x-card>
@endsection

Explicación de los elementos

1. Componente principal (<x-card>)

   • Se llama con title como atributo

   • El contenido entre las etiquetas va al $slot principal

2. Slot principal ($slot)

   • Recibe todo el contenido interno automáticamente

   • En nuestro caso: el formulario y la lista

3. Slot con nombre (footer)

   • Definido con <x-slot name="footer">

   • Opcional (se verifica con @isset en el componente)

Tipos de slots

Tipo	Descripción	Ejemplo
Slot principal	Contenido por defecto	{{ $slot }}
Slot con nombre	Contenido específico	{{ $footer }}
Slot con atributos	Datos adicionales	{{ $user->name }}

Beneficios de usar componentes

1. Reutilización: Puedes usar el componente card en cualquier vista

2. Consistencia: Mantiene el mismo estilo en toda la aplicación

3. Organización: Separa la lógica de presentación

4. Flexibilidad: Permite contenido dinámico con slots

Los componentes pueden ser aún más potentes cuando se combinan con:

• Props (atributos)

• Clases condicionales

• Slots con datos

• Componentes anónimos

El resto de la aplicación (rutas, controlador, modelo) sigue exactamente igual que en los ejemplos anteriores.

Usando el componente Layout

Para utilizar nuestro componente en la vista welcome.blade.php:

1. Dejamos solo el <h1> en la vista

2. Tenemos dos opciones para usar el componente:

Opción 1: Directiva @component

blade

@component('components.layout')
    <!-- Contenido que irá en el $slot -->
@endcomponent

Opción 2: Etiqueta de componente (recomendada)

blade

<x-layout>
    <!-- Contenido que irá en el $slot -->
</x-layout>

La segunda opción es más limpia y asume automáticamente que el componente está en la carpeta components.

Slots con nombre para contenido opcional

Si queremos agregar un sidebar opcional:

1. En el layout:

blade

@isset($sidebar)
    <div id="sidebar">{{ $sidebar }}</div>
@endisset

<!-- Alternativa más corta: -->
@isset($sidebar)
    {{ $sidebar }}
@endisset

2. En la vista:

blade

<x-layout>
    <x-slot name="sidebar">
        <!-- Contenido del sidebar -->
    </x-slot>
</x-layout>

Propiedades del componente

Para modificar metadatos como título y descripción:

1. En el layout:

blade

<title>{{ $metaTitle ?? 'Título por defecto' }}</title>
<meta name="description" content="{{ $metaDescription ?? 'Descripción por defecto' }}">

2. En la vista (como atributos):

blade

<x-layout 
    :meta-title="Título personalizado" 
    :meta-description="Descripción personalizada"
>
    <!-- Nota: usamos kebab-case en atributos pero camelCase en propiedades -->
</x-layout>

Componentes anidados

Si tenemos componentes en subcarpetas:

blade

<x-navigation.main /> <!-- Para components/navigation/main.blade.php -->

Evaluando código PHP en propiedades

Si necesitamos evaluar código PHP en las propiedades:

blade

<x-component :prop=":2 + 2" /> <!-- Evaluará a 4 -->
<x-component prop="2 + 2" />   <!-- Mostrará el string "2 + 2" -->

Conclusión

Con estos cambios, podemos actualizar todas nuestras vistas para usar el layout consistente. Los componentes de Blade nos permiten:

• Reducir código repetido

• Crear plantillas reutilizables

• Mantener una estructura limpia y organizada

• Trabajar con lógica opcional (slots)

Componentes en Laravel: Reutiliza tu Código de Forma Elegante

En Laravel, los componentes son una forma poderosa de estructurar y reutilizar bloques de código en tus vistas. Con ellos, puedes encapsular lógica y diseño en piezas independientes, haciendo tu aplicación más mantenible y escalable.

Tipos de Componentes en Laravel

1. Componentes de Clase

Permiten encapsular lógica y vista en una clase PHP y una plantilla Blade.

Crear un componente:

bash

php artisan make:component Alert

Esto genera:

• app/View/Components/Alert.php (clase)

• resources/views/components/alert.blade.php (vista)

Ejemplo:

php

// Alert.php
namespace App\View\Components;

use Illuminate\View\Component;

class Alert extends Component {
    public $type;

    public function __construct($type = 'info') {
        $this->type = $type;
    }

    public function render() {
        return view('components.alert');
    }
}

html

<!-- alert.blade.php -->
<div class="alert alert-{{ $type }}">
    {{ $slot }}
</div>

Uso en Blade:

html

<x-alert type="success">
    ¡Operación exitosa!
</x-alert>

2. Componentes Anónimos (Inline)

Si no necesitas lógica compleja, puedes definirlos directamente en Blade.

Creación:

bash

php artisan make:component forms.input --inline

Ejemplo:

php

// app/View/Components/Forms/Input.php
namespace App\View\Components\Forms;

use Illuminate\View\Component;

class Input extends Component {
    public function render() {
        return <<<'blade'
            <input {{ $attributes->merge(['class' => 'form-control']) }}>
        blade;
    }
}

Uso:

html

<x-forms.input type="email" name="email" placeholder="Tu correo" />

3. Componentes Dinámicos

Permiten renderizar diferentes componentes según una condición.

Ejemplo:

html

@php
    $component = auth()->user()->isAdmin() ? 'admin-alert' : 'user-alert';
@endphp

<x-dynamic-component :component="$component" message="Bienvenido" />

Ventajas de Usar Componentes

✅ Reutilización – Evita repetir código.
✅ Organización – Separa lógica y presentación.
✅ Personalización – Aceptan atributos y slots.
✅ Legibilidad – Mejora la claridad de tus vistas.

Conclusión

Los componentes en Laravel son una herramienta esencial para construir aplicaciones modernas y mantenibles. Empieza a usarlos para simplificar tu código y mejorar la estructura de tus proyectos.

¿Ya usas componentes en Laravel? ¡Cuéntanos tu experiencia! 

En Laravel, los Componentes y Slots son una característica poderosa de Blade que te permite crear elementos reutilizables y modularizar tu interfaz de usuario. Son especialmente útiles para evitar repetir código HTML en diferentes partes de tu aplicación (como cards, modales, alertas, etc.).

---

1. ¿Qué son los Componentes y Slots?

• Componentes: Bloques de UI reutilizables (ejemplo: una alerta, un card, un modal).

• Slots: Espacios dentro de un componente donde puedes inyectar contenido dinámico.

  • Slot por defecto: Contenido principal.

  • Slots con nombre: Contenido específico para ciertas secciones del componente.

---

2. Tipos de Componentes

a) Componentes Anónimos (Archivos de Vista)

Se definen como archivos .blade.php en resources/views/components/.

Ejemplo: Crear una Alert Box

1. Crear el componente:

   php

   <!-- resources/views/components/alert.blade.php -->
   <div class="alert alert-{{ $type }}">
       {{ $slot }} <!-- Slot principal (contenido dinámico) -->
   </div>

2. Usar el componente:

   php

   <x-alert type="success">
       ¡Éxito! La operación se completó correctamente.
   </x-alert>

   Resultado:

   html

   <div class="alert alert-success">
       ¡Éxito! La operación se completó correctamente.
   </div>

---

b) Componentes con Slots Nombrados

Útil cuando necesitas múltiples secciones dentro de un componente.

Ejemplo: Un Card con Título y Cuerpo

1. Definir el componente (resources/views/components/card.blade.php):

   php

   <div class="card">
       <div class="card-header">
           {{ $title }} <!-- Slot con nombre: 'title' -->
       </div>
       <div class="card-body">
           {{ $slot }} <!-- Slot principal (cuerpo) -->
       </div>
   </div>

2. Usar el componente:

   php

   <x-card>
       <x-slot name="title">Título del Card</x-slot>
       Contenido principal del card aquí...
   </x-card>

   Resultado:

   html

   <div class="card">
       <div class="card-header">Título del Card</div>
       <div class="card-body">Contenido principal del card aquí...</div>
   </div>

---

c) Componentes de Clase (Más Avanzados)

Si necesitas lógica más compleja, puedes generar un componente con Artisan:

bash

php artisan make:component Alert

Esto crea:

• app/View/Components/Alert.php (Clase del componente).

• resources/views/components/alert.blade.php (Vista del componente).

Ejemplo: Componente con Lógica

1. Definir la clase (app/View/Components/Alert.php):

   php

   <?php
   namespace App\View\Components;
   use Illuminate\View\Component;
   
   class Alert extends Component {
       public $type;
       public function __construct($type = 'info') {
           $this->type = $type;
       }
       public function render() {
           return view('components.alert');
       }
   }

2. Definir la vista (resources/views/components/alert.blade.php):

   php

   <div class="alert alert-{{ $type }}">
       {{ $slot }}
   </div>

3. Usar el componente:

   php

   <x-alert type="danger">
       ¡Error! Algo salió mal.
   </x-alert>

---

3. Ventajas de Usar Componentes y Slots

✅ Reutilización: Evita repetir código HTML.
✅ Modularidad: Separa la lógica y el diseño.
✅ Mantenibilidad: Cambios en un componente se reflejan en todas sus instancias.
✅ Flexibilidad: Slots permiten contenido dinámico sin sacrificar estructura.

---

4. Ejemplo Avanzado: Modal Reutilizable

1. Componente (resources/views/components/modal.blade.php):

   php

   <div class="modal">
       <div class="modal-header">
           {{ $title }}
           <button class="close">&times;</button>
       </div>
       <div class="modal-body">
           {{ $slot }}
       </div>
       <div class="modal-footer">
           {{ $footer ?? 'Botón por defecto' }}
       </div>
   </div>

2. Uso:

   php

   <x-modal title="Confirmar acción">
       ¿Estás seguro de eliminar este registro?
       <x-slot name="footer">
           <button class="btn btn-danger">Eliminar</button>
       </x-slot>
   </x-modal>

---

Conclusión

Los Componentes y Slots en Laravel Blade son esenciales para crear interfaces modulares y mantenibles. Puedes usarlos para:

• Alertas, cards, modales, formularios reutilizables.

• Evitar duplicar HTML.

• Mejorar la organización del código

w