This question already has answers here:
Passing an instance method as argument in PHP
(3 answers)
Closed 9 years ago.
I have a class in PHP like this:
class RandomNumberStorer{
var $integers = [];
public function store_number($int){
array_push($this->integers, $int);
}
public function run(){
generate_number('store_number');
}
}
...elsewhere I have a function that takes a function as a parameter, say:
function generate_number($thingtoDo){
$thingToDo(rand());
}
So I initialise a RandomNumberStorer and run it:
$rns = new RandomNumberStorer();
$rns->run();
And I get an error stating that there has been a 'Call to undefined function store_number'. Now, I understand that that with store_number's being within the RandomNumberStorer class, it is a more a method but is there any way I can pass a class method into the generate_number function?
I have tried moving the store_number function out of the class, but then I then, of course, I get an error relating to the reference to $this out of the context of a class/ instance.
I would like to avoid passing the instance of RandomNumberStorer to the external generate_number function since I use this function elsewhere.
Can this even be done? I was envisaging something like:
generate_number('$this->store_number')
You need to describe the RandomNumberStore::store_number method of the current instance as a callable. The manual page says to do that as follows:
A method of an instantiated object is passed as an array containing an
object at index 0 and the method name at index 1.
So what you would write is:
generate_number([$this, 'store_number']);
As an aside, you could also do the same in another manner which is worse from a technical perspective, but more intuitive:
generate_number(function($int) { $this->store_number($int); });
Related
This question already has answers here:
Why is type hinting necessary in PHP?
(6 answers)
Closed 4 years ago.
I am not able to understand what is the meaning of having any model or interface object into the method parameters.
For example,
public function checkRights(CommentInterface $comment)
{
return true;
}
so here what does CommentInterface do? why we are not only passing $comment here? How do you name this kind of thing in programming language?
I am new to object oriented php
Thanks.
This is called as Type Hinting.
Type hinting forces you to only pass objects of a particular type. This prevents you from passing incompatible values, and creates a standard if you're working with a team etc.,
check the following example:
class Profile {
private $setting;
public function __construct(Setting $setting)
{
$this->setting = $setting;
}
}
Because we need to use the $setting object inside the function, we inject/pass/type-hint it as a parameter.
This question already has answers here:
Dynamic static method call in PHP?
(9 answers)
Closed 6 years ago.
I have a couple of methods whose returns are being cached, and the cache key is the name of the method itself.
For instance, if this is my class
class tester {
static function test() {
$data = build_data();
cache(__METHOD__, $data);
}
}
The cache key value is tester::test.
I am implementing functionality to warm the cache. If I have all the cache keys, I could just call them one by one.
foreach ( $keys as $key ) {
$key();
}
But apparently, I can't call a string like 'tester::test' in this manner
Fatal error: Call to undefined function tester::test() ...
Do I have to do string parsing, to pull apart the class name and method, and then call them like $class::$method()? Or is there a simpler way to do it?
Thanks to Michael Lihs for linking the question in their comment; it turns out that call_user_func() does what I'm looking for.
This question already has answers here:
Calling closure assigned to object property directly
(12 answers)
Closed 8 years ago.
Is it possible to store a function in PHP object's properties like this:
class testing {
public $testvars;
function __construct(){
$this->testvars = function(){
return "Test String";
};
}
}
If it's possible, how do you call it?
I have been trying to call it like this:
$main = new testing();
$main->testvars();
But it throws an error:
Fatal error: Call to undefined method testing::testvars()
Try to call like
$this->testvars();
Considering that you are calling this function in the same class.And if you are calling this in another class you need to add this _call() function
public function __call($method, $args) {
if(isset($this->$method) && is_callable($this->$method)) {
return call_user_func_array(
$this->$method,
$args
);
}
}
to your new class and you can call it as
$main->testvars();
The real problem is: yes, PHP syntax has lack of support fur such situation. Neither {..} nor (..) may help you. The only way to access the property (without __call() magic) is:
class testing {
public $testvars;
function __construct(){
$this->testvars = function(){
return "Test String";
};
}
}
$obj = new testing();
echo call_user_func_array($obj->testvars, []);
So to pass your callback into call_user_func_array(). Note big difference with passing of [$obj, 'testvars'] (which won't work here, obviously) - since your property contains a callback, but not class contains such method. You may also use call_user_func() of course.
As for syntax support, there is an RFC which is proposed by Nikita Popov and which will allow you to resolve the issue with syntax only - so no additional function calls would be needed (Fortunately, that RFC was accepted and has real chances to be implemented in newer PHP versions).
You have to call your closure using call_user_func() or call_user_func_array().
So you can do the following:
$testing = new testing();
echo call_user_func($testing->testvars);
To call your closure outside of the class itself.
This question already has answers here:
PHP: Static and non Static functions and Objects
(5 answers)
Closed 8 years ago.
I am still learning OOP PHP and I keep swapping and changing between the following way of calling methods within an object
$obj = new Model();
$obj->method($param);
against
Model::method($params);
I understand the difference when I within the method as I can use $this in the first example, and I have to use self:: in the second.
Which is the correct way and what are the reasons of using each way
The reason I ask is I cannot find a suitable search term to research. I am currently reading a book on OOP and it will probably tell at some point, but would be nice to know now.
Foo::bar() calls the static class method, while $foo->bar() calls the instance method on an object. These are two completely different things. You do not need an object instance to call Foo::bar(), and in fact you do not have access to instance data when doing so. Foo::bar() is essentially nothing else but a regular function call like bar(), except that the function is attached to a class.
Instance methods act on a specific object instance:
class User {
protected $name;
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
public static function hi() {
// no access to $this->name here, since static
// methods are not bound to specific instances
echo 'Hi';
}
}
$dave = new User('Dave');
$mary = new User('Mary');
echo $dave->getName(); // Dave
echo $mary->getName(); // Mary
User::hi(); // Hi
Unless you understand this, you know nothing about OOP.
First example is a non-static call to the method, second a static call.
The first is better if you want to access private variables of your Model, second is better if you use the method like a normal function.
In general you should declare methods of the first type as static (public static function method(){}).
First case is invocation of method on class instance, second case is call of static method.
See http://php.net/manual/en/language.oop5.static.php
There is no "proper" way because both call types serve different purposes.
The first call type is the standard way of handling objects: You initialize a concrete instance of a class. This instance can have its own internal values and each instance can use these values to create a different result when you call the method with the same parameter.
The second call type is called static and operates directly on the class, there is no instance (hence no $this). There are some use cases for it, see this answer for Java, it's the same for PHP.
This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
PHP: How to chain method on a newly created object?
I can create an instance and call it's method via:
$newObj = new ClassName();
$newObj -> someMethod();
But is there any way I can do it in a shorter notation, an anonymous instance? I tried this:
(new ClassName())->someMethod();
But it doesn't seem to work as expected.
Additional Info: The method I want to call is public but not static.
PHP 5.4 supports it.
If you can't update you can workaround like this:
function yourclass($param) {
return new yourclass($param);
}
yourclass()->method();
Don't forget that your constructor must return $this;
Not that i know of.
But! - You could implement a Singleton Pattern and then call:
ClassName::getInstance()->someMethod();
Or, to cut it short ;)
ClassName::gI()->someMethod();
If someMethod does not refer to $this, you could also simply call it as a static function, though it wasn't defined as one:
ClassName::someMethod();
If the method is static and doesn't rely on any class variables (maybe you've put it in a class just for organisation purposes), you can simply call it staticly as phil is demonstrating with getInstance:
ClassName::someMethod()