PHP-Code-Generator

Suchen Sie ein Werkzeug zur Generierung von PHP-Code für Klassen, Funktionen oder komplette Dateien?
  • Kennt alle neuesten PHP-Features (wie Property Hooks, Enums, Attribute usw.)
  • Ermöglicht Ihnen die einfache Modifizierung bestehender Klassen
  • Der Ausgabecode entspricht dem PSR-12 / PER Coding Style
  • Eine ausgereifte, stabile und weit verbreitete Bibliothek

Installation

Sie können die Bibliothek mit dem Werkzeug Composer herunterladen und installieren:

composer require nette/php-generator

Die PHP-Kompatibilität finden Sie in der Kompatibilitätstabelle.

Klassen

Beginnen wir gleich mit einem Beispiel zur Erstellung einer Klasse mithilfe von 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');

// Code einfach durch Typumwandlung in einen String oder mit echo generieren:
echo $class;

Gibt folgendes Ergebnis zurück:

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

Zur Generierung des Codes können wir auch den sogenannten Printer verwenden, den wir im Gegensatz zu echo $class weiter konfigurieren können:

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

Wir können Konstanten (Klasse Constant) und Variablen (Klasse Property) hinzufügen:

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

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

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

Generiert:

final protected const int ID = 123;

/** @var int[] */
private static $items = [1, 2, 3];

public ?array $list = null;

Und wir können Methoden hinzufügen:

$method = $class->addMethod('count')
	->addComment('Zähle es.')
	->setFinal()
	->setProtected()
	->setReturnType('?int') // Rückgabetypen bei 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 Properties, eingeführt in PHP 8.0, können an den Konstruktor übergeben werden:

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

Das Ergebnis ist:

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

Readonly-Eigenschaften und -Klassen können mit der Funktion setReadOnly() markiert werden.

Wenn die hinzugefügte Eigenschaft, Konstante, Methode oder der Parameter bereits existiert, wird eine Ausnahme ausgelöst.

Klassenmitglieder können mit removeProperty(), removeConstant(), removeMethod() oder removeParameter() entfernt werden.

Sie können auch vorhandene Method-, Property- oder Constant-Objekte zur Klasse 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);

Sie können auch bestehende Methoden, Eigenschaften und Konstanten unter einem anderen Namen mit cloneWithName() klonen:

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

Interface oder Trait

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

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

Verwendung von Traits:

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

Ergebnis:

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

Enums

Aufzählungen (Enums), die mit PHP 8.1 eingeführt wurden, können Sie einfach so erstellen: (Klasse EnumType):

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

echo $enum;

Ergebnis:

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

Sie können auch skalare Äquivalente definieren und so eine “backed” Aufzählung erstellen:

$enum->addCase('Clubs', '♣');
$enum->addCase('Diamonds', '♦');

Zu jedem case kann ein Kommentar oder Attribute mit addComment() oder addAttribute() hinzugefügt werden.

Anonyme Klassen

Wir übergeben null als Namen und haben eine anonyme Klasse:

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

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

Ergebnis:

$obj = new class ($val) {

	public function __construct($foo)
	{
	}
};

Globale Funktionen

Den Code von Funktionen generiert 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 die Ausgabe gemäß PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printFunction($function);

Ergebnis:

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

Anonyme Funktionen

Den Code anonymer Funktionen generiert 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 die Ausgabe gemäß PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printClosure($closure);

Ergebnis:

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

Kurze Arrow-Funktionen

Sie können auch eine verkürzte anonyme Funktion mit dem Printer ausgeben:

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

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

Ergebnis:

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

Signaturen von Methoden und Funktionen

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

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

Einzelne Parameter werden durch die Klasse Parameter repräsentiert. Auch hier können Sie alle denkbaren Eigenschaften festlegen:

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

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

Zur Definition sogenannter variadischer Parameter (oder auch Splat-Operator) dient setVariadic():

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

Generiert:

function count(...$items)
{
}

Körper von Methoden und Funktionen

Der Körper kann auf einmal an die Methode setBody() übergeben oder schrittweise (zeilenweise) durch wiederholten Aufruf von addBody():

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

Ergebnis

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

Sie können spezielle Platzhalter verwenden, um Variablen einfach einzufügen.

Einfache Platzhalter ?

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

Ergebnis

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

Platzhalter für Variadic ...?

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

Ergebnis:

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

Sie können auch benannte Parameter für PHP 8 mit ...?: verwenden:

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

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

Der Platzhalter wird mit einem Backslash \? escapet.

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

Ergebnis:

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

Printer und PSR-Konformität

Zur Generierung 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

Er kann Code aller weiteren Elemente generieren und bietet Methoden wie printFunction(), printNamespace() usw.

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

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

Müssen Sie das Verhalten anpassen? Erstellen Sie Ihre eigene Version durch Vererbung der Klasse Printer. Diese Variablen können neu konfiguriert werden:

class MyPrinter extends Nette\PhpGenerator\Printer
{
	// Zeilenlänge, nach der ein Zeilenumbruch erfolgt
	public int $wrapLength = 120;
	// Einrückungszeichen, kann durch eine Sequenz von Leerzeichen ersetzt werden
	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 Gruppen von 'use statements' für Klassen, Funktionen und Konstanten
	public int $linesBetweenUseTypes = 0;
	// Position der öffnenden geschweiften Klammer für Funktionen und Methoden
	public bool $bracesOnNextLine = true;
	// Platziert einen einzelnen Parameter auf einer Zeile, auch wenn er ein Attribut hat oder unterstützt wird
	public bool $singleParameterOnOneLine = false;
	// lässt Namespaces aus, die keine Klasse oder Funktion enthalten
	public bool $omitEmptyNamespaces = true;
	// Trennzeichen zwischen der rechten Klammer und dem Rückgabetyp von Funktionen und Methoden
	public string $returnTypeColon = ': ';
}

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

Der Standard-Printer formatiert den Code so, wie wir es in ganz Nette tun. Da Nette viel früher als PSR entstanden ist und PSR jahrelang keine Standards rechtzeitig lieferte, sondern teilweise erst mit mehrjähriger Verspätung nach Einführung eines neuen Features in PHP, kam es dazu, dass sich der Codierungsstandard in einigen Kleinigkeiten unterscheidet. Der größere Unterschied ist nur die Verwendung von Tabulatoren anstelle von Leerzeichen. Wir wissen, dass die Verwendung von Tabulatoren in unseren Projekten die Anpassung der Breite ermöglicht, was für Menschen mit Sehbehinderungen unerlässlich ist. Ein Beispiel für einen kleinen Unterschied ist die Platzierung der geschweiften Klammer auf einer separaten Zeile bei Funktionen und Methoden, und zwar immer. Die Empfehlung von PSR erscheint uns unlogisch und führt zu einer Verringerung der Code-Übersichtlichkeit.

Typen

Jeder Typ oder Union-/Intersection-Typ kann als String übergeben werden, Sie können auch vordefinierte Konstanten für native Typen verwenden:

use Nette\PhpGenerator\Type;

$member->setType('array'); // oder Type::Array;
$member->setType('?array'); // or Type::nullable(Type::Array);
$member->setType('array|string'); // or 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 Eigenschaften oder Parametern usw.:

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 auch Parameter an Literal übergeben und sie mithilfe von Platzhaltern in gültigen PHP-Code formatieren lassen:

new Literal('substr(?, ?)', [$a, $b]);
// generiert beispielsweise: substr('hello', 5);

Ein Literal, das die Erstellung eines neuen Objekts darstellt, kann einfach mit der Methode new generiert werden:

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

Attribute

PHP 8-Attribute können zu allen Klassen, Methoden, Eigenschaften, Konstanten, Enums, Funktionen, Closures und Parametern hinzugefügt werden. Als Parameterwerte 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 Get- und Set-Operationen für Eigenschaften 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;

Generiert:

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

Eigenschaften und Property Hooks können abstrakt 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 Eigenschaften ein. Sie können unterschiedliche Zugriffsebenen für Lesen und Schreiben festlegen.

Die Sichtbarkeit kann entweder mit der Methode setVisibility() mit zwei Parametern oder mit setPublic(), setProtected() oder setPrivate() mit dem Parameter mode eingestellt werden, der angibt, ob sich die Sichtbarkeit auf das Lesen oder Schreiben der Eigenschaft bezieht. 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;

Generiert:

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

    protected(set) int $id;
}

Namensraum

Klassen, Eigenschaften, Schnittstellen und Enums (im Folgenden Klassen genannt) können in Namensräumen gruppiert werden, die durch die Klasse PhpNamespace repräsentiert werden:

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

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

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

Wenn die Klasse bereits existiert, wird eine Ausnahme ausgelöst.

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 den vollqualifizierten Namen einer Klasse, Funktion oder Konstante gemäß den definierten Aliasen zu vereinfachen, verwenden Sie die Methode simplifyName:

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

Den vereinfachten Namen einer Klasse, Funktion oder Konstante können Sie umgekehrt mit der Methode resolveName in den vollqualifizierten Namen umwandeln:

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

Übersetzungen von Klassennamen

Wenn eine Klasse Teil eines Namensraums ist, wird sie leicht unterschiedlich gerendert: Alle Typen (z. B. Typehints, Rückgabetypen, Name der Elternklasse, implementierte Schnittstellen, verwendete Eigenschaften und Attribute) werden automatisch übersetzt (wenn Sie dies nicht deaktivieren, siehe unten). Das bedeutet, dass Sie in den Definitionen vollständige Klassennamen verwenden müssen, und diese werden im resultierenden Code durch Aliase (gemäß den use-Klauseln) oder durch vollqualifizierte Namen 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 manuell
$method->addParameter('arg')
	->setType('Bar\OtherClass'); // wird zu \Bar\OtherClass übersetzt

echo $namespace;

// oder verwenden Sie PsrPrinter für die Ausgabe gemäß 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 Übersetzung kann wie folgt deaktiviert werden:

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

PHP-Dateien

Klassen, Funktionen und Namensräume können in PHP-Dateien gruppiert werden, die durch die Klasse PhpFile repräsentiert werden:

$file = new Nette\PhpGenerator\PhpFile;
$file->addComment('Diese Datei wurde automatisch generiert.');
$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 die Ausgabe gemäß PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printFile($file);

Ergebnis:

<?php

/**
 * Diese Datei wurde automatisch generiert.
 */

declare(strict_types=1);

namespace Foo;

class A
{
}

function foo()
{
}

Warnung: Es ist nicht möglich, weiteren Code außerhalb von Funktionen und Klassen zu Dateien hinzuzufügen.

Generierung nach bestehenden Mustern

Neben der Modellierung von Klassen und Funktionen mit der oben beschriebenen API können Sie diese auch automatisch nach bestehenden Mustern generieren lassen:

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

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

// erstellt eine Closure nach der angegebenen
$closure = Nette\PhpGenerator\Closure::from(
	function (stdClass $a, $b = null) {},
);

Die Körper von Funktionen und Methoden sind standardmäßig leer. Wenn Sie sie ebenfalls laden möchten, verwenden Sie diese Methode (erfordert die Installation des Pakets nikic/php-parser):

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

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

Laden aus PHP-Dateien

Funktionen, Klassen, Schnittstellen und Enums können auch direkt aus einem String geladen werden, der PHP-Code enthält. Zum Beispiel erstellen wir so ein ClassType-Objekt:

$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 Methodenkörpern ignoriert (z. B. bei Properties usw.), da diese Bibliothek keine API zur Bearbeitung hat.

Sie können auch direkt eine gesamte PHP-Datei laden, die eine beliebige Anzahl von Klassen, Funktionen oder sogar Namensräumen enthalten kann:

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

Der einleitende Kommentar der Datei und die strict_types-Deklaration werden ebenfalls geladen. Jeglicher andere globale Code wird hingegen ignoriert.

Es ist erforderlich, dass nikic/php-parser installiert ist.

Wenn Sie globalen Code in Dateien oder einzelne Anweisungen in Methodenkörpern manipulieren müssen, ist es besser, direkt die Bibliothek nikic/php-parser zu verwenden.

Class Manipulator

Die Klasse ClassManipulator bietet Werkzeuge zur Manipulation von Klassen.

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

Die Methode inheritMethod() kopiert eine Methode aus einer Elternklasse oder einer implementierten Schnittstelle in Ihre Klasse. Dies ermöglicht es Ihnen, die Methode zu überschreiben oder ihre Signatur zu erweitern:

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

Die Methode `inheritProperty()` kopiert eine Eigenschaft aus einer Elternklasse in Ihre Klasse. Dies ist nützlich, wenn Sie dieselbe Eigenschaft in Ihrer Klasse haben möchten, aber vielleicht mit einem anderen Standardwert:

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

Die Methode implement() implementiert automatisch alle Methoden und Eigenschaften aus einer gegebenen Schnittstelle oder abstrakten Klasse in Ihrer Klasse:

$manipulator->implement(SomeInterface::class);
// Jetzt implementiert Ihre Klasse SomeInterface und enthält alle seine Methoden

Ausgabe von Variablen

Die Klasse Dumper konvertiert eine Variable in parsbaren PHP-Code. 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 ['a', 'b', 123] aus

Kompatibilitätstabelle

PhpGenerator 4.1 ist kompatibel mit PHP 8.0 bis 8.4.

  1. Dokumentation
  2. PHP-Code-Generator
Version: 4.0