Why are PHP function signatures so inconsistent? [closed]

Question

I was going through some PHP functions and I could not help notice the following:

<?php
function foo(&$var) { }

foo($a); // $a is "created" and assigned to null

$b = array();
foo($b['b']);
var_dump(array_key_exists('b', $b)); // bool(true)

$c = new StdClass;
foo($c->d);
var_dump(property_exists($c, 'd')); // bool(true)
?>

Notice the array_key_exists() and property_exists() function. In the first one, the property name(key for an array) is the first parameter while in the second one it is the second parameter. By intuition, one would expect them to have similar signature. This can lead to confusion and the development time may be wasted by making corrections of this type.

Shouldn't PHP, or any language for that matter, consider making the signatures of related functions consistent?

Answer 1

What you propose is essentially changing signatures to many existing functions. Think for a minute what effect that would have on existing code. Now suppose PHP group have released PHP version N that changes signatures of 30% of the functions. Now imagine you have to write code that runs on both PHP v.N and PHP v.{N-1} - how much fun would that be?

Now imagine you are a hoster or corporative data center manager - what incentive would you have to support PHP v.N, provided that once you switch, all the code would be broken and the users will come to your office with pitchforks and torches?

Answer 2

Because PHP is The Language Without Any Specification.

And literally everyone could add a couple of functions, and there was no question of consistency at the beginning. SO, the mess.

Answer 3

Most good languages are and strive to be consistent.

It is just the reality of the state of PHP. As StasM mentioned, it would be a nightmare to try and switch things like that after the fact. It would affect too much existing code. Often PHP simply deprecates functions and creates newer better functions that are more consistent, but that can take a lot of time.

I think successful PHP programmers either remember the particular syntax or use software that automatically tells them the syntax.

Answer 4

The major source of inconsistency is that many (most?) of the php in built functions are really wrappers around some C library. The initial thinking was "I am wrapping C function xxxx therefore I should keep the parameter order the same". When it came to writing a "pure php" function this thinking was extended to "xxxx takes file and options the new function takes a file name and options so it makes sense to have yyyy take the same parameters in the same order.

The big flaw here is that the underlying C libraries were very inconsistent to begin with.

Answer 5

The (a?) reason was to remain compatible with previous versions of PHP. Instead of changing function names that would break many applications, the functions remain. However, by intuition, yes consistent function naming should be taken into consideration for new languages.

I have to disagree with you on the fact development time is wasted. Learning PHP may take longer to understand the naming of certain functions, but once mastered (or at least aware of) it becomes a non issue.

Compatibility > Consistency (at least to PHP)