logo cosasdedevs

Todo lo que necesitas saber sobre Composer

Todo lo que necesitas saber sobre Composer

My Profile
Oct 23, 2020

¡Hola! Esta semana vamos a seguir viendo cositas de PHP y esta vez nos toca ver una herramienta que será indispensable entenderla perfectamente si quieres ser programador en PHP y esta herramienta es Composer.

Pero antes de nada...

¿Qué es Composer?

Composer es una herramienta que nos ayudará con la gestión de dependencias en PHP. Esta nos permitirá elegir los paquetes que necesitemos en nuestro proyecto, los instalará y actualizará por nosotros lo que nos ahorrará tiempo y quebraderos de cabeza.

Vale, me has convencido, esto tiene buena pinta y ahora...

¿Cómo lo instalo?

Para instalar Composer en tu PC debes ir a esta página y según tu sistema operativo seguir las instrucciones. Para Windows solo tienes que descargar el instalador y abrirlo y para Mac y Linux deberás seguir las instrucciones que aparecen en la página de descarga.

Una vez instalado, abrimos una terminal y lanzamos el siguiente comando para verificar que todo esté ok.

composer -v

Ahora que hemos verificado que nuestra instalación es correcta, es hora de iniciar un proyecto desde 0 con Composer.

Iniciar un proyecto con Composer

Para iniciar un proyecto con Composer tenemos que lanzar el siguiente comando en la raiz del proyecto en el que estemos trabajando.

composer init

Al pulsar enter nos aparecerá una guía de instalación. Lo primero que nos pedirá será el nombre del paquete en el que el vendor es el nombre del autor o proyecto y el name será el nombre que le queramos dar al proyecto. Por defecto elige tu nombre de usuario y el nombre de la carpeta en la que estás iniciando el proyecto, en mi caso lo dejaré así.

El segundo parámetro que pide es una breve descripción, ahí podéis añadir lo que queráis.

El siguiente parámetro es el autor, ahí es donde podéis poner vuestro nombre y el de los demás colaboradores del proyecto.

En minimun Stagility diremos stable, esto quiere decir que cuando instalemos un paquete mediante composer y sino especificamos una versión, solo instalará la última versión estable.

En Package Type vamos a decir que es de tipo project.

Como licencia añadiremos una de tipo MIT.

Ahora nos pedirá que definamos las dependencias y las dependencias de desarrollo, como lo haremos más adelante, pulsamos enter en ambos casos para saltarnos este paso.

Por último nos pedirá que confirmemos los cambios, escribimos yes y nos generará un archivo llamado composer.json donde está almacenada la configuración que hemos realizado anteriormente.

Si queréis información más detalla acerca de la configuración del archivo de Composer os dejo el enlace a la documentación 😉.

Cargar dependencias propias y de terceros con Composer

Una de las particularidades de composer es que nos permite añadir namespaces donde están alojadas nuestras clases y archivos que queramos que se carguen al iniciar nuestro proyecto. Esto nos ahorrará tener que cargar con clases y archivos de forma manual y nos facilitará el trabajo enormemente.

Para testar esta parte, lo primero que vamos a hacer es crear en nuestro directorio raíz una carpeta llamada app, esta contendrá un archivo llamado helpers.php y otra carpeta llamada classes. Dentro de classes vamos a crear un archivo llamado Calc.php.

Debería quedar algo así:

tutorial_composer/
├── app
│   ├── classes
│   │   └── Calc.php
│   └── helpers.php
└── composer.json
Una vez hecho esto, abrimos el archivo composer.json y justo antes de la llave de cierre añadiremos una nueva clave llamada autoload que contendrá nuestros archivos y namespaces.

Para añadir el archivo app/helpers.php a nuestra carga automática, dentro de autoload añadiremos la clave files y dentro de ella el archivo o archivos que queramos añadir, en nuestro caso el archivo app/helpers.php. Nos debería quedar algo así:

{
    "name": "alber/tutorial_composer",
    "description": "Tutorial de configuraci\u0000n de un proyecto con Composer",
    "type": "project",
    "license": "MIT",
    "authors": [
        {
            "name": "Alberto",
            "email": "alberto.r.caballero.87@gmail.com"
        }
    ],
    "minimum-stability": "stable",
    "require": {},
    "autoload": {
        "files": [
            "app/helpers.php"
        ]
    }
}
Para añadir los namespaces, crearemos la clave psr-4 dentro de autoload y como clave pondremos el nombre del namespace y como valor su ruta.
 
En nuestro caso, el nombre que le daremos al namespace será App y muy importante, siempre hay que añadir el doble slash invertido para evitar conflictos entre nombres parecidos. Como valor le damos el nombre de nuestra carpeta donde guardamos toda las clases y helpers llamada app. Ahora nuestro archivo de configuración deberá quedar así:
{
    "name": "alber/tutorial_composer",
    "description": "Tutorial de configuraci\u0000n de un proyecto con Composer",
    "type": "project",
    "license": "MIT",
    "authors": [
        {
            "name": "Alberto",
            "email": "alberto.r.caballero.87@gmail.com"
        }
    ],
    "minimum-stability": "stable",
    "require": {},
    "autoload": {
        "psr-4": {
            "App\\": "app/"
        },
        "files": [
            "app/helpers.php"
        ]
    }
}

Una vez realizada la configuración, lanzamos el siguiente comando que generará todos los archivos necesarios para configurar la auto carga de nuestras clases y archivos:

composer dump

Este comando generará una carpeta llamada vendor donde se alojará el archivo autoload.php que es el que utilizaremos para la carga automática de clases y archivos y toda la configuración para acceder a estas. Ahora nuestro proyecto debería verse así:

tutorial_composer/
├── app
│   ├── classes
│   │   └── Calc.php
│   └── helpers.php
├── composer.json
└── vendor
    ├── autoload.php
    └── composer
        ├── ClassLoader.php
        ├── LICENSE
        ├── autoload_classmap.php
        ├── autoload_files.php
        ├── autoload_namespaces.php
        ├── autoload_psr4.php
        ├── autoload_real.php
        └── autoload_static.php

Ahora vamos a testar que la autocarga funciona correctamente, para ello vamos al archivo app/classes/Calc.php donde crearemos una clase y una función para realizar sumas, para ello abrimos el archivo y añadimos el siguiente código:

<?php

namespace App\classes;

class Calc
{
    public function sum($num1, $num2)
    {
        return $num1 + $num2;
    }
}

Como veis, definimos el namespace en la clase, ya que si no el autoload no encontrará la clase y después añadimos una clase con una única función para realizar sumas.

Una vez hecho esto, vamos al directorio raíz y creamos un archivo index.php, en él añadiremos el siguiente código para testar que podemos acceder a la clase.

<?php

require __DIR__ . '/vendor/autoload.php';

$calc = new App\classes\Calc;
echo $calc->sum(5, 4) . PHP_EOL;

Lo primero que hacemos es cargar el archivo vendor/autoload.php, esto hará que cuando llamemos a una clase el autoload la cargue automáticamente sin tener que estar nosotros preocupándonos de añadirla manualmente.

Después instanciamos la clase y ejecutamos el método sum. Para ejecutarlo, vamos a nuestra terminal y lanzamos el siguiente comando:

php index.php

Si todo ha ido bien debería mostrarnos el resultado por pantalla, en nuestro caso el número 9.

Ahora que ya hemos visto como testar las clases, es hora de probar con el archivo app/helpers.php, para ello vamos a crear una función que nos cree la instancia de la clase Calc sin tener que estar escribiendo todo el rollo de new App\classes\Calc cada vez que la necesitemos. Para ello, abrimos el archivo app/helpers.php y añadimos el siguiente código:

<?php

if (!function_exists('calc')) {
    function calc()
    {
        return new App\classes\Calc;
    }
}

En este archivo lo que estamos haciendo es comprobar si no existe la función calc, esta es una comprobación que se realiza en este tipo de archivos como buena práctica y para evitar errores. Si no existe, crearemos la función calc() que retornará una instancia de la clase.

Volvemos al archivo index.php y modificamos la línea en la que creamos una instancia de la clase, en vez de ello, llamaremos a la función que hemos creado anteriormente de tal forma que ahora quedará así el código:

<?php

require __DIR__ . '/vendor/autoload.php';

$calc = calc();
echo $calc->sum(5, 4) . PHP_EOL;

Como veis, ahora se ve un código mucho más limpio y el resultado es el mismo.

Y ahora que ya sabemos instalar nuestras propias dependencias, es hora de probar con dependencias externas. Para ver todas los paquetes disponibles desde composer debemos ir a la página de https://packagist.org/, en ella, podemos utilizar el buscador para encontrar los paquetes que queramos instalar, una vez accedamos a uno de ellos, podremos ver información sobre las versiones de PHP en las que funciona, si requiere de otras librerías, documentación sobre su uso y el comando para instalarlo.

Para este ejemplo vamos a instalar guzzle que es una herramienta para lanzar de forma sencilla peticiones http. Para ello podemos acceder a la página del paquete que es esta https://packagist.org/packages/guzzlehttp/guzzle y en ella veremos el comando para instalarla que siempre será composer require <vendor>/<nombre-del-paquete>:

composer require guzzlehttp/guzzle

Al lanzar este comando se descargará el paquete dentro de la carpeta vendor, si además depende de otros paquetes, estos también se descargarán.

Una cosa a aclarar muy importante, es que cuando estamos trabajando en un proyecto colaborativo y por ejemplo lo estamos compartiendo en cualquier sistema de versiones es que la carpeta vendor nunca se sube al repositorio, por lo tanto si descargamos un proyecto de un repositorio y tenemos que trabajar con él, lo primero que haremos será lanzar el siguiente comando para instalar todas las dependencias:

composer install

Una vez aclaro esto sigamos. Si abrimos el archivo composer.json, veremos que ahora aparece una nueva clave llamada require que contiene el paquete guzzle y la versión instalada. Ahí es donde aparecerán todas las dependencias que descarguemos en nuestro proyecto.

Por último también se genera un archivo llamado composer.lock. Este archivo es super importante porque este contiene información acerca de las dependencias instaladas y las dependencias de las que depende esta.

Esto es muy importante, ya que si estamos trabajando en un proyecto colaborativo, descargamos el proyecto e instalamos las dependencias pero no tenemos el archivo composer.lock es posible que las dependencias de las que depende la dependencia que queramos instalar haya actualizado sus versiones y al ejecutar el proyecto no tengamos el funcionamiento deseado.

Por propia experiencia al heredar un proyecto, he tenido muchos problemas con esto al no tener el archivo composer.lock así que cuidadin con esto 😅.

Ahora abrimos el archivo index.php de nuevo y añadimos el siguiente código para testar que podemos utilizar la librería guzzle:

<?php

require __DIR__ . '/vendor/autoload.php';

// $calc = calc();
// echo $calc->sum(5, 4) . PHP_EOL;

$client = new \GuzzleHttp\Client();
$response = $client->request('GET', 'https://www.google.es/');

echo $response->getStatusCode();

Si todo ha ido bien deberíamos ver por pantalla el estado de la respuesta a la petición a Google que será el número 200.

Ahora ya sabemos instalar paquetes pero ¿Qué pasa si lo que queremos es eliminar un paquete que ya no utilizamos?

Desinstalar paquetes

Pues bien, si por ejemplo ya no usamos guzzle y lo queremos desinstalar, pues para ello usaremos el siguiente comando:

composer remove guzzlehttp/guzzle

También podemos eliminar la referencia desde el archivo composer.json eliminando la línea con el paquete y lanzando el siguiente comando:

composer update

Instalar versiones concretas de un paquete

Si por razones de compatibilidad o cualquier otro problema necesitamos instalar una versión anterior de un paquete, deberemos pasar un parámetro adicional con la versión que queremos instalar:

composer require guzzlehttp/guzzle "6.*"

En este ejemplo le decimos que queremos instalar la última versión de la versión 6. Podríamos ser más específicos y añadir por ejemplo "6.4" si queremos esa versión en concreto.

Ver información sobre un paquete

Si queremos obtener información acerca de un paquete el comando que deberemos utilizar será show:

composer show guzzlehttp/guzzle 

Este comando nos mostrará información acerca la versión que tenemos, descripción, licencia, dependencias, etc.

Por último si la liamos parda y eliminamos la carpeta vendor por error, don't worry, mientras tengamos los archivos composer.json y composer.lock todo estará bien. Simplemente lanzamos el siguiente comando y se descargarán todos los paquetes de nuevo además de realizar la configuración del autoload:

composer install

Conclusiones

Composer es una herramienta brutal que nos quitará un montón de trabajo y quebraderos de cabeza. Si aún no la estáis usando en vuestros proyectos os animo a que la uséis, ya veréis como os facilita la vida 😁.

También os dejo el enlace al repositorio del proyecto por si tenéis cualquier duda pinchando aquí.

Como siempre, os recomiendo seguirme en Twitter y nos vemos en el siguiente tutorial 👋.

También te puede interesar:

Nos tomamos en serio tu privacidad

Utilizamos cookies propias y de terceros para mejorar la experiencia del usuario a través de su navegación. Si pulsas entendido aceptas su uso. Ver política de cookies.

🐍 Sígueme en Twitter

Si te gusta el contenido que subo y no quieres perderte nada, sígueme en Twitter y te avisaré cada vez que cree contenido nuevo 💪
Luego ¡Te sigo!