PHP Kod Üreteci

Sınıflar, fonksiyonlar veya tam dosyalar için PHP kodu oluşturmak için bir araç mı arıyorsunuz?
  • PHP'deki en son yeniliklerin tümünü destekler (property hooks, enumlar, nitelikler vb.)
  • Mevcut sınıfları kolayca değiştirmenizi sağlar
  • Çıktı kodu PSR-12 / PER kodlama stili ile uyumludur
  • Olgun, kararlı ve yaygın olarak kullanılan bir kütüphane

Kurulum

Kütüphaneyi Composer aracını kullanarak indirip kurun:

composer require nette/php-generator

PHP uyumluluğunu tabloda bulabilirsiniz.

Sınıflar

Doğrudan ClassType kullanarak bir sınıf oluşturma örneğiyle başlayalım:

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

$class
	->setFinal()
	->setExtends(ParentClass::class)
	->addImplement(Countable::class)
	->addComment("Sınıf açıklaması.\nİkinci satır\n")
	->addComment('@property-read Nette\Forms\Form $form');

// kodu basitçe bir dizeye dönüştürerek veya echo kullanarak oluşturun:
echo $class;

Aşağıdaki sonucu döndürür:

/**
 * Sınıf açıklaması
 * İkinci satır
 *
 * @property-read Nette\Forms\Form $form
 */
final class Demo extends ParentClass implements Countable
{
}

Kodu oluşturmak için, echo $class'tan farklı olarak daha fazla yapılandırabileceğimiz sözde bir yazıcı da kullanabiliriz:

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

Sabitler (Constant sınıfı) ve değişkenler (Property sınıfı) ekleyebiliriz:

$class->addConstant('ID', 123)
	->setProtected() // sabitlerin görünürlüğü
	->setType('int')
	->setFinal();

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

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

Oluşturur:

final protected const int ID = 123;

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

public ?array $list = null;

Ve metotları ekleyebiliriz:

$method = $class->addMethod('count')
	->addComment('Say.')
	->setFinal()
	->setProtected()
	->setReturnType('?int') // metotlarda dönüş türleri
	->setBody('return count($items ?: $this->items);');

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

Sonuç:

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

PHP 8.0 tarafından tanıtılan tanıtılmış parametreler yapıcıya iletilebilir:

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

Sonuç:

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

Salt okunur özellikler ve sınıflar setReadOnly() fonksiyonu kullanılarak işaretlenebilir.

Eklenen özellik, sabit, metot veya parametre zaten mevcutsa, bir istisna fırlatılır.

Sınıf üyeleri removeProperty(), removeConstant(), removeMethod() veya removeParameter() kullanılarak kaldırılabilir.

Sınıfa mevcut Method, Property veya Constant nesnelerini de ekleyebilirsiniz:

$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);

Ayrıca mevcut metotları, özellikleri ve sabitleri cloneWithName() kullanarak farklı bir ad altında klonlayabilirsiniz:

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

Arayüz veya Trait

Arayüzler ve trait'ler oluşturabilirsiniz (InterfaceType ve TraitType sınıfları):

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

Trait kullanma:

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

Sonuç:

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

Enumlar

PHP 8.1'in getirdiği enumları şu şekilde kolayca oluşturabilirsiniz: (EnumType sınıfı):

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

echo $enum;

Sonuç:

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

Ayrıca skaler eşdeğerleri tanımlayabilir ve böylece “backed” bir enum oluşturabilirsiniz:

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

Her case'e addComment() veya addAttribute() kullanarak bir yorum veya #attributes eklemek mümkündür.

Anonim Sınıflar

Ad olarak null iletiriz ve anonim bir sınıfımız olur:

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

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

Sonuç:

$obj = new class ($val) {

	public function __construct($foo)
	{
	}
};

Genel Fonksiyonlar

Fonksiyonların kodunu GlobalFunction sınıfı oluşturur:

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

// veya PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printFunction($function);

Sonuç:

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

Anonim Fonksiyonlar

Anonim fonksiyonların kodunu Closure sınıfı oluşturur:

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

// veya PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printClosure($closure);

Sonuç:

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

Kısaltılmış Ok Fonksiyonları

Ayrıca bir yazıcı kullanarak kısaltılmış bir anonim fonksiyon yazdırabilirsiniz:

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

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

Sonuç:

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

Metot ve Fonksiyon İmzaları

Metotları Method sınıfı temsil eder. Görünürlüğü, dönüş değerini ayarlayabilir, yorumlar, nitelikler vb. ekleyebilirsiniz:

$method = $class->addMethod('count')
	->addComment('Say.')
	->setFinal()
	->setProtected()
	->setReturnType('?int');

Bireysel parametreleri Parameter sınıfı temsil eder. Yine, akla gelebilecek tüm özellikleri ayarlayabilirsiniz:

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

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

Sözde variadics parametreleri (veya splat operatörü) tanımlamak için setVariadic() kullanılır:

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

Oluşturur:

function count(...$items)
{
}

Metot ve Fonksiyon Gövdeleri

Gövde, setBody() metoduna bir kerede iletilebilir veya addBody()'nin tekrarlanan çağrılarıyla (satır satır) kademeli olarak iletilebilir:

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

Sonuç

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

Değişkenleri kolayca eklemek için özel yer tutucular kullanabilirsiniz.

Basit yer tutucular ?

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

Sonuç

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

Variadic yer tutucu ...?

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

Sonuç:

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

PHP 8 için adlandırılmış parametreleri ...?: kullanarak da kullanabilirsiniz:

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

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

Yer tutucu, ters eğik çizgi \? ile kaçılır

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

Sonuç:

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

Yazıcı ve PSR Uyumluluğu

PHP kodu oluşturmak için Printer sınıfı kullanılır:

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

$printer = new Nette\PhpGenerator\Printer;
echo $printer->printClass($class); // şununla aynı: echo $class

Diğer tüm öğelerin kodunu oluşturabilir, printFunction(), printNamespace() vb. gibi metotlar sunar.

Ayrıca, çıktısı PSR-2 / PSR-12 / PER kodlama stili ile uyumlu olan PsrPrinter sınıfı da mevcuttur:

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

Davranışı özel ihtiyaçlarınıza göre ayarlamanız mı gerekiyor? Printer sınıfından miras alarak kendi sürümünüzü oluşturun. Bu değişkenler yeniden yapılandırılabilir:

class MyPrinter extends Nette\PhpGenerator\Printer
{
	// satır kaydırmanın gerçekleştiği satır uzunluğu
	public int $wrapLength = 120;
	// girinti karakteri, boşluk dizisiyle değiştirilebilir
	public string $indentation = "\t";
	// özellikler arasındaki boş satır sayısı
	public int $linesBetweenProperties = 0;
	// metotlar arasındaki boş satır sayısı
	public int $linesBetweenMethods = 2;
	// sınıflar, fonksiyonlar ve sabitler için 'use ifadeleri' grupları arasındaki boş satır sayısı
	public int $linesBetweenUseTypes = 0;
	// fonksiyonlar ve metotlar için açılış küme parantezinin konumu
	public bool $bracesOnNextLine = true;
	// bir niteliği olsa veya desteklense bile tek bir parametreyi tek bir satıra yerleştirin
	public bool $singleParameterOnOneLine = false;
	// herhangi bir sınıf veya fonksiyon içermeyen ad alanlarını atlar
	public bool $omitEmptyNamespaces = true;
	// fonksiyonların ve metotların sağ parantezi ile dönüş türü arasındaki ayırıcı
	public string $returnTypeColon = ': ';
}

Standart Printer ve PsrPrinter tam olarak nasıl ve neden farklıdır? Neden pakette yalnızca bir yazıcı, yani PsrPrinter yok?

Standart Printer, kodu tüm Nette'de yaptığımız gibi biçimlendirir. Nette'nin PSR'den çok daha önce ortaya çıkması ve ayrıca PSR'nin yıllarca standartları zamanında değil, örneğin PHP'de yeni bir özelliğin tanıtılmasından birkaç yıl sonra teslim etmesi nedeniyle, kodlama standardı birkaç küçük ayrıntıda farklılık gösterir. Daha büyük fark sadece boşluklar yerine sekmelerin kullanılmasıdır. Projelerimizde sekmeler kullanarak, görme engelli kişiler için gerekli olan genişlik ayarlamasına izin verdiğimizi biliyoruz. Küçük bir farklılığın örneği, fonksiyonlarda ve metotlarda ve her zaman ayrı bir satırda küme parantezinin yerleştirilmesidir. PSR tavsiyesi bize mantıksız görünüyor ve kod okunabilirliğinin azalmasına yol açıyor.

Tipler

Herhangi bir tür veya union/intersection türü bir dize olarak iletilebilir, ayrıca yerel türler için önceden tanımlanmış sabitleri de kullanabilirsiniz:

use Nette\PhpGenerator\Type;

$member->setType('array'); // veya Type::Array;
$member->setType('?array'); // veya Type::nullable(Type::Array);
$member->setType('array|string'); // veya Type::union(Type::Array, Type::String)
$member->setType('Foo&Bar'); // veya Type::intersection(Foo::class, Bar::class)
$member->setType(null); // türü kaldırır

Aynısı setReturnType() metodu için de geçerlidir.

Değişmezler

Literal kullanarak herhangi bir PHP kodunu iletebilirsiniz, örneğin özelliklerin veya parametrelerin varsayılan değerleri için vb:

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;

Sonuç:

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

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

Ayrıca Literal'a parametreler iletebilir ve bunları yer tutucuları kullanarak geçerli PHP koduna biçimlendirmesini sağlayabilirsiniz:

new Literal('substr(?, ?)', [$a, $b]);
// örneğin oluşturur: substr('hello', 5);

Yeni bir nesnenin oluşturulmasını temsil eden bir değişmez, new metodu kullanılarak kolayca oluşturulabilir:

Literal::new(Demo::class, [$a, 'foo' => $b]);
// örneğin oluşturur: new Demo(10, foo: 20)

Nitelikler

PHP 8 niteliklerini tüm sınıflara, metotlara, özelliklere, sabitlere, enumlara, fonksiyonlara, closure'lara ve parametrelere ekleyebilirsiniz. Parametre değerleri olarak #literals de kullanılabilir.

$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;

Sonuç:

#[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

Property hooks (PropertyHook sınıfı tarafından temsil edilir) kullanarak, PHP 8.4'te tanıtılan bir özellik olan özellikler için get ve set işlemlerini tanımlayabilirsiniz:

$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;

Oluşturur:

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

Özellikler ve property hooks soyut veya final olabilir:

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

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

Asimetrik Görünürlük

PHP 8.4, özellikler için asimetrik görünürlük sunar. Okuma ve yazma için farklı erişim seviyeleri ayarlayabilirsiniz.

Görünürlük, iki parametreli setVisibility() metoduyla veya görünürlüğün özelliğin okunmasına mı yoksa yazılmasına mı uygulanacağını belirten mode parametresiyle setPublic(), setProtected() veya setPrivate() kullanılarak ayarlanabilir. Varsayılan mod 'get''tir.

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

$class->addProperty('name')
    ->setType('string')
    ->setVisibility('public', 'private'); // okuma için public, yazma için private

$class->addProperty('id')
    ->setType('int')
    ->setProtected('set'); // yazma için protected

echo $class;

Oluşturur:

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

    protected(set) int $id;
}

Ad Alanı

Sınıflar, özellikler, arayüzler ve enumlar (bundan sonra sınıflar olarak anılacaktır), PhpNamespace sınıfı tarafından temsil edilen ad alanlarında gruplandırılabilir:

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

// ad alanında yeni sınıflar oluşturun
$class = $namespace->addClass('Task');
$interface = $namespace->addInterface('Countable');
$trait = $namespace->addTrait('NameAware');

// veya mevcut bir sınıfı ad alanına ekleyin
$class = new Nette\PhpGenerator\ClassType('Task');
$namespace->add($class);

Sınıf zaten mevcutsa, bir istisna fırlatılır.

Use yan tümceleri tanımlayabilirsiniz:

// 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');

Tanımlanan takma adlara göre tam nitelikli bir sınıf, fonksiyon veya sabit adını basitleştirmek için simplifyName metodunu kullanın:

echo $namespace->simplifyName('Foo\Bar'); // 'Bar', çünkü 'Foo' mevcut ad alanıdır
echo $namespace->simplifyName('iter\range', $namespace::NameFunction); // 'range', tanımlanan use ifadesi nedeniyle

Tersine, basitleştirilmiş bir sınıf, fonksiyon veya sabit adını resolveName metodunu kullanarak tam nitelikli bir ada dönüştürebilirsiniz:

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

Sınıf Adı Çözümlemesi

Bir sınıf bir ad alanının parçası olduğunda, biraz farklı oluşturulur: tüm türler (örneğin, tür ipuçları, dönüş türleri, üst sınıf adı, uygulanan arayüzler, kullanılan özellikler ve nitelikler) otomatik olarak çözümlenir (bunu kapatmazsanız, aşağıya bakın). Bu, tanımlarda tam sınıf adlarını kullanmanız gerektiği ve bunların sonuç kodunda takma adlarla (use yan tümcelerine göre) veya tam nitelikli adlarla değiştirileceği anlamına gelir:

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

$class = $namespace->addClass('Demo');
$class->addImplement('Foo\A') // A olarak basitleştirilecek
	->addTrait('Bar\AliasedClass'); // AliasedClass olarak basitleştirilecek

$method = $class->addMethod('method');
$method->addComment('@return ' . $namespace->simplifyType('Foo\D')); // yorumlarda manuel olarak basitleştiriyoruz
$method->addParameter('arg')
	->setType('Bar\OtherClass'); // \Bar\OtherClass olarak çözümlenecek

echo $namespace;

// veya PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printNamespace($namespace);

Sonuç:

namespace Foo;

use Bar\AliasedClass;

class Demo implements A
{
	use AliasedClass;

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

Otomatik çözümleme şu şekilde kapatılabilir:

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

PHP Dosyaları

Sınıflar, fonksiyonlar ve ad alanları, PhpFile sınıfı tarafından temsil edilen PHP dosyalarında gruplandırılabilir:

$file = new Nette\PhpGenerator\PhpFile;
$file->addComment('Bu dosya otomatik olarak oluşturulmuştur.');
$file->setStrictTypes(); // declare(strict_types=1) ekler

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

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

echo $file;

// veya PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printFile($file);

Sonuç:

<?php

/**
 * Bu dosya otomatik olarak oluşturulmuştur.
 */

declare(strict_types=1);

namespace Foo;

class A
{
}

function foo()
{
}

Uyarı: Dosyalara fonksiyonlar ve sınıflar dışında başka kod eklemek mümkün değildir.

Mevcut Olanlara Göre Oluşturma

Sınıfları ve fonksiyonları yukarıda açıklanan API kullanarak modellemenin yanı sıra, mevcut kalıplara göre otomatik olarak oluşturulmalarını da sağlayabilirsiniz:

// PDO sınıfıyla aynı bir sınıf oluşturur
$class = Nette\PhpGenerator\ClassType::from(PDO::class);

// trim() fonksiyonuyla aynı bir fonksiyon oluşturur
$function = Nette\PhpGenerator\GlobalFunction::from('trim');

// belirtilene göre bir closure oluşturur
$closure = Nette\PhpGenerator\Closure::from(
	function (stdClass $a, $b = null) {},
);

Fonksiyonların ve metotların gövdeleri varsayılan olarak boştur. Bunları da yüklemek istiyorsanız, bu yöntemi kullanın (nikic/php-parser paketinin yüklenmesini gerektirir):

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

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

PHP Dosyalarından Yükleme

Fonksiyonları, sınıfları, arayüzleri ve enumları doğrudan PHP kodu içeren bir dizeden de yükleyebilirsiniz. Örneğin, bir ClassType nesnesini şu şekilde oluştururuz:

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

	class Demo
	{
		public $foo;
	}
	XX);

PHP kodundan sınıfları yüklerken, metot gövdeleri dışındaki tek satırlık yorumlar (ör. özelliklerde vb.) yoksayılır, çünkü bu kütüphanenin bunlarla çalışmak için bir API'si yoktur.

Ayrıca, herhangi bir sayıda sınıf, fonksiyon veya hatta ad alanı içerebilen tüm bir PHP dosyasını doğrudan yükleyebilirsiniz:

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

Dosyanın başlangıç yorumu ve strict_types bildirimi de yüklenir. Tersine, diğer tüm genel kod yoksayılır.

nikic/php-parser'ın yüklenmesi gerekir.

Dosyalardaki genel kodu veya metot gövdelerindeki bireysel deyimleri manipüle etmeniz gerekiyorsa, doğrudan nikic/php-parser kütüphanesini kullanmak daha iyidir.

Sınıf Manipülatörü

ClassManipulator sınıfı, sınıfları manipüle etmek için araçlar sağlar.

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

inheritMethod() metodu, üst sınıftan veya uygulanan arayüzden bir metodu sınıfınıza kopyalar. Bu, metodu geçersiz kılmanıza veya imzasını genişletmenize olanak tanır:

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

`inheritProperty()` metodu, üst sınıftan bir özelliği sınıfınıza kopyalar. Sınıfınızda aynı özelliğe sahip olmak istediğinizde, ancak belki farklı bir varsayılan değerle yararlıdır:

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

implement() metodu, verilen arayüzden veya soyut sınıftan tüm metotları ve özellikleri sınıfınızda otomatik olarak uygular:

$manipulator->implement(SomeInterface::class);
// Artık sınıfınız SomeInterface'i uygular ve tüm metotlarını içerir

Değişken Dökümü

Dumper sınıfı, bir değişkeni ayrıştırılabilir PHP koduna dönüştürür. Standart var_export() fonksiyonundan daha iyi ve daha net bir çıktı sağlar.

$dumper = new Nette\PhpGenerator\Dumper;

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

echo $dumper->dump($var); // ['a', 'b', 123] yazdırır

Uyumluluk Tablosu

PhpGenerator 4.1, PHP 8.0 ila 8.4 ile uyumludur.

  1. Dokümantasyon
  2. PHP Kod Üreteci
versiyon: 4.0