What features would you like to have in PHP? [closed]

Question

Since it's the holiday season now and everybody's making wishes, I wonder - which language features you would wish PHP would have added? I am interested in some practical suggestions/wishes for the language. By practical I mean:

1. Something that can be practically done (not: "I wish PHP would guess what my code means and fix bugs for me" or "I wish any code would execute under 5ms")
2. Something that doesn't require changing PHP into another language (not: "I wish they'd drop $ signs and use space instead of braces" or "I wish PHP were compiled, statically typed and had # in it's name")
3. Something that would not require breaking all the existing code (not: "Let's rename 500 functions and change parameter order for them")
4. Something that does change the language or some interesting aspect of it (not: "I wish there was extension to support for XYZ protocol" or "I wish bug #12345 were finally fixed")
5. Something that is more than a rant (not: "I wish PHP wouldn't suck so badly")

Anybody has any good wishes?

Mod edit: Stanislav Malyshev is a core PHP developer.

Answer 1

I wouldn't mind named parameters.

getData(0, 10, filter => NULL, cache => true, removeDups => true);
// instead of:
getData(0, 10, NULL, true, true);

// or how about:
img(src => 'blah.jpg', alt => 'an albino platypus', title => 'Yowza!');

Unfortunately the PHP devs shot that idea down already.

Answer 2

More dereferencing:

echo something_that_returns_array()[4];

Others have mentioned named parameters, and shorter array syntax. I wouldn't mind shorter object syntax, as well.

$a1 = array(1, 2, 3, 4);
$a2 = [1, 2, 3, 4];

$b1 = (object)array('name' => 'foo');
$b2 = {'name' => 'foo'}; // or something?

Answer 3

After working with PHP for about 13 years, and heavily with JS for about 4, there are a couple things I think PHP would do well to borrow from JS:

1) shorthand notation for Arrays and Objects. I believe this may have been discussed and shot down on Internals (so I hear – I don't like to see how the sausage is made), but I really, really find that the literal notation for arrays and objects in JS is a big productivity win.

For example:

$arr     = [1,2,3,4];
$assoc   = [foo=>'bar', baz=>'boo'];
$stdobj  = {foo->'bar', baz->'boo'};

Is (IMHO) just much easier to write and cleaner than

$arr     = array(1,2,3,4); // not too bad
$assoc   = array("foo"=>'bar', baz=>'boo'); // not too bad either
$stdobj  = new stdClass; // this gets pretty rough
$stdobj->foo = 'bar';
$stdobj->baz = 'boo';

I've heard that some concern about potential confusion was raised, but really, is this any more confusing than, say, heredoc notation? At very least, making a stdClass object in PHP is verbose enough to discourage the practice, I think.

2) Being able to redefine previously-defined functions and methods would be really useful. It would particular simplify situations extending a class and instantiating the new class is either overly complex or impractical. I do think we should avoid redefinition of core/non-userspace functions and methods, though.

---

In addition to those two, I think PHP must transparently support unicode. This is becoming more and more of a problem for developers, and the solutions currently offered in PHP are confusing and frequently non-performant. Making all standard string functionality unicode-friendly out of the box would be a massive win for PHP programmers.

Thanks for asking!

Answer 4

Things I would like, as a former long-time PHP apologist:

1. Shorter syntax for arrays. PHP arrays are one of the awesomest features of the language because of their flexibility, but it's a drag to write some_array_method($argity, array('key' => $value));. I believe this proposal was already eviscerated on the PHP mailing list unfortunately.
2. finally support
3. Attributes/annotations. These allow you to add custom behavior to a method in a way that allows code reuse. For example, in an MVC framework, one could define an AuthorizeAttribute that would indicate that a controller or action method requires the user to be authorized. The framework itself would be responsible for looking for the attributes and acting on them accordingly. I believe PHPUnit already uses a sort of attribute by putting them in docblock comments, which can be read using reflection, but putting actual functionality in docblock comments is certainly a hack.
4. Shorter lambda syntax. Instead of having to write function($x){ return $x*2;}, maybe I could write $x => return $x*2, or something. This is again something just sort of makes it a drag to use this feature. For example $results = array_filter(array(1,2,3), function($a) { return $a % 2; }): vs $results = array_filter(array(1,2,3), $a => return $a % 2 ); The former just has so much more plumbing that's basically irrelevant to the actual work you're trying to accomplish.
5. A built-in Decimal (fixed-point math) that supported math operations through the normal operators would be kind of nice, since we don't have operator overloading.
6. MOAR MAGIC METHODS. Magic methods are great. I could see PHP adding operator overloading via magic methods (I know this will basically never happen.) But in general, they provide really great ways to hook into the language and do cool things.

Answer 5

Make PHP truly object oriented. The slap on another global function evolution of PHP needs to end.

array_merge(array_filter(array_intersect_key($arr1, $arr2), "is_int"), $arr3);

This is hard for me to read. I have to make my own mental stack and sort of compile it myself. Basically it should read in the reverse. $dog->wakeup()->bark(); is easy to read compared to bark(wakeup($dog))

$arr1->array_intersect_key($arr2)->array_filter("is_int")->array_merge($arr3);

You've made the step towards enabling object/method support now please use it in actual core PHP functions.

Let's rename 500 functions and change parameter order for them.

Shifting this functionality to methods would enable them to be renamed using some consistently. Would it break any backwards compatibility if strings and arrays had their own methods?

Answer 6

A language-integrated-query-engine would be great. Sort of like what is available in .NET called LINQ. It would help sort through massive arrays of data, and standardize database access, so that fewer SQL-injection attacks succeed.

Answer 7

Oh. Type hinting for primitives. That would be nice.

Answer 8

I really wish for better unicode support out of the box. Most languages move in that direction but PHP still have strange commands littered all over.

PHP strings are just plain byte arrays. Their content is non-portable as it is dependent on the current default encoding.

The same applies to the representation built by serialize. It contains a length-prefixed byte representation of the string without actually storing any encoding information.

Most PHP (string) functions have no clue about Unicode. For a detailed list including each function’s risk level, refer to: http://www.phpwact.org/php/i18n/utf-8

http://blog.ginkel.com/2010/03/php-unicode-support-or-the-lack-thereof/

Answer 9

Make strings object like, with built in methods to replace the inconsistently named and parametered non-object ones. e.g.

$subject->replace($search,$replace);
$string->split($separator);
$string->trim();

etc.

Edit: one more thing: These methods should always expect and emit UTF-8, except for ones specifically intended to deal with encodings. If input is invalid UTF-8, an exception should be thrown, even if the output of the function wouldn't be affected by the encoding.

Answer 10

1) I would love for newly instantiated objects to return "$this" so I can method chain, $user = new User('john')->setLastName('Doe')->save();

2) If you've ever used ruby, and most recently node, they have a great interactive shell (IRB). I would love for PHP to have one that was actually useful.

3) Traits/Mixins, but I hear those are on the way.

4) I want to second the short array $myArray = ['my', 'array'];

5) Consistent naming/order (i.e. needle haystack)

Answer 11

1) please get rid of includes(). References to other files should be references, and not actually place the contents of one source code file into another. Far too many PHP programmers use includes() as a type of function call rather than a means to reference a library. This leads to all sorts of ambiguity in variable state and unstable code. Replace this with a Perl-like 'use' command.

2) please provide an out of the box method of compiling a PHP application into a single distributable bytecode file or executable. This will greatly enhance the appeal of PHP as a commercial development language. This should be a basic component of the language. Dont worry about the html files used for an application's GUI because...

3) please get rid of the ability to embed PHP tags into HTML. Or at least provide a 'no embed' mode. This is an absolute mess and encourages bad design by mixing application logic and presentation together. Developers should be using templates for display and not slapping PHP files together and hoping for the best.

Signed,

GrandmasterB

ps: dont listen to what others here say, I've been nice all year

Answer 12

An ini directive to E_ERROR on undefined constants, rather than assume it's a string with E_NOTICE.

Answer 13

Normalize the global namespace with a well thought-out naming convention that makes sense to new-comers!

To quote our beloved Jeff Atwood: PHP sucks but it doesn't matter!

Answer 14

Strings should be objects

Answer 15

1) Shorter array/object syntax, a la JavaScript (as previously mentioned)

2) Allow const variables to allow the result of a calculation like define() does.

3) Chaining directly from the constructor: new User()->name('Ryan');

4) Array dereferencing: something_that_returns_array()[4];

5) Expanded SPL support. SPL does a decent job of reimagining string and array functions (among other things) as objects. Expanding SPL could solve a lot of gripes about the language being so janky.

6) Using ArrayObject() should be as transparent as using array(). You should be able to do things like array_filter($array_object_instance) without doing array_filter($array_object_instance->getArrayCopy()). Even better, of course, would be $array_object_instance->filter().

7) Full-on Unicode would be nice.

8) Stop doing weird automatic type conversions. For example, you should not be able to echo a SimpleXMLElement object without first explicitly typecasting it as a string. Or at least, throw something when it happens (e.g., in strict mode, or whatever mode error_reporting(-1) is).

9) Support for either multiple threads, or some sort of evented/asynchronous callbacks. This matters most when trying to upload large files via cURL. Instead of old-skool threads, something like Apple's Grand Central Dispatch would be nice. Or even something JavaScript-like where you can make async requests and define callbacks.

10) Consistent naming/order (i.e. needle haystack) would be nice, but I think this could be better solved with SPL.

11) An officially supported interactive PHP shell, like IRB. Facebook has one called phpsh that was written in Python, but it lacks the polish I would like to see.

12) For the Reflection API, add support for (a) docblock comments on constants (global & class), and (b) support for parsing PHPDoc-like comments into a sensible data structure. There's a PECL package called "docblock" that attempts to do this, but it doesn't appear that the author got very far.

EDIT: 13) I would also love to see the ability to use ! and ? in function names -- like Ruby can.

Answer 16

1) Array comprehension in the style of Python list comprehension:

$newlist = array($x->something for $x in $oldlist);

//with short array syntax:
$newlist = [$x->something for $x in $oldlist];

2) Short array syntax

$newlist = [1,2,3,4,...];

3) Make empty() not consider the string '0' as true

Answer 17

I would like to see a legit method of creating/defining CONSTANT arrays. There are a few hackish ways to simulate this kind of functionality but it would be nice if it was just a straight up feature of PHP. It would be nice if you could create an array in a way that is similar to Java's "final" declaration.

I created a login system that is very quick to setup. All you have to do is change the contents of an array in a text file to specify the fields you want for user information. Using a swath of for loops it handles everything from form generation and input sensitization, to database calls but it is all dependent on this original array.

The file with the array is locked down with permissions but once the array is moving around in the ether it is mutable. Although I feel the system is pretty secure I don't like leaving anything to chance. A method to finalize arrays would be nice for a situation like this.

New Idea!!

Ohhh, I thought of something else I would really really like in php. I would like some kind of system to control php file operations and directory operations similar to the way .htaccess works.

The .phpaccess file should trigger some kind same domain/same origin policy.

For example, If I were hosting many sites with virtual hosts I could have a .phpaccess file in a directory that would tell php to check the orgin of any scripts being executed which are trying to operate on my protected directory. If the script did not come from that directory or its sub-directories then the file operations / or socket operations will be denied.

I think a system like this would make virtual hosting a much safer environment. If you could place one of these at the top of each virtual host it would lessen the chance of someone finding a way to sneak in from a neighboring virtual host.

Also if it would be good to have a method of securing it in the inverse of this manner. ie, restricting the reach of scripts in a single directory to that directory.

Its the yin and the yang ya know!

Answer 18

My two biggest wishes as a hardcore PHP programmer:

1. Support finally. It's a big mess to fictionally get around this through flags or similar means.
2. I would LOVE to see support on C#'s syntax for getters and setters. When you have lots of getters and setters a simple syntax such as C#'s is a great performance booster instead of doing it the Java way and writing getter and setter methods. Magic methods are awesome in cases where you want to create members dynamically (for instance, if you want to give a template renderer some variables to use), but are no good for normal properties on which you would like the IDE to autocomplete, know their types, and so on. this would help make code smaller and still as readable and easy to use.

Answer 19

Language syntax: There are some good clues in pihipi and phpreboot of what developers are interested in (though phpreboot goes too far becoming JS).

Development methodology: It would greatly enhance the lifespan of PHP.net if such surveys were actually taken into account. Do not make any more willy-nilly afternoon IRC session syntax decisions.

Individual features: Some have been mentioned before, but I'll happily burn some karma to be extra blunt here:

• Unicode string type.
• Bigint (see Python).
• Runkit builtin to remove/rename/override builtin functions and classes, which aren't always that well designed.
• Modern OOP
  • multiple inheritance (instead of complexity to support seldom edge cases with clumsy traits syntax)
  • scalars can double as objects (see Python), e.g. array() works as ArrayObject, or strings as SplString (needs usable methods, all string funcs should be available as str::toupper())
• Deprecate the shitty shit \ namespace syntax, fix the parser, and adopt :: as alternative. You know, like a real language.
• Any variation of LINQ (allthough I don't trust you guys do devise a sensible syntax)
• or XML literals.
• Get rid of php.ini runtime behaviour and semantic switches. It takes out some of the excitement, true, but would benefit developers and user base.
• Yes, magic_quotes are not gone yet.
• Convert Zend Engine bytecode to PBC

Albeit, if this isn't obvious, I'd happily fund anyone else to do the latter, and kill off php.net as main implementation. :P
Oh, just noticed, it's community wiki. So there's a chance you're not actually here for the karma, but genuine interest. If so, look into the <b> issue </b> which seriously hurts the language (directoritis).

Answer 20

I'd love to see unification of Errors and Exceptions into a single concept (Exceptions). Its great to be able to catch exceptions and write them to a log, to find and fix bugs that way. But if there's something fundamentally wrong (read: PHP Error) in a codepath that is very rarely hit, there's no good way to funnel that info into that same database of issues.

Please, Santa, introduce a switch in php.ini that would make all errors into exceptions - ideally, exceptions I can catch in my code.

Answer 21

PHP suits me just fine as it is for knocking up small to medium websites; I must be a bit unimaginative, the only thing I could think of as a response to this question would be something that makes it scale better for high traffic sites.

I'm thinking in terms of spawning off processes to other cores, for example updating a database in one process while creating the output page in another process. A quick google search indicates that this can be simulated, but is not supported directly in php at present.

Answer 22

I really missed that scalar types are not treated as objects, and real objects can not act like any other type or object (except for string due to __toString()).

Answer 23

• support for enumerations (like java 1.5+)
• Be able to define method return types, in interfaces and classes
• support for annotations / metadata definition on properties and methods.
• be able to do strict type hinting for method scalar arguments.

Answer 24

Clean up "User Contributed Notes" on http://php.net. They are a real mess sometimes, while being a great value in general.

Answer 25

There are some fairly decent array functions in PHP, providing list processing capacity, with callbacks and create_function() providing a basic lambda calculus.

The main problem with it, is that it is far too verbose in PHP, a shorthand system would be excellent, particularly where the map/reduce commands are concerned.

More importantly, the list functions are not entirely complete:

• there is no foldr function, array_reduce() provides foldl
• array_map() should pass the key in the second argument, as array_walk() does
• an array_map_keys() could be useful for key modification
• list comprehension is very clunky, range(), array_fill() and array_fill_keys() only handle so many cases, and array_filter() is separate

I'm not aiming to make PHP in to Haskell, but PHP is often used for list type data structure manipulation and having a full set of tools in this regard would be useful.

Answer 26

Operator overloading:

$result = $MatrixA + $MatrixB * $MatrixC;

Answer 27

Add Exceptions instead of producing E_WARNING... It's very annoying that I can't use something such as:

try{
   $f = fopen('asd', 'r');
   flock($f, LOCK_SH);

   while(!feof($f)){
       echo fread($f, 512);
   }

   fclose($f);

}catch(IOException $ex){
   echo 'Oops, something wrong: '.$ex->getCode();
}

Of course, currently is not much practical but it's very annoying to receive:

WARNING

WARNING

WARNING

and I can't control the flow of code without writing my own error_handler and string sniffing which error has been produced (permission, incorrect filename or anything else; I don't mind about other sources of errors here) in order to throw correct exception.

I hope I haven't to explain why it's important.

PHP became Object-Oriented an amount time ago and we, programmers who use PHP, are looking forward for OO features, not introducing "goto"... When I found out it really happend, I thought it was an April Fool's day.

Answer 28

1. Consolidate the object model - make all objects extend base Object class. The Object class would (among other things) implement all the magic methods (so they'd be no longer magic!)

2. Move extensions to their own namespaces - unclutter the global namespace $conn = new \MySQLi\Connection();

3. Un-cripple the spl_autoload() function! Seriously, this is possibly one of the greatest features of PHP and also the most useless at the same time. spl_autoload is the default autoloader, that supports namespaces and multiple file extensions, but for some unknown reason requires the filenames to be lowercased. There is a bug report filled for this, but the staff replied they won't fix it because of backward compatibility. Right... it's not like every framework ships with it's own autoloader, since the default one is crippled!

Answer 29

Large file support. Pretty please?

See http://bugs.php.net/bug.php?id=27792 (though there may be more areas/functions that need attention as well).

Answer 30

Bring taint support up to latest version and include it in standard builds, preferably turned on in the default config http://wiki.php.net/rfc/taint

This would prevent XSS and SQL injection attacks by making people code properly.