PHP Class Logic, OOP, Validate API in each class?

Think of it as validating logged-in user when a user requests "logged-in users only" section of a web site. That is, user is validated every time a new request is made - majority of sites do this via session so it happens behind the scenes without users actually knowing (unless they known better :D) - you basically need to do the same with calls to API, i.e. every API request that requires a valid user needs to have user validation.

Putting it inside a constructor is probably not the best option, if for nothing else, the Balance class should not worry about validation - you should create a Validation class and call it statically if need to (of course, once you validate you can just store that state and keep validation true during a single request).

The best practice would be to decouple as much as possible. There are two schools of thought on constructors:

• Constructors should be used only for initialization (two stage construction)
• Constructors can "do work" (one stage construction)

The second is more convenient and even sensible in some cases, but the first makes your framework easier to test, which is very important.

You can also do some sort of lazy initialization (with or without the calls in the constructor) where validation is run once when it is needed, but not otherwise. This increases verbosity of the code, but it may be more efficient:

private $validated = false;
public function getAmount() {
   if (!$this->validated) {
      $this->validate();
   }
   return $this->amount;
}
public function validate() {
   $this->validated = true;
}

First of all, the code in your quote is invalid PHP syntax (lets call it pseudo code).

If you do the validation in the constructor, it will be called only the first time you do

$instance = new getBalance;

Then wehn you call $instance->getAmount(); $instance->getDate(); etc, it won't be called again.

Without knowing anything about your problem I would in fact call the validation from the construct like:

public function __construct(){
    $this->validate();
}

If that doesn't work for you, then elaborate.

I think with a custom setter and getter .. you can validate all values before you set them

Sample

    class Balance{

        private $amount ;
        private $date ;
        private $count  = 0 ;

        function __construct ($amount , $date)
        {
            $this->setAmount($amount);
            $this->setDate($date);

            // Do somthign to count
            $this->count++;
        }


        function getAmount()
        {
            return $this->amount ;
        }

        function getDate()
        {
            return $this->date ;
        }

        function setAmount ($amount)
        {
            //validate Amount
            $this->amount = $amount ;
        }

        function setDate($date)
        {
            //validate date 
            $this->date = $date ;
        }

        function getCount()
        {
            return $this->count ;
        }
    }



    $balance = new Balance(2500,date("Y-n-d",time()));
    echo $balance->getAmount() , " " , $balance->getDate();

I hope this helps

Thanks

:)

This is my solution (i'am not saying it's the best one):

Class getBalance(){

    private $isValid = false;

    public __construct() {
    //do validation
        if validation pass
            $this->isValid = true;
        else
        $this->isValid = false;
    }

    function getAmount(){
        if($isValid) {
            var amount = obeject->amount;
            return amount;
        }
        else
            return "object not valid";
    }

    function getDate(){
        var amount = obeject->date;
        return date;
    }

    function getCount(){
        var amount = obeject->count;
        return count;
    }
}

Some comments: I keep a variable isValid that tells me if the object passed validation during construction (So DO VALIDATE IN CONSTRUCTOR)

Each method before returning check whether the isValid is true or false if you want