Nette PhpGenerator

Suchen Sie ein Werkzeug, um PHP-Code für Klassen, Funktionen oder ganze Dateien zu erzeugen?

Unterstützt alle neuesten PHP-Funktionen (etwa Property Hooks, Enums, Attribute usw.)
Erlaubt es Ihnen, bestehende Klassen einfach zu verändern
Ausgabe konform zum Coding Style PSR-12 / PER
Ausgereifte, stabile und weit verbreitete Bibliothek

Installation

Die Bibliothek laden und installieren Sie mit dem Werkzeug Composer:

composer require nette/php-generator

Zur Kompatibilität mit PHP siehe die Kompatibilitätstabelle.

Klassen

Beginnen wir mit einem Beispiel für das Erstellen einer Klasse mit ClassType:

$class = new Nette\PhpGenerator\ClassType('Demo');

$class
	->setFinal()
	->setExtends(ParentClass::class)
	->addImplement(Countable::class)
	->addComment("Beschreibung der Klasse.\nZweite Zeile\n")
	->addComment('@property-read Nette\Forms\Form $form');

// den Code erzeugen Sie einfach durch Casten zu string oder mit echo:
echo $class;

Das ergibt folgendes Ergebnis:

/**
 * Beschreibung der Klasse.
 * Zweite Zeile
 *
 * @property-read Nette\Forms\Form $form
 */
final class Demo extends ParentClass implements Countable
{
}

Zum Erzeugen des Codes können Sie auch einen Printer verwenden, der sich anders als echo $class weiter konfigurieren lässt:

$printer = new Nette\PhpGenerator\Printer;
echo $printer->printClass($class);

Sie können Konstanten (Klasse Constant) und Properties (Klasse Property) hinzufügen:

$class->addConstant('ID', 123)
	->setProtected() // Sichtbarkeit der Konstanten
	->setType('int')
	->setFinal();

$class->addProperty('items', [1, 2, 3])
	->setPrivate() // oder setVisibility('private')
	->setStatic()
	->addComment('@var int[]');

$class->addProperty('list')
	->setType('?array')
	->setInitialized(); // gibt '= null' aus

Das erzeugt:

final protected const int ID = 123;

/** @var int[] */
private static $items = [1, 2, 3];
public ?array $list = null;

Und Sie können Methoden hinzufügen:

$method = $class->addMethod('count')
	->addComment('Zähle es.')
	->setFinal()
	->setProtected()
	->setReturnType('?int') // Rückgabetypen für Methoden
	->setBody('return count($items ?: $this->items);');

$method->addParameter('items', []) // $items = []
	->setReference()           // &$items = []
	->setType('array');        // array &$items = []

Das Ergebnis ist:

/**
 * Zähle es.
 */
final protected function count(array &$items = []): ?int
{
	return count($items ?: $this->items);
}

Promoted Parameters, die in PHP 8.0 eingeführt wurden, lassen sich dem Konstruktor übergeben:

$method = $class->addMethod('__construct');
$method->addPromotedParameter('name');
$method->addPromotedParameter('args', [])
	->setPrivate();

Das Ergebnis ist:

public function __construct(
	public $name,
	private $args = [],
) {
}

Readonly-Properties und -Klassen lassen sich mit der Funktion setReadOnly() kennzeichnen.

Existiert eine hinzugefügte Property, Konstante, Methode oder ein Trait bereits, wird eine Exception geworfen. Parameter werden dagegen überschrieben.

Mitglieder der Klasse lassen sich mit removeProperty(), removeConstant(), removeMethod() oder removeParameter() entfernen.

Sie können der Klasse auch bestehende Objekte vom Typ Method, Property oder Constant hinzufügen:

$method = new Nette\PhpGenerator\Method('getHandle');
$property = new Nette\PhpGenerator\Property('handle');
$const = new Nette\PhpGenerator\Constant('ROLE');

$class = (new Nette\PhpGenerator\ClassType('Demo'))
	->addMember($method)
	->addMember($property)
	->addMember($const);

Bestehende Methoden, Properties und Konstanten können Sie außerdem mit cloneWithName() unter einem anderen Namen klonen:

$methodCount = $class->getMethod('count');
$methodRecount = $methodCount->cloneWithName('recount');
$class->addMember($methodRecount);

Interfaces oder Traits

Sie können Interfaces und Traits erstellen (Klassen InterfaceType und TraitType):

$interface = new Nette\PhpGenerator\InterfaceType('MyInterface');
$trait = new Nette\PhpGenerator\TraitType('MyTrait');

Verwendung eines Traits:

$class = new Nette\PhpGenerator\ClassType('Demo');
$class->addTrait('SmartObject');
$class->addTrait('MyTrait')
	->addResolution('sayHello as protected')
	->addComment('@use MyTrait<Foo>');
echo $class;

Das Ergebnis ist:

class Demo
{
	use SmartObject;
	/** @use MyTrait<Foo> */
	use MyTrait {
		sayHello as protected;
	}
}

Enums

Die in PHP 8.1 eingeführten Enums erstellen Sie ganz einfach so (Klasse EnumType):

$enum = new Nette\PhpGenerator\EnumType('Suit');
$enum->addCase('Clubs');
$enum->addCase('Diamonds');
$enum->addCase('Hearts');
$enum->addCase('Spades');

echo $enum;

Das Ergebnis ist:

enum Suit
{
	case Clubs;
	case Diamonds;
	case Hearts;
	case Spades;
}

Sie können auch skalare Entsprechungen definieren und ein Backed Enum erstellen:

$enum = new Nette\PhpGenerator\EnumType('Suit');
$enum->addCase('Clubs', '♣');
$enum->addCase('Diamonds', '♦');

Zu jedem Case können Sie mit addComment() oder addAttribute() einen Kommentar oder Attribute hinzufügen.

Anonyme Klassen

Übergeben Sie null als Namen, und Sie haben eine anonyme Klasse:

$class = new Nette\PhpGenerator\ClassType(null);
$class->addMethod('__construct')
	->addParameter('foo');

echo '$obj = new class ($val) ' . $class . ';';

Das Ergebnis ist:

$obj = new class ($val) {
	public function __construct($foo)
	{
	}
};

Globale Funktionen

Den Code globaler Funktionen erzeugt die Klasse GlobalFunction:

$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->setBody('return $a + $b;');
$function->addParameter('a');
$function->addParameter('b');
echo $function;

// oder verwenden Sie PsrPrinter für eine Ausgabe konform zu PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printFunction($function);

Das Ergebnis ist:

function foo($a, $b)
{
	return $a + $b;
}

Anonyme Funktionen

Den Code anonymer Funktionen (Closures) erzeugt die Klasse Closure:

$closure = new Nette\PhpGenerator\Closure;
$closure->setBody('return $a + $b;');
$closure->addParameter('a');
$closure->addParameter('b');
$closure->addUse('c')
	->setReference();
echo $closure;

// oder verwenden Sie PsrPrinter für eine Ausgabe konform zu PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printClosure($closure);

Das Ergebnis ist:

function ($a, $b) use (&$c) {
	return $a + $b;
}

Kurze Arrow-Funktionen

Mit dem Printer können Sie auch eine kurze Arrow-Funktion ausgeben:

$closure = new Nette\PhpGenerator\Closure;
$closure->setBody('$a + $b');
$closure->addParameter('a');
$closure->addParameter('b');

echo (new Nette\PhpGenerator\Printer)->printArrowFunction($closure);

Das Ergebnis ist:

fn($a, $b) => $a + $b;

Signaturen von Methoden und Funktionen

Methoden werden durch die Klasse Method repräsentiert. Sie können die Sichtbarkeit und den Rückgabetyp setzen, Kommentare und Attribute hinzufügen usw.:

$method = $class->addMethod('count')
	->addComment('Zähle es.')
	->setFinal()
	->setProtected()
	->setReturnType('?int');

Die einzelnen Parameter werden durch die Klasse Parameter repräsentiert. Auch hier können Sie alle denkbaren Eigenschaften setzen:

$method->addParameter('items', []) // $items = []
	->setReference()           // &$items = []
	->setType('array');        // array &$items = []

// function count(array &$items = [])

Um variadische Parameter zu definieren (auch als Splat-Operator bekannt), verwenden Sie setVariadic():

$method = $class->addMethod('count');
$method->setVariadic(true);
$method->addParameter('items');

Das erzeugt:

function count(...$items)
{
}

Rümpfe von Methoden und Funktionen

Der Rumpf lässt sich auf einmal an die Methode setBody() übergeben oder schrittweise (Zeile für Zeile) durch wiederholte Aufrufe von addBody():

$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addBody('$a = rand(10, 20);');
$function->addBody('return $a;');
echo $function;

Das Ergebnis ist:

function foo()
{
	$a = rand(10, 20);
	return $a;
}

Zum bequemen Einsetzen von Variablen können Sie spezielle Platzhalter verwenden.

Einfache Platzhalter ?:

$str = 'any string';
$num = 3;
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addBody('return substr(?, ?);', [$str, $num]);
echo $function;

Das Ergebnis ist:

function foo()
{
	return substr('any string', 3);
}

Platzhalter für variadische Parameter ...?:

$items = [1, 2, 3];
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->setBody('myfunc(...?);', [$items]);
echo $function;

Das Ergebnis ist:

function foo()
{
	myfunc(1, 2, 3);
}

Mit ...?: können Sie außerdem benannte Parameter für PHP 8 verwenden:

$items = ['foo' => 1, 'bar' => true];
$function->setBody('myfunc(...?:);', [$items]);

// myfunc(foo: 1, bar: true);

Der Platzhalter wird mit einem Backslash escapt: \?:

$num = 3;
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addParameter('a');
$function->addBody('return $a \? 10 : ?;', [$num]);
echo $function;

Das Ergebnis ist:

function foo($a)
{
	return $a ? 10 : 3;
}

Printer und PSR-Konformität

Zum Erzeugen von PHP-Code dient die Klasse Printer:

$class = new Nette\PhpGenerator\ClassType('Demo');
// ...

$printer = new Nette\PhpGenerator\Printer;
echo $printer->printClass($class); // dasselbe wie: echo $class

Sie kann Code für alle weiteren Elemente erzeugen und bietet Methoden wie printFunction(), printNamespace() usw.

Es gibt außerdem die Klasse PsrPrinter, deren Ausgabe dem Coding Style PSR-2 / PSR-12 / PER entspricht:

$printer = new Nette\PhpGenerator\PsrPrinter;
echo $printer->printClass($class);

Sie müssen das Verhalten anpassen? Erstellen Sie eine eigene Variante, indem Sie die Klasse Printer erben. Diese Variablen können Sie neu konfigurieren:

class MyPrinter extends Nette\PhpGenerator\Printer
{
	// Zeilenlänge, ab der umbrochen wird
	public int $wrapLength = 120;
	// Einrückungszeichen, lässt sich durch eine Folge von Leerzeichen ersetzen
	public string $indentation = "\t";
	// Anzahl der Leerzeilen zwischen Properties
	public int $linesBetweenProperties = 0;
	// Anzahl der Leerzeilen zwischen Methoden
	public int $linesBetweenMethods = 2;
	// Anzahl der Leerzeilen zwischen den Gruppen der 'use statements' für Klassen, Funktionen und Konstanten
	public int $linesBetweenUseTypes = 0;
	// Position der öffnenden geschweiften Klammer bei Funktionen und Methoden
	public bool $bracesOnNextLine = true;
	// setzt einen einzelnen Parameter in eine Zeile, auch wenn er ein Attribut hat oder promoted ist
	public bool $singleParameterOnOneLine = false;
	// lässt Namespaces weg, die keine Klasse und keine Funktion enthalten
	public bool $omitEmptyNamespaces = true;
	// setzt declare(strict_types) in dieselbe Zeile wie <?php
	public bool $declareOnOpenTag = false;
	// Trenner zwischen der schließenden Klammer und dem Rückgabetyp von Funktionen und Methoden
	public string $returnTypeColon = ': ';
}

Wie und warum unterscheiden sich der Standard-Printer und der PsrPrinter eigentlich? Warum gibt es im Paket nicht einfach nur einen Printer, den PsrPrinter?

Der Standard-Printer formatiert den Code so, wie wir es in ganz Nette tun. Weil Nette viel früher entstanden ist als PSR und weil die PSR-Standards oft verspätet kamen (manchmal Jahre nach der Einführung einer neuen PHP-Funktion), unterscheidet sich der Coding Standard von Nette in einigen kleinen Details. Der Hauptunterschied ist die Verwendung von Tabs statt Leerzeichen. Wir wissen, dass die Verwendung von Tabs in unseren Projekten eine Anpassung der Breite erlaubt, was für Menschen mit Sehbehinderung wesentlich ist. Ein Beispiel für einen kleinen Unterschied ist, dass die öffnende geschweifte Klammer bei Funktionen und Methoden immer in einer eigenen Zeile steht. Die Empfehlung von PSR erscheint uns unlogisch und führt zu geringerer Übersichtlichkeit des Codes.

Typen

Jeder Typ sowie Union- und Intersection-Typen lassen sich als String übergeben; für native Typen können Sie außerdem vordefinierte Konstanten verwenden:

use Nette\PhpGenerator\Type;

$member->setType('array'); // oder Type::Array
$member->setType('?array'); // oder Type::nullable(Type::Array)
$member->setType('array|string'); // oder Type::union(Type::Array, Type::String)
$member->setType('Foo&Bar'); // oder Type::intersection(Foo::class, Bar::class)
$member->setType(null); // entfernt den Typ

Dasselbe gilt für die Methode setReturnType().

Literale

Mit Literal können Sie beliebigen PHP-Code übergeben, zum Beispiel für Standardwerte von Properties oder Parametern:

use Nette\PhpGenerator\Literal;

$class = new Nette\PhpGenerator\ClassType('Demo');

$class->addProperty('foo', new Literal('Iterator::SELF_FIRST'));

$class->addMethod('bar')
	->addParameter('id', new Literal('1 + 2'));

echo $class;

Ergebnis:

class Demo
{
	public $foo = Iterator::SELF_FIRST;

	public function bar($id = 1 + 2)
	{
	}
}

Sie können Literal auch Parameter übergeben und sie mit Platzhaltern zu gültigem PHP-Code formatieren lassen:

new Literal('substr(?, ?)', [$a, $b]);
// erzeugt zum Beispiel: substr('hello', 5)

Ein Literal, das die Erzeugung eines neuen Objekts darstellt, lässt sich bequem mit der Methode new erzeugen:

Literal::new(Demo::class, [$a, 'foo' => $b]);
// erzeugt zum Beispiel: new Demo(10, foo: 20)

Attribute

Die Attribute von PHP 8 lassen sich allen Klassen, Methoden, Properties, Konstanten, Enums, Funktionen, Closures und Parametern hinzufügen. Als Werte der Parameter können auch Literale verwendet werden.

$class = new Nette\PhpGenerator\ClassType('Demo');
$class->addAttribute('Table', [
	'name' => 'user',
	'constraints' => [
		Literal::new('UniqueConstraint', ['name' => 'ean', 'columns' => ['ean']]),
	],
]);

$class->addProperty('list')
	->addAttribute('Deprecated');

$method = $class->addMethod('count')
	->addAttribute('Foo\Cached', ['mode' => true]);

$method->addParameter('items')
	->addAttribute('Bar');

echo $class;

Ergebnis:

#[Table(name: 'user', constraints: [new UniqueConstraint(name: 'ean', columns: ['ean'])])]
class Demo
{
	#[Deprecated]
	public $list;


	#[Foo\Cached(mode: true)]
	public function count(
		#[Bar]
		$items,
	) {
	}
}

Property Hooks

Mit Property Hooks (repräsentiert durch die Klasse PropertyHook) können Sie für Properties die Operationen get und set definieren, eine Funktion, die in PHP 8.4 eingeführt wurde:

$class = new Nette\PhpGenerator\ClassType('Demo');
$prop = $class->addProperty('firstName')
    ->setType('string');

$prop->addHook('set', 'strtolower($value)')
    ->addParameter('value')
	    ->setType('string');

$prop->addHook('get')
	->setBody('return ucfirst($this->firstName);');

echo $class;

Das erzeugt:

class Demo
{
    public string $firstName {
        set(string $value) => strtolower($value);
        get {
            return ucfirst($this->firstName);
        }
    }
}

Properties und Property Hooks können abstract oder final sein:

$class->addProperty('id')
    ->setType('int')
    ->addHook('get')
        ->setAbstract();

$class->addProperty('role')
    ->setType('string')
    ->addHook('set', 'strtolower($value)')
        ->setFinal();

Asymmetrische Sichtbarkeit

PHP 8.4 führt asymmetrische Sichtbarkeit für Properties ein. Sie können für das Lesen und das Schreiben unterschiedliche Zugriffsstufen setzen.

Die Sichtbarkeit lässt sich entweder mit der Methode setVisibility() mit zwei Parametern setzen oder mit setPublic(), setProtected() bzw. setPrivate(), wobei der Parameter mode angibt, ob die Sichtbarkeit für das Lesen oder das Schreiben der Property gilt. Der Standardmodus ist 'get'.

$class = new Nette\PhpGenerator\ClassType('Demo');

$class->addProperty('name')
    ->setType('string')
    ->setVisibility('public', 'private'); // public zum Lesen, private zum Schreiben

$class->addProperty('id')
    ->setType('int')
    ->setProtected('set'); // protected zum Schreiben

echo $class;

Das erzeugt:

class Demo
{
    public private(set) string $name;

    protected(set) int $id;
}

Namespace

Klassen, Traits, Interfaces und Enums (im Folgenden Klassen genannt) lassen sich in Namespaces gruppieren, die durch die Klasse PhpNamespace repräsentiert werden:

$namespace = new Nette\PhpGenerator\PhpNamespace('Foo');

// neue Klassen im Namespace erzeugen
$class = $namespace->addClass('Task');
$interface = $namespace->addInterface('Countable');
$trait = $namespace->addTrait('NameAware');

// oder eine bestehende Klasse bzw. Funktion in den Namespace einfügen
$class = new Nette\PhpGenerator\ClassType('Task');
$namespace->add($class);

Existiert im Namespace bereits eine Klasse desselben Namens, wird eine Exception geworfen.

Sie können use-Klauseln definieren:

// use Http\Request;
$namespace->addUse(Http\Request::class);
// use Http\Request as HttpReq;
$namespace->addUse(Http\Request::class, 'HttpReq');
// use function iter\range;
$namespace->addUseFunction('iter\range');

Um einen vollqualifizierten Klassen-, Funktions- oder Konstantennamen anhand der definierten Aliase oder des aktuellen Namespace zu vereinfachen, verwenden Sie die Methode simplifyName:

echo $namespace->simplifyName('Foo\Bar'); // 'Bar', weil 'Foo' der aktuelle Namespace ist
echo $namespace->simplifyName('iter\range', $namespace::NameFunction); // 'range', wegen des definierten use-Statements

Umgekehrt können Sie einen vereinfachten Klassen-, Funktions- oder Konstantennamen mit der Methode resolveName in einen vollqualifizierten Namen zurückverwandeln:

echo $namespace->resolveName('Bar'); // 'Foo\Bar'
echo $namespace->resolveName('range', $namespace::NameFunction); // 'iter\range'

Auflösung von Klassennamen

Ist eine Klasse Teil eines Namespace, wird sie etwas anders gerendert: Alle Typen (etwa Typdeklarationen, Rückgabetypen, der Name der Elternklasse, implementierte Interfaces, verwendete Traits und Attribute) werden automatisch aufgelöst (sofern Sie das nicht abschalten, siehe unten). Das bedeutet, dass Sie in den Definitionen vollqualifizierte Klassennamen verwenden müssen, und im resultierenden Code werden sie durch Aliase (gemäß den use-Klauseln) oder vereinfachte Namen (wenn sie im selben Namespace liegen) ersetzt:

$namespace = new Nette\PhpGenerator\PhpNamespace('Foo');
$namespace->addUse('Bar\AliasedClass');

$class = $namespace->addClass('Demo');
$class->addImplement('Foo\A') // wird zu A vereinfacht
	->addTrait('Bar\AliasedClass'); // wird zu AliasedClass vereinfacht

$method = $class->addMethod('method');
$method->addComment('@return ' . $namespace->simplifyType('Foo\D')); // in Kommentaren vereinfachen wir von Hand
$method->addParameter('arg')
	->setType('Bar\OtherClass'); // wird zu \Bar\OtherClass übersetzt

echo $namespace;

// oder verwenden Sie PsrPrinter für eine Ausgabe konform zu PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printNamespace($namespace);

Ergebnis:

namespace Foo;

use Bar\AliasedClass;

class Demo implements A
{
	use AliasedClass;

	/**
	 * @return D
	 */
	public function method(\Bar\OtherClass $arg)
	{
	}
}

Die automatische Auflösung lässt sich so abschalten:

$printer = new Nette\PhpGenerator\Printer; // oder PsrPrinter
$printer->setTypeResolving(false);
echo $printer->printNamespace($namespace);

PHP-Dateien

Klassen, Funktionen und Namespaces lassen sich in PHP-Dateien gruppieren, die durch die Klasse PhpFile repräsentiert werden:

$file = new Nette\PhpGenerator\PhpFile;
$file->addComment('Diese Datei wurde automatisch erzeugt.');
$file->setStrictTypes(); // fügt declare(strict_types=1) hinzu

$class = $file->addClass('Foo\A');
$function = $file->addFunction('Foo\foo');

// oder
// $namespace = $file->addNamespace('Foo');
// $class = $namespace->addClass('A');
// $function = $namespace->addFunction('foo');

echo $file;

// oder verwenden Sie PsrPrinter für eine Ausgabe konform zu PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printFile($file);

Ergebnis:

<?php

/**
 * Diese Datei wurde automatisch erzeugt.
 */

declare(strict_types=1);

namespace Foo;

class A
{
}

function foo()
{
}

Bestehende Objekte von Klassen, Funktionen und Namespaces können Sie mit der Methode add() in die Datei einfügen:

$file = new Nette\PhpGenerator\PhpFile;
$class = new Nette\PhpGenerator\ClassType('Demo');
$file->add($class);

Bitte beachten Sie: In die Dateien lässt sich außerhalb von Funktionen, Klassen oder Namespaces kein zusätzlicher Code (wie echo 'hello') einfügen.

Generieren aus bestehenden Elementen

Außer dem Modellieren von Klassen und Funktionen über die oben beschriebene API können Sie sie auch automatisch anhand bestehender per Reflexion erzeugen lassen:

// erzeugt eine Klasse, die mit der Klasse PDO identisch ist
$class = Nette\PhpGenerator\ClassType::from(PDO::class);

// erzeugt eine Funktion, die mit der Funktion trim() identisch ist
$function = Nette\PhpGenerator\GlobalFunction::from('trim');

// erzeugt eine Closure anhand der übergebenen
$closure = Nette\PhpGenerator\Closure::from(
	function (stdClass $a, $b = null) {},
);

Standardmäßig sind die Rümpfe von Funktionen und Methoden leer. Wenn Sie sie ebenfalls laden wollen, verwenden Sie diesen Weg (er setzt das installierte Paket nikic/php-parser voraus):

$class = Nette\PhpGenerator\ClassType::from(Foo::class, withBodies: true);

$function = Nette\PhpGenerator\GlobalFunction::from('foo', withBody: true);

Laden aus PHP-Dateien

Funktionen, Klassen, Interfaces und Enums lassen sich auch direkt aus einem String mit PHP-Code laden. Zum Beispiel, um ein Objekt ClassType zu erzeugen:

$class = Nette\PhpGenerator\ClassType::fromCode(<<<XX
	<?php

	class Demo
	{
		public $foo;
	}
	XX);

Beim Laden von Klassen aus PHP-Code werden einzeilige Kommentare außerhalb von Methodenrümpfen (etwa bei Properties) ignoriert, denn diese Bibliothek hat keine API, um mit ihnen zu arbeiten.

Sie können auch eine ganze PHP-Datei direkt laden, die beliebig viele Klassen, Funktionen oder sogar Namespaces enthalten kann:

$file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php'));

Der einleitende Kommentar der Datei und die Deklaration strict_types werden ebenfalls geladen. Der gesamte übrige globale Code wird jedoch ignoriert.

Setzt das installierte Paket nikic/php-parser voraus.

Wenn Sie globalen Code in Dateien oder einzelne Anweisungen innerhalb von Methodenrümpfen bearbeiten müssen, verwenden Sie besser die Bibliothek nikic/php-parser direkt.

Class Manipulator

Die Klasse ClassManipulator bietet Werkzeuge zum Manipulieren von Klassen.

$class = new Nette\PhpGenerator\ClassType('Demo');
$manipulator = new Nette\PhpGenerator\ClassManipulator($class);

Die Methode inheritMethod() kopiert eine Methode aus einer Elternklasse oder einem implementierten Interface in Ihre Klasse. Dadurch können Sie die Methode überschreiben oder ihre Signatur erweitern:

$method = $manipulator->inheritMethod('bar');
$method->setBody('...');

Die Methode inheritProperty() kopiert eine Property aus einer Elternklasse in Ihre Klasse. Das ist nützlich, wenn Sie dieselbe Property in Ihrer Klasse haben wollen, womöglich mit einem anderen Standardwert:

$property = $manipulator->inheritProperty('foo');
$property->setValue('new value');

Die Methode implement() implementiert in Ihrer Klasse automatisch alle abstrakten Methoden und Properties des angegebenen Interface oder der angegebenen abstrakten Klasse:

$manipulator->implement(SomeInterface::class);
// Ihre Klasse implementiert nun SomeInterface und enthält Rümpfe für alle ihre Methoden

Ausgabe von Variablen

Die Klasse Dumper wandelt eine Variable in parsebaren PHP-Code um. Sie liefert eine bessere und übersichtlichere Ausgabe als die Standardfunktion var_export().

$dumper = new Nette\PhpGenerator\Dumper;

$var = ['a', 'b', 123];

echo $dumper->dump($var); // gibt aus ['a', 'b', 123]

Kompatibilitätstabelle

PhpGenerator 4.2 ist kompatibel mit PHP 8.1 bis 8.5.

Wenn Sie auf eine neuere Version aktualisieren, sehen Sie sich die Seite Upgrade an.