Hoe kan ik er voor zorgen dat PHP een error geeft op een teveel aan parameters als ik een functie van een class aanroep ?

<?php
abstract class basis {
  protected function _fout($k) {
    trigger_error('Eigenschap "' . $k . '" van object "'
      . get_class($this) . '" bestaat niet of is niet publiek.');
  }
  function __get(string $k) {$this->_fout($k);}
  function __set(string $k, $v) {$this->_fout($k);}
}
class test extends basis {
  function __construct() {}
}
$uit = new test('ik wil hier een error op');
?>
Ik zou niet zo snel weten waarom je dit zou willen gebruiken, maar als je dan toch gebruikmaakt van een Basis class dan zou ik daar ook gebruik van maken.

Heb een voorbeeldje voor je gemaakt.
Goed idee van func_num_args(). Kan ik dat ook gebruiken in de base class voor elke functie?

Ik had ooit een functie met meerdere argumenten:
<?php
class x {
 function y(string $a, string $b) : self {}
}
?>

En na refactoren werd dat
<?php
class x {
 function y(string $a) : self {}
}
?>

Maar ergens was ik vergeten de functie-call te wijzigen en bleef dit staan:
$x->y($a, $b); // geen error...
En toen bedacht ik me dat je in PHP altijd meer argumenten kan geven dan een functie aankan.
Het zou mooi zijn als dat vanuit de basisklasse kan worden opgelost, zodat mijn code meer strikt wordt.
Ad Fundum op 30/03/2022 08:55:14

Goed idee van func_num_args(). Kan ik dat ook gebruiken in de base class voor elke functie?

Mja, even mijn vorige voorbeeld aangepast naar dit voorbeeld.

Maar eigenlijk moet je dit echt niet willen. Als je dit bij iedere functie-aanroep doet, zorgt dat voor veel onnodige controles en functie-aanroepen.

Ik zou zeggen, als je een functie achteraf wijzigt, zoek dan even waar die functie nog meer wordt gebruikt en pas 'm daar aan. Je bent nu een oplossing aan het bedenken voor iets wat zich in de praktijk ooit misschien een keertje voordoet, maar wat wel je code vertroebelt met vele extra controles en functie-aanroepen. Ik denk niet dat je dat moet willen.
OK, bedankt voor het meedenken.
Ik was al bang dat het moeilijk zou gaan, maar die SO-links helpen wel met
<?php
if(func_num_args()>count(get_defined_vars())) throw new Exception('Too many args.');
?>

En de RFC (https://wiki.php.net/rfc/strict_argcount)
Heb je mijn voorbeeld ook gezien?
Ja, dat heb ik gezien, en het is wat je zegt. PHP is er niet voor gemaakt, dus moet ik het niet willen.
Ik denk dat dat inderdaad de enige juiste conclusie is. Overigens verbaast het me wel dat er geen warning wordt gegeven als er te veel argumenten worden meegegeven aan een functie. Wellicht is dat om dit soort dingen mogelijk te maken:

$rekenmachine = new Rekenmachine();
$rekenmachine->optellen(2, 5, 8, 34, 56, 104);
PHP heeft zelf ook dergelijke functies. bijvoorbeeld array_merge()

Daar mag je een aantal array's opgeven en die worden samengevoegd.

In de manual staat nu

array_merge(array ...$arrays): array

Maar een aantal PHP versies geleden was ...$array nog een onbekende syntax.
Daar kon je dus omheen door gewoon meerdere parameters mee te geven.

Reageren