La guía determinante para compilar código PHP

Idealmente, vamos a usar PHP 8.0 (la última versión en el instante de redactar este producto) para todos y cada uno de los websites y lo actualizaremos tan rápido como se publique la novedosa versión. No obstante, los programadores de forma frecuente deben emplear ediciones anteriores de PHP, como en el momento en que crean complementos públicos para WordPress o utilizan código viejo que impide que se actualice el ambiente del servidor web.

En estas situaciones, tenemos la posibilidad de abandonar la promesa de usar el último código PHP. Pero hay una alternativa mejor: todavía tenemos la posibilidad de utilizar PHP 8.0 para redactar nuestro código fuente y transformarlo a la versión previo de PHP, aun PHP 7.1.

En esta guía, le enseñaremos todo cuanto precisa comprender para compilar código PHP.

¿Qué es una traducción?

La traducción transforma el código fuente de un lenguaje de programación al código fuente pertinente en exactamente el mismo lenguaje de programación o en uno diferente.

La traducción no es un término nuevo en el avance web: los programadores de clientes del servicio probablemente estén familiarizados con el compilador de código JavaScript Babel.

Babel transforma el código JavaScript de la versión actualizada de ECMAScript 2015+ a una versión previo que funciona con navegadores mucho más viejos. Ejemplo de la función de flecha de ES2015:

[2, 4, 6].map((n) => n * 2);

... Babel lo transforma a ES5:

[2, 4, 6].map(function(n) );

¿Qué traduce PHP?

Una viable novedad en el avance web es la aptitud de transformar código del lado del servidor, singularmente PHP.

La colección de PHP marcha del mismo modo que la colección de JavaScript: el código fuente de la versión actualizada de PHP se transforma al código pertinente de la versión previo de PHP.

Utilizando exactamente el mismo ejemplo que antes en PHP 7.4, use la función de flecha:

$nums = array_map(fn($n) => $n * 2, [2, 4, 6]);

... se puede transformar a la versión PHP 7.3 pertinente:

$nums = array_map(
  function ($n) ,
  [2, 4, 6]
);

Las funcionalidades de flecha se tienen la posibilidad de invertir por el hecho de que son azúcar sintáctico, esto es, una exclusiva sintaxis que crea un accionar que existe. Esta es la fruta a tu alcance.

No obstante, asimismo existen algunas peculiaridades novedosas que crean nuevos hábitos, con lo que un código afín no está libre en ediciones anteriores de PHP. Este es la situacion del género de unión introducido en PHP 8.0:

function someFunction(float|int $param): string|float|int|null

Siempre y cuando la novedosa función se utilice para el avance y no para la producción, aún se puede traducir en estas situaciones. Entonces, sencillamente tenemos la posibilidad de remover la función completamente del código recopilado sin secuelas graves.

Un caso de muestra de esto es el género de unión. Esta función se usa para revisar que el género de entrada y el valor que da no coinciden para eludir fallos. Si hablamos de un enfrentamiento de tipos, quiere decir que tuvo un fallo de avance, y debemos procurarlo y solventarlo antes que el código llegue a producción.

Entonces tenemos la posibilidad de remover esta característica del código de producción:

function someFunction($param)

Si el fallo persiste en producción, el mensaje de fallo que se da no es tan exacto como con el género de conexión. No obstante, esta viable deficiencia se solventa si se puede emplear primero el género de conexión.

En un planeta especial, deberíamos poder utilizar PHP 8.0 en todos nuestros websites y poder actualizarlo tan rápido como se lance una exclusiva versión. Eso es, pero no en todos los casos es de esta manera. Aquí hallará todo sobre la colección de código PHP 👇Realice click para twittear

Provecho de compilar código PHP

La colección deja a los individuos redactar apps con la última versión de PHP y hacer una versión que asimismo sea correcta para ámbitos con ediciones anteriores de PHP.

O sea singularmente útil para los programadores que crean sistemas de administración de contenido (CMS) heredados. Por servirnos de un ejemplo, WordPress todavía acepta de manera oficial PHP 5.6 (si bien sugiere PHP 7.4+). Porcentaje de sitios de WordPress que utilizan las ediciones de PHP 5.6 a 7.2 - todos son EOL (End of Life), lo que quiere decir que por el momento no reciben actualizaciones de seguridad - hasta un 34.8%, y esos que ejecutan ediciones PHP de PHP fuera de la versión 8.0 - 99.5% :

Por consiguiente, para una audiencia global, probablemente los temas y complementos de WordPress estén codificados con ediciones anteriores de PHP para acrecentar su cobertura potencial. Merced a la traducción, estos se tienen la posibilidad de codificar con PHP 8.0 y asimismo se lanzarán para ediciones anteriores de PHP a fin de que logren captar muchos individuos como resulte posible.

En verdad, cualquier app que necesite aceptar una versión de PHP que no sea la mucho más reciente (aun en las ediciones en la actualidad aceptadas de PHP) puede favorecerse.

Esto se aplica a Drupal, que necesita PHP 7.3 La traducción deja a los programadores hacer módulos Drupal libres públicamente con PHP 8.0 y publicarlos con PHP 7.3.

Otro ejemplo es la creación de código personalizado para clientes del servicio que por alguna razón no tienen la posibilidad de emplear PHP 8.0. Merced a la traducción, los programadores aún tienen la posibilidad de redactar los desenlaces en PHP 8.0 y ejecutarlos en estos ámbitos heredados.

¿Cuándo debería compilar PHP?

El código PHP siempre y en todo momento se puede compilar salvo que integre algunas funcionalidades PHP que no estaban libres en ediciones anteriores de PHP.

Este puede ser la situacion de los atributos introducidos en PHP 8.0:

#[SomeAttr]
function someFunc() 

#[AnotherAttr]
class SomeClass 

En el ejemplo previo del empleo de las funcionalidades de flecha, el código se puede compilar pues las funcionalidades de flecha son azúcar sintáctico. Por contra, los atributos crean patrones de accionar totalmente nuevos. Este accionar asimismo se puede replicar en PHP 7.4 y ediciones anteriores, pero solo codificado de forma manual, o sea, no automatizado por herramientas o procesos (la IA (inteligencia artificial) puede proveer una solución, pero aún no lo hicimos).

Recursos inmuebles empleados con objetivos de avance, como #[Deprecated]Exactamente la misma el tipo Union, se puede remover. No obstante, las funcionalidades que cambian la manera en que marcha una app en producción no se tienen la posibilidad de remover ni transformar de manera directa.

Hasta hoy, ningún compilador pudo emplear código con atributos PHP 8.0 y producir de forma automática el código PHP 7.4 pertinente. Por consiguiente, si su código PHP necesita la utilización de atributos, va a ser bien difícil o irrealizable traducirlos.

Funcionalidades PHP compilables

Estas son peculiaridades de PHP 7.1 y siguientes y hoy en día se tienen la posibilidad de compilar. Si su código emplea solo estas funcionalidades, puede estar seguro de que su app de traducción marcha apropiadamente. En caso contrario, debe contrastar si el código recopilado falló.

Compilador PHP

Hoy día hay una herramienta para compilar código PHP: Rector.

Rector es una herramienta de reactor de PHP que transforma código PHP según con reglas programables. Entramos el código fuente y las reglas aplicables y el rector transforma el código.

Rector trabaja por medio de la línea de comandos y se instala en el emprendimiento a través del compositor. A lo largo de la ejecución, el rector da las "diferencias" en el código antes y tras la conversión (verde añadido, colorado eliminado):

¿Exactamente en qué versión de PHP debería compilar?

A fin de que el código se transforme entre ediciones de PHP, se tienen que hacer las reglas correctas.

En la actualidad, la Biblioteca del Rector tiene dentro la mayor parte de las reglas de conversión de código en el rango de PHP 8.0 a 7.1. En consecuencia, tenemos la posibilidad de transformar de forma fiable el código PHP a la versión 7.1.

Existen algunas reglas de conversión en PHP 7.1 a 7.0 y 7.0 a 5.6, pero estas reglas no quieren ser pormenorizadas. Se están finalizando, con lo que posiblemente tengamos la posibilidad transformar el código PHP a la versión 5.6.

Traducción y backport

El backporting es afín a la traducción, pero mucho más fácil. Posiblemente el código de backporting no dependa de las novedosas funcionalidades del idioma. En su sitio, copie / pegue / personalice el código correspondiente de la novedosa versión de idioma para conseguir exactamente la misma ocupación para la versión de idioma previo.

Por servirnos de un ejemplo, una función str_contains Anunciado en PHP 8.0. Exactamente las mismas peculiaridades en PHP 7.4 y ediciones anteriores se tienen la posibilidad de llevar a cabo de forma fácil de la próxima forma:

if (!defined('PHP_VERSION_ID') || (defined('PHP_VERSION_ID') && PHP_VERSION_ID < 80000)) 

Debido a que el backporting es más fácil que la compilación, deberíamos optar por esta solución cuando el backporting complete el trabajo.

En cuanto al área entre PHP 8.0 y 7.1, podemos usar la biblioteca polyfill de Symphony:

Estas bibliotecas admiten las siguientes funciones, clases, constantes e interfaces:

Un ejemplo de PHP modificado

Veamos ejemplos de código PHP convertido y algunos paquetes que se han convertido por completo.

Código PHP

Esta match Las expresiones se introdujeron en PHP 8.0. Este código fuente:

function getFieldValue(string $fieldName): ?string

... transformado a la versión PHP 7.4 pertinente, utilice switch Operador:

function getFieldValue(string $fieldName): ?string

El operador nullsafe asimismo se ingresó en PHP En 8.0:

public function getValue(TypeResolverInterface $typeResolver): ?string

El código recopilado primero debe detallar un valor de función para la novedosa variable a fin de que la función no se ejecute un par de veces:

public function getValue(TypeResolverInterface $typeResolver): ?string

PHP 8.0 asimismo ingresó una función para fomentar las funcionalidades del constructor que dejan a los programadores redactar menos código:

class QueryResolver

La colección para PHP 7.4 crea un fragmento de código terminado:

 class QueryResolver
 

El código previo tiene dentro los atributos escritos usados en PHP 7.4. En el momento en que transforme este código a PHP 7.3, va a ser sustituido por docblocks:

 class QueryResolver
 

Bulto PHP

Las próximas bibliotecas se traducirán en producción:

Virtudes y desventajas de compilar PHP

Los resultados positivos de la colección PHP ahora se han descrito: deja que el código fuente utilice PHP 8.0 (la última versión de PHP), que se transforma a una versión inferior de PHP a fin de que la producción logre ejecutarse en apps o ámbitos heredados.

Esto nos deja transformarnos de forma eficaz en mejores programadores y hacer código de más calidad. Esto se origina por que nuestro código fuente puede utilizar las clases combinados de PHP 8.0, los atributos escritos en PHP 7.4 y los diversos tipos y pseudotipos que se añaden a cada novedosa versión de PHP (mixed Empezando con PHP 8.0, object PHP 7.2) y otras especificaciones modernas de PHP.

Estas peculiaridades nos dejan advertir mejor fallos en el desarrollo de avance y redactar código mucho más simple de leer.

Observemos en este momento las desventajas.

Debe codificarse y sostenerse

Rector El código se puede compilar de forma automática, pero el desarrollo puede necesitar una entrada manual para trabajar con nuestra configuración particular.

Las bibliotecas de otros asimismo tienen que traducirse

Si transformarlos lleva a fallos, se transforma en un inconveniente pues requerimos familiarizarnos con su código fuente para conocer las probables causas. Si el inconveniente se puede arreglar y el emprendimiento es de código abierto, debemos mandar una petición de extracción. Si la biblioteca no es de código abierto, tenemos la posibilidad de combatir óbices.

El directivo no nos avisará si el código es imposible traducir.

Si el código fuente tiene dentro atributos de PHP 8.0 u otras funcionalidades no compilables, no tenemos la posibilidad de proseguir. No obstante, el directivo no está mirando esta situación, con lo que debemos revisarla de forma manual. Es posible que esto no sea un enorme inconveniente para nuestro código fuente, como ahora lo conocemos, pero puede transformarse en una barrera para la dependencia de otros.

Los datos de corrección de fallos usan código traducido en vez de código fuente.

En el momento en que una app en producción crea un mensaje de fallo con un rastreo de pila, el número de línea señala el código recopilado. Requerimos transformar el código recopilado al código original para conseguir el número de línea pertinente en el código fuente.

El código traducido asimismo ha de estar listo

El emprendimiento que compilamos y ciertas otras bibliotecas instaladas en el ambiente de producción tienen la posibilidad de emplear exactamente las mismas dependencias de otros. Esta dependencia de otros compila nuestro emprendimiento y mantiene el código fuente original para otras bibliotecas. Por consiguiente, la versión cambiada debe ir antecedida de PHP-Scoper, Strauss u otras herramientas para eludir probables enfrentamientos.

La conversión debe celebrarse a lo largo de la integración continua (CI)

Ya que el código traducido sustituye naturalmente al código fuente, no debemos realizar el desarrollo de traducción en nuestra PC de avance, en caso contrario corremos el peligro de padecer resultados consecutivos. Es mucho más simple efectuar este desarrollo a lo largo de la operación de CI (consulte ahora para conseguir mucho más información).

De qué forma compilar PHP |

Primero requerimos disponer un rector en nuestro emprendimiento de avance:

composer require rector/rector --dev

Entonces creamos un rector.php Un fichero de configuración en el directorio raíz del emprendimiento que tiene dentro el grupo de reglas requerido. Para degradar su código de PHP 8.0 a 7.1, utilizamos la próxima configuración:

use Rector\Equipo\ValueObject\DowngradeSetList;
use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;

return static function (ContainerConfigurator $containerConfigurator): void ;

Para confirmarnos de que el desarrollo salga como se suponía, tenemos la posibilidad de utilizar el Rector process Un comando en modo seco que pasa la localización que se está procesando (en un caso así, todos y cada uno de los ficheros de la carpeta src/):

vendor/bin/rector process src --dry-run

Para llenar la traducción, efectuamos el primordial process Comando, cambia el fichero a su localización de hoy:

vendor/bin/rector process src

Nota: en el momento en que andamos rector process En nuestra PC de avance, el código fuente se transforma a la localización adecuada src/No obstante, deseamos hacer el código transformado en una localización diferente a fin de que no reemplacemos el código fuente en el momento en que el código sea degradado. Por consiguiente, es preferible efectuar el desarrollo a lo largo de la integración continua.

Optima el desarrollo de traducción

Si quiere hacer desenlaces traducidos a producción, todo cuanto debe realizar es transformar el código de producción, sencillamente puede omitir el código de avance. Esto nos deja eludir revertir todas y cada una de las pruebas (para nuestro emprendimiento y sus dependencias) y todas y cada una de las dependencias de avance.

En lo que se refiere a la prueba, ahora conocemos la localización de la prueba para nuestro emprendimiento, por poner un ejemplo, en una carpeta tests/Asimismo requerimos saber dónde se encuentran las dependencias, en sus subcarpetas, por servirnos de un ejemplo tests/, test/ con Test/ (Para distintas bibliotecas). Entonces le mencionamos al directivo que omita el procesamiento de estas carpetitas:

return static function (ContainerConfigurator $containerConfigurator): void ;

En concepto de dependencias, el compositor sabe cuáles de ellas se usan para el avance (en require-dev existir composer.json) ¿Y cuáles de ellos se usan para la producción (los que vienen require).

Para conseguir la ruta de todas y cada una de las dependencias de producción del compositor, prosiga estos pasos:

composer info --path --no-dev

Este comando crea una lista de dependencias con un nombre y una ruta como se expone ahora:

brain/cortex                     /Users/leo/GitHub/leoloso/PoP/vendor/brain/cortex
composer/installers              /Users/leo/GitHub/leoloso/PoP/vendor/composer/installers
composer/semver                  /Users/leo/GitHub/leoloso/PoP/vendor/composer/semver
guzzlehttp/guzzle                /Users/leo/GitHub/leoloso/PoP/vendor/guzzlehttp/guzzle
league/pipeline                  /Users/leo/GitHub/leoloso/PoP/vendor/league/pipeline

Tenemos la posibilidad de agarrar todos y cada uno de los caminos y colocarlos en el comando Rector, que entonces ejecuta src/ Carpetitas y aquellas que poseen todas y cada una de las dependencias de producción:

$ paths="$(composer info --path --no-dev | cut -d' ' -f2- | sed 's/ //g' | tr '\n' ' ')"
$ vendor/bin/rector process src $paths

Las actualizaciones auxiliares tienen la posibilidad de eludir que Rector maneje las dependencias que están utilizando la versión de destino de PHP. Si la biblioteca ahora está codificada con PHP 7.1 (o una de las próximas ediciones), no es requisito que la transforme a PHP 7.1.

Para realizar esto, tenemos la posibilidad de conseguir una lista de bibliotecas que PHP 7.2 y ediciones siguientes necesitan y conducir solo esas bibliotecas, y conseguimos los nombres de todas y cada una estas bibliotecas por medio de Composer. why-not Comando de la próxima forma:

composer why-not php "7.1.*" | grep -o "\S*\/\S*"

Por el hecho de que este comando no se aplica --no-dev Si solo quiere integrar dependencias de producción, primero debemos remover las dependencias de avance y hacer un autocargador, realizar los comandos y después regresar a agregarlos:

$ composer install --no-dev
$ packages=$(composer why-not php "7.1.*" | grep -o "\S*\/\S*")
$ composer install

compositor info --path La ruta al comando de búsqueda de packs es la próxima:

# Executing this command
$ composer info psr/cache --path   
# Produces this response:
psr/cache /Users/leo/GitHub/leoloso/PoP/vendor/psr/cache

Ejecutamos este comando en todos y cada uno de los elementos de la lista para conseguir todas y cada una de las sendas de traducción:

for package in $packages
do
  path=$(composer info $package --path | cut -d' ' -f2-)
  paths="$paths $path"
done

Por último, ponemos esta lista predisposición del directivo (tal como la lista de proyectos). src/ Carpeta):

vendor/bin/rector process src $paths

Escollos que se tienen que eludir al compilar código

La traducción de código puede considerarse un arte y, en la mayoría de los casos, necesita cambios concretos en el emprendimiento. Observemos varios de los inconvenientes que tenemos la posibilidad de combatir.

Las reglas de la cadena no en todos los casos se abordan

Las reglas concatenadas significan que las reglas tienen que cambiar el código desarrollado por las reglas precedentes.

Por poner un ejemplo, una biblioteca symfony/cache Pega este código:

final class CacheItem implements ItemInterface

En el momento en que PHP 7.4 se transforma a la versión 7.3, la función tag Tienen que efectuarse 2 cambios:

El resultado final habría de ser de esta manera Ver:

final class CacheItem implements ItemInterface

No obstante, el Rector solo entrega escenarios intermedios:

final class CacheItem implements ItemInterface

El inconveniente es que el directivo no en todos los casos puede supervisar el orden en que se aplican las reglas.

La solución es saber qué reglas de la cadena no se abordan y efectuar una exclusiva ejecución del primordial para aplicarlas.

Para detectar la regla de la cadena, efectuamos el rector un par de veces en el código fuente, como se expone ahora:

$ vendor/bin/rector process src
$ vendor/bin/rector process src --dry-run

La primera oportunidad que ejecutamos la traducción como se suponía, la segunda vez que empleamos --dry-run Compruebe si es requisito efectuar cambios. Si hay un comando presente, se acaba con un código de fallo y la salida "diff" señala qué reglas aún se tienen la posibilidad de utilizar. Esto quiere decir que el primer cronometraje no está terminado y ciertas reglas de la cadena no se procesan.

En el momento en que hayamos definido una regla de cadena (o regla) que no se aplica, tenemos la posibilidad de hacer otro fichero de configuración de rector, por servirnos de un ejemplo: rector-chained-rule.php Las reglas que faltan se ejecutan para todos y cada uno de los ficheros en vez de las reglas terminadas src/, En esta ocasión tenemos la posibilidad de realizar algunas reglas faltantes para algunos ficheros ajustables:

// rector-chained-rule.php
use Rector\Core\Configuration\Option;
use Rector\DowngradePhp74\Rector\ClassMethod\DowngradeSelfTypeDeclarationRector;
use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;

return static function (ContainerConfigurator $containerConfigurator): void ;

Al final, le señalamos al rector que use el nuevo fichero de configuración accediendo por segunda vez --config:

# First pass with all modifications
$ vendor/bin/rector process src

# Second pass to fix a specific problem
$ vendor/bin/rector process --config=rector-chained-rule.php

Las dependencias de Composer tienen la posibilidad de ser inconsistentes

La biblioteca puede declarar dependencia del avance (p. Ej. require-dev existir composer.json), pero aún mencionan a ciertos códigos de producción (p. ej. src/, No tests/).

En la mayoría de los casos, esto no es un inconveniente por el hecho de que posiblemente el código no se cargue en producción, con lo que jamás va a haber fallos en la app. No obstante, en el momento en que el rector maneja el código fuente y sus dependencias, corrobora que se logre cargar todo el código referenciado. Si el fichero se refiere al código de una biblioteca eliminada, el Rector da un fallo (por el hecho de que se comunica solo para avance).

Por poner un ejemplo, una categoría EarlyExpirationHandler El ingrediente de caché de Symphony incorpora el diseño de usuario. MessageHandlerInterface Desde el ingrediente remitente:

class EarlyExpirationHandler implements MessageHandlerInterface

No obstante, symfony/cache opinión symfony/messenger Conviértase en una dependencia del avance en el momento en que el directivo está corriendo un emprendimiento ligado symfony/cache, Fallo al mandar:

[ERROR] Could not process "vendor/symfony/cache/Messenger/EarlyExpirationHandler.php" archivo, due to:             
  "Analyze fallo: "Class Symfony\Component\Messenger\Handler\MessageHandlerInterface not found.". Include your archivos in "$parameters->equipo(Option::AUTOLOAD_PATHS, [...]);" in "rector.php" config.
  See https://github.com/rectorphp/rector#configuration".   

Hay tres resoluciones a este inconveniente:

1. En la configuración de Rector, ignore el manejo de ficheros que se refieren a esta una parte del código:

return static function (ContainerConfigurator $containerConfigurator): void ;

2. Descargue la biblioteca que falta y añada su ruta a fin de que el rector se cargue de manera automática:

return static function (ContainerConfigurator $containerConfigurator): void ;

3. Realice que el emprendimiento dependa de la biblioteca de producción que falta:

composer require symfony/messenger

Traducción y también integración continua

Como se mentó previamente, requerimos emplear nuestra PC de avance --dry-run Marque en el momento en que ejecute el rector; en caso contrario, el código fuente va a ser sustituido por el código recopilado. Por consiguiente, es preferible dejar que el desarrollo de traducción real se ejecute a lo largo de la integración continua (CI) a fin de que tengamos la posibilidad comenzar un corredor temporal para realizar el desarrollo.

El instante perfecto para el desarrollo de traducción es hacer una versión para nuestro emprendimiento. Por poner un ejemplo, el próximo código es un fluído de trabajo de acciones de GitHub que crea un complemento de WordPress:

name: Generate Installable Complemento and Upload as Release Asset
on:
  release:
    types: [published]
jobs:
  build:
    name: Build, Downgrade and Upload Release
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        emplees: actions/[email protected]
      - name: Downgrade code for production (to PHP 7.1)
        run: |
          composer install
          vendor/bin/rector process
          sed -i 's/Requires PHP: 7.4/Requires PHP: 7.1/' graphql-api.php
      - name: Build project for production
        run: |
          composer install --no-dev --optimize-autoloader
          mkdir build
      - name: Create artifact
        emplees: montudor/[email protected]
        with:
          args: zip -X -r build/graphql-api.zip . -x *.git* node_modules/\* .* "*/\.*" CODE_OF_CONDUCT.md CONTRIBUTING.md ISSUE_TEMPLATE.md PULL_REQUEST_TEMPLATE.md rector.php *.dist composer.* dev-helpers** build**
      - name: Upload artifact
        emplees: actions/[email protected]
        with:
            name: graphql-api
            path: build/graphql-api.zip
      - name: Upload to release
        emplees: JasonEtco/[email protected]
        with:
          args: build/graphql-api.zip application/zip
        env:
          GITHUB_TOKEN: $

Este fluído de trabajo incluye métodos estándar para difundir complementos de WordPress por medio de la utilidad de GitHub. La novedosa operación que transforma el código de extensión de PHP 7.4 a 7.1 es la próxima:

      - name: Downgrade code for production (to PHP 7.1)
        run: |
          vendor/bin/rector process
          sed -i 's/Requires PHP: 7.4/Requires PHP: 7.1/' graphql-api.php

Resumiendo, este fluído de trabajo en este momento efectúa los próximos pasos:

1. Vea el código fuente del complemento de WordPress de un fichero escrito en PHP 7.4
2. Disponer sus dependencias de compositor
3. Transforme su código de PHP 7.4 a 7.1
4. Cambie el título del fichero profesor del complemento a "Necesita PHP" "7.4" llegar "7.1"
5. Suprime todas y cada una de las dependencias primordiales para el avance.
6. Crea un fichero zip desde la extensión sin ficheros insignificantes
7. Descargue el fichero .zip como una función de publicación (asimismo como artefactos de GitHub)

Prueba el código transformado

¿De qué manera entendemos que el código marcha bien tras transformarlo a PHP 7.1? En otras expresiones, ¿de qué manera entendemos que se ha cambiado completamente sin los restos de la versión superior del código PHP?

De la misma con la colección del código, tenemos la posibilidad de llevar a cabo la solución en el desarrollo de CI. La iniciativa es utilizar PHP 7.1 para modificar el ambiente del corredor y realizar el linter con el código cambiado. Si el segmento de código no funciona con PHP 7.1 (por poner un ejemplo, atributos no editados escritos en PHP 7.4), la ortografía va a dar un fallo.

Una ortografía correcta para PHP es PHP Parallel Lint. Tenemos la posibilidad de disponer esta biblioteca como una dependencia de avance en un emprendimiento o dejar que el desarrollo de CI la instale como un emprendimiento de redacción sin dependencia:

composer create-project php-parallel-lint/php-parallel-lint

Siempre y cuando el código incluye PHP 7.2 y posterior, PHP Parallel Lint da el próximo fallo:

Run php-parallel-lint/parallel-lint layers/ vendor/ --exclude vendor/symfony/polyfill-ctype/bootstrap80.php --exclude vendor/symfony/polyfill-intl-grapheme/bootstrap80.php --exclude vendor/symfony/polyfill-intl-idn/bootstrap80.php --exclude vendor/symfony/polyfill-intl-normalizer/bootstrap80.php --exclude vendor/symfony/polyfill-mbstring/bootstrap80.php
PHP 7.1.33 | 10 parallel jobs
............................................................   60/2870 (2 %)
............................................................  120/2870 (4 %)
...
............................................................  660/2870 (22 %)
.............X..............................................  720/2870 (25 %)
............................................................  780/2870 (27 %)
...
............................................................ 2820/2870 (98 %)
..................................................           2870/2870 (100 %)


Checked 2870 archivos in 15.4 seconds
Syntax fallo found in 1 archivo

------------------------------------------------------------
Parse fallo: layers/GraphQLAPIForWP/plugins/graphql-api-for-wp/graphql-api.php:55
    53|     '0.8.0',
    54|     \__('GraphQL API for WordPress', 'graphql-api'),
  > 55| )))  
Unexpected ')' in layers/GraphQLAPIForWP/plugins/graphql-api-for-wp/graphql-api.php on-line 55
Fallo: Process completed with exit code 1.

Añada un conector al fluído de trabajo de CI. Los pasos para realizar y evaluar el código de PHP 8.0 a 7.1 son:

1. Enseñar código fuente
2. Deje que el ambiente ejecute PHP 8.0 a fin de que el rector logre interpretar el código fuente
3. Transformar código en PHP 7.1
4. Instale la herramienta de artículo PHP
5. Cambiar el ambiente a PHP versión 7.1
6. Ejecute Linter con código recopilado

Este fluído de trabajo de acción de GitHub completa el trabajo:

name: Downgrade PHP tests
jobs:
  main:
    name: Downgrade code to PHP 7.1 vía Rector, and execute tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        emplees: actions/[email protected]

      - name: Equipo-up PHP
        emplees: shivammathur/[email protected]
        with:
          php-version: 8.0
          coverage: none

      - name: Local packages - Downgrade PHP code vía Rector
        run: |
          composer install
          vendor/bin/rector process

      # Prepare for testing on PHP 7.1
      - name: Install PHP Parallel Lint
        run: composer create-project php-parallel-lint/php-parallel-lint --ansi

      - name: Switch to PHP 7.1
        emplees: shivammathur/[email protected]
        with:
          php-version: 7.1
          coverage: none

      # Lint the transpiled code
      - name: Run PHP Parallel Lint on PHP 7.1
        run: php-parallel-lint/parallel-lint src/ vendor/ --exclude vendor/symfony/polyfill-ctype/bootstrap80.php --exclude vendor/symfony/polyfill-intl-grapheme/bootstrap80.php --exclude vendor/symfony/polyfill-intl-idn/bootstrap80.php --exclude vendor/symfony/polyfill-intl-normalizer/bootstrap80.php --exclude vendor/symfony/polyfill-mbstring/bootstrap80.php

Tenga presente que múltiples bootstrap80.php Los ficheros de la biblioteca Symfony Polyfill (no se necesita traducción) tienen que excluirse del linter. Estos ficheros poseen PHP 8.0, con lo que Linter lanza fallos al procesarlos. No obstante, es seguro excluir estos ficheros por el hecho de que unicamente se cargan en producción en el momento en que se emplea PHP 8.0 o posterior:

if (\PHP_VERSION_ID >= 80000) 

Así sea que esté creando un complemento público de WordPress o mejorando un código viejo, existen muchas causas por las que posiblemente no logre utilizar la última versión de PHP 👩‍💻 Aprenda de qué manera la traducción puede asistir con esta guía 👇Realice click para twittear

Generalizar

Este producto nos enseña de qué manera compilar nuestro código PHP, dejarnos utilizar PHP 8.0 en el código fuente y hacer una versión correcta para PHP 7.1. La traducción se efectúa a través del Rector de PHP Reactoration Tool.

Compilar código nos transforma en mejores programadores por el hecho de que tenemos la posibilidad de detectar mejor las fallas de avance y hacer código que, como es natural, es mucho más simple de leer y entender.

La traducción asimismo nos deja dividir el código con requisitos concretos de PHP de un sistema de administración de contenido. Si deseamos emplear la última versión de PHP para hacer complementos de WordPress o módulos de Drupal libres públicamente sin limitar seriamente nuestra base de individuos, tenemos la posibilidad de llevarlo a cabo en este momento.

¿Tiene alguna pregunta sobre la colección de PHP? ¡Deja tu comentario en la sección de opiniones!