Composer, un administrador de dependencias para PHP

Composer es un administrador de dependencias para PHP que rastrea las dependencias locales de sus proyectos y bibliotecas. Para quienes usan Java, Composer vendría siendo algo como Maven o como CPAN para los programadores Perl.

Se usa en los principales frameworks web modernos para PHP (como Laravel, Symfony, etc.). Para descargarlo debemos ir a este sitio: https://getcomposer.org/download/

También existe una imagen Docker de Composer:

$ docker pull composer/composer
$ docker run --rm -it -v "$(pwd):/app" composer/composer install

Pero, antes de hacer nada, ¿Para qué sirve Composer?

Como desarrolladores PHP, nos ayuda a:

• Resolver las dependencias para paquetes PHP.
• Cargar automáticamente paquetes de PHP.
• Mantener todos los paquetes actualizados.

Una vez instalado, verificamos:

$ composer --version

Si todo va bien, mostrará versión instalada.

A continuación una pequeña lista de comandos más usados de Composer

Comandos más usados de Composer

Obtener ayuda:

$ composer --help

Listar comandos disponibles:

$ composer list

Obtener información de Composer:

$ composer about

Inicializa un nuevo proyecto con un archivo composer.json :

$ composer init

Instala un paquete y lo añade a composer.json :

$ composer require [paquete]

Ejemplo:

$ composer require monolog/monolog

Instala todas las dependencias listadas en composer.json :

$ composer install

Actualiza las dependencias a sus versiones más recientes compatibles :

$ composer update

Desinstala un paquete y lo elimina de composer.json :

$ composer remove [paquete]

Ejemplo:

$ composer remove monolog/monolog

Regenera el archivo de autoloading (vendor/autoload.php):

$ composer dump-autoload

Diagnosticar el sistema para identificar errores comunes:

$ composer diagnose

También es usado para crear proyectos. Veamos un ejemplo de como crear un proyecto Symfony:

$ composer create-project symfony/skeleton:"7.3.x-dev" miproyecto

Esto nos creará un proyecto Symfony, para ejecutar la aplicación debemos ejecutar este comando:

$ symfony server:start

Abrimos el navegador en la dirección: http://localhost:8000/

Continuaremos con esta serie sobre PHP y sus herramientas.

Enlaces:

https://getcomposer.org
https://www.codementor.io/@jadjoubran/php-tutorial-getting-started-with-composer-8sbn6fb6t

Un framework web ligero para PHP: CodeIgniter

Según el sitio oficial:

CodeIgniter es un potente framework PHP de tamaño muy reducido, creado para desarrolladores que necesitan un conjunto de herramientas simple y elegante para crear aplicaciones web con todas las funciones.

Características:

• Ligero: footprint pequeño (~2MB). 
• MVC: soporta el patrón Modelo-Vista-Controlador. 
• Fácil configuración: mínima configuración inicial. 
• Rendimiento: optimizado para alta velocidad. 
• Seguridad: incluye herramientas para proteger contra CSRF, XSS, y validación de datos. 
•  Documentación clara: guías detalladas y comunidad activa. 
•  Flexibilidad: no impone estructuras rígidas, compatible con PHP 7.4+.

Como ya es habitual en este blog crearemos un sencillo ejemplo usando ahora este micro framework.

Usaremos Composer para crear el proyecto.

Creando un proyecto con CodeIgniter(y Composer)

Creamos el proyecto:

$ composer create-project codeigniter4/appstarter hola-mundo

Nos ubicamos en el directorio creado:

$ cd hola-mundo

Copiamos el archivo env a .env

$ cp env .env

Editamos el archivo .env y descomentamos y ajustamos la variable app.baseURL para que quede de la siguiente manera:

app.baseURL = 'http://localhost:8080'

Ejecutamos la aplicación:

$ php spark serve

Abrimos el navegador en la dirección:

http://localhost:8080

¡Hemos creado nuestra primera aplicación usando CodeIgniter y Compose!

En algunos casos deberás editar el archivo php.ini y descomentar extension=intl (quitando el ;) :

extension=intl

Ejecutar este comando e iniciar de nuevo el server:

$ compose install
$ php spark serve

Enlaces:

https://www.codeigniter.com/

Conociendo Laravel: un framework para PHP

Laravel es un framework de PHP para desarrollar aplicaciones web, conocido por su sintaxis elegante, herramientas integradas y enfoque en la simplicidad y robustez. Facilita tareas como autenticación, enrutamiento, sesiones y más.

Si ya contamos con PHP y Composer instalados podemos crear un proyecto de la siguiente forma:

$ composer global require laravel/installer

Creamos un directorio y nos ubicamos en este:

$ mkdir proyecto
$ cd proyecto

Verificamos instalación:

$ laravel  --version

Creamos el proyecto:

$ laravel  new generador

Esto nos mostrará un prompt, elegiremos todo por default. Si todo va bien, se generará nuestro proyecto.

Nos ubicamos en el directorio creado (generador):

$ cd generador

Instalamos las dependencias y ejecutamos la aplicación:

$ npm install && npm run build
$ composer run dev

Si todo va bien, abriremos el navegador en la dirección:

http://localhost:5173/

¡Hemos creado nuestra primera aplicación con Laravel!

Enlaces:

https://laravel.com/

Slim framework: un micro framework para PHP

Slim es un micro framework PHP que le ayuda a escribir rápidamente aplicaciones web y API simples pero potentes.

Requisitos:

• Si no se tiene PHP instalado, instalarlo. 
• Si no se tiene Composer, instalarlo.

PHP:

https://www.php.net/downloads.php

Composer:

https://getcomposer.org/download/

Nota: Durante la instalación se te pedirá un proxy. Si no lo tienes, omite el paso y continua. También requerirás reiniciar tu máquina.

Instalando Slim Framework

Comprobamos la instalación de PHP y Composer:

$ php --version

$ composer --version

Creamos un directorio, nos posicionamos sobre este y generamos el proyecto:

$ mkdir proyecto-slim
$ cd proyecto-slim
$ composer create-project slim/slim-skeleton generator

Una vez generado, nos ubicamos en el directorio creado:

$ cd generator

index.php

Ejecutamos el proyecto:

$ php -S localhost:8081 -t public

¡Hemos creado nuestro primer proyecto con Slim Framework!

Hay otra forma de instalar y crear un proyecto. Debemos crear un directorio y ubicarnos en el.

$ mkdir proyecto
$ cd proyecto

Instalamos lo necesario para trabajar con Slim Framework:

$ composer require slim/slim
$ composer require slim/psr7

Se creará un directorio vendor y dos archivos (composer.json y composer.lock).

Verificamos el archivo JSON (vendor/composer.json):

{
    "require": {
        "slim/slim": "^4.0",
        "slim/psr7": "^1.0"
    }
}

Creamos un archivo index.php

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

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

$app = AppFactory::create();

$app->get('/', function (Request $request, Response $response, array $args) {
    $response->getBody()->write("¡Hola, Slim Framework!");
    return $response;
});

$app->run();

Ejecutamos la aplicación:

$ php -S localhost:8081

Tendremos ejecutandose nuestra aplicación en la dirección:

http://localhost:8081/

Algunas impresiones:

• Para ser un "micro" framework se genera todo un proyecto con muchos directorios y archivos "innecesarios". 
• Habrá que realizar un escudriñamiento más a fondo para ver cuales son sus puntos fuertes y de donde flaquea.

Enlaces:

https://www.slimframework.com/
https://getcomposer.org/download/

GCP: Creando y borrando tablas con BigQuery (Java, Python, etc.)

En un post pasado dimos un pequeño vistazo a GCP y BigQuery. Continuaremos con más ejemplos de Java y BigQuery.

Ejemplo 1. Crear una tabla con BigQuery.

CrearTableBigQuery.java

package com.codemonkey.main;

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CrearTableBigQuery {

   public static final String MY_DATASET_NAME = "midataset";
   public static final String MY_TABLE_NAME= "usuarios";

  public static void main(String[] args) {

    String datasetName = MY_DATASET_NAME;
    String tableName = MY_TABLE_NAME;
    Schema schema =
        Schema.of(
            Field.of("nombre", StandardSQLTypeName.STRING),
            Field.of("activo", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    try {
   
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Tabla creada exitosamente!!");
    } catch (BigQueryException e) {
      System.err.println("Ha ocurrido un error al crear la tabla: \n" + e.getMessage());
    }
  }
}

Si todo funciona correctamente, entonces la tabla usuarios habrá sido creada correctamente.

En Python el código tan solo consta de unas breves líneas de código:

creartablabq.py

from google.cloud import bigquery

client = bigquery.Client()
table_id = "midataset.usuarios"
schema = [
    bigquery.SchemaField("nombre", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("edad", "INTEGER", mode="REQUIRED"),
]
table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  
print(
    "Se ha creado la tabla {}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ejemplo 2. Eliminar una tabla con BigQuery.

EliminarTabla.java

package com.codemonkey.main;

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class EliminarTabla {

  public static void main(String[] args) {
    String datasetName = "midataset";
    String tableName = "usuarios";
    borrarTabla(datasetName, tableName);
  }

  public static void borrarTabla(String datasetName, String tableName) {
    try {

      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
      boolean success = bigquery.delete(TableId.of(datasetName, tableName));
      if (success) {
        System.out.println("Tabla borrada exitosamente");
      } else {
        System.out.println("Tabla no encontrada");
      }
    } catch (BigQueryException e) {
      System.out.println("Ha ocurrido un error al borrar la tabla. \n" + e.getMessage());
    }
  }
}

Si funciona correctamente, la tabla será eliminada.

Ahora en Python:

eliminartablabq.py

from google.cloud import bigquery

client = bigquery.Client()

table_id = 'myproject.mydataset.usuarios'

client.delete_table(table_id, not_found_ok=True) 
print("Tabla eliminada: '{}'.".format(table_id))

¿Y qué con otros clientes cómo PHP, etc.?

Hay clientes para otros lenguajes además de Java y Python, también puede usar C#, PHP, y Go.

borrartablebq.php

use Google\Cloud\BigQuery\BigQueryClient;

/**
 * Borrar determinada tabla
 *
 * @param string $projectId El ID de tu proyecto.
 * @param string $datasetId El ID de tu dataset.
 * @param string $tableId El ID de tu tabla.
 */
function eliminarTabla(string $projectId, string $datasetId, string $tableId): void
{
    $bigQuery = new BigQueryClient([
      'projectId' => $projectId,
    ]);
    $dataset = $bigQuery->dataset($datasetId);
    $table = $dataset->table($tableId);
    $table->delete();
    printf('Tabla eliminada %s.%s' . PHP_EOL, $datasetId, $tableId);
}

Cómo se puede observar, es relativamente fácil emplear el client library de GCP para nuestros proyectos en la nube.

El código fue tomado de este enlace: https://cloud.google.com/bigquery/docs/samples/bigquery-delete-table

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/04/gcp-google-cloud-bigquery.html
https://codemonkeyjunior.blogspot.com/2024/04/google-cloud-platform-gcp-en-un-vistazo.html
https://codemonkeyjunior.blogspot.com/2024/04/gcp-google-cloud-storage.html

PHP: herramientas para probar nuestras aplicaciones

He aquí una lista de las herramientas más populares para probar nuestras aplicaciones PHP.

XAMPP

XAMPP es una distribución de Apache completamente gratuita y fácil de instalar que contiene MariaDB, PHP y Perl. El paquete de instalación de XAMPP ha sido diseñado para ser increíblemente fácil de instalar y usar.

https://www.apachefriends.org/es/index.html

WampServer

Es un entorno de desarrollo web de Windows. Te permite crear aplicaciones web con Apache2, PHP y una base de datos MySQL.

https://www.wampserver.com/en/

EasyPHP

Un entorno de desarrollo PHP completo y listo para usar en Windows que incluye el servidor web Apache, SQL Server MySQL y otras herramientas de desarrollo.

https://www.easyphp.org/

AppServ

Appserv es una herramienta para Windows con Apache, MySQL, PHP y otras adiciones, en la cual estas aplicaciones se configuran en forma automática, lo que permite ejecutar un servidor web completo.

https://www.appserv.org/en

Uw Amp

Servidor Wamp gratuito con Apache MySQL PHP y SQLite

https://www.uwamp.com/en/

Instalar PHP en Windows (vídeo Youtube)

Ya en un post anterior vimos como instalar PHP (CLI): https://codemonkeyjunior.blogspot.com/2023/01/instalar-php-cgi.html ahora veremos como hacerlo para sistemas Windows.
Acá el clásico script para obtener toda la información del intérprete PHP:
index.php

<?php
   phpinfo();
?>

Ejecutar con:

php -S localhost:8000

Enlaces:

https://www.php.net/manual/en/install.windows.manual.php
https://www.php.net/manual/en/install.windows.php

Instalar PHP CGI

En está ocasión instalaremos PHP CLI y CGI.

Instalación de PHP CLI

# Instalación PHP CLI
sudo apt-get update
sudo apt-get install php-cli -y
php --version

Instalación de PHP CGI

# Instalación PHP CGI
sudo apt-get update
sudo apt-get install php-cgi -y
php-cgi --version

Crearemos un archivp PHP que invoque la función : phpinfo()

info.php

<?php
 phpinfo();
?>

Ejecutamos en una terminal:

php-cgi info.php > info.html 

Con esto obtendremos la información del PHP instalado en nuestra máquina.

Enlaces:

https://codemonkeyjunior.blogspot.com/search?q=php

PHP: expresiones regulares y otras cosas

PHP es un lenguaje bastante vilipendiado. No lo neguemos, tú, yo, tus colegas han tenido debates sobre "lo malo" que es el lenguaje. Sin embargo, con la madurez reconocemos que hemos estado equivocados, bastante equivocados. PHP es un lenguaje que ha salido avante a pesar del advenimiento de otros lenguajes de programación modernos. Con este lenguaje puedes crear servicios web, aplicaciones web dinámicas, etc. Tiene centenares o/y miles de Frameworks que facilitan (o complican) la vida del programador. Node JS, Angular... son lo de hoy, pero siempre habrá desarrollos que requieran algún programador que sepa PHP.
Antes de comenzar... instalaremos PHP Cli.

$ sudo apt-get update
$ sudo apt-get install php-cli -y
$ php --version

Las expresiones regulares son mecanismos par hacer coincidir patrones y/o cadenas. Para trabajar con expresiones regulares debemos:

1. Definir qué patrón se quiere buscar
2. Cadena donde se quiere buscar ese patrón

Ejemplo. Programa que verifique si las cadenas cumplen un patrón definido.

regex.php

<?php

  // Si empieza con F o f
  $expr1 = "/^F|f/";
  $cadena = "Fernando";
  if(preg_match($expr1, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si son dígitos
  $expr2 ="/[0-9]/";
  $cadena = "123456";
  if(preg_match($expr2, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son caracteres normales 
  $expr3 ="/\W/";
  $cadena = "%&@#!?{}[=";
  if(preg_match($expr3, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si tiene espacios
  $expr4 ="/\s/";
  $cadena = "a b c ";
  if(preg_match($expr4, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no tiene espacios vacíos
  $expr5 ="/\S/";
  $cadena = "abcdef";
  if(preg_match($expr5, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si es un dígito 
  $expr6 ="/\d/";
  $cadena = "12087";
  if(preg_match($expr6, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no es un dígito 
  $expr7 ="/\D/";
  $cadena = "TRES MIL UNO";
  if(preg_match($expr7, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si es un caracter 
  $expr7 ="/\w/";
  $cadena = "El gato tiene 3 patas.";
  if(preg_match($expr7, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son dígitos 
  $expr8 ="/[^0-9]/";
  $cadena = "Whisky";
  if(preg_match($expr8, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son dígitos 
  $expr9 ="/[^a-z]/";
  $cadena = "anita lava la tina";
  if(preg_match($expr9, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

?>

Ejecutando:

$ php -S 127.0.0.1:8080 regex.php

¡Feliz código!
Enlaces:
https://symfony.es/
https://codeigniter.com/
https://cakephp.org/
https://laravel.com/
https://miguelgomezsa.com/blog/laravel-vs-codeigniter
https://carlos-herrera.com/laravel-vs-codeigniter/
https://codemonkeyjunior.wordpress.com/2020/09/06/docker-instalando-imagen-de-php/

¿Por qué programamos?

Es una pregunta que deberíamos hacernos antes de empezar a estudiar y/o aprender programación. La pregunta parece tan sencilla y compleja a la vez.

¿Por qué programamos? Algunos dirán que programamos porque nos pagan, otros porque les parece muy divertido y otros más divagarán en sus respuestas.

Tal vez la respuesta más lógica (y adecuada) es porque necesitamos resolver problemas. Es obvio que estos problemas tienen que ver con las empresas o centros de trabajo donde estamos. Donde se nos paga por crear programas o depurar proyectos existentes.

También existen personas que programan porque les motiva a crear cosas y no necesariamente estudiaron computación (o algo relacionado con las computadoras).  Así como hay gente que programa aunque no les guste (sic). 

Con el tiempo "el gusto de programar" puede terminar; gente que es muy buena programando y resolviendo problemas relativos a la programación, pero que termina odiando su trabajo.

Los que nos dedicamos a la programación debemos entender que no todos sabemos de todo, algunas cosas nos parecerán muy sencillas y otras nos provocaran mucha frustración al no poder resolverlas lo más rápido posible.

También la frustración de usar un lenguaje o herramienta que no nos guste, por ejemplo, usar Visual Studio (con C#) en lugar de Java o Python con Eclipse o cualquier otro IDE; las fechas de entrega de proyectos, las desveladas, no tener vida social, soportar personas que no nos agradan, etc..

A veces tienes que trabajar con gente que no tiene idea de lo que es la programación e ignora cual es tu trabajo, o peor  que ni el mismo tiene idea de lo que él hace ahí.  Su jefe inmediato le pide que ponga a trabajar a los de sistemas. ¿En qué? Ni él mismo lo sabe, solo hace lo que le pidieron.

En los comics de Dilbert se puede ver cada situación que viven los programadores, lo manejan de una manera muy sarcástica, pero aunque parezca exagerado no dista mucho de la realidad.

Para concluir, programamos porque necesitamos resolver problemas de la gente, por ejemplo, diseñar un programa para los cajeros automáticos, hacer que la interfaz sea lo más sencilla para el usuario final (aunque esta comprobado que eso no ayuda mucho, ya que la gente muchas veces no sabe usarlos aunque solo consista en apretar unos cuantos botones).