I am currently writing code and want to make sure all the params that get passed to a function/method are valid. Since I am writing in PHP I don't have access to all the facilities of other languages like C, C++ or Java to check for parameters values and types

public function inscriptionExists($sectionId, $userId) // PHP


public boolean inscriptionExists(int sectionId, int userId) // Java

So I have to rely on exceptions if I want to make sure that my params are both integers.

Since I have a lot of places where I need to check for param validity, what would be the best way to create a validation/exception machine and avoid code duplication?

I was thinking on a static factory (since I don't want to pass it to all of my classes) with a signature like:

public static function factory ($value, $valueType, $exceptionType = 'InvalidArgumentException');

Which would then call the right sub process to validate based on the type.

Am I on the right way, or am I going completely off the road and overthinking my problem?


2 Answers 2


PHP provides type hinting for objects and arrays. Unfortunately, not for scalar types such as string or int.

There are various approaches. One is to use assert statements :

public function inscriptionExists($sectionId, $userId){

One needs to ensure assert is active at least during development :

assert_options(ASSERT_ACTIVE, 1)

You could write a utility class along these lines

class Check{

  public static function int(& $param, $name){
    if( !is_int($param) ){
       throw new InvalidArgumentException($name.' is not an integer');

and then

public function inscriptionExists($sectionId, $userId){
  Check::int($sectionId, 'sectionId');
  Check::int($userId, 'userId');
  • 1
    +1 for actually providing a solution to the problem instead of avoiding it like I did. Commented Dec 12, 2012 at 16:10

I think you are over-thinking your problem

In my opinion, dynamic typing is one of the features of PHP that makes it highly enjoyable to work with. Instead of enforcing strict typing rules, you can just document your function really well to indicate the parameters you expect. If the contract is not met, then results may vary and the fault is on the user of your function.

Plus if your code base is used only internally (by you and your team), you should have no problems with parameter types as you developped the code and should know how to use it. If your project is a library available to the public, good documentation is key. You should also have good unit tests to make sure your code behaves as expected and to provide examples on how to use your library.

I see you are trying to write Java code in PHP and that means that you still don't understand PHP well. When writing code in a given language, you should try to embrace the language features/philosophy instead of looking back to what you already know and trying to adapt.

  • I am not trying to write Java code in PHP, I used it only as an exemple, what I'm really trying to do is to make sure that all the pre condition for the function are met to make sure that I have a stable result and an higher traceability of the differents bugs that can occur du to bad method usage
    – JF Dion
    Commented Dec 12, 2012 at 15:39
  • @JFDion Well this is one of the risks of using a dynamic language. Fortunately, the advantages really outweight it and you should learn to take advantage of the dynamic nature of the language. I find that good documentation and unit tests really help to avoid such kind of bugs and bad usage. Commented Dec 12, 2012 at 15:46
  • The PHP code is making a shit toward this since you can have your function and force parameters to be arrays or instances of classes/interfaces, but since int, strings and other simple stuctures aren't managed through objects, you can't validate them based on type like in : function myFunction(array $myArray, myClass $object)
    – JF Dion
    Commented Dec 12, 2012 at 15:57
  • @JFDion While it is true that PHP provides such functionality, I recommend against using it. You don't seem to grok the advantages of duck typing and dynamic languages in general. PHP is a very badly designed language and is a trash full of unrelated partly-implemented features. Possibility to use static typing is one of those uncompleted features as you can't force primitive types as you mentioned. Once you go past these atrocities, PHP is a nice guy. You should try to avoid static typing altogether. Commented Dec 12, 2012 at 16:02

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.