Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 4 years ago.
Improve this question
I am currently working within CodeIgniter and I am struggling to understand how to properly use Anemic or Rich Entity Classes within my programming.
I am looking to create an anemic entity that has getters/setters, but I am wondering how this all works.
For instance:
I can use the object to set and get information while an instance of the object is being created for the first time, but when retrieving information from my database how do I return the information into an object so that I can use the objects methods?
I have heard of using Doctrine to map objects to a relational database but I have already created the database schema I want to use and I am unsure about getting Doctrine to map to an existing database.
I have thought about trying:
Using the __construct function to set all of the objects properties
using the array I get from the SQL query, which seems improper.
Creating an instance of the object and setting all the objects
properties to the values of the array I get from the SQL query, which seems tedious.
Creating a method within the object that takes the array I get from
the SQL query and assigns all of the values to the proper object
properties, which seems okay.
But my question is: Is there a universally accepted practice for doing this? (other than Doctrine)
I would suggest using Doctrine or other ORM tool, but if you want to DIY, here is small example of using reflection.
<?php
class Foo {
private $id;
private $name;
public function getId(){ return $this->id; }
public function getName(){ return $this->name; }
public function setName($name){ return $this->name = $name; }
}
$dataFromDb = [
[
'id' => 1,
'name' => 'John'
]
];
foreach ($dataFromDb as $row) {
$foo = new Foo();
$ref = new ReflectionClass('Foo');
foreach ($row as $propName => $propValue) {
$prop = $ref->getProperty($propName);
$prop->setAccessible(true);
$prop->setValue($foo, $propValue);
}
var_dump($foo);
}
Related
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 3 years ago.
Improve this question
I'm new in PHP OOP and curious about method. How to make method inside method (I dont know what its name)?
For example, I can access like this
<?php
$myClass = new CarClass;
$myClass->createNew->bodySection->setColor("red");
Just like Codeigniter for calling a Models or Library using this.
<?php
$this->myLibrary->getData()
It's different from method chaining where between method call there is no parameter, its like javascript.
Can I achieve that? Or any alternative?
Thank you
Given the code,
$myClass = new myCar;
$myClass->createNew->bodySection->setColor("red");
we can make the following statements:
myCar has a property named “createNew”.
createNew holds some unknown object
The unknown object has a property called bodySection
The property named bodySection contains an unknown object that has a method named setColor()
Clear as mud?
There are several ways this could be illustrated; here’s one:
class myCar {
public createNew;
public function __construct() {
$this->createNew = new Foo;
}
}
class Foo {
public bodySection;
public function __construct() {
$this->bodySection = new Bar;
}
}
class Bar {
public function setColor($color) {
echo "Color is $color";
}
}
$myClass = new MyClass;
$myClass->createNow->bodySection->setColor('red');
// output: Color is red
The first problem here is that “createNow” doesn’t make sense as a property; it’s an action, not something that a myCar would own or do.
Likewise, a bodySection would probably have a color as a property, to be set with its own setter method, not some external object.
Bottom line, making long chains of pointers is not something to seek after; rather, they’re probably better kept as short as possible. Otherwise your object probably knows too much about to many things.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
Is it a good practice to create query function inside Database class (which must be created with singletone pattern). Or better create another class with database interface, or something like that, and get database instance in constructor? (Sorry for my English :)
<?php
class Database
{
private static $_pdo = null;
private static function getDatabase() {
if (self::$_pdo === null) {
self::$_pdo = new PDO("mysql:host=localhost;dbname=contact_manager", 'root', '');
}
return self::$_pdo;
}
public static function query($query, $parameters) {
Database::_toArray($parameters);
$query = self::getDatabase()->prepare($query);
$query->execute($parameters);
$result = $query->fetchAll(PDO::FETCH_ASSOC);
return $result;
}
private static function _toArray(&$parameters) {
if (!is_array($parameters)) {
$parameters = array($parameters);
}
}
private function __construct() { }
private function __clone() { }
private function __wakeup() { }
}
?>
This is very wide theme is it good practice or not. As for me there're can be some points of view.
If you don't plan extend your project with another databases which queries should be called via same interface - this solution is OK
If we look at this from SOLID's point of view this is bad decision. According to SOLID you have to separate DB connection from queries. This is because of D-principle (dependency inversion) + S-principle (single responsibility). Also you have to define your own DatabaseInterface which you will use for injection your connection into Repositories - classes which encapsulate your DB queries.
However, this decision also depends on size of your project and your goal. If you just want to make everything right instead of inventing your own brand new bicycle, just take some framework like Symfony or Laravel and forget about this low-level stuff.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
I'm very new to php classes and I was wonder why do I need to declare it to a variable and set it as NEW?
Here is an example :
class myFirstClass {
function Version(){
return 'Version 1';
}
function Info(){
return 'This class is doing nothing';
}
}
$hola = new myFirstClass;
echo $hola->Version();
Why this won't work WITHOUT declare it to a variable and set it to NEW ?
In other words... Without this line :
$hola = new myFirstClass;
I'm so used to functions so it looks weird to me...
This is a basic principle of Object Oriented Programming (OOP). Let's use a library system for example. If you want to get the name of a book, you cannot just say "give me the name of the book", you have to know what book (by id, author, whatever).
In functions, you can write one that looks like this:
function get_book($id){ // code }
In OOP it doesn't really work that way. You have a class book that keeps a name. But that name is only for that given book.
class Book {
var $name;
public __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
}
In order to call the getName() function we need to have a book. This is what new does.
$book = new Book("my title");
Now if we use the getName() function on $book we'll get the title.
$book->getName(); // returns "my title"
Hope that helps.
You are right! It is not necessary to use the new operator:
class myFirstClass {
static function Version(){// static keyword
return 'Version 1';
}
function Info(){
return 'This class is doing nothing';
}
}
echo myFirstClass::Version();// direct call
To create an instance of a class, the new keyword must be used. An object will always be created unless the object has a constructor defined that throws an exception on error. Classes should be defined before instantiation (and in some cases this is a requirement).
If a string containing the name of a class is used with new, a new instance of that class will be created. If the class is in a namespace, its fully qualified name must be used when doing this.
The Basics
http://php.net/manual/en/language.oop5.basic.php
Classes and Objects
http://php.net/manual/en/language.oop5.php
This line:
$hola = new myFirstClass;
Is saying: create a new object called $hola, then put a new instance of myFirstClass into $hola. Now $hola is literally a object containing a new instance of myFirstClass.
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
I am new to PHP from the .net world and this is the code that i have,
class A
{
Album $album; // In C# .net i could have done this and assigned the display action album data to this
public function displayAction()
{
$form = new ButtonForm();
$id = (int)$this->params('id');
if (!$id) {
return $this->redirect()->toRoute('album', array('action'=>'add'));
}
$album = $this->getAlbumTable()->getAlbum($id);
return array(
'id' => $id,
'album' => $album,
'form' => $form
);
}
}
How can i do this is PHP ?
Consider that i come a pure object oriented technology. So help will be highly appreciated.
I know you can do type hinting in function arguments, but I am thinking that you can't with field variables of a class. Instead of Album $album; use public $album;. Then you can access it freely outside the object. e.g.
$obj = new A();
echo $obj->album;
Keep in mind though your var must be declared public to access it this way. private and protected will not allow access in the global scope. You will need to create accessor functions in that case.
EDIT
Also, whenever accessing field variables within your class use the $this keyword. So again, instead of $album you use $this->album.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 1 year ago.
Improve this question
When declaring an array as a class member, which way should it be done?
class Test1 {
private $paths = array();
public function __construct() {
// some code here
}
}
or
class Test2 {
private $paths;
public function __construct() {
$this->paths = array();
// some code here
}
}
Which one is better in terms of good practices and performance? What would you recommend?
I'd suggest doing this when declaring a class variable. A constructor can be overriden in extending classes, which might result in E_NOTICEs or even E_WARNINGs if any of your functions depend on this variable being an array (even an empty one)
If you are going to populate your array dynamically during initialization, do it in the constructor. If it contains fixed values, do it in the property declaration.
Trying to populate an array dynamically (e.g. by using the return value of a certain function or method) within the declaration results in a parse error:
// Function call is not valid here
private $paths = get_paths();
Performance is not a real concern here as each has its own use case.
In general, because I write mostly in other languages besides PHP, I like to declare my instance variables outside of the constructor. This let's me look at the top of a class and get an idea for all properties and their access modifiers without having to read the code.
For example, I really don't like methods like this
// ...
// whole bunch of code
// ...
public function initialize() {
$this->foo = array();
// some other code to add some stuff to foo
}
Now, if I just look at the class, I can't be sure there is a variable foo even available. If there is, I don't know if I have access to it from anywhere outside the instance.
If instead I have:
public $foo = array();
at the top of my class, I know that foo is an instance property, and that I can access it from elsewhere.
There are no performance implications. Stop obsessing over things that don't matter - concentrate on performance problems that ARE there: measure first, optimize only the top offenders.