New Features in PHP 5.6

http://www.sitepoint.com/new-features-php-5-6/

by gulbrandr • 13 years ago

70 62 13 years ago

sitepoint.com

poobrains• 13 years ago

Any word on when all functions will be UTF-8 safe?

jcampbell13• 13 years ago

Other than "substring", how often do you really run into this problem? I have never had a problem with PHP and UTF-8.

Oh, good luck trying to match all unicode punctuation with Python/Javascript. With php it is as simple as preg_match('/\pP/u'

I deal with a lot of UTF-8 issues, and while php is super ugly, there are pretty good solutions in cases where it requires ugly hacks in other languages.

Zancarius2• 13 years ago

strlen and strpos are two fairly commonly used functions that come to mind.

acabal• 13 years ago

Pretty often. Yes you can use mb_* functions everywhere but not all string functions have an mb_* counterpart, and forget just once and you risk blowing up the entire rest of the request. Not to mention times when you have to use a 3rd party library that doesn't bother with mb_*.

Native UTF is such an important thing... I know it's tough to implement, but come on guys!

dhoulb2• 13 years ago

I do run into this fairly regularly. The mb_ functions are solid, but I was hitting something the other day where a character, I think it was NBSP, was causing a string to output empty in 5.4 (but was working fine in 5.3).

I think there's something that needs to be fixed at a core level, maybe with PHP 6, that just guts how the language deals with multibyte. Even if it means making it backwards incompatible. I'd probably take the opportunity to drop the mb_ functions, namespace the entire language, and make it multibyte by default. Needs doing eventually!

nikic• 13 years ago

It's a common misconception. Many people don't understand that the normal string functions are perfectly safe on UTF-8, as long as you don't use hardcoded lengths or offsets. I.e. substr($str, 0, 50) is not safe due to the explicit "50" in there, but substr($str, 0, strpos($str, "foo")) will work correctly on any well-formed UTF-8.

If people have encoding issues in PHP it usually just means that they didn't manage to set up their database properly (you know, finding which one of the 10 encoding options in MySQL is the right one ;)

From my personal experience I've had a lot more issues with encoding in Python than I had in PHP - exactly because PHP ignores encoding and lets me deal with it.

Joeri• 13 years ago

Sorry, but PHP's string handling is abysmal.

- strlen can't be used for length checks if you care about length in characters, a problem compounded when you use a real database where field lengths are defined in characters instead of bytes

- the only way to iterate char by char instead of byte per byte is to use mb_substr, as there is no trick to make $str[$i] do anything but return bytes.

- the string and array API's have inverse ordering of their parameters, which means that after a decade of writing PHP I still can't remember which is which without looking it up

- Typing mb_ in front of everything is ugly enough, but it also makes autocompletion tricky, especially since the strings don't have methods. (e.g. $str->pos())

- Speaking of which, since the strings don't have methods, they stick out like a sore thumb in OO code. String and array handling code invariably ends up ugly unless you write everything procedural style (and then you have other issues).

- Sort() cannot be made to sort unicode on windows, regardless of which parameters you give it. In fact, the only way to sort unicode on windows is by using the Collator from the intl extension. Part of that is microsoft's fault by not supporting UTF-8 in the windows API's at all, but PHP isn't helping.

- If you don't care about windows, the proper way to sort text is first calling setlocale(LC_COLLATE, "en_US.UTF8") and then passing the SORT_LOCALE_STRING argument as second parameter to every call to sort(). Ugly, ugly, ugly.

- natsort(), aka "natural sort" cannot be used to sort text like a human would expect, in any context. It always produces invalid results, even for ANSI codepages. (e.g. try to sort resume, rope and résumé)

- The use of utf8_decode and utf8_encode is actively harmful in almost all circumstancces. There is never a good reason to use them, since the very rare case where you need them iconv or mb_convert_encoding are better suited. Yet, the PHP documentation doesn't tell you this, causing lots of people to be led astray (as I once was).

- Oh yeah, and there are no less than three API's for unicode string handling, the mb_ functions, the iconv_ functions and the grapheme_ functions. What's the difference? I don't know, and I really can't be bothered to read PHP's source to find out.

- htmlentities() always requires the parameters ENT_QUOTES, "UTF-8" to do its job securely (well, almost, as it doesn't encode forward slash which OWASP recommends). Unless you use a wrapper, your code is yet again uglified.

- The secure way to JSON-encode text is, and I kid you not, json_encode($data, JSON_HEX_TAG|JSON_HEX_APOS|JSON_HEX_QUOT|JSON_HEX_AMP). Try typing that three times in a row, I dare you.

- And finally, mysql is by far the worst database for unicode handling, because it cannot sort unicode text according to the standard, at all, no matter what you do. That's not PHP's fault ofcourse, but since I'm bitching... :)

leeoniya• 13 years ago

i would love to see them make an explicit BC break and fix everything listed at http://phpsadness.com/

wvenable7• 13 years ago

If you break BC you might as well just another language, because that's what it will be.

The correct approach is slow and steady improvements. I suspect standard library improvements will come not by renaming existing functions but by adding new API.

BugBrother• 13 years ago

The Perl way is to declare minimum language version to execute a code file. E.g. use v5.12;

Then you can do extensions [even changing central functionality] in a sane way, with backward compatibility. (A language implementation need to implement deprecated features for older versions, of course.)

I agree with your point re APIs.

NameNickHN• 13 years ago

And thousands of developers would hate it. Sure, some things are ugly but the usage is too widespread in order to get rid of them. Look at the register_globals disaster and how long it took to throw that out. And it was only one little thing. Imagine tens or hundreds of them.

shocks• 13 years ago

Yeah, because that worked out SO well with Python… ;P

jmccree• 13 years ago

It amuses me people want PHP to follow the path of Python or Perl. On the latest version of Ubuntu: PHP 5.5, Python 2.x Perl 5.x. PHP has gradually improving, adding functionality, and spreading minimal BC breaks over a long period. If PHP had went the PHP 6 route back round ~08, it'd likely be split into two projects already, splitting up the community with it.

agumonkey2• 13 years ago

Sure PHP had a lot of catch-up to do, but they're really on a fast pace these days.

astrodust4• 13 years ago

In ten years it might actually be a first-class language.

It's going to take a ferocious amount of work to shed its reputation as a web-only scripting language.

maratd• 13 years ago

shed its reputation as a web-only

What? It is web-only. That's the entire point behind it. It's not a reputation, it's the goal of the project.

RobAley• 13 years ago

I refer you to http://www.phpbeyondtheweb.com

romanovcode• 13 years ago

I don't think so. It just piles up all the futures on top of old futures which just makes it more spaghetti-like.

Like their OOP and Namespaces - Sure, cool that PHP has those but compared to other languages like Ruby, C#, Java, etc.. PHP implements these futures horribly.

wvenable7• 13 years ago

OOP in PHP is pretty much the same as most other languages. And the implementation of namespaces is literally the only choice when combined with all the other existing PHP features.

If you're looking for mis-features, you need better examples than these.

mildtrepidation• 13 years ago

This is true. However, in my opinion, moving quickly is less important than changing effectively. Effective change can happen quickly or slowly, depending on the change intended and the effort required, but it's a different metric than simply moving in some direction while retaining the previous state.

PHP is painful to work with for a lot of reasons. It's also very easy to work with for a lot of reasons, but in my opinion, a lot of those -- despite being considered by some to be strengths of the language -- are used, and in many cases intended, to be shortcuts to functionality a more robust language would embrace explicitly.

PHP suffers from many, many failures of design. It suffers further, and worse, from an ongoing and intentional failure to address almost all of these failures. It's Frankenstein's language. If it were sentient, it would rebel and run off into some cold and inhospitable place.

A fast pace is velocity. They have that. What they don't have is a good direction, and without a good direction, a long vector is at best a roll of the dice.

Mikushi• 13 years ago

Not sure what you are into but PHP is anything but painful to work with. It's the easiest to get started, cheapest to run, and frankly when you actually use it for what it is intended, output web pages, I fail to find better.

At the end of the day, if you keep it simple you can go far without ever needing to do much maintenance and scaling. Most failure to scale I've seen come from bloated code base and code written by people who are not PHP developers.

agumonkey2• 13 years ago

From a distance PHP is splitting cells. People added tools to its eco system, and practices based on pseudo-Java OOP. See PSR code style that basically forbids PHP to be PHP, no inline formatting, split lib as side-effect free and 'main' .. The people behind this movement will probably have integrated the new language construct very soon. So instead of Frankenstein I see a two-headed organism.

coldtea3• 13 years ago

The arguments in the linked email of some Ilia Alshanetsky regarding the shorthand array syntax are incredibly dense...

foldor• 13 years ago

I'm liking the variadic functions syntax. It's definitely better than requiring all extra parameters to be sent as arrays. Even if that's how they end up in the function.

apinstein• 13 years ago

The current implementation doesn't require extra params as arrays... you can pass as many (or as few) parameters to any PHP function regardless of defined function signature; the declared parameters will be auto-populated. Additionally, you can call func_get_args() inside of any function and get an array with all params, meaning it's a trivial array_slice (and/or list) away from extracting all vargs.

That said, the new ...$params is 100% better.

asnyder• 13 years ago

I really like the ...$param syntax. When we first created NOLOH (http://www.noloh.com) back in 2005 we decided on $dotdotdot as a syntactic salt, but this is obviously much nicer. Also, by ref ... is really really nice. Very few cases where it's necessary, but having that is a pretty big deal.

Since PHP 5.3, PHP has gotten some really nice features, they've definitely been doing a pretty good job over the past few years.

dhoulb2• 13 years ago

Would REEEEEEALLY like to see readonly properties in classes.

They had a proposal a while ago to add getter and setter function support, which would be cool and would've allowed it (with some function overhead), but is probably a bit OTT for PHP.

readonly properties would allow you to make truly solid classes. You'd be able to lock them down from outside interference.

Methods could trust that property values hadn't been tampered with from outside, while still providing a way for outside code to read those values extremely quickly, without function overhead.

I think it's an awesome idea, especially since the getter/setter proposal failed. It's very PHPy, and it strikes a nice middle ground between fully public properties and private ones.

External code really shouldn't be able to mess with my class's internal properties anyway, it violates separation of concerns.

SDGT2• 13 years ago

You can already do this by using a magic setter that blows out an exception whenever its called for whichever variables you denote. A little hacky, but it does indeed prevent setting of certain vars in your classes.

wvenable7• 13 years ago

Actually, even easier than SDGT's or krapp's suggestions is to declare your properties private or protected and use a magic getter to expose those properties as public readonly.

It's so easy to do that a readonly keyword seems unnecessary.

krapp7• 13 years ago

I agree with you. This is the closest i've been able to get...

   class whatever{
     
     private $Properties=array();

     function __set($key,$val){
        try{
         if(!isset($this->Properties[$key])){
            $this->Properties[$key]=$val;
         }
        }catch(Exception $e){
        //...
        }
      }

      function __get($key){
       try{
        if(isset($this->Properties[$key])){
          return $this->Properties[$key];
        }
       }catch(Exception $e){
       //...
       }
     }
    }

krapp7• 13 years ago

I just noticed some errors in this but the basic gist works... I shouldn't have added the isset checks, those would prevent it from throwing the exceptions -_-

datphp5• 13 years ago

Your code doesn't work...

The catch will never be called, and you should never use isset() because it will return false if the value exists but is null.

    whatever->param = null;
    whatever->param = 123;

Both lines will execute here.

    function __set($k, $v){
        if (array_key_exists($k, $this->Properties)){
            throw new ReadOnlyException();
        }else{
            $this->Properties[$k] = $v;
        }
    }

semerda2• 13 years ago

Does anyone else here find the PHP namespace format horrible and unlike the standard dot notation?

wvenable7• 13 years ago

I hated it till I started using it, now I don't mind. Dot was never used in PHP because it's the string concat operator. PHP needs a unique operator for namespaces because the types of symbols (is it a namespace, class, interface, etc) aren't known at compile time (unlike Java, C#, etc).

coldtea3• 13 years ago

Dot was never used in PHP because it's the string concat operator.

So how about them using the -> operator? Most languages that use . for class method access also reuse it for namespacing.

New Features in PHP 5.6

Related Stories