In diesem Artikel wird detailliert beschrieben, wie Sie die Nikic PhpParser-Bibliothek verwenden, um Array-Variablen in PHP-Dateien programmgesteuert zu ?ndern, insbesondere wie Sie neue Elemente korrekt zu vorhandenen Arrays hinzufügen. Durch das Parsen von PHP-Code in einen abstrakten Syntaxbaum (AST) demonstriert der Artikel die korrekte Methode zur Identifizierung des Zielarrays beim Durchlaufen des AST und die Verwendung von AST-Knotenklassen wie ?PhpParser\Node\Expr\ArrayItem“ und ?PhpParser\Node\Scalar\String_“ zum Erstellen und Einfügen neuer Array-Elemente, wodurch Fehler vermieden werden, die durch das direkte Mischen von Originaldaten und verursacht werden AST-Knoten.

Verwenden Sie Nikic PhpParser, um Array-Variablen in PHP-Dateien zu ?ndern

Bei der Durchführung von Aufgaben wie Codeautomatisierung, Refactoring oder statischer Analyse müssen wir m?glicherweise PHP-Code programmgesteuert lesen, analysieren oder sogar ?ndern. Nikic PhpParser ist ein leistungsstarkes Tool, das PHP-Code in abstrakte Syntaxb?ume (AST) analysiert und es uns erm?glicht, diese Baumstrukturen zu durchlaufen und zu manipulieren. Dieser Artikel konzentriert sich auf die Verwendung von Nikic PhpParser zum ?ndern von Array-Variablen in PHP-Dateien, insbesondere auf das korrekte Hinzufügen neuer Schlüssel-Wert-Paare zu vorhandenen Arrays.

1. Vorbereitung: PHP-Code analysieren

Zuerst ben?tigen wir eine PHP-Datei, die die Ziel-Array-Variable enth?lt. Angenommen, wir haben die Datei first.php mit folgendem Inhalt:

 <?php define("CONSTANT1", "cons1value");

$variable1 = "var1value";

$variable2 = array(
    ?key1“ => ?value1“,
    ?key2“ => ?value2“
);

Unser Ziel ist es, $variable2 wie folgt zu ?ndern:

 <?php define("CONSTANT1", "cons1value_updated");

$variable1 = "var1value_updated";

$variable2 = array(
    ?key1“ => ?value1_updated“,
    ?key2“ => ?value2“, // Gehen Sie davon aus, dass dieser Wert unver?ndert bleibt, oder ?ndern Sie ihn nach Bedarf. ?key_3_added“ => ?value3_added“
);

Um dies zu erreichen, müssen wir Nikic PhpParser verwenden, um die Datei first.php zu analysieren und ihren AST abzurufen.

 <?php require &#39;vendor/autoload.php&#39;; // Stellen Sie sicher, dass der Composer-Autoloader konfiguriert ist. use PhpParser\Error;
verwenden Sie PhpParser\ParserFactory;
verwenden Sie PhpParser\NodeTraverser;
verwenden Sie PhpParser\PrettyPrinter\Standard;
verwenden Sie PhpParser\Node\Expr\ArrayItem;
verwenden Sie PhpParser\Node\Scalar\String_;
verwenden Sie PhpParser\Node\Expr\Assign;
verwenden Sie PhpParser\Node\Expr\Array_;
verwenden Sie PhpParser\Node\Expr\Variable;

$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
$prettyPrinter = neuer Standard;
$traverser = neuer NodeTraverser;

$source = file_get_contents("first.php");

versuchen {
    $stmts = $parser->parse($source);
    // Hier k?nnen wir einen benutzerdefinierten NodeVisitor hinzufügen, um ?nderungen zu verarbeiten // $traverser->addVisitor(new MyNodeVisitor());
    // $stmts = $traverser->traverse($stmts);
} Catch (Fehler $error) {
    echo "Analysefehler: {$error->getMessage()}\n";
    Ausfahrt();
}

// $stmts enth?lt jetzt den abstrakten Syntaxbaum von first.php

2. Durchlaufen Sie den AST und suchen Sie das Zielarray

Um $variable2 zu ?ndern, müssen wir den AST durchlaufen und die entsprechende Variablenzuweisungsanweisung finden. In AST wird die Variablenzuweisung normalerweise als PhpParser\Node\Expr\Assign-Knoten dargestellt, mit Variablen auf der linken Seite (PhpParser\Node\Expr\Variable) und Werten auf der rechten Seite (z. B. PhpParser\Node\Expr\Array_).

 // ... (Fortsetzung des obigen Codes)

foreach ($stmts als $stmt) {
    // Prüfen, ob es sich um eine Ausdrucksanweisung (ExprStmt) handelt und der Ausdruck eine Zuweisungsoperation (Assign) ist
    if ($stmt Instanz von PhpParser\Node\Stmt\Expression && $stmt->expr Instanz von Assign) {
        $assign = $stmt->expr;

        // Prüfen, ob die linke Seite der Zuweisung eine Variable ist if ($assign->var exampleof Variable) {
            // überprüfen Sie, ob der Variablenname ?Variable2“ ist.
            if ($assign->var->name === 'variable2') {
                // Prüfen, ob die rechte Seite der Zuweisung ein Array ist if ($assign->expr exampleof Array_) {
                    $arrayNode = $assign->expr;

                    // Jetzt ist $arrayNode der Array-Knoten, den wir ?ndern m?chten // Durchlaufen Sie die vorhandenen Array-Elemente und ?ndern Sie den Wert von ?key1“ foreach ($arrayNode->items as $item) {
                        if ($item-Instanz von ArrayItem && $item->key-Instanz von String_) {
                            switch ($item->key->value) {
                                Fall 'key1':
                                    // Den Wert von 'key1' ?ndern $item->value = new String_("value1_updated");
                                    brechen;
                                Fall 'key2':
                                    // Angenommen, wir m?chten auch ?key2“ ?ndern
                                    // $item->value = new String_("value2_updated");
                                    brechen;
                            }
                        }
                    }

                    // Versuchen Sie, neue Elemente hinzuzufügen // Falscher Weg: PHP-Array direkt hinzufügen // $arrayNode->items[] = ["key3_added" => "value3_added"];
                    // Dies führt zu einem Fehler, da die AST-Knotenliste ein AST-Knotenobjekt und kein rohes PHP-Array erwartet.
                }
            }
        }
    }
}

// Den ge?nderten Code drucken // echo $prettyPrinter->prettyPrintFile($stmts);

3. Fügen Sie neue Array-Elemente korrekt hinzu

Im obigen Code ist es falsch, das PHP-Array ["key3_added" => "value3_added"] direkt zu $arrayNode->items hinzuzufügen. Nikic PhpParser befasst sich mit abstrakten Syntaxb?umen und $arrayNode->items erwartet Objekte vom Typ PhpParser\Node\Expr\ArrayItem, keine gew?hnlichen PHP-Arrays.

Um ein Schlüssel-Wert-Paar ordnungsgem?? hinzuzufügen, müssen wir einen ArrayItem-Knoten erstellen, der den Schlüssel und den Wert als PhpParser\Node\Scalar\String_ oder einen anderen geeigneten Ausdrucksknoten enth?lt.

 // ... (Fortsetzung des obigen Codes)

foreach ($stmts als $stmt) {
    if ($stmt Instanz von PhpParser\Node\Stmt\Expression && $stmt->expr Instanz von Assign) {
        $assign = $stmt->expr;
        if ($assign->var exampleof Variable && $assign->var->name === 'variable2') {
            if ($assign->expr Instanz von Array_) {
                $arrayNode = $assign->expr;

                // Durchlaufen und ?ndern vorhandener Elemente foreach ($arrayNode->items as $item) {
                    if ($item-Instanz von ArrayItem && $item->key-Instanz von String_) {
                        if ($item->key->value === 'key1') {
                            $item->value = new String_("value1_updated");
                        }
                    }
                }

                // Neue Elemente korrekt hinzufügen // Einen String-Knoten erstellen, der den neuen Schlüssel darstellt $newKey = new String_("key_3_added");
                // Einen String-Knoten erstellen, der den neuen Wert darstellt $newValue = new String_("value3_added");
                //Erstelle einen ArrayItem-Knoten und verknüpfe Schlüssel und Werte $newArrayItem = new ArrayItem($newValue, $newKey);

                //Den neu erstellten ArrayItem-Knoten zur Elementliste des Array-Knotens hinzufügen $arrayNode->items[] = $newArrayItem;

                // Sie k?nnen es auch direkt in eine Zeile schreiben // $arrayNode->items[] = new ArrayItem(new String_("value3_added"), new String_("key_3_added"));
            }
        }
    }
}

//Den ge?nderten Code drucken echo $prettyPrinter->prettyPrintFile($stmts);

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe (oder ein ?hnliches Format, abh?ngig von der Konfiguration von PrettyPrinter):

 <?php define("CONSTANT1", "cons1value");
$variable1 = "var1value";
$variable2 = array(
    ?key1“ => ?value1_updated“,
    ?key2“ => ?value2“,
    ?key_3_added“ => ?value3_added“
);

4. Vollst?ndiger Beispielcode

Um den gesamten Prozess deutlicher darzustellen, finden Sie hier ein vollst?ndiges Beispiel mit allen Schritten:

 <?php require &#39;vendor/autoload.php&#39;;

verwenden Sie PhpParser\Error;
verwenden Sie PhpParser\ParserFactory;
verwenden Sie PhpParser\NodeTraverser;
verwenden Sie PhpParser\PrettyPrinter\Standard;
verwenden Sie PhpParser\Node\Expr\ArrayItem;
verwenden Sie PhpParser\Node\Scalar\String_;
verwenden Sie PhpParser\Node\Expr\Assign;
verwenden Sie PhpParser\Node\Expr\Array_;
verwenden Sie PhpParser\Node\Expr\Variable;
verwenden Sie PhpParser\Node\Stmt\Expression; //Ausdrucksknoten einführen // 1. Erstellen Sie eine Beispiel-PHP-Datei file_put_contents(&#39;first.php&#39;, &#39;<?php

define("CONSTANT1", "cons1value");

$variable1 = "var1value";

$variable2 = array(
    ?key1“ => ?value1“,
    ?key2“ => ?value2“
);
');

// 2. Parser und Drucker initialisieren $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
$prettyPrinter = neuer Standard;
$traverser = neuer NodeTraverser; // Obwohl dieses Beispiel direkt durchl?uft, ist NodeTraverser eine allgemeinere Methode $source = file_get_contents("first.php");

versuchen {
    $stmts = $parser->parse($source);
} Catch (Fehler $error) {
    echo "Analysefehler: {$error->getMessage()}\n";
    Ausfahrt();
}

// 3. Durchlaufen Sie den AST und ?ndern Sie ihn foreach ($stmts as $stmt) {
    // Prüfen, ob es sich um eine Ausdrucksanweisung handelt (Stmt\Expression)
    if ($stmt-Instanz von Ausdruck && $stmt->expr-Instanz von Assign) {
        $assign = $stmt->expr;

        // überprüfen Sie, ob die linke Seite der Zuweisung eine Variable ist und der Variablenname ?Variable2“ lautet.
        if ($assign->var exampleof Variable && $assign->var->name === 'variable2') {
            // Prüfen, ob die rechte Seite der Zuweisung ein Array ist if ($assign->expr exampleof Array_) {
                $arrayNode = $assign->expr;

                // Durchlaufen Sie vorhandene Array-Elemente und ?ndern Sie den Wert von ?key1“ foreach ($arrayNode->items as $item) {
                    if ($item-Instanz von ArrayItem && $item->key-Instanz von String_) {
                        if ($item->key->value === 'key1') {
                            // Den Wert von 'key1' ?ndern $item->value = new String_("value1_updated");
                        }
                    }
                }

                // Neues Array-Element hinzufügen 'key_3_added' => 'value3_added'
                $arrayNode->items[] = new ArrayItem(
                    new String_("value3_added"), // Wertknoten new String_("key_3_added") // Schlüsselknoten);
            }
        }
    }
}

// 4. Den ge?nderten Code drucken $modifiedCode = $prettyPrinter->prettyPrintFile($stmts);
echo "--- Ge?nderter PHP-Code ---\n";
echo $modifiedCode;

// 5. Bereinigen Sie die Beispieldatei unlink('first.php');

5. Anmerkungen und Zusammenfassung

1. Verstehen Sie die AST-Struktur: Der Kern von Nikic PhpParser ist der abstrakte Syntaxbaum. Alle Codeelemente werden als spezifische PhpParser\Node-Objekte dargestellt. Wenn Sie Code ?ndern oder hinzufügen müssen, müssen Sie ihn mit der entsprechenden Node-Unterklasse erstellen.
2. Unterscheiden Sie Rohdaten von AST-Knoten: Dies ist eine h?ufige Gefahr. Bei Array-Operationen ist $arrayNode->items beispielsweise eine Liste von ArrayItem-Objekten und keine Liste gew?hnlicher PHP-Arrays. Der Versuch, ein PHP-Array direkt hinzuzufügen, führt zu einem Typkonfliktfehler.
3. Verwenden Sie die richtige Knotenklasse: Verwenden Sie für Zeichenfolgenliterale PhpParser\Node\Scalar\String_; für ganze Zahlen verwenden Sie PhpParser\Node\Scalar\LNumber; Verwenden Sie für Variablen PhpParser\Node\Expr\Variable usw.
4. Bedeutung von Use-Anweisungen: Wenn Sie die verschiedenen Knotenklassen von PhpParser verwenden, stellen Sie sicher, dass Sie die korrekte Use-Anweisung am Anfang der Datei hinzufügen, z. B. use PhpParser\Node\Expr\ArrayItem; um Ausführlichkeit in vollst?ndig qualifizierten Klassennamen zu vermeiden.
5. Versionskompatibilit?t: Es kann API-Unterschiede zwischen verschiedenen Versionen der Nikic PhpParser-Bibliothek geben. Die Beispiele in diesem Artikel basieren auf neueren Versionen (z. B. nikic/php-parser 4.x-Serie). Bitte stellen Sie sicher, dass die von Ihrem Projekt verwendete Bibliotheksversion damit kompatibel ist.

Wenn Sie diese Prinzipien befolgen, k?nnen Sie Nikic PhpParser effektiv für die komplexe Manipulation und Konvertierung von PHP-Code nutzen. Das Verst?ndnis der internen Struktur des AST ist der Schlüssel für eine erfolgreiche ?nderung des Programmcodes.

Das obige ist der detaillierte Inhalt vonVerwenden Sie Nikic PhpParser, um Array-Variablen in PHP-Dateien zu ?ndern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!