PHP Parser

Analizador PHP

Este es un analizador PHP escrito en PHP. Su propósito es simplificar el análisis y la manipulación del código estático.

Documentación para la versión 5.x (actual; para ejecutar en PHP >= 7.4; para analizar PHP 7.0 a PHP 8.4, con soporte limitado para analizar PHP 5.x).

Documentación para la versión 4.x (compatible; para ejecutar en PHP >= 7.0; para analizar PHP 5.2 a PHP 8.3).

Características

Las principales características que proporciona esta biblioteca son:

• Análisis de código PHP 7 y PHP 8 en un árbol de sintaxis abstracta (AST).

• El código no válido se puede analizar en un AST parcial.

• El AST contiene información de ubicación precisa.

• Volcar el AST en forma legible por humanos.

• Convertir un AST nuevamente a código PHP.

• El formato se puede conservar para los AST parcialmente modificados.

• Infraestructura para atravesar y modificar AST.

• Resolución de nombres con espacios de nombres.

• Evaluación de expresiones constantes.

• Constructores para simplificar la construcción de AST para la generación de código.

• Conversión de un AST a JSON y viceversa.

Inicio rápido

Instale la biblioteca usando el compositor:

php composer.phar require nikic/php-parser

Analice algo de código PHP en un AST y descargue el resultado en un formato legible por humanos:

 <?phpuse PhpParserError;use PhpParserNodeDumper;use PhpParserParserFactory;$code = <<<'CODE'<?phpfunction test($foo){ var_dump($foo);}CODE;$parser = (new ParserFactory())->createForNewestSupportedVersion ();intenta {$ast = $ analizador->parse($código);
} catch (Error $error) {echo "Error de análisis: {$error->getMessage()}n";return;
}$dumper = nuevo NodeDumper;echo $dumper->dump($ast) . "norte";

Esto arroja un AST con un aspecto similar a este:

array(
    0: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: test
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                flags: 0
                type: null
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: foo
                )
                default: null
            )
        )
        returnType: null
        stmts: array(
            0: Stmt_Expression(
                expr: Expr_FuncCall(
                    name: Name(
                        name: var_dump
                    )
                    args: array(
                        0: Arg(
                            name: null
                            value: Expr_Variable(
                                name: foo
                            )
                            byRef: false
                            unpack: false
                        )
                    )
                )
            )
        )
    )
)

Recorramos el AST y realicemos algún tipo de modificación. Por ejemplo, elimine todos los cuerpos funcionales:

 use PhpParserNode;use PhpParserNodeStmtFunction_;use PhpParserNodeTraverser;use PhpParserNodeVisitorAbstract;$traverser = new NodeTraverser();$traverser->addVisitor(la nueva clase extiende NodeVisitorAbstract {función pública enterNode(Nodo $nodo) {if ($nodo instancia de función_) {// Limpiar la función cuerpo$nodo->stmts = [];
        }
    }
});$ast = $traverser->traverse($ast);echo $dumper->dump($ast) . "norte";

Esto nos da un AST donde Function_::$stmts están vacíos:

array(
    0: Stmt_Function(
        attrGroups: array(
        )
        byRef: false
        name: Identifier(
            name: test
        )
        params: array(
            0: Param(
                attrGroups: array(
                )
                type: null
                byRef: false
                variadic: false
                var: Expr_Variable(
                    name: foo
                )
                default: null
            )
        )
        returnType: null
        stmts: array(
        )
    )
)

Finalmente, podemos convertir el nuevo AST nuevamente a código PHP:

 use PhpParserPrettyPrinter;$prettyPrinter = new PrettyPrinterStandard;echo $prettyPrinter->prettyPrintFile($ast);

Esto nos da nuestro código original, menos la llamada var_dump() dentro de la función:

 <?prueba de función php ($foo)
{
}

Para obtener una introducción más completa, consulte la documentación.

Documentación

1. Introducción

2. Uso de componentes básicos.

Documentación de componentes:

• Caminando por el AST

• Visitantes del nodo

• Modificar el AST de un visitante

• Travesías de cortocircuito

• Visitantes intercalados

• API de búsqueda de nodos simple

• Referencias de padres y hermanos

• Resolución de nombres

• Opciones de resolución de nombres

• Contexto de resolución de nombres

• Bonita impresión

• Convirtiendo AST nuevamente a código PHP

• Personalización del formato

• Transformaciones de código que preservan el formato

• constructores AST

• Constructores fluidos para nodos AST

• lexer

• Emulación

• Tokens, posiciones y atributos.

• Manejo de errores

• Información de columna para errores

• Recuperación de errores (análisis de código sintácticamente incorrecto)

• Evaluación de expresión constante

• Evaluación de inicializadores constantes/propiedades/etc.

• Manejo de errores y expresiones no admitidas

• Representación JSON

• Codificación y decodificación JSON de AST

• Actuación

• Deshabilitar Xdebug

• Reutilizar objetos

• Impacto de la recolección de basura

• Preguntas frecuentes

• Referencias de padres y hermanos