Check if something is a function before calling it - php

Question

I have a class that looks a bit like this:
<?php
namespace App\Http\Controllers;
use Exception;
use Illuminate\Http\Request;
class FormatAddressController extends Controller
{
public function __construct()
{
$this->middleware(['api-auth']);
$this->middleware(['api-after']);
}
public function format(Request $request) {
// TODO first, get customer settings to see what functions to run, and how to run them
// but, assume that the settings come as an array where the key is the function name
// and the value is one of NULL, false, or settings to pass through to the function
$settings = ['isoAndCountry' => true, 'testFunc' => ['testSetting' => 'test setting value']];
$address = $request->input('address');
$errors = [];
foreach ($settings as $funcName => $funcSettings) {
try {
$address = $this->$funcName($funcSettings, $address); // every function has to return the modified address
} catch(Exception $e) {
$errors[$funcName] = $e;
}
}
return response()->json([
'address' => $address,
'errors' => $errors
]);
}
public function isoAndCountry($settings, $address) {
// TODO
return $address;
}
}
Now, when I call this function, isoAndCountry, through that settings loop I defined above, it works! It works just fine.
However I tried following this thread and checking is_callable and... it errors:
if (is_callable($this->$funcName)) {
try {
$address = $this->$funcName($funcSettings, $address); // every function has to return the modified address
} catch(Exception $e) {
$errors[$funcName] = $e;
}
}
How can I check if it's callable? Why doesn't this work?

Answer 1

You have to use method_exists here to check if the method really exists in the class.
foreach ($settings as $funcName => $funcSettings) {
if (method_exists($this, $funcName)) {
$this->$funcName($funcSettings, $address);
}
}
The reason why is_callable will not work in your scenario is because Laravel controllers has a __call magic method which will handle undefined methods, so running is_callable on any non existing methods would return true.
Take the following class as an example:
class A
{
public function __construct()
{
var_dump(is_callable([$this, 'testFunc']));
}
}
The output of new A would be false. However, if you add the following into the class:
public function __call($name, $arguments)
{
//
}
Now the output of the var_dump would return true.
You can read more about the __call scenario I've mentioned right here: https://www.php.net/manual/en/function.is-callable.php#118623
For more information about __call: https://www.php.net/manual/en/language.oop5.overloading.php#object.call

Answer 2

May be this can also solve the problem :
if(method_exists($this,$funcName)){ ... }

Answer 3

You can use
if (is_callable([$this, $funcName])) { ...
instead.
The way you have it written with is_callable($this->$funcName), it's going to look for a property called $funcName on $this, (which probably doesn't exist) and check if that's callable. If you use that array syntax it will evaluate the named method instead.
It may be simpler in this case to use
if (method_exists($this, $funcName)) {
since you're using it in another method of the same object, if the method exists it should be callable.

Answer 4

You need to differentiate between class properties and methods. For example in this class:
class A {
private $foo = null;
public function getFoo() {
return $this->foo;
}
}
the private $foo is property and can be checked by property_exists()
the public function getFoo() is method and can be checked by method_exists()
https://www.php.net/manual/en/function.property-exists.php
https://www.php.net/manual/en/function.method-exists.php
I think that $this->$funcName works only for properties.