Namespaces Lección 54 de 75 8 min de lectura

Use y Alias

La palabra clave use te permite importar clases, funciones y constantes de otros namespaces. Con as puedes crear alias para evitar conflictos o simplificar nombres largos.

Importar clases con use

En lugar de escribir el nombre completo de una clase cada vez, puedes importarla con use:

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

// Importar clases
use App\Models\Usuario;
use App\Models\Producto;
use App\Services\CarritoService;

class TiendaController
{
    public function __construct(
        private readonly CarritoService $carrito
    ) {}

    public function agregarProducto(Producto $producto): void
    {
        $this->carrito->agregar($producto);
    }

    public function obtenerUsuario(int $id): Usuario
    {
        return new Usuario($id, 'cliente@example.com');
    }
}

Sin use, tendrías que escribir \App\Models\Usuario, \App\Models\Producto, etc. cada vez que los uses.

Importar múltiples clases del mismo namespace

Cuando importas varias clases del mismo namespace, puedes agruparlas:

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

// Importación agrupada (PHP 7+)
use App\Models\{Usuario, Producto, Pedido};
use App\Services\{CarritoService, PagoService};
use App\Exceptions\{NotFoundException, ValidationException};

class PedidoController
{
    public function crear(Usuario $usuario, Producto $producto): Pedido
    {
        if ($producto->stock <= 0) {
            throw new ValidationException('Producto sin stock');
        }

        return new Pedido($usuario, $producto);
    }
}

Alias con as

Cuando dos clases tienen el mismo nombre, usa as para crear un alias:

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

// Dos clases llamadas Usuario de diferentes namespaces
use App\Auth\Usuario as UsuarioAuth;
use App\Blog\Usuario as UsuarioBlog;

// También útil para nombres muy largos
use App\Services\Payment\Stripe\StripePaymentProcessor as StripeProcessor;

class PerfilController
{
    public function sincronizar(int $id): void
    {
        // Usar los alias
        $auth = new UsuarioAuth('admin', 'hash');
        $blog = new UsuarioBlog($id, 'Admin', 'Mi biografía');

        $processor = new StripeProcessor();
    }
}

Importar funciones

Usa use function para importar funciones de otros namespaces:

PHP

<?php

// src/Helpers/strings.php
namespace App\Helpers;

declare(strict_types=1);

function slugify(string $texto): string
{
    $texto = strtolower($texto);
    $texto = preg_replace('/[^a-z0-9]+/', '-', $texto) ?? $texto;
    return trim($texto, '-');
}

function truncar(string $texto, int $longitud): string
{
    if (strlen($texto) <= $longitud) {
        return $texto;
    }
    return substr($texto, 0, $longitud) . '...';
}

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

use function App\Helpers\slugify;
use function App\Helpers\truncar;

class ArticuloController
{
    public function crear(string $titulo, string $contenido): array
    {
        return [
            'slug' => slugify($titulo),
            'titulo' => $titulo,
            'resumen' => truncar($contenido, 150),
            'contenido' => $contenido,
        ];
    }
}

Importar constantes

Usa use const para importar constantes:

PHP

<?php

// src/Config/app.php
namespace App\Config;

declare(strict_types=1);

const VERSION = '2.0.0';
const DEBUG = true;
const MAX_UPLOAD_SIZE = 10 * 1024 * 1024; // 10MB

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

use const App\Config\VERSION;
use const App\Config\DEBUG;
use const App\Config\MAX_UPLOAD_SIZE;

class InfoController
{
    public function version(): array
    {
        return [
            'version' => VERSION,
            'debug' => DEBUG,
            'max_upload' => MAX_UPLOAD_SIZE,
        ];
    }
}

Importar clases globales

Las clases nativas de PHP están en el namespace global. Puedes importarlas para no escribir \ cada vez:

PHP

<?php

namespace App\Services;

declare(strict_types=1);

use DateTime;
use DateTimeImmutable;
use InvalidArgumentException;
use RuntimeException;

class ReporteService
{
    public function generar(string $fechaInicio, string $fechaFin): array
    {
        $inicio = new DateTimeImmutable($fechaInicio);
        $fin = new DateTimeImmutable($fechaFin);

        if ($inicio > $fin) {
            throw new InvalidArgumentException(
                'La fecha de inicio debe ser anterior a la de fin'
            );
        }

        return [
            'desde' => $inicio->format('Y-m-d'),
            'hasta' => $fin->format('Y-m-d'),
            'generado' => (new DateTime())->format('Y-m-d H:i:s'),
        ];
    }
}

Orden de las declaraciones use

Coloca las declaraciones use después del namespace y antes del código. Una convención común es ordenarlas:

PHP

<?php

namespace App\Controllers;

declare(strict_types=1);

// 1. Clases globales (PHP nativas)
use DateTime;
use InvalidArgumentException;

// 2. Clases de librerías externas (vendor)
use Psr\Log\LoggerInterface;

// 3. Clases de tu aplicación
use App\Models\Usuario;
use App\Services\AuthService;

// 4. Funciones (si las hay)
use function App\Helpers\slugify;

// 5. Constantes (si las hay)
use const App\Config\VERSION;

class AuthController
{
    // ...
}

Ejemplo práctico completo

PHP

<?php

// src/Models/Articulo.php
namespace App\Models;

declare(strict_types=1);

class Articulo
{
    public function __construct(
        public readonly int $id,
        public readonly string $titulo,
        public readonly string $contenido,
        public readonly Usuario $autor
    ) {}
}

PHP

<?php

// src/Services/BlogService.php
namespace App\Services;

declare(strict_types=1);

use DateTimeImmutable;
use InvalidArgumentException;
use App\Models\{Articulo, Usuario};

class BlogService
{
    /** @var Articulo[] */
    private array $articulos = [];

    public function publicar(string $titulo, string $contenido, Usuario $autor): Articulo
    {
        if (trim($titulo) === '') {
            throw new InvalidArgumentException('El título es requerido');
        }

        $articulo = new Articulo(
            id: count($this->articulos) + 1,
            titulo: $titulo,
            contenido: $contenido,
            autor: $autor
        );

        $this->articulos[] = $articulo;
        return $articulo;
    }

    /** @return Articulo[] */
    public function listar(): array
    {
        return $this->articulos;
    }
}

PHP

<?php

// src/Controllers/BlogController.php
namespace App\Controllers;

declare(strict_types=1);

use App\Models\Usuario;
use App\Services\BlogService;

class BlogController
{
    public function __construct(
        private readonly BlogService $blogService
    ) {}

    public function crearArticulo(array $datos): array
    {
        $autor = new Usuario(
            id: $datos['autor_id'],
            email: $datos['autor_email']
        );

        $articulo = $this->blogService->publicar(
            titulo: $datos['titulo'],
            contenido: $datos['contenido'],
            autor: $autor
        );

        return [
            'id' => $articulo->id,
            'titulo' => $articulo->titulo,
            'autor' => $articulo->autor->email,
        ];
    }
}

Ejercicios

Ejercicio 1: Importación básica

Crea una clase App\Controllers\ProductoController que use las clases App\Models\Producto y App\Services\InventarioService. Importa también InvalidArgumentException del namespace global. Implementa un método actualizar(int $id, array $datos) que lance la excepción si el array está vacío.

Ver solución

<?php

namespace App\Controllers;

declare(strict_types=1);

use App\Models\Producto;
use App\Services\InventarioService;
use InvalidArgumentException;

class ProductoController
{
    public function __construct(
        private readonly InventarioService $inventario
    ) {}

    public function actualizar(int $id, array $datos): Producto
    {
        if (empty($datos)) {
            throw new InvalidArgumentException(
                'Los datos no pueden estar vacíos'
            );
        }

        $producto = $this->inventario->buscar($id);
        $producto->actualizar($datos);

        return $producto;
    }
}

Ejercicio 2: Resolver conflictos

Tienes dos clases llamadas Logger: una en App\Logs\Logger (tu implementación) y otra en Vendor\Debug\Logger (de una librería). Crea una clase App\Services\DiagnosticoService que use ambas, utilizando alias para distinguirlas.

Ver solución

<?php

namespace App\Services;

declare(strict_types=1);

use App\Logs\Logger as AppLogger;
use Vendor\Debug\Logger as DebugLogger;

class DiagnosticoService
{
    public function __construct(
        private readonly AppLogger $appLogger,
        private readonly DebugLogger $debugLogger
    ) {}

    public function ejecutar(): void
    {
        // Logger de aplicación para mensajes normales
        $this->appLogger->info('Iniciando diagnóstico');

        // Logger de debug para información técnica
        $this->debugLogger->debug('Memoria usada: ' . memory_get_usage());

        $this->appLogger->info('Diagnóstico completado');
    }
}

Ejercicio 3: Funciones y constantes

Crea un archivo App\Helpers\math.php con funciones porcentaje() y redondear(), más una constante PI_PRECISION. Luego, impórtalas en otra clase usando use function y use const.

Ver solución

<?php

// src/Helpers/math.php
namespace App\Helpers;

declare(strict_types=1);

const PI_PRECISION = 3.14159265359;

function porcentaje(float $valor, float $total): float
{
    return ($valor / $total) * 100;
}

function redondear(float $numero, int $decimales = 2): float
{
    return round($numero, $decimales);
}

// src/Services/CalculadoraService.php
namespace App\Services;

declare(strict_types=1);

use function App\Helpers\porcentaje;
use function App\Helpers\redondear;
use const App\Helpers\PI_PRECISION;

class CalculadoraService
{
    public function calcularDescuento(float $precio, float $descuento): array
    {
        $porcentajeDescuento = porcentaje($descuento, $precio);

        return [
            'descuento' => redondear($porcentajeDescuento),
            'pi' => PI_PRECISION,
        ];
    }
}

Puntos clave

use importa clases para no escribir nombres completos
use Clase as Alias crea un nombre alternativo
Agrupa imports: use App\Models\{A, B, C}
use function para funciones
use const para constantes
Importa clases globales (DateTime, Exception) para código más limpio
Ordena los imports: globales, vendor, app, funciones, constantes

¿Has encontrado un error o tienes sugerencias para esta lección?

Enviar feedback

¿Te está gustando el curso?

Tenemos cursos premium con proyectos reales y soporte.

Descubrir cursos premium