Preguntas en entrevista técnica de Laravel
Tags: laravel, php, webdev, español
Published: 2024-04-12 23:21:54

Prepararse para una entrevista técnica es fundamental para destacar como candidato y demostrar tus habilidades técnicas.

Algunas razones por las cuales prepararse son:

- **Demostrar conocimiento específico**, ya que en las entrevistas técnicas se evalúa la comprensión profunda de la tecnología o lenguaje de programación requerido por el perfil de la posición.
- **Demostrar experiencia** como desarrollador. Puedes hablar sobre proyectos anteriores, desafíos o cómo solucionarías ciertos problemas.
- **Obtener confianza**. Prepararte te dará la confianza necesaria durante la entrevista. Practicar con preguntas y escenarios frecuentes te ayudará a responder de manera más efectiva.
- **Diferenciarte de otros candidatos**. Piensa en esto, hay muchos desarrolladores allá afuera (y muchos más que vienen en camino) y todos tenemos habilidades distintas, pero prepararte para una entrevista hará que destaques. Y es que las compañías buscan candidatos que puedan integrarse de inmediato a los proyectos.

Así es que prepararse para una entrevista técnica te dará la oportunidad de repasar tus conocimientos y adquirir nuevos, demostrarás tus habilidades e irás más allá de los conocimientos prácticos con los que ya cuentas.

Es por esto que aquí te dejo algunas de las preguntas más comunes que surgen durante una entrevista técnica para desarrolladores web donde se requiera experiencia con el framework Laravel.

> Para este artículo me basé en la publicación de [FullStack.Cafe - Real Tech Interview Questions And Answers For Devs](https://www.fullstack.cafe/blog/laravel-interview-questions), agregando mayor contexto, ejemplos y _beneficios o ventajas_ de cada tema, para enriquecer las respuestas.

---

#### 1. ¿Qué es Laravel?
> Dificultad: ⭐

Laravel es un **framework de PHP** que facilita el desarrollo de aplicaciones web. Su diseño de software se basa en el patrón **MVC (Modelo Vista Controlador)**, que lo convierte en una herramienta poderosa para desarrolladores que buscan crear aplicaciones modernas más eficientes y estructuradas.

#### 2. ¿Cuáles son los beneficiones de utilizar Laravel sobre otros frameworks de desarrollo web?
> Dificultad: ⭐

[Laravel](https://laravel.com/) ofrece una serie de ventajas que lo distinguen de otros frameworks web, por ejemplo: 
- **Sintaxis elegante** que permite aplicar técnicas de _clean code_.
- El uso de **Eloquent ORM** para interactuar con bases de datos.
- Un sistema de **enrutamiento** flexible y fácil de usar.
- Una **estructura** de archivos simple y organizada.
- **Paquetes y funcionalidades** precargadas, como autenticación y autorización.
- Una **documentación muy completa**, además de una **comunidad** muy grande, que permite aprender y resolver la mayoría de los problemas.

#### 3. ¿Qué es el Patrón de diseño Facade y cómo se usan en Laravel?
> Dificultad: ⭐⭐

El **Patrón de diseño Facade** es una técnica de programación utilizada para simplificar la interacción con sistemas complejos. En Laravel, este patrón proporciona una interfaz simplificada para acceder a funcionalidades del framework.

En palabras simples, actúa como una "fachada" que simplifica el acceso a funcionalidades específicas sin exponer todos los detalles internos de dichas funciones.

En Laravel, los _Facades_ son clases que ofrecen un acceso "**estático**" a objetos dentro del **Service Container** de la aplicación. Estos Facades ofrecen una sintaxis simple, similar a los métodos estáticos, pero mantienen _flexibilidad_ y _testabilidad _de las inyecciones de dependencias. Un ejemplo del uso de Facades es el siguiente:

```php
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Route;

Route::get('/cache', function() {
    return Cache::get('key');
});
```

Los **beneficios** de usar Facades en Laravel son **sintaxis elegante**, **facilitan las pruebas** y **evitan el exceso de uso de dependencias**.

#### 4. ¿Qué es el Service Container?
> Dificultad: ⭐⭐

El **Service Container** en Laravel es una herramienta para gestionar las dependencias de clases y realizar la **_inyección de dependencias_** en la aplicación.

La **inyección de dependencias** es una técnica donde las dependencias de una clase se "inyectan" en la clase a través del constructor, o en algunos casos utilizando métodos "setter". Con esta técnica, las clases reciben automáticamente las instancias de otras clases necesarias para funcionar correctamente.

Ahora bien, el **Service Container** es la aplicación del concepto anterior en la aplicación de Laravel. La función principal es administrar las dependencias entre clases.

Las ventajas de contar con el Service Container en Laravel son la **resolución automática** de dependencias, una **menor configuración** a la hora de crear clases nuevas, y finalmente una aplicación **más limpia y mantenible**.

#### 5. ¿Qué son las migraciones?
> Dificultad: ⭐⭐

Se podría pensar en las **migraciones** de Laravel como el "control de versiones" para la base de datos. Ya que permiten a un equipo crear, modificar y compartir el esquema de base de datos de la aplicación.

Las migraciones son clases que nos permiten crear y modificar la estructura de la base de datos, así como sus tablas y columnas según sea necesario.

Se escriben con código y se ejecutan mediante comandos, y cada migración representa un cambio específico en la base de datos, por lo que facilita el seguimiento de cambios realizados.

Algunos de los **beneficios** son el **control de versiones**, la **colaboración** y la **reproducibilidad**, es decir, puedes **_recrear_** la base de datos en cualquier entorno utilizando las mismas migraciones.

#### 6. ¿Qué es Eloquent ORM?
> Dificultad: ⭐⭐

**Eloquent** es un componente del framework que se encarga de la **interacción con bases de datos**.

Eloquent es el **ORM (Object-Related Mapper)** predeterminado de Laravel, su función es mapear las tablas de la base de datos a objetos, que son los **Modelos** dentro de la estructura de la aplicación. 

Cada modelo es una clase, el cual contiene métodos para efectuar consultas como `select`, `where`, `join`, etc. El siguiente es un ejemplo de un modelo:

```php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $table = 'users'; // Nombre de la tabla
    protected $fillable = ['name', 'email']; // Columnas permitidas para asignación masiva
}
```

y para consultar usuarios se hace de la siguiente manera:

```php
$user = User::find(1); // Buscar usuario con ID 1
echo $user->name; // Acceder al nombre del usuario
```

Entre los **beneficios** de usar Eloquent se encuentra la **sintaxis expresiva**, **relaciones** entre modelos sencillas y legibles, y que **facilita las pruebas**.

#### 7. ¿Qué es el Query Builder en Laravel?
> Dificultad: ⭐⭐

El **Query Builder** en Laravel es una interfaz que permite interactuar con bases de datos de manera estructurada y segura, al igual que Eloquent ORM, pero sirve para construir consultas mucho más complejas.

Con Query Builder puedes consultar tablas y sus relaciones sin necesidad de tener un modelo y sin escribir **Raw Queries**, es decir, consultas SQL directamente en el código. El resultado de una consulta es una **Colección**, es decir, una instancia de `Illuminate\Support\Collection`.

El Query builder utiliza enlace de parámetros PDO para proteger la aplicación contra ataques de inyección SQL.

Un ejemplo de uso es el siguiente:
```php
use Illuminate\Support\Facades\DB;

$users = DB::table('users')->get();
```

El método `get` devuelve una colección y se puede acceder a las columnas como propiedades del objeto de la siguiente manera:

```php
foreach ($users as $user) {
    echo $user->name;
}
```

Los **beneficios** son la **independencia de la base de datos**, una **sintaxis simple y legible** y la **seguridad** contra _SQL Injection_.

#### 8. ¿Cuáles son los beneficios de _Eager Loading_ y cuándo usarlos?
> Dificultad: ⭐⭐⭐

**Eager Loading** en Laravel es una técnica esencial para optimizar las consultas a la base de datos y mejorar el rendimiento al trabajar con relaciones entre modelos.

Principalmente resuelve el problema de las consultas **N+1** al recuperar modelos relacionados de antemano mediante una sola consulta, evitando realizar múltiples consultas adicionales para obtener datos de los modelos relacionados.

Los **beneficios** son múltiples, tales como **mejora del rendimiento**, evita el problema **N+1**, garantiza la **consistencia de datos**, entre otros.

Cúando usar **Eager Loading**:
- Cuando sepas que **accederas a datos relacionados** en la mayoría de las consultas.
- Cuando muestres **listas o tablas de datos** el uso de eager loading es crucial.
- Si tienes **relaciones anidadas**, por ejemplo un autor con sus libros.

Supongamos que tienes una tabla de Libros `Book` con una relación de _muchos a uno_ con Autores `User`, para cargar todos los libros con sus autores, puedes usar:

```php
$books = Book::with('user')->get();
foreach ($books as $book) {
    echo $book->title . ' escrito por ' . $post->user->name;
}
```

#### 9. ¿Cómo hacer _soft deletes_?
> Dificultad: ⭐⭐

Los **soft deletes** son una técnica que permite marcar registros como eliminados sin borrarlos físicamente de la base de datos. Esto es útil para mantener un historial o permitir la recuperación de datos eliminados.

Para hacer un _soft delete_ en laravel, primero debemos tener una columna llamada `deleted_at` en la tabla, se puede agregar mediante una migración. Además, en el modelo utilizamos el trait `softDeletes` de Laravel.

- En la migración, agregamos la columna `deleted_at`:

```php
Schema::table('customers', function (Blueprint $table) {
    $table->softDeletes();
});
```

- En el modelo, utilizamos el trait SoftDeletes:

```php
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class Customer extends Model
{
    use SoftDeletes;
    // ...
}
```

- Para eliminar registros:
```php
$customer = Customer::find(1);
$customer->delete(); // Marca como eliminado (soft delete)
```

- Para restaurar un registro eliminado:
```php
$customer->restore(); // Restaura el registro
```

#### 10. ¿Qué son los _Query Scope_?
> Dificultad: ⭐⭐⭐

Los **Scopes** son métodos personalizados que puedes definir en los modelos de Eloquent para aplicar filtros comunes a las consultas.

Las **ventajas** de utilizar Query Scopes es que puedes **reutilizar** consultas en los modelos, hace que las consultas sean más expresivas y **fáciles de entender**, además de que promueven la **coherencia** en el código al aplicar las mismas restricciones o filtros en diferentes partes de la aplicación.

Supongamos que tienes un modelo `Post` con una columna `status`, puedes crear un scope para obtener solo los posts con status _activo_:

```php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public function scopeActive($query)
    {
        return $query->where('status', 'active');
    }
}
```

De esta manera, en el controlador utilizas el scope así:
```php
$activePosts = Post::active()->get();
```

Además de esto, puedes crear **Scopes Dinámicos** que acepten parámetros:
```php
// model
public function scopeStatus($query, $status)
{
    return $query->where('status', $status);
}

// controller
$publishedPosts = Post::status('published')->get();
$draftPosts = Post::status('draft')->get();
```

#### 11. ¿Qué son los nombres de rutas en Laravel?
> Dificultad: ⭐

Los **nombres de rutas** en Laravel son una herramienta útil para referir una ruta específica por medio de un nombre, es decir, puedes asignar un nombre a una ruta por medio del método `name` en la definición de ésta:

```php
Route::get('/user/profile', function () {
    // ...
})->name('profile');
```

Ahora puedes utilizar este nombre en lugar de la URL completa en cualquier parte de la aplicación:
```php
$url = route('profile'); // Genera la URL del perfil
return redirect()->route('profile'); // Redirige al perfil
```

Las ventajas de esta herramienta son: 
- **Legibilidad**: Hace que el código sea más claro y fácil de entender.
- **Mantenimiento**: Cambiar la URL de una ruta se hace en la definición y no en cada parte del código donde requieras la ruta.
- **Evita errores de escritura**: Al usar nombres, se reduce la posibilidad de errores tipográficos en las URLs.

#### 12. ¿Qué es un _Closure_ en Laravel?
> Dificultad: ⭐⭐⭐

Un **Closure** es una función anónima. Los Closures se utilizan con frecuencia como métodos _Callback_ y pueden pasarse como parámetros a otras funciones.

Conceptualmente, un Closure es una función con algunos argumentos "fijos" por el entorno cuando se define. Permite sortear las restricciones de alcance de variables de manera limpia.

Considera el siguiente ejemplo:

```php
function manejar(Closure $closure) {
    $closure();
}

manejar(function() {
    echo '¡Hola!';
});
```

Aquí se define la función `manejar` que toma un Closure como parámetro. El Closure se ejecuta dentro de la función `manejar`, lo que resulta en un "¡Hola!".

Los **casos de uso** de los Closures pueden ser **devoluciones de llamada (Callbacks)**, **reglas de validación personalizadas** o **middlewares** en Laravel.

#### 13. Menciona algunos _Aggregates_ que ofrece el Query Builder de Laravel.
> Dificultad: ⭐⭐⭐

El **Query Builder** de Laravel proporciona varios métodos de agregación (**Aggregates**) para calcular valores en las consultas de manera eficiente. Algunos de ellos son:

1. **Count**. Devuelve el número total de registros en una tabla.
```php
$count = DB::table('users')->count();
```

2. **Sum**. Calcula la suma de los valores en una columna específica.
```php
$totalAmount = DB::table('orders')->sum('amount');
```

3. **Max**. Obtiene el valor máximo en una columna:
```php
$highestScore = DB::table('scores')->max('score');
```

4. **Min**. Obtiene el valor mínimo en una columna:
```php
$lowestPrice = DB::table('products')->min('price');
```

5. **Avg**. Calcula el promedio de los valores en una columna:
```php
$averageRating = DB::table('reviews')->avg('rating');
```

#### 14. ¿Qué son los eventos en Laravel?
> Dificultad: ⭐⭐⭐

Los **eventos** son una funcionalidad de Laravel que permite observar y manejar acciones específicas, aplicando el **Patrón de Diseño Observer**.

Básicamente, nos permite **suscribirnos** y **escuchar** eventos en la aplicación. Un evento es un incidente o alguna acción detectada y manejada por el programa.

Algunos ejemplos de _eventos_ pueden ser cuando un usuario se registra, cuando un usuario inicia sesión, cuando se crea un pedido o se agrega un nuevo registro en alguna tabla de la base de datos.

Las clases de **eventos** se registran en el directorio `app/Events`, mientras que las acciones o _listeners_ se registran en el directorio `app/Listener`. Para crearlos puedes utilizar los comandos:

```
php artisan make:event OrderCreated
 
php artisan make:listener SendNewOrderNotification --event=OrderCreated
```

Esto creará la clase del evento, la cual no contiene lógica. Simplemente está ligada al modelo `Order`:

```php
namespace App\Events;
 
use App\Models\Order;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
 
class OrderCreated
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
 
    /**
     * Create a new event instance.
     */
    public function __construct(
        public Order $order,
    ) {}
}
```

También genera la clase necesaria para manejar el evento (Listener):

```php
namespace App\Listeners;
 
use App\Events\OrderCreated;
 
class SendNewOrderNotification 
{
    /**
     * Create the event listener.
     */
    public function __construct()
    {
        // ...
    }
 
    /**
     * Handle the event.
     */
    public function handle(OrderCreated $event): void
    {
        // Access the order using $event->order...
    }
}
```

---
Por supuesto que hay muchísimos más temas que podrían salir durante la entrevista, tantos que sería imposible listarlos todos. Pero en general, considero que esta guía puede servirte para prepararte y profundizar en tus conocimientos sobre Laravel.

Recuerda siempre mencionar casos donde puedes aplicar estos conceptos o técnicas, así como tus experiencias própias con Laravel.

En general, una entrevista revisa aspectos básicos como **Bases de datos**, **Patrones de Diseño**, **Rendimiento** o **Principios de Desarrollo**. Considero que estos temas se cubren en esta guía, ya que al utilizar un frameword como Laravel estamos aplicando estas técnicas, quizás inconcientemente, pero esta guía quizás puede ayudarte a detectar estos principios (como SOLID o KISS), patrones de diseño o arquitectura (como Observadores o  Eventos) y técnicas para mejorar el _performance_ o rendimiento de una aplicación (como Aggregates o Scopes).

Espero que esta guía haya sido de mucha ayuda en tu camino hacia la entrevista técnica, te deseo la mejor de las suertes, aunque sé que no la necesitarás.

Como consejo final, confía en tí y en tus conocimientos. Si no conoces algo, pregunta a tu entrevistador la respuesta e interactúa con él.

En futuras publicaciones agregaré preguntas comunes (o no tanto) sobre PHP, otros temas de desarrollo y tips en general para ayudarte a tener mejores entrevistas.

Déjame en los comentarios si conoces algunas otras preguntas comunes, ya sea que te hayan hecho o que se te ocurran que pueden preguntar en una entrevista técnica de desarrollador web con Laravel.