DEV Community: Mauro Chojrin

Por qué programar en Spanglish es una mala idea

Mauro Chojrin — Mon, 25 Oct 2021 18:01:17 +0000

Es muy común, cuando uno está dando los primeros pasos en programación, la adopción de malas prácticas. En este sentido los desarrolladores de habla hispana tenemos una ligera desventaja respecto de nuestros colegas angloparlantes: para ellos palabras como if, for o while tienen sentido por sí mismas. A nostoros en cambio nos requiere un esfuerzo… Seguir leyendo Por qué programar en Spanglish es una mala idea

La entrada Por qué programar en Spanglish es una mala idea se publicó primero en Leeway Academy.

Functional Programming in PHP: What, Why, and How

Mauro Chojrin — Thu, 21 Oct 2021 17:59:12 +0000

If you’ve been around software development for a while, you have probably heard about functional programming. You’re probably wondering whether it is as interesting as people say and if you should go through the effort of learning about it.

Let’s explore what functional programming (FP) is, why you should master it, and how to apply all of these concepts without leaving your language of choice: PHP.

What Is Functional Programming?

Functional programming is a paradigm (a way of thinking about solving a problem and structuring programs). Usually, when people think of programming, they think about the most common paradigm: imperative programming.

In imperative programming, your job is to answer the question of how to solve a problem. You produce a set of instructions to tell a computer what it should do (and in what order) to create a specific output given an input.

We’re not telling you anything you didn’t already know, right? (Other than putting a name to something you’ve been doing your entire life). Bear with us for a minute.

Functional programming's basis is the principle of declarative programming, where your job is no longer to define the how but what and let the computer fill the gaps.

It sounds like magic, doesn’t it? Well, I bet you’re already using some of it. Think SQL.

When you write SELECT * FROM users, you’re not telling the database engine how to get the user information from the disk, build the record set, and more. You’re simply stating your wishes out loud and letting the genie do its work.

Functional programming is a similar idea.

In imperative programming, a function is another name, a routine (a chunk of code you can call any time without re-writing it repeatedly). In functional programming, a function is more closely related to the mathematical concept, as in mapping. This concept creates a more abstract view where the actual mapping computation for a particular input is a secondary concern.

Let’s look at a simple example. Say you have an array of N elements, and you want to find the biggest. Using imperative programming, you’d express the solution somewhat like:

Function GetMaxValue(a): 

Max = a[0] 

For i = 1 to len(a): 
  If a[i] > max: 
    max = a[i] 

Return max

In FP, you’d write the solution like:

Function GetMaxValue(a): 

If len(a) == 1: 
  return a[0] 
Else: 
  return max(a[0], GetMaxValue(a[1..len(a)]))

Of course, this on its own doesn’t constitute a whole paradigm. One feature of every functional language is that functions are first-class values. The distinction between function and variable is somewhat blurry.

You can think about functions like a particular data type that happens to be callable. In that sense, there’d be nothing weird about an assignment such as F = GetMaxValue (note the difference between this assignment and F = GetMaxValue([1, 2, 3])).

Also, since a function is nothing but a datatype, nothing prevents you from returning a function from a function or receiving one as a parameter. That’s where it gets interesting.

However, before going deeper, we need to address an important question: why should you care?

Why You Should Learn About Functional Programming

FP creates code that is easier to read, maintain, re-use, and test. It also allows for elegant meta-programming, as you’ll see in the examples below.

Now, let’s jump into the nitty-gritty of PHP implementation.

How to Use Functional Programming in PHP

While PHP is not a functional language, it enables you to take advantage of many exciting functional features. PHP uses tools to implement FP: the callable type and the Closure Class.

Let’s examine some simple examples to see those tools in action.

Say you have an array of Person objects with a method getAge(), and you want to create a list of Persons ordered by age. Using non-functional programming, your code looks somewhat like:

<?php 

class Person 
{ 
  private int $age; 

  public function __construct() 
  {
     $this->age = rand(5, 50); 
  } 

  public function getAge(): int 
  {
    return $this->age;
  } 

  public function isOlderThan(Person $otherPerson): bool 
  { 
     return $this->getAge() > $otherPerson->getAge(); 
  }
}

$persons = []; 

for ( $i = 0; $i < 5; $i++ ) {
  $persons[] = new Person();     
} 

echo "Before: ".PHP_EOL; 
print_r($persons); 

for ( $i = 0; $i < count($persons); $i++ ) { 
  for ($j = 0; $j < count($persons) - 1; $j++ ) { 
    if ($persons[$j]->isOlderThan($persons[$j + 1]) { 
      $aux = $persons[$j + 1]; 
      $persons[$j + 1] = $persons[$j]; 
      $persons[$j] = $aux; 
    } 
  } 
} 

echo "After:".PHP_EOL; 
print_r($persons); 
echo "After:".PHP_EOL; 
print_r($persons);

This code works just fine, but since usort enables you to sort an array based on any criteria you want, wouldn’t it be better to use it? See how the new version looks:

<?php 
class Person 
{
  private int $age; 

  public function __construct() 
  {
    $this->age = rand(5, 50); 
  } 

  public function getAge(): int 
  {
    return $this->age; 
  } 

  public function isOlderThan(Person $otherPerson): bool 
  {
    return $this->getAge() > $otherPerson->getAge(); 
  } 
} 

$persons = []; 

for ( $i = 0; $i < 5; $i++ ) { 
  $persons[] = new Person();
}

echo "Before: ".PHP_EOL; 
print_r($persons);
usort($persons, 'personOrder'); 

echo "After:".PHP_EOL; 
print_r($persons); 

echo "After:".PHP_EOL; 
print_r($persons);

You may wonder what that personOrder is that suddenly appeared. It is a good, old function defined like this:

function personOrder(Person $p1, Person $p2) 
{ 
    if ($p1->getAge() === $p2->getAge()) { 
        return 0; 
    } elseif ($p1->getAge() > $p2->getAge()) { 
        return 1; 
    } else { 
        return -1; 
    }
}

As you can see, the order criteria are entirely isolated from the looping code, making it easy to change if needed (for instance, if you must present the list in descending order). In this case, the string 'personOrder' constitutes the callable, which passes to the usort function.

Another common use of this kind of construct is creating a new array based on a given function’s sequential application to every element in an array, like this:

$ages = []; 

for ($i = 0; $i < count($persons); $i++ ) {
  $ages[] = $persons[$i]->getAge(); 
}

echo "Ages: ".PHP_EOL; 
print_r($ages);

This can translate into:

echo "Ages: ".PHP_EOL; 

print_r(array_map( 
    function(Person $p) { 
        return $p->getAge(); 
    }, 
    $persons 
));

This example introduces two new concepts.

The function array_map, which takes a function as an argument and returns the result of applying it as a second parameter to every element in the array (this is called a higher-order function)
The definition of an anonymous function (a closure).

Think about this inline function definition as similar to using a literal value (string, int, float, or others) instead of a variable. It is handy if you’re using it one time. Otherwise, it can backfire.

The last general example is about getting some elements out of an array, also known as filtering.

For filtering, PHP offers you the function array_filter, which takes a function as an argument. The code evaluates this function for each element of the array. Those functions evaluating to true will be present in the resulting collection.

Let’s see how we’d go about getting a list of every person above 18 years old:

echo "Over 18: ".PHP_EOL; 

print_r(array_filter($persons,  
    function(Person $p) { 
        return $p->getAge() > 18; 
    } 
));

Now let’s say you don’t want to hardcode the age threshold but receive it via a command-line interface (CLI) parameter.

To bring that context information into your anonymous function, you use the keyword use, like this:

$threshold = $argv[1]; 

echo "Over $threshold: ".PHP_EOL; 

print_r(array_filter($persons,  
    function(Person $p) use ($threshold) { 
        return $p->getAge() > $threshold; 
    } 
));

By now, you’re probably thinking that this is a little too much work just to save yourself from writing a couple of foreach here and there, right? Well, of course, this is just the tip of the iceberg. You can do much more using FP.

Consider the following code, for example:

<?php 

function f(Closure $g, int $p1): Closure 
{
   return function($p2) use ($g, $p1) { 
     return $g($p1, $p2); 
   }; 
}

echo f(function(int $arg1, int $arg2) { 
    return $arg1 + $arg2; 
    }, 3)(5);

This code looks strange, right? When would you possibly need something like this?

Let's examine a couple of real-life examples using these structures.

Real-Life Functional Programming in PHP Examples

Generic Cache Mechanism Based on Callbacks

Consider a company producing and maintaining a social network for amateur travelers. At one point, they discovered some website pages were taking way too much time to render since someone had created them using many heavy SQL queries.

The developers came up with an idea to cache parts of these pages and stored this pre-generated content in in-memory key-value storage. They implemented this by creating a class responsible for serving the cached content if available or producing it otherwise.

To achieve this goal, the developers wrote a method within that class that looked somewhat like this:

function getCachedContent(string $key, Closure $generationFunction, array $generationParams): $string 
{ 
  if ( !$this->isContentAvailable($key) ) {
    $this->store($key, 
      call_user_func_array($generationFunction, 
      $generationParams)); 
  } 

  return $this->get($key); 
}

Note: the actual code is a little more complex due to some infrastructure concerns beyond the purpose of this post. It’s a little rusty, but you can still check it out on GitHub.

The whole idea here is that the developers completely separated the cache management code from the code to produce the cached contents by using a few FP tricks. Note how the getCachedContent() method has no clue whatsoever about the function it will eventually call nor its parameters.

Lazy Dependency Injection Container

A different project had a peculiarity: several helper classes performed a wide array of tasks. This project needed these helpers in all sorts of combinations depending on the actual request served. Since there were many simultaneous users, if the developers were not careful with memory and CPU use, the situation could deteriorate quite fast.

The project had a little dependency injection container (a simple class to store all these helpers and access them as needed). The problem is, on every request, the developers had to create all the helpers’ instances instead of just those to produce the response.

The solution is to switch from a structure such as:

$depContainer = new DependencyInjectionContainer(); 
$depContainer->addDependency(new HelperClass());

To:

$depContainer = new DependencyInjectionContainer(); 

$depContainar->addDependencyFactory(HelperClass::class, function() { 

    return new HelperClass(); 

});

This way, the code only creates helpers when actually needed. It’s the container’s job to check if the object is available and, if not, call the appropriate factory function and return the newly-created instance.

This method results in much more efficient memory use and reduced time to render a page since the code does not execute constructors for unused classes.

Go Functional!

In this article, you learned (a little) what functional programming is all about, why you should pay attention to it, and how to implement it using PHP. Granted, it’s not easy, but the benefits are palpable after you get past the initial friction.

To go deeper into understanding functional programming concepts, read about currying, partial application, and pure functions. For specific ways to practice functional programming within PHP, check out this Functional PHP book and this library.

Cómo validar que un correo existe usando PHP

Mauro Chojrin — Tue, 10 Aug 2021 12:32:00 +0000

Seguramente alguna vez te habrás topado con la necesidad de registrar correos electrónicos de los visitantes de tu sitio, ¿cierto? Usualmente esto se hace para mantenerlos al tanto de las novedades. Claro que, aunque vos tengas las mejores intenciones, es entendible que la gente sea un poco escéptica con tanto spammer dando vueltas, por lo […]

La entrada Cómo validar que un correo existe usando PHP se publicó primero en Leeway Academy.

Cómo compartir con otras personas tu proyecto PHP ya terminado

Mauro Chojrin — Thu, 03 Jun 2021 17:26:00 +0000

Listo. Terminado. Finito. Ah… qué placer, ¿no? Después de horas frente a la pantalla, incontables tazas de café y miles de bugs resueltos, por fin llegará el merecido descanso… sólo falta hacer la demo para el cliente. Es que si no se hace el cliente no podrá dar su visto bueno y sin él… difícil […]

La entrada Cómo compartir con otras personas tu proyecto PHP ya terminado se publicó primero en Leeway Academy.

Guía para solucionar problemas de DataTables con Ajax y PHP

Mauro Chojrin — Mon, 10 May 2021 15:17:00 +0000

Usá DataTables te dijeron. «Es el mejor plugin que vas a encontrar para mostrar datos en forma resumida» «Es súper fácil de usar» Si… claro. Armar la tabla no es muy complicado, es cierto, pero cuando le empezabas a encontrar el gustito… las cosas se complicaron. ¿Y ahora? ¿¿Qué pasa que no se cargan los […]

La entrada Guía para solucionar problemas de DataTables con Ajax y PHP se publicó primero en Leeway Academy.

Cuál es la mejor librería para hacer PDF desde PHP

Mauro Chojrin — Wed, 05 May 2021 13:39:30 +0000

Si desarrollás aplicativos para empresas apuesto que te habrás topado con la necesidad de emitir reportes en PDF, ¿cierto? Un caso típico es el de generar facturas. De por sí es un tema integrarte con los webservices del fisco (Léase AFIP, SUNAT, DGI, DIAN, etc…) y cuando pensaste que todo era cuesta abajo a partir […]

La entrada Cuál es la mejor librería para hacer PDF desde PHP se publicó primero en Leeway Academy.

Administrando proyectos PHP con Composer

Mauro Chojrin — Wed, 21 Apr 2021 20:40:07 +0000

Leer o escribir planillas de Excel, incorporar alguna pasarela de pago, autenticación vía redes sociales, etc... son necesidades muy comunes en las aplicaciones web modernas.

Si bien en teoría podrías desarrollar tus propios códigos para solventar estas necesidades, es claro que perderías tiempo muy valioso haciéndolo, en lugar de concentrarte en lo que realmente importa: resolver los problemas del negocio.

Por ello, lo más común es valerse de código que otros hayan desarrollado para tí.

En el caso de PHP, existen diversas formas de incorporar código de terceros a tus proyectos.

El manejo de librerías de terceros en proyectos PHP

Históricamente esto se realizaba simplemente descargando algún archivo comprimido y depositándolo en algún directorio que pareciera cómodo.

Un tiempo más tarde apareció en escena PEAR y todo mejoró bastante, sin embargo, todavía existían problemas derivados de la incompatibilidad entre versiones de diferentes librerías y lograr una aplicación de cierta envergadura se tornaba algo bastante complicado.

Uno de los grandes problemas que presentaba el manejo de dependencias a través de PEAR era la dificultad de replicar los cambios realizados en forma local en otros ambientes (pruebas, producción, etc…).

Todo eso cambió a partir de la aparición de composer.

Composer al rescate

Composer fue realmente un game-changer para los que desarrollamos utilizando php.

Se trata de una herramienta de muy alto nivel que administra las dependencias de nuestros proyectos de un modo sumamente cómodo.

El principal cambio que introduce composer es la incorporación de las dependencias al propio código del proyecto.

Esto hace muy sencilla la igualación de ambientes ya que todo lo que se necesita para ejecutar una determinada aplicación está presente en un archivo (Que puede/debe ser subido al controlador de versiones junto con el resto del proyecto).

El formato elegido para la configuración de composer es json, un formato simple de escribir y leer para humanos.

Composer define una serie de claves que pueden utilizarse para declarar qué paquetes de terceros deben ser instalados para que nuestra aplicación pueda funcionar.

Este es un ejemplo de archivo composer.json de uno de mis proyectos:

{
    "name": "leewayweb/followapp",
    "license": "proprietary",
    "type": "project",
    "minimum-stability": "stable",
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        },
        "psr-0": {
            "": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "App\\Tests\\": "tests/"
        }
    },
    "require": {
        "php": "^7.3",
        "ext-ctype": "*",
        "ext-iconv": "*",
        "abdielcs/expanded-collection-bundle": "^0.1.0",
        "doctrine/doctrine-bundle": "^2.0",
        "doctrine/doctrine-cache-bundle": "^1.2",
        "doctrine/doctrine-migrations-bundle": "^2.0",
        "doctrine/orm": "^2.7",
        "fabpot/goutte": "^3.2",
        "knplabs/knp-menu-bundle": "^3.0",
        "nelexa/zip": "^3.3",
        "phpoffice/phpspreadsheet": "^1.10",
        "scheb/yahoo-finance-api": "^3.1",
        "sensio/framework-extra-bundle": "^5.0",
        "sunra/php-simple-html-dom-parser": "^1.5",
        "symfony/asset": "4.4.*",
        "symfony/console": "*",
        "symfony/dotenv": "*",
        "symfony/flex": "^1.5",
        "symfony/form": "4.4.*",
        "symfony/framework-bundle": "*",
        "symfony/http-client": "4.4.*",
        "symfony/monolog-bundle": "^3.5",
        "symfony/orm-pack": "^1.0",
        "symfony/polyfill-apcu": "^1.0",
        "symfony/security-bundle": "4.4.*",
        "symfony/swiftmailer-bundle": "^3.4",
        "symfony/translation": "4.4.*",
        "symfony/twig-pack": "^1.0",
        "symfony/validator": "4.4.*",
        "symfony/web-server-bundle": "4.4.*",
        "symfony/yaml": "*",
        "twbs/bootstrap": "^4.3"
    },
    "require-dev": {
        "dama/doctrine-test-bundle": "^6.3",
        "doctrine/doctrine-fixtures-bundle": "^3.3",
        "easycorp/easy-deploy-bundle": "^1.0",
        "fzaninotto/faker": "^1.9",
        "symfony/maker-bundle": "^1.14",
        "symfony/phpunit-bridge": "^4.0",
        "symfony/profiler-pack": "^1.0",
        "vimeo/psalm": "^3.7"
    },
    "config": {
        "preferred-install": {
            "*": "dist"
        },
        "sort-packages": true
    },
    "scripts": {
        "auto-scripts": {
            "cache:clear": "symfony-cmd",
            "assets:install %PUBLIC_DIR%": "symfony-cmd"
        },
        "post-install-cmd": [
            "@auto-scripts"
        ],
        "post-update-cmd": [
            "@auto-scripts"
        ]
    },
    "conflict": {
        "symfony/symfony": "*"
    },
    "extra": {
        "symfony": {
            "allow-contrib": false,
            "require": "4.4.*"
        }
    }
}

Puede parecer un poco complejo a primera vista, ¿cierto? Pues no te dejes intimidar :)

Este proyecto está basado en el framework Symfony, con lo cual muchas de sus dependencias y configuraciones le dan soporte a esta herramienta.

De todo lo que se ve, la clave más importante es require, en ella se declaran todas las librerías de terceros que serán necesarias para correr la aplicación sin problemas.

En este ejemplo vemos que la primera es "php": "^7.3", esto significa que para que la aplicación pueda ejecutarse el servidor debe contar con un intérprete de php en versión, al menos, 7.3.

Posteriormente vemos "ext-ctype": "*" y "ext-iconv": "*", lo que indica que, además de la versión de php, se requieren estas extensiones instaladas.

Hasta aquí vemos las dependencias duras, aquellas que, si no se satisfacen, harán que composer arroje un error al intentar instalar/configurar la aplicación.

Las siguientes dependencias siguen el patrón vendor/package, esto permite inferir que se trata de paquetes escritos en php.

Lo que se ve a la derecha de la definición de las dependencias es una restricción de versión, una de las partes más interesantes y complejas de composer, por ahora sólo digamos que a través de estas expresiones podemos evitar conflictos entre las diferentes dependencias.

El segundo archivo importante que trae consigo composer es composer.lock.

Este archivo también tiene formato json, sin embargo no está pensado para ser editado manualmente.

Su objetivo es congelar las versiones que se utilizarán efectivamente para evitar esos problemas tipo “en mi casa andaba”.

¿Por qué no alcanza con el archivo composer.json?

Precisamente por la existencia de expresiones de versiones.

Por ejemplo, en el archivo .json encontraremos cosas como "symfony/console": "*" (Usar cualquier versión del componente symfony/console) y en el archivo .lock veremos:

{
            "name": "symfony/console",
            "version": "v4.4.8",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/console.git",
                "reference": "10bb3ee3c97308869d53b3e3d03f6ac23ff985f7"
            },
}

Es decir una referencia resuelta: un número de versión específico que será utilizado en nuestro proyecto.

Ambos archivos deben ser incorporados al controlador de versiones que utilicemos.

Veamos algunos ejemplos prácticos

Cómo instalar composer

Lo primero que debemos hacer para utilizar composer es instalar la utilidad de línea de comandos.

La mejor forma de hacerlo es seguir las instrucciones del sitio getcomposer.org.

Al día de hoy sería:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('sha384', 'composer-setup.php') === '756890a4488ce9024fc62c56153228907f1545c228516cbf63f885e036d37e9a59d27d63f46af1d4d07ee0f76181c7d3') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Para verificar que todo ha salida correctamente puedes correr:

php composer.phar --version

Y deberías ver algo como:

Composer version 2.0.11 2021-02-24 14:57:23

Cómo crear un nuevo proyecto usando composer

Si bien es posible escribir directamente en el archivo composer.json, lo más recomendable es utilizar la herramienta que acabas de descargar.

Para crear un nuevo proyecto puedes utilizar este comando:

php composer.phar init

El cual te irá realizando una serie de preguntas y, en base a tus respuestas, generará el archivo apropiado.

Una pregunta muy importante es esta:

Would you like to define your dependencies (require) interactively [yes]?

En general te recomiendo responder que sí, de esta forma podrás incorporar las librerías que utilizarás de una forma muy cómoda.

No te preocupes si aún no las conoces todas, incorporarlas posteriormente será muy sencillo también.

Cuando te pida Search for a package: ingresa leewayweb/ci_php y luego dale enter hasta el final.

Muy importante contestar sí a la pregunta Would you like to install dependencies now [yes]?

Al hacerlo verás cómo composer descarga todo lo necesario para que puedas empezar a desarrollar tu proyecto.

Al cabo de un momentito deberías ver algo como:

Y si pides el listado de archivos de tu directorio encontrarás:

Se han creado los archivos composer.json, composer.lock y, muy importante, el directorio vendor.

En ese directorio se encontrarán todas las librerías que vayas a utilizar junto con un archivo de configuración de la función de carga automática (autoload), el cual deberás incluir en tu proyecto.

Cómo utilizar librerías administradas por composer

Lo primero que debes hacer al comenzar un nuevo archivo en el que vayas a requerir usar alguna librería instalada vía composer es:

<?php

require_once 'vendor/autoload.php';

Y luego podrás usar las clases definidas en tus librerías.

En nuestro caso quedaría así:

<?php

require_once 'vendor/autoload.php';

use Leewayweb\CiValidator\CiValidator;

$validator = new CiValidator();

if ($validator->validate_ci($argv[1])) {
        echo 'Valid CI!';
} else {
        echo 'Invalid CI!';
}

echo PHP_EOL;

Este es un ejemplo de un script que permite validar cédulas de identidad uruguayas pero del mismo modo puedes usar cualquier librería.

Cómo incorporar nuevas librerías

Para incorporar nuevas librerías tienes dos opciones:

Agregar manualmente una entrada en la clave require del archivo composer.json y ejecutar el comando composer install
Ejecutar el comando composer require y seguir las instrucciones

Supongo que a esta altura imaginarás cuál te recomendaré :)

Qué otras operaciones pueden hacerse con composer

A través de composer es sumamente simple:

Eliminar dependencias
Actualizar versiones de dependencias
Verificar qué librerías requieren actualizaciones
Comprender por qué una determinada dependencia no puede ser instalada
Crear tus propios comandos para ser ejecutados luego de actualizar dependencias

Entre otras que puedes conocer leyendo la documentación oficial.

De dónde salen los paquetes de Composer

Supongo que para este momento te estarás preguntando de dónde sale toda esta magia.

La respuesta es el sitio packagist.org.

Se trata de un enorme repositorio de paquetes instalables vía composer disponibles en forma pública.

Incluso puedes publicar tus propios paquetes ahí y contribuir a la comunidad :)

De aquí en adelante

Bueno, ahora que has conocido composer espero te haya gustado tanto como a mí y te ayude a ahorrar tiempo y dolores de cabeza.

Si te ha quedado alguna duda o comentario te invito a que lo dejes por aquí o me contactes a través de mis redes sociales.

¿Es cierto que PHP está muerto?

Mauro Chojrin — Tue, 09 Mar 2021 12:30:22 +0000

Leo por ahí cosas como: «He vuelto a estudiar PHP porque quiero aprender bien a programar con él y no entiendo por qué siempre se termina hablando sobre si PHP está o no muerto, personalmente lo veo muy vivo pero cuando veo tanto vídeo de ese estilo dudo un poco en seguir estudiando PHP« «No […]

La entrada ¿Es cierto que PHP está muerto? se publicó primero en Leeway Academy.

¿Cuál es la diferencia entre PDO y MySQLi?

Mauro Chojrin — Wed, 17 Feb 2021 18:46:00 +0000

Si me decís que estás desarrollando una aplicación web usando PHP y no me das más datos, cerrando los ojos diría que estás usando una base de datos MySQL y, seguro que en el 80% de los casos acertaría. Es un hecho: PHP y MySQL son un dúo muy común en este mundillo. Lo que […]

La entrada ¿Cuál es la diferencia entre PDO y MySQLi? se publicó primero en Leeway Academy.

¿Qué son las extensiones de PHP?

Mauro Chojrin — Tue, 16 Feb 2021 18:45:52 +0000

Quién no se cruzó con mensajes como: Debes tener instalada/habilitada la extension en PHP sobre GD Pero… ¿qué es exactamente una extensión de PHP? Para comprenderlo debes conocer un poco cómo funciona PHP internamente. A continuación te daré una visión algo simplificada, si quieres una explicación completa y detallada te recomiendo este excelente tutorial de […]

La entrada ¿Qué son las extensiones de PHP? se publicó primero en Leeway Academy.

¿Qué tan «globales» son las variables globales en PHP?

Mauro Chojrin — Thu, 31 Dec 2020 14:27:00 +0000

Parece una pregunta rara, ¿no? Seguro estás pensando «¿Dónde está la trampa?», ¿cierto? En general se entiende que una variable global es aquella que está presente (es decir, puede ser leída y modificada) en cualquier lugar de un programa. El caso de PHP es algo particular. Para comenzar si hicieras algo como esto: Esperarías ver: […]

La entrada ¿Qué tan «globales» son las variables globales en PHP? se publicó primero en Leeway Academy.