PHP 8.4.0 RC4 available for testing

Kurucular ve Yıkıcılar

Kurucular

__construct(mixed ...$değerler = ""): void

PHP geliştiricilerin sınıflar için kurucu yöntemler bildirmesine imkan verir. Bir kurucu yöntemi olan sınıflar her yeni nesne oluşturuluşunda bu yöntemi çağırırlar, bu bakımdan nesne kullanılmadan önce yapılması gereken ilklendirmeler için kurucular çok uygundur.

Bilginize: Çocuk sınıflardan kurucusu olanlar için örtük olarak ebeveyn sınıfın kurucusu çağrılmaz. Ebeveyn sınıfın kurucusunu çocuk sınıftan çağırmak için, çocuk sınıf içinden parent::__construct() çağrısı yapılması gerekir. Çocuğun bir kurucu tanımlamaması halinde, normal sınıf yöntemi gibi (eğer private olarak tanımlanmadıysa) ana sınıftan miras alınabilir.

Örnek 1 - Miras almada kurucuların kullanımı

<?php
class AnaSınıf {
function
__construct() {
print
"AnaSınıf kurucusundayız\n";
}
}

class
AltSınıf extends AnaSınıf {
function
__construct() {
parent::__construct();
print
"AltSınıf kurucusundayız\n";
}
}

class
DiğerAltSınıf extends AnaSınıf {
// AnaSınıf'ın kurucusunu miras alır
}

// AnaSınıf kurucusunda
$obj = new AnaSınıf();

// AnaSınıf kurucusunda
// AltSınıf kurucusunda
$obj = new AltSınıf();

// AnaSınıf kurucusunda
$obj = new DiğerAltSınıf();
?>

Diğer yöntemlerin tersine, __construct() genişletilirken olağan bağımsız değişken sırası uyumluluk kurallarından muaftır.

Kurucular, karşılık gelen nesnelerinin somutlaştırılması sırasında çağrılan sıradan yöntemlerdir. Bu nedenle, gerekli olabilen, bir türe ve öntanımlı bir değere sahip olabilen rastgele sayıda bağımsız değişken tanımlayabilirler. Kurucu bağımsız değişkenleri, sınıf adından sonra gelen parantezlerin içine yerleştirilerek çağrılır.

Örnek 2 - Kurucu bağımsız değişkenlerinin kullanımı

<?php
class Point {
protected
int $x;
protected
int $y;

public function
__construct(int $x, int $y = 0) {
$this->x = $x;
$this->y = $y;
}
}
// Bağımsız değişkenlerin ikisini de aktaralım
$p1 = new Point(4, 5);
// Yalnız gerekli bağımsız değişkeni aktaralım.
// $y öntanımlı olan 0 değerini alır.
$p2 = new Point(4);
// isimli bağımsız değişken kullanımı (PHP 8.0 ve sonrası):
$p3 = new Point(y: 5, x: 4);
?>

Bir sınıf kurucuya sahip değilse veya kurucu bağımsız değişkensizse yaylı ayraçlar konmayabilir.

Eski tarz kurucular

PHP 8.0.0'dan önce, genel isim alanındaki sınıflar, eski tarz kurucu ile aynı adı taşıyan bir yöntemi yorumlar. Bu sözdizimi kaldırılmış olup bir E_DEPRECATED hatasıyla sonuçlanırsa da yöntem yine de bir kurucu olarak çağrılır. Hem __construct() hem de aynı adı taşıyan yöntem tanımlanmışsa __construct() çağrılır.

İsim alanlı sınıflarda veya PHP 8.0.0 öncesinde herhangi bir sınıfta, sınıfla aynı ismi taşıyan bir yöntemin özel bir anlamı yoktur.

Yeni kodlarda daima __construct() kullanın.

Kurucu Tanıtımı

PHP 8.0.0'dan itibaren, kurucu bağımsız değişkenleri de bir nesne özelliğine karşılık gelecek şekilde tanıtılabilir. Kurucu bağımsız değişkenlerinin kurucudaki bir özelliğe atanması, ancak başka şekilde çalıştırılmaması çok yaygındır. Kurucu tanıtımı, bu kullanım durumu için kestirme bir yol sağlar. Yukarıdaki örnek aşağıdaki gibi yeniden yazılabilir.

Örnek 3 - Kurucu özelliği tanıtımının kullanımı

<?php
class Point {
public function
__construct(protected int $x, protected int $y = 0) {
}
}

Bir kurucu bağımsız değişkeni değiştirici içerdiğinde, PHP bunu hem nesne özelliği hem de kurucu bağımsız değişkeni olarak yorumlar ve özelliğe bağımsız değişkenin değerini atar. Kurucu gövdesi boş olabilir veya başka ifadeler içerebilir. Bu ifadeler, bağımsız değişken değerleri karşılık gelen özelliklere atandıktan sonra yorumlanır.

Tüm bağımsız değişkenlerin tanıtımı gerekmez. Tanıtılan ve tanıtılmayan bağımsız değişkenleri herhangi bir sırayla karıştırmak ve eşleştirmek mümkündür. Tanıtılan bağımsız değişkenlerin kurucuyu çağıran kod üzerinde hiçbir etkisi yoktur.

Bilginize:

Görünürlük değiştirici (public, protected veya private) kullanımı, özellik tanıtımı yapmanın en olası yoludur, ancak diğer herhangi bir tek değiştirici de (salt okunur gibi) aynı etkiye sahip olacaktır.

Bilginize:

Nesne özellikleri, ortaya çıkabilecek motor belirsizliği nedeniyle callable türde olamaz. Tanıtılan bağımsız değişkenler de bu nedenle callable türde olamaz. Bununla birlikte, başka herhangi bir tür bildirimine izin verilir.

Bilginize:

Tanıtılan özellikler, hem özellik hem de işlev bağımsız değişkenlerinin yeniden yorumlanmasını sağladığından, hem özellikler hem de bağımsız değişkenler için tüm adlandırma kısıtlamaları geçerlidir.

Bilginize:

Tanıtılan kurucu bağımsız değişkenlerine yerleştirilen öznitelikler, hem özelliğe hem de bağımsız değişkene atanır. Tanıtılan kurucu bağımsız değişkenindeki öntanımlı değerler, özelliğe değil, yalnızca bağımsız değişkene atanır.

İlkendiricilerde new kullanımı

PHP 8.1.0 ve sonrasında, nesneler öznitelik bağımsız değişkenlerinin yanısıra öntanımlı bağımsız değişkenler, statik bağımsız değişkenler ve küresel sabitler olarak kullanılabilmektedir. Buna ek olarak, nesneler define()'a da aktarılabilmektedir.

Bilginize:

Dinamik veya dizge olmayan bir sınıf adının veya anonim bir sınıfın kullanımına izin verilmez. Bağımsız değişken genişletmeye izin verilmez. Desteklenmeyen ifadelerin bağımsız değişken olarak kullanımına izin verilmez.

Örnek 4 Using new in initializers

<?php

// All allowed:
static $x = new Foo;

const
C = new Foo;

function
test($param = new Foo) {}

#[
AnAttribute(new Foo)]
class
Test {
public function
__construct(
public
$prop = new Foo,
) {}
}

// Hiçbirine izin verilmez (derleme-anı hatası):
function test(
$a = new (CLASS_NAME_CONSTANT)(), // dinamik sınıf adı
$b = new class {}, // anonim sınıf
$c = new A(...[]), // bağımsız değişken genişletme
$d = new B($abc), // desteklenmeyen sabit ifadesi
) {}
?>

Statik kurucu yöntemleri

PHP, sınıf başına yalnızca tek bir kurucuyu destekler. Bununla birlikte, bazı durumlarda, bir nesnenin farklı girdilere sahip farklı yollarla oluşturulabilmesi istenebilir. Bunu yapmanın önerilen yolu, kurucu sarmalayıcıları olarak statik yöntemler kullanmaktır.

Örnek 5 - Statik kurucu yöntemlerinin kullanımı

<?php
class Product {

private ?
int $id;
private ?
string $name;

private function
__construct(?int $id = null, ?string $name = null) {
$this->id = $id;
$this->name = $name;
}

public static function
fromBasicData(int $id, string $name): static {
$new = new static($id, $name);
return
$new;
}

public static function
fromJson(string $json): static {
$data = json_decode($json, true);
return new static(
$data['id'], $data['name']);
}

public static function
fromXml(string $xml): static {
// Özelleştirmeler buraya.
$data = convert_xml_to_array($xml);
$new = new static();
$new->id = $data['id'];
$new->name = $data['name'];
return
$new;
}
}

$p1 = Product::fromBasicData(5, 'Widget');
$p2 = Product::fromJson($some_json_string);
$p3 = Product::fromXml($some_xml_string);

Kurucu, haricen çağrılmasını önlemek için özel veya korumalı yapılabilir. Bu durumda, sınıfı yalnızca statik bir yöntem örnekleyebilir. Aynı sınıf tanımında olduklarından, aynı nesne örneğinde olmasa bile özel yöntemlere erişebilirler. Özel kurucu isteğe bağlıdır ve kullanım durumuna bağlı olarak anlamlı olabilir veya olmayabilir.

Nesneyi örneklemenin farklı yollarını göstermek için üç tür public static yöntem vardır.

  • fromBasicData() gerekli bağımsız değişkenleri alıp kurucuyu çalıştırarak nesney oluşturur vesonucu döndürür.
  • fromJson() bir JSON dizesi alıp bazı önişlemlerden geçirip kurucuya gereken biçime dönüştürür ve yeni nesneyi döndürür.
  • fromXml() bir XML dizesi alıp önişemden geçirerek çıplak bir nesne oluşurur. Kurucu hala çağrılabilirse de bağımsız değişkenlerin tamamı seçimlik olduğundan yöntem bunları yoksayar. Sonucu döndürmeden önce değerleri doğrudan nesne özelliklerine atar.

Üç durumda da, static anahtar sözcüğü, kodun bulunduğu sınıfın adına çevrilir. Bu durumda, Product.

Yıkıcılar

__destruct(): void

PHP C++ gibi nesne yönelimli dillerdekine benzer bir yıkıcı tasarımına sahiptir. Yıkıcı yöntem, belli bir nesneye başka bir gönderim yoksa veya nesne kapanma sırasında açıkça yok edildiği anda çalıştırılacaktır.

Örnek 6 - Yıkıcı Örneği

<?php
class YıkıcıSınıf
{
function
__construct()
{
print
"Kurucu çalıştı\n";
}

function
__destruct()
{
print
"" . __CLASS__ . " yok ediliyor\n";
}
}

$obj = new YıkıcıSınıf();
?>

Kurucularda olduğu gibi ebeveyn yıkıcılar çocuk sınıflar için dolaylı olarak çağrılmayacaktır. Ebeveyn sınıfın yıkıcısının çalışması için çocuk sınıfın yıkıcısından parent::__destruct() çağrısının yapılması gerekir. Ayrıca, kuruculardaki gibi, bir çocuk sınıf kendisininkini gerçeklemediyse ebeveyninin yıkıcısını miras alabilir.

Betiğin icrası exit() kullanılarak durdurulsa bile yıkıcı çağrılacaktır. exit() işlevinin bir yıkıcı içersinde çağrılması kalan kapanma yordamlarının icrasını engelleyecektir.

Bilginize:

Yıkıcılar, HTTP başlıklarının gönderilmiş olmasını sağlamak için betik sonlanırken çağrılırlar. Betiğin kapanma aşamasındaki çalışma dizini bazı SAPI’lerde (Apache gibi) farklı olabilir.

Bilginize:

Bir yıkıcı içinden bir istisna oluşturmaya çalışmak (betiğin sonlandırılması sırasında) ölümcül hata ile sonuçlanır.

add a note

User Contributed Notes 14 notes

up
158
david dot scourfield at llynfi dot co dot uk
13 years ago
Be aware of potential memory leaks caused by circular references within objects. The PHP manual states "[t]he destructor method will be called as soon as all references to a particular object are removed" and this is precisely true: if two objects reference each other (or even if one object has a field that points to itself as in $this->foo = $this) then this reference will prevent the destructor being called even when there are no other references to the object at all. The programmer can no longer access the objects, but they still stay in memory.

Consider the following example:

<?php

header
("Content-type: text/plain");

class
Foo {

/**
* An indentifier
* @var string
*/
private $name;
/**
* A reference to another Foo object
* @var Foo
*/
private $link;

public function
__construct($name) {
$this->name = $name;
}

public function
setLink(Foo $link){
$this->link = $link;
}

public function
__destruct() {
echo
'Destroying: ', $this->name, PHP_EOL;
}
}

// create two Foo objects:
$foo = new Foo('Foo 1');
$bar = new Foo('Foo 2');

// make them point to each other
$foo->setLink($bar);
$bar->setLink($foo);

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 1 or Foo 2, so they OUGHT to be __destruct()ed
// but they are not, so we get a memory leak as they are still in memory.
//
// Uncomment the next line to see the difference when explicitly calling the GC:
// gc_collect_cycles();
//
// see also: http://www.php.net/manual/en/features.gc.php
//

// create two more Foo objects, but DO NOT set their internal Foo references
// so nothing except the vars $foo and $bar point to them:
$foo = new Foo('Foo 3');
$bar = new Foo('Foo 4');

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 3 or Foo 4 and as there are no more references
// to them anywhere, their __destruct() methods are automatically called here,
// BEFORE the next line is executed:

echo 'End of script', PHP_EOL;

?>

This will output:

Destroying: Foo 3
Destroying: Foo 4
End of script
Destroying: Foo 1
Destroying: Foo 2

But if we uncomment the gc_collect_cycles(); function call in the middle of the script, we get:

Destroying: Foo 2
Destroying: Foo 1
Destroying: Foo 3
Destroying: Foo 4
End of script

As may be desired.

NOTE: calling gc_collect_cycles() does have a speed overhead, so only use it if you feel you need to.
up
31
domger at freenet dot de
7 years ago
The __destruct magic method must be public.

public function __destruct()
{
;
}

The method will automatically be called externally to the instance. Declaring __destruct as protected or private will result in a warning and the magic method will not be called.

Note: In PHP 5.3.10 i saw strange side effects while some Destructors were declared as protected.
up
3
Hayley Watson
1 year ago
There are other advantages to using static factory methods to wrap object construction instead of bare constructor calls.

As well as allowing for different methods to use in different scenarios, with more relevant names both for the methods and the parameters and without the constructor having to handle different sets of arguments of different types:

* You can do all your input validation before attempting to construct the object.
* The object itself can bypass that input validation when constructing new instances of its own class, since you can ensure that it knows what it's doing.
* With input validation/preprocessing moved to the factory methods, the constructor itself can often be reduced to "set these properties to these arguments", meaning the constructor promotion syntax becomes more useful.
* Having been hidden away from users, the constructor's signature can be a bit uglier without becoming a pain for them. Heh.
* Static methods can be lifted and passed around as first class closures, to be called in the normal fashion wherever functions can be called, without the special "new" syntax.
* The factory method need not return a new instance of that exact class. It could return a pre-existing instance that would do the same job as the new one would (especially useful in the case of immutable "value type" objects by reducing duplication); or a simpler or more specific subclass to do the job with less overhead than a more generic instance of the original class. Returning a subclass means LSP still holds.
up
25
spleen
16 years ago
It's always the easy things that get you -

Being new to OOP, it took me quite a while to figure out that there are TWO underscores in front of the word __construct.

It is __construct
Not _construct

Extremely obvious once you figure it out, but it can be sooo frustrating until you do.

I spent quite a bit of needless time debugging working code.

I even thought about it a few times, thinking it looked a little long in the examples, but at the time that just seemed silly(always thinking "oh somebody would have made that clear if it weren't just a regular underscore...")

All the manuals I looked at, all the tuturials I read, all the examples I browsed through - not once did anybody mention this!

(please don't tell me it's explained somewhere on this page and I just missed it, you'll only add to my pain.)

I hope this helps somebody else!
up
8
iwwp at outlook dot com
4 years ago
To better understand the __destrust method:

class A {
protected $id;

public function __construct($id)
{
$this->id = $id;
echo "construct {$this->id}\n";
}

public function __destruct()
{
echo "destruct {$this->id}\n";
}
}

$a = new A(1);
echo "-------------\n";
$aa = new A(2);
echo "=============\n";

The output content:

construct 1
-------------
construct 2
=============
destruct 2
destruct 1
up
4
mmulej at gmail dot com
2 years ago
*<Double post> I can't edit my previous note to elaborate on modifiers. Please excuse me.*

If both parent and child classes have a method with the same name defined, and it is called in parent's constructor, using `parent::__construct()` will call the method in the child.

<?php

class A {
public function
__construct() {
$this->method();
}
public function
method() {
echo
'A' . PHP_EOL;
}
}
class
B extends A {
public function
__construct() {
parent::__construct();
}
}
class
C extends A {
public function
__construct() {
parent::__construct();
}
public function
method() {
echo
'C' . PHP_EOL;
}
}
$b = new B; // A
$c = new C; // C

?>

In this example both A::method and C::method are public.

You may change A::method to protected, and C::method to protected or public and it will still work the same.

If however you set A::method as private, it doesn't matter whether C::method is private, protected or public. Both $b and $c will echo 'A'.
up
5
david at synatree dot com
16 years ago
When a script is in the process of die()ing, you can't count on the order in which __destruct() will be called.

For a script I have been working on, I wanted to do transparent low-level encryption of any outgoing data. To accomplish this, I used a global singleton class configured like this:

class EncryptedComms
{
private $C;
private $objs = array();
private static $_me;

public static function destroyAfter(&$obj)
{
self::getInstance()->objs[] =& $obj;
/*
Hopefully by forcing a reference to another object to exist
inside this class, the referenced object will need to be destroyed
before garbage collection can occur on this object. This will force
this object's destruct method to be fired AFTER the destructors of
all the objects referenced here.
*/
}
public function __construct($key)
{
$this->C = new SimpleCrypt($key);
ob_start(array($this,'getBuffer'));
}
public static function &getInstance($key=NULL)
{
if(!self::$_me && $key)
self::$_me = new EncryptedComms($key);
else
return self::$_me;
}

public function __destruct()
{
ob_end_flush();
}

public function getBuffer($str)
{
return $this->C->encrypt($str);
}

}

In this example, I tried to register other objects to always be destroyed just before this object. Like this:

class A
{

public function __construct()
{
EncryptedComms::destroyAfter($this);
}
}

One would think that the references to the objects contained in the singleton would be destroyed first, but this is not the case. In fact, this won't work even if you reverse the paradigm and store a reference to EncryptedComms in every object you'd like to be destroyed before it.

In short, when a script die()s, there doesn't seem to be any way to predict the order in which the destructors will fire.
up
8
prieler at abm dot at
17 years ago
i have written a quick example about the order of destructors and shutdown functions in php 5.2.1:

<?php
class destruction {
var
$name;

function
destruction($name) {
$this->name = $name;
register_shutdown_function(array(&$this, "shutdown"));
}

function
shutdown() {
echo
'shutdown: '.$this->name."\n";
}

function
__destruct() {
echo
'destruct: '.$this->name."\n";
}
}

$a = new destruction('a: global 1');

function
test() {
$b = new destruction('b: func 1');
$c = new destruction('c: func 2');
}
test();

$d = new destruction('d: global 2');

?>

this will output:
shutdown: a: global 1
shutdown: b: func 1
shutdown: c: func 2
shutdown: d: global 2
destruct: b: func 1
destruct: c: func 2
destruct: d: global 2
destruct: a: global 1

conclusions:
destructors are always called on script end.
destructors are called in order of their "context": first functions, then global objects
objects in function context are deleted in order as they are set (older objects first).
objects in global context are deleted in reverse order (older objects last)

shutdown functions are called before the destructors.
shutdown functions are called in there "register" order. ;)

regards, J
up
8
Per Persson
12 years ago
As of PHP 5.3.10 destructors are not run on shutdown caused by fatal errors.

For example:
<?php
class Logger
{
protected
$rows = array();

public function
__destruct()
{
$this->save();
}

public function
log($row)
{
$this->rows[] = $row;
}

public function
save()
{
echo
'<ul>';
foreach (
$this->rows as $row)
{
echo
'<li>', $row, '</li>';
}
echo
'</ul>';
}
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>

Without the $nonset->foo(); line, Before and After will both be printed, but with the line neither will be printed.

One can however register the destructor or another method as a shutdown function:
<?php
class Logger
{
protected
$rows = array();

public function
__construct()
{
register_shutdown_function(array($this, '__destruct'));
}

public function
__destruct()
{
$this->save();
}

public function
log($row)
{
$this->rows[] = $row;
}

public function
save()
{
echo
'<ul>';
foreach (
$this->rows as $row)
{
echo
'<li>', $row, '</li>';
}
echo
'</ul>';
}
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>
Now Before will be printed, but not After, so you can see that a shutdown occurred after Before.
up
4
Yousef Ismaeil cliprz[At]gmail[Dot]com
11 years ago
<?php

/**
* a funny example Mobile class
*
* @author Yousef Ismaeil Cliprz[At]gmail[Dot]com
*/

class Mobile {

/**
* Some device properties
*
* @var string
* @access public
*/
public $deviceName,$deviceVersion,$deviceColor;

/**
* Set some values for Mobile::properties
*
* @param string device name
* @param string device version
* @param string device color
*/
public function __construct ($name,$version,$color) {
$this->deviceName = $name;
$this->deviceVersion = $version;
$this->deviceColor = $color;
echo
"The ".__CLASS__." class is stratup.<br /><br />";
}

/**
* Some Output
*
* @access public
*/
public function printOut () {
echo
'I have a '.$this->deviceName
.' version '.$this->deviceVersion
.' my device color is : '.$this->deviceColor;
}

/**
* Umm only for example we will remove Mobile::$deviceName Hum not unset only to check how __destruct working
*
* @access public
*/
public function __destruct () {
$this->deviceName = 'Removed';
echo
'<br /><br />Dumpping Mobile::deviceName to make sure its removed, Olay :';
var_dump($this->deviceName);
echo
"<br />The ".__CLASS__." class is shutdown.";
}

}

// Oh ya instance
$mob = new Mobile('iPhone','5','Black');

// print output
$mob->printOut();

?>

The Mobile class is stratup.

I have a iPhone version 5 my device color is : Black

Dumpping Mobile::deviceName to make sure its removed, Olay :
string 'Removed' (length=7)

The Mobile class is shutdown.
up
3
bolshun at mail dot ru
16 years ago
Ensuring that instance of some class will be available in destructor of some other class is easy: just keep a reference to that instance in this other class.
up
1
Jonathon Hibbard
14 years ago
Please be aware of when using __destruct() in which you are unsetting variables...

Consider the following code:
<?php
class my_class {
public
$error_reporting = false;

function
__construct($error_reporting = false) {
$this->error_reporting = $error_reporting;
}

function
__destruct() {
if(
$this->error_reporting === true) $this->show_report();
unset(
$this->error_reporting);
}
?>

The above will result in an error:
Notice: Undefined property: my_class::$error_reporting in my_class.php on line 10

It appears as though the variable will be unset BEFORE it actually can execute the if statement. Removing the unset will fix this. It's not needed anyways as PHP will release everything anyways, but just in case you run across this, you know why ;)
up
-2
Reza Mahjourian
18 years ago
Peter has suggested using static methods to compensate for unavailability of multiple constructors in PHP. This works fine for most purposes, but if you have a class hierarchy and want to delegate parts of initialization to the parent class, you can no longer use this scheme. It is because unlike constructors, in a static method you need to do the instantiation yourself. So if you call the parent static method, you will get an object of parent type which you can't continue to initialize with derived class fields.

Imagine you have an Employee class and a derived HourlyEmployee class and you want to be able to construct these objects out of some XML input too.

<?php
class Employee {
public function
__construct($inName) {
$this->name = $inName;
}

public static function
constructFromDom($inDom)
{
$name = $inDom->name;
return new
Employee($name);
}

private
$name;
}

class
HourlyEmployee extends Employee {
public function
__construct($inName, $inHourlyRate) {
parent::__construct($inName);
$this->hourlyRate = $inHourlyRate;
}

public static function
constructFromDom($inDom)
{
// can't call parent::constructFromDom($inDom)
// need to do all the work here again
$name = $inDom->name; // increased coupling
$hourlyRate = $inDom->hourlyrate;
return new
EmployeeHourly($name, $hourlyRate);
}

private
$hourlyRate;
}
?>

The only solution is to merge the two constructors in one by adding an optional $inDom parameter to every constructor.
up
-4
ziggy at start dot dust
2 years ago
Please note that constructor argument promotion is kind of half-baked (at least as of 8.1 and it does not look to be changed in 8.2) and you are not allowed to reuse promoted argument with other promoted arguments. For example having "old style" constructor:

<?php
public function __construct(protected string $val, protected Foo $foo = null) {
$this->val = $val;
$this->foo = $foo ?? new Foo($val);
}
?>

you will not be able to use argument promotion like this:

<?php
public function __construct(protected string $val, protected Foo $foo = new Foo($val)) {}
?>

nor

<?php
public function __construct(protected string $val, protected Foo $foo = new Foo($this->val)) {}
?>

as in both cases you will face "PHP Fatal error: Constant expression contains invalid operations".
To Top