This question already has an answer here:
Accessing variables through classes
(1 answer)
Closed 9 years ago.
I have the following class:
class validationHandler{
private $dataType; //set via constructor ...
private $validation = null;
private function requireValidation(){
if($this->validation == null){
$this->validation = loadDataFromJSONfile($this->dataType);
}
}
public function validate($data){
$this->requireValidation();
//validate... the rules are in the $validation-variable
}
}
When an object needs to validate some data, it makes a new validation-object and calls validate().
The first time something needs to be validated, the data is loaded from a json-file.
But: Sometimes I have several Objects which need the same validation-file. And This code loads the file for each Object.
Question: Is there a way to set $validation global, so that every object accesses the same variable, but without loosing the private-property?
(Notice that I have different validation-files and different kinds of objects. An objects tells the validationHanlder in __construct() which type it has, and which validation-file should be loaded. So I need $validation to be an array. (Didn't write it in the code, so it's more readable)
You want to create your variable using static, it sounds like.
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:
What are the advantages of using getters and setters instead of functions or simply public fields in PHP? [closed]
(15 answers)
Closed 5 years ago.
I need to know how getter and setter will work in PHP.
Because some interviewer asked tricky question about getter and setter.
I have failed to explain.
Can any one help me out?
Getters and setters are used to- at a later stage- make it possible to provide logic when the developer requests or sets a variable.
If you, for example, want to add a layer of validation to prevent your object from being misused. What if you wanted to make sure that the person’s $name variable is a string variable and not something else? Well, we can simply add that layer of validation to our setter method:
//Set the person's name.
public function setName($name){
if(!is_string($name)){
throw new Exception('$name must be a string!');
}
$this->name = $name;
}
In the PHP code above, we modified the setter method setName so that it validates the $name variable. Now, if a programmer attempts to set the $name variable to an array or a boolean, our function will throw an Exception. If we wanted to, we could also make sure that the $name variable is not a blank string.
Big thanks to this post.
Best of luck on your interview!
This question already has answers here:
Check variable is public php
(3 answers)
Closed 7 years ago.
I'm building a class. I intend for this class to be a sort of master parent class for a lot of API and database interactions later on.
Assume it looks something like this
class api_controller{
public $method = 'get';
private $table;
protected $table_id_column;
//Rest of code is really not needed
}
I was wondering if it was possible, from within PHP, to figure out if a variable is public,private, or protected if given the name? If it is, I had planned to use it as a checking station to make sure that no child methods alter data they've been restricted from accessing via an inherited method.
I had googled my question and came up with a lot of get_object_vars() vs get_class_vars() discussions, as well as a great many discussions about the difference between private, protected, and public. From my search of Object/Class functions through the PHP database, I didn't see anything that immediately jumped out at me as my answer.
I was thinking that it may have to be a try/catch statement done by accessing the variable and seeing if it throws an error (which would let me know if it was public/private), but I'm unsure of how to determine past that point. Even then, this method would have to be a member of the parent class, so it would have access to all of its own private variables.
Any Ideas?
Use Reflection:
$class = new ReflectionClass('api_controller');
$property = $class->getProperty('method');
// then you could check by
// there are also methods of isProtected, isPublic, etc...
if ($property->isPrivate()) {
// ..
}
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:
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); });