Consejos y trucos de PHP para desarrollo backend: Frameworks y bases de datos

[Ignacio]

Consejos y trucos de PHP para desarrollo backend: Frameworks y bases de datos

PHP sigue siendo una de las tecnologías más utilizadas en el desarrollo backend, y con buena razón. Su ecosistema maduro, amplia comunidad y evolución constante lo convierten en una opción sólida para proyectos de cualquier escala. En este post, compartiré consejos prácticos para trabajar con PHP en diferentes frameworks y bases de datos.

Mejores prácticas generales de PHP

1. Usa tipado estricto

Desde PHP 7.0, el tipado estricto mejora la calidad del código y reduce errores:

declare(strict_types=1);

function calcularTotal(float $precio, int $cantidad): float {
    return $precio * $cantidad;
}

2. Aprovecha las características modernas

PHP 8.x introdujo características poderosas:

• Named arguments: Mejoran la legibilidad
• Match expressions: Alternativa más limpia a switch
• Nullsafe operator: Reduce verificaciones nulas
• Enums: Tipos seguros para valores constantes

// Named arguments
$resultado = buscarUsuario(
    nombre: 'Juan',
    activo: true,
    limite: 10
);

// Match expression
$mensaje = match($codigo) {
    200 => 'Éxito',
    404 => 'No encontrado',
    500 => 'Error del servidor',
    default => 'Código desconocido'
};

3. Composer es tu aliado

Gestiona dependencias profesionalmente y aprovecha el autoloading PSR-4:

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Trabajando con Frameworks

Laravel

Consejos clave:

1. Usa Eloquent con criterio: Los modelos son potentes, pero no abuses de las consultas N+1. Usa with() para eager loading:

// ❌ Malo: N+1 queries
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->autor->nombre;
}

// ✅ Bueno: Una query con join
$posts = Post::with('autor')->get();

2. Jobs y Queues: Desacopla tareas pesadas del request principal:

ProcessarPedido::dispatch($pedido)->onQueue('pagos');

3. Service Container: Aprovecha la inyección de dependencias:

public function __construct(
    private readonly UserRepository $users,
    private readonly EmailService $mailer
) {}

Symfony

Consejos clave:

1. Bundles modulares: Organiza tu código en bundles reutilizables
2. Doctrine Query Builder: Más flexible que DQL puro:

$query = $em->createQueryBuilder()
    ->select('u')
    ->from('App\Entity\Usuario', 'u')
    ->where('u.activo = :activo')
    ->setParameter('activo', true)
    ->orderBy('u.nombre', 'ASC')
    ->getQuery();

3. Event Dispatcher: Desacopla la lógica con eventos:

$dispatcher->dispatch(new UsuarioRegistradoEvent($usuario));

Slim/Lumen (Micro-frameworks)

Consejos clave:

1. Middleware: Organiza la lógica transversal (auth, logging, CORS)
2. Mantén las rutas limpias: Usa controladores separados
3. PSR-7/PSR-15: Adhiérete a los estándares para mejor interoperabilidad

Optimización con bases de datos

MySQL/MariaDB

1. Índices estratégicos:

-- Para búsquedas frecuentes
CREATE INDEX idx_usuario_email ON usuarios(email);

-- Índices compuestos para queries complejas
CREATE INDEX idx_pedido_fecha_estado ON pedidos(fecha_creacion, estado);

2. Prepared Statements siempre:

$stmt = $pdo->prepare('SELECT * FROM usuarios WHERE email = ?');
$stmt->execute([$email]);

3. EXPLAIN es tu amigo:
Analiza queries lentas antes de optimizar.

PostgreSQL

1. JSONB para datos semi-estructurados:

// En Laravel/Eloquent
$usuarios = Usuario::where('metadata->nivel', '>', 5)->get();

2. Full-text search nativo:

CREATE INDEX idx_productos_busqueda ON productos 
USING gin(to_tsvector('spanish', nombre || ' ' || descripcion));

3. Particionamiento de tablas grandes:
Útil para logs y datos históricos.

MongoDB (con extensión oficial)

1. Proyecciones para reducir datos transferidos:

$usuarios = $collection->find(
    ['activo' => true],
    ['projection' => ['nombre' => 1, 'email' => 1]]
);

2. Agregaciones para análisis complejos:

$resultado = $collection->aggregate([
    ['$match' => ['status' => 'completado']],
    ['$group' => [
        '_id' => '$categoria',
        'total' => ['$sum' => '$monto']
    ]]
]);

Redis (cache y sessions)

1. Cache de queries costosas:

$usuarios = Cache::remember('usuarios_activos', 3600, function() {
    return Usuario::where('activo', true)->get();
});

2. Rate limiting:

$key = "rate_limit:api:{$userId}";
$intentos = Redis::incr($key);
if ($intentos === 1) {
    Redis::expire($key, 60); // 60 segundos
}

Consejos de rendimiento

1. OPcache activado siempre en producción
2. Usa APCu o Redis para cache de aplicación
3. Lazy loading de recursos pesados
4. Database connection pooling cuando sea posible
5. Monitorea con herramientas como New Relic o Blackfire

Seguridad básica

• Nunca confíes en input del usuario
• Usa password_hash() y password_verify()
• Configura correctamente los headers de seguridad
• Mantén PHP y dependencias actualizadas
• Usa variables de entorno para credenciales (.env)

Recursos recomendados

• PHP.net documentation (siempre actualizada)
• PHP: The Right Way (phptherightway.com)
• Laracasts (para Laravel)
• SymfonyCasts (para Symfony)

Conclusión

PHP moderno es un lenguaje robusto y eficiente cuando se utiliza correctamente. La clave está en conocer bien el framework elegido, optimizar las interacciones con la base de datos, y seguir buenas prácticas de desarrollo.

¿Qué otros consejos agregarían? ¿Hay algún framework o base de datos específica sobre la que quieran profundizar? ¡Los leo en los comentarios!