Existen muchas bibliotecas útiles que se lanzan todos los días y, con la ayuda de Composer y Github , son fáciles de encontrar y usar. Aquí te listo 24 de las más geniales y útiles con las que me he topado. ¿Tienes una favorita? ¡puedes compartírnosla en los comentarios!
- Dispatch – Micro Framework
Dispatch es un micro Frame PHP. No te ofrece la configuración completa de MVC, pero puedes definir reglas y métodos de URL para organizar mejor su aplicación. Esto es perfecto para API, sitios simples o prototipos:
// incluye la biblioteca
incluir 'dispatch.php';
// define tus rutas
get ('/ saludar', function () {
// renderizar una vista
render ('forma de saludo');
});
// gestor de publicaciones
publicar ('/ saludar', función () {
$ nombre = de ($ _ POST, 'nombre');
// renderiza una vista pasando algunos locales
render ('greet-show', array ('nombre' => $ nombre));
});
// sirva su sitio
envío();
Puede hacer coincidir tipos específicos de solicitudes y rutas HTTP, representar vistas y más. Si combina Dispatch con algunos de los otros frames, ¡puedes lograr una configuración realmente poderosa y liviana!
- Klein – Enrutador ultrarrápido para PHP
Klein es otra biblioteca de enrutamiento liviana para PHP 5.3+. Tiene una sintaxis un poco más detallada que Dispatch, pero es bastante rápido.
responder ('/ [: nombre]', función ($ solicitud) {
echo 'Hola'. $ solicitud-> nombre;
});
También puede suscribirse a métodos HTTP específicos y usar expresiones regulares como rutas:
responder ('GET', '/ posts', $ devolución de llamada);
responder ('POST', '/ posts / create', $ devolución de llamada);
responder ('PUT', '/ posts / [i: id]', $ devolución de llamada);
responder ('BORRAR', '/ posts / [i: id]', $ devolución de llamada);
// Para hacer coincidir varios métodos de solicitud:
responder (array ('POST', 'GET'), $ ruta, $ devolución de llamada);
// O quizás quieras manejar las solicitudes en el mismo lugar
responder ('/ publicaciones / [crear | editar: acción]? / [i: id]?', función ($ solicitud, $ respuesta) {
cambiar ($ solicitud-> acción) {
// hacer algo
}
});
Esto es muy funcional para para proyectos pequeños, pero debes de ser ordenado al usar una biblioteca como esta para aplicaciones más grandes, ya que su código puede volverse inmaterial muy rápido. Para este propósito, estaría mejor con un marco MVC completo como Laravel o CodeIgniter .
- Ham – Biblioteca de enrutamiento con almacenamiento en caché
Ham también es un frame de enrutamiento liviano, este usa el almacenamiento en caché para obtener aún más ganancias de velocidad. Lo logra almacenando en caché todo lo relacionado con E / S en XCache / APC.
requieren '../ham/ham.php';
$ aplicación = new Ham ('ejemplo');
$ aplicación-> config_from_file ('settings.php');
$ aplicación-> ruta ('/ cerdo', función ($ aplicación) {
volver "Delicioso cerdo";
});
$ hola = función ($ aplicación, $ nombre = 'mundo') {
return $ aplicación-> render ('hola.html', matriz (
'nombre' => $ nombre
));
};
$ aplicación-> ruta ('/ hola /
', $ hola);
$ aplicación-> ruta ('/', $ hola);
$ aplicación-> ejecutar ();
La biblioteca necesita que se tenga instalado XCache o APC, lo que significa que no funcionará en la mayoría de los proveedores de alojamiento. Pero si tienes uno de estos instalado o si controlas tu servidor web, debería probar este frame muy rápido.
- Assetic – Gestión de activos
Assetic es un marco de gestión de activos para PHP. Combina y minimiza sus activos CSS / JS. Así es como se usa:
use AsseticAssetAssetCollection;
use AsseticAssetFileAsset;
use AsseticAssetGlobAsset;
$ js = nueva colección de activos (matriz (
new GlobAsset ('/ ruta / a / js / *'),
new FileAsset ('/ ruta / a / otro.js'),
));
// el código se fusiona cuando se desecha el activo
echo $ js-> dump ();
Combinar activos de esta manera es una buena idea, ya que puede acelerar tu sitio. No solo se reduce el tamaño total de descarga, sino que también se eliminan muchas solicitudes HTTP innecesarias (dos de las cosas que más afectan el tiempo de carga de la página).
- ImageWorkshop: manipulación de imágenes con capas
ImageWorkshop es una biblioteca de código abierto que le permite manipular imágenes con capas. Con él puede cambiar el tamaño, recortar, hacer miniaturas, agregar marcas de agua y más.
// Inicializamos la capa italia de la imagen italy.jpg
$ italyLayer = ImageWorkshop :: initFromPath
('/ruta/a/images/italy.jpg');
// Inicializamos la capa de marca de agua de la imagen watermark.png
$ watermarkLayer = ImageWorkshop :: initFromPath ('/ ruta / a / images / watermark.png');
$ imagen = $ italyLayer-> getResult ();
// ¡Esta es la imagen generada!
encabezado ('Tipo de contenido: imagen / jpeg');
imagejpeg ($ imagen, nulo, 95);
// Elegimos mostrar un JPG con una calidad de salida del 95%;
ImageWorkshop está desarrollado para facilitar los casos más comunes de manipulación de imágenes en PHP. Sin embargo, si necesitas algo más poderoso, deberías checar la biblioteca Imagine .
- Snappy – Biblioteca de instantáneas / PDF
Snappy es una biblioteca PHP5 que le permite tomar instantáneas o archivos PDF de URL o documentos HTML. Depende del binario wkhtmltopdf , que está disponible en Linux, Windows y OSX.
require_once '/path/to/snappy/src/autoload.php';
use Knp \ Snappy \ Pdf;
// Inicializa la biblioteca con el
// ruta al binario wkhtmltopdf:
$ rápido = nuevo Pdf ('/ usr / local / bin / wkhtmltopdf');
// Mostrar el pdf resultante en el navegador
// configurando el encabezado Content-type en pdf:
encabezado ('Tipo de contenido: aplicación / pdf');
encabezado ('Contenido-Disposición: archivo adjunto; nombre de archivo = "archivo.pdf"'); echo $ rápido-> getOutput ('http://www.github.com');
Ten en cuenta que es posible que tu proveedor de alojamiento no permita la llamada a binarios externos.
- Idiorm – Biblioteca de ORM ligera
Es una biblioteca ORM liviana y un generador de consultas fluido para PHP5 que se basa en PDO. Con él, puede olvidarse de escribir SQL tedioso:
$ usuario = ORM :: for_table ('usuario')
-> where_equal ('nombre de usuario', 'j4mie')
-> buscar_uno ();
$ usuario-> primer_nombre = 'Jamie';
$ usuario-> guardar ();
$ tweets = ORM :: for_table ('tweet')
-> seleccione ('tweet. *')
-> unirse ('usuario', matriz (
'user.id', '=', 'tweet.user_id'
))
-> where_equal ('usuario.nombre de usuario', 'j4mie')
-> buscar_muchos ();
foreach ($ tweets como $ tweet) {
echo $ tweet-> texto;
}
Idiorm tiene una biblioteca hermana llamada Paris , que es una implementación de Active Record construida sobre ella.
- Underscore – Cinturón de utilidades de PHP
Underscore es un puerto del Underscore.js original , el cinturón de herramientas para aplicaciones JavaScript. La versión de PHP no decepciona y tiene soporte para casi todas las funciones del original. Algunos ejemplos:
__ :: cada (matriz (1, 2, 3), función ($ num) {echo $ num. ',';}); // 1,2,3,
$ multiplicador = 2;
__ :: cada (matriz (1, 2, 3), función ($ num, $ índice) use ($ multiplicador) {
echo $ index. '='. ($ num * $ multiplicador). ','; });
// imprime: 0 = 2,1 = 4,2 = 6,
__ :: reducir (matriz (1, 2, 3), función ($ memo, $ num) {return $ memo + $ num;}, 0); // 6
__ :: buscar (matriz (1, 2, 3, 4), función ($ num) {return $ num% 2 === 0;}); // 2
__ :: filtro (matriz (1, 2, 3, 4), función ($ num) {return $ num% 2 === 0;}); // matriz (2, 4)
La biblioteca también tiene soporte para encadenamiento, lo que la hace aún más poderosa.
- Requests: Requests HTTP sencillas
Requests es una biblioteca que facilita la emisión de solicitudes HTTP. Si eres olvidadizo, y nunca recuerdas las diversas opciones que se le pasaron a Curl, esto es para ti:
$ encabezados = matriz ('Aceptar' => 'aplicación / json');
$ opciones = matriz ('auth' => matriz ('usuario', 'contraseña'));
$ request = Requests :: get ('https://api.github.com/gists', $ encabezados, $ opciones);
var_dump ($ solicitud-> código_estado); // int (200)
var_dump ($ solicitud-> encabezados ['tipo de contenido']);
// cadena (31) "aplicación / json; juego de caracteres = utf-8"
var_dump ($ solicitud-> cuerpo); // cadena (26891) "[…]"
Con esta biblioteca, puedes enviar solicitudes HTTP HEAD, GET, POST, PUT, DELETE y PATCH HTTP, agregar archivos y parámetros con matrices y acceder a todos los datos de respuesta.
- Buzz: biblioteca de solicitudes HTTP simple
Buzz es otra biblioteca PHP para emitir solicitudes HTTP.
$ request = new Buzz \ Message \ Request ('HEAD', '/', 'http://google.com');
$ respuesta = nuevo Buzz \ Message \ Response ();
$ cliente = nuevo Buzz \ Client \ FileGetContents ();
$ cliente-> enviar ($ solicitud, $ respuesta);
echo $ request; echo $ respuesta;
Carece de documentación, por lo que tendrás que leer el código fuente para tener una idea de todas las opciones que admite.
- Goutte – Biblioteca de web scraping
Goutte proporciona una buena API para rastrear sitios web y extraer datos de las respuestas HTML / XML. Goutte funciona con PHP 5.3.3 o posterior.
require_once '/path/to/goutte.phar';
use GoutteClient;
$ cliente = nuevo Cliente ();
$ rastreador = $ cliente-> solicitud ('OBTENER', 'http://www.symfony-project.org/');
// Haga clic en los enlaces:
$ enlace = $ rastreador-> selectLink ('Complementos') -> enlace ();
$ rastreador = $ cliente-> clic ($ enlace);
// Extrae datos con una sintaxis similar a CSS:
$ t = $ rastreador-> filtro ('# datos') -> texto ();
echo "Aquí está el texto: $ t";
- Carbon – Biblioteca DateTime
Carbon es una simple extensión de API para DateTime. Mejora la clase con algunos métodos útiles para trabajar con fechas y horas. Por ejemplo:
printf ("Ahora mismo es% s", Carbon :: now () -> toDateTimeString ());
printf ("Ahora mismo en Vancouver es% s", Carbon :: now ('America / Vancouver'));
$ mañana = Carbon :: ahora () -> addDay ();
$ lastWeek = Carbon :: ahora () -> subWeek ();
$ nextSummerOlympics = Carbon :: createFromDate (2012) -> addYears (4);
$ officialDate = Carbon :: ahora () -> toRFC2822String ();
$ howOldAmI = Carbon :: createFromDate (1975, 5, 21) -> edad;
$ noonTodayLondonTime = Carbon :: createFromTime (12, 0, 0, 'Europa / Londres');
$ endOfWorld = Carbon :: createFromDate (2012, 12, 21, 'GMT');
// las comparaciones siempre se hacen en UTC
if (Carbon :: ahora () -> gte ($ endOfWorld)) {
morir();
}
if (Carbon :: ahora () -> isWeekend ()) {
echo '¡Fiesta!';
}
echo Carbon :: ahora () -> subMinutes (2) -> diffForHumans (); // 'hace 2 minutos'
Últimamente no se le ha visto modificaciones a Carbon, por lo que es posible que desee consultar Datum , una bifurcación en la que se sigue trabajando.
- Ubench – Biblioteca de Micro Benchmarking
Ubench es una micro biblioteca para comparar tu código PHP. Supervisa el tiempo de ejecución y el uso de la memoria. He aquí un ejemplo:
use UbenchUbench;
$ banco = nuevo Ubench;
$ banco-> inicio ();
// Ejecuta algún código
$ banco-> fin ();
// Obtiene el tiempo transcurrido y la memoria
echo $ banco-> getTime (); // 156 ms o 1,123 s
echo $ banco-> getTime (verdadero); // microtiempo transcurrido en flotación
echo $ banco-> getTime (falso, '% d% s'); // 156ms o 1s
echo $ banco-> getMemoryPeak (); // 152B o 90,00Kb o 15,23Mb
echo $ banco-> getMemoryPeak (verdadero); // pico de memoria en bytes
echo $ banco-> getMemoryPeak (falso, '% .3f% s'); // 152B o 90.152Kb o 15.234Mb
// Devuelve el uso de memoria en la marca final
echo $ banco-> getMemoryUsage (); // 152B o 90,00Kb o 15,23Mb
Sería una buena idea ejecutar estas comprobaciones solo durante el desarrollo.
- Validación: motor de validación de entrada
La validación afirma ser el motor de validación más impresionante jamás creado para PHP. ¿Pero puede cumplir?
use RespectValidationValidator como v;
// Validación simple
$ número = 123;
v :: numeric () -> validar ($ número); //cierto
// Validación encadenada
$ usernameValidator = v :: alnum () -> noWhitespace () -> longitud (1,15);
$ usernameValidator-> validate ('alganet'); //cierto
// Validando atributos de objeto
$ usuario = nueva clase estándar;
$ usuario-> nombre = 'Alexandre';
$ usuario-> fecha de nacimiento = '1987-07-01';
// Valida sus atributos en una sola cadena:
$ userValidator = v :: atributo ('nombre', v :: cadena () -> longitud (1,32))
-> atributo ('fecha de nacimiento', v :: fecha () -> edad mínima (18));
$ userValidator-> validar ($ usuario); //cierto
Con esta biblioteca puede validar sus formularios u otros datos enviados por el usuario. Además, admite una amplia cantidad de comprobaciones existentes, generando excepciones y mensajes de error personalizables.
- Filterus – Biblioteca de filtrado
Filterus es otra biblioteca de filtrado, pero no solo puede validar, sino también filtrar la entrada para que coincida con un patrón preestablecido.
$ f = Filtro :: fábrica ('cadena, máx: 5');
$ str = 'Esta es una cadena de prueba';
$ f-> validar ($ str); // falso
$ f-> filtro ($ str); // 'Esta '
Filterus tiene muchos patrones incorporados, admite el encadenamiento e incluso puede validar elementos de matriz con reglas de validación individuales.
- Faker – Generador de datos falsos
Faker es una biblioteca PHP que genera datos falsos. Puede resultar útil cuando necesite completar una base de datos de prueba o generar datos de muestra para su aplicación web. También es muy fácil de usar:
// requiere el autocargador Faker
require_once '/path/to/Faker/src/autoload.php';
// usa la fábrica para crear una instancia de FakerGenerator
$ faker = FakerFactory :: create ();
// generar datos accediendo a propiedades
echo $ faker-> nombre; // 'Lucy Cechtelar';
echo $ faker-> dirección;
// "426 Jordy Lodge
// Cartwrightshire, SC 88120-6700 "
echo $ falso-> texto;
// Sint velit eveniet. Rerum atque repellat voluptatem quia …
Mientras sigas accediendo a las propiedades del objeto, seguirá devolviendo datos generados aleatoriamente.
- Moustache.php – Elegante biblioteca de plantillas
Moustache es un lenguaje de plantillas popular que tiene implementaciones en prácticamente todos los lenguajes de programación. Esto te brinda la ventaja de que puede reutilizar tus plantillas tanto en el lado del cliente como en el del servidor. Moustache.php es una implementación que usa, logicamente, PHP:
$ m = nuevo Mustache_Engine;
echo $ m-> render ('Hola {{planeta}}', array ('planeta' => '¡Mundo!')); // "¡Hola Mundo!"
Para ver ejemplos más avanzados, sugiero echar un vistazo a los documentos oficiales de Moustache .
- Gaufrette – Capa de abstracción del sistema de archivos
Gaufrette es una biblioteca PHP5 que proporciona una capa de abstracción del sistema de archivos. Hace posible trabajar con archivos locales, servidores FTP, Amazon S3 y más de la misma manera. Esto te permite desarrollar tus aplicación sin tener que saber cómo va a acceder a sus archivos en el futuro.
use GaufretteFilesystem;
use GaufretteAdapterFtp como FtpAdapter;
use GaufretteAdapterLocal como LocalAdapter;
// Archivos locales:
$ adapter = new LocalAdapter ('/ var / media');
// Opcionalmente use un adaptador FTP:
// $ ftp = new FtpAdapter ($ ruta, $ host, $ nombre de usuario, $ contraseña, $ puerto);
// Inicializa el sistema de archivos:
$ sistema de archivos = nuevo sistema de archivos ($ adaptador);
// Úselo:
$ contenido = $ sistema de archivos-> leer ('miArchivo');
$ content = 'Hola, soy el nuevo contenido';
$ sistema de archivos-> escribir ('miArchivo', $ contenido);
También hay adaptadores en memoria caché y en memoria, y se agregarán más con el tiempo.
- Omnipay – Biblioteca de procesamiento de pagos
Omnipay es una biblioteca de procesamiento de pagos para PHP. Tiene una API clara y consistente y es compatible con docenas de puertas de enlace. Con esta biblioteca, solo necesita aprender una API y trabajar con una variedad de procesadores de pago.
use OmnipayCreditCard;
use OmnipayGatewayFactory;
$ puerta de enlace = GatewayFactory :: create ('Stripe');
$ puerta de enlace-> setApiKey ('abc123');
$ formData = ['number' => '4111111111111111', 'expiryMonth' => 6, 'expiryYear' => 2016];
$ respuesta = $ pasarela-> compra (['monto' => 1000, 'tarjeta' => $ formData]);
if ($ respuesta-> isSuccessful ()) {
// el pago fue exitoso: actualizar la base de datos
print_r ($ respuesta);
} elseif ($ respuesta-> isRedirect ()) {
// redirigir a la pasarela de pago externa
$ respuesta-> redireccionar ();
} demás {
// pago fallido: muestra un mensaje al cliente
salir ($ respuesta-> getMessage ());
}
El uso de la misma API coherente facilita la compatibilidad con varios procesadores de pago o el cambio cuando surge la necesidad.
20. PHP Geo – Biblioteca de ubicación geográfica
phpgeo es una biblioteca simple para calcular distancias entre coordenadas geográficas con alta precisión. Por ejemplo:
use LocationCoordinate;
use LocationDistanceVincenty;
$ coordenada1 = nueva coordenada (19.820664, -155.468066); // Cumbre de Mauna Kea
$ coordenada2 = nueva coordenada (20.709722, -156.253333); // Cumbre Haleakala
$ calculadora = nuevo Vincenty ();
$ distancia = $ calculadora-> getDistance ($ coordenada1, $ coordenada2); // devuelve 128130.850 (metros; ≈128 kilómetros)
Esto funcionará muy bien en aplicaciones que utilizan datos de ubicación. Para obtener las coordenadas, puede utilizar la API de ubicación HTML5, la API de Yahoo o ambas.
