PHP 5.3: обзор

    Дни идут чередой, погода улучшается, а между тем PHP 5.3 всё ближе и ближе — надо быть во всеоружии.
    Недавно вышел RC2, затем будет RC3, а затем Stable (примерно через месяц).

    Первое, о чем хочется сказать: 5.2 медленнее 5.1, но 5.3 быстрее 5.1. В 5.3 введено много оптимизаций (в том числе таблиц связей), и это не может не радовать.

    Особенных проблем обратной совместимости нет, за исключением введения новых зарезервированных слов и других малозначительных моментов.
    Подробно они описаны тут — wiki.php.net/doc/scratchpad/upgrade/53

    Помимо этого есть много новшеств:

    1. mysqlnd.
    Как известно, PHP общается с MySQL-сервером посредством C-wrapper'а над libmysql, однако реализация имеет огромный оверхед (к примеру, когда Вы делаете mysql_fetch_assoc, результат имеет аж три копии в памяти).
    MySQL Native Driver представляет собой эффективную замену libmysql на C-уровне. Однако, интерфейсы (mysql, mysqli, PDO) не должны никак от этого пострадать.

    2. Closures.
    Вам надоело видеть create_function() под ободком вашего унитаза?
    $lambda = function() {echo 'Hello World!';};
    $lambda();


    * This source code was highlighted with Source Code Highlighter.

    Также Вы можете сделать:
    class myLambda
    {
      public function __invoke() {echo 'Hello World!';}
    }
    $lambda = new myLambda;
    $lambda();


    * This source code was highlighted with Source Code Highlighter.
    Более, того, можно задействовать переменные из области видимости контекста внутрь функции:
    $var = 'Hello World!';
    $func = function() use ($var) {echo $var;};
    $func();


    * This source code was highlighted with Source Code Highlighter.
    Так очень удобно делать при использовании preg_replace_callback, и при задании событий.

    Использовать $this в коде замыкания недопустимо. Это планировалось изначально, но у разработчиков возникли технические проблемы.
    Однако, можно передать ссылку на объект, используя use, это позволит получит доступ к публичным интерфейсам.

    Мануал по адресу wiki.php.net/rfc/closures

    3. namespaces. Пространства имён.
    namespace hello;
    class msg
    {
     public static function write() {echo 'Hello';}
    }
    msg::write();
    namespace World;
    class msg
    {
     public static function write() {echo ' World!';}
    }
    msg::write();


    * This source code was highlighted with Source Code Highlighter.
    Пример специально приведен несуразный. namespace'ы удобно использовать для логического объединения классов, для того чтобы константы не пересекались, и во многих других случаях. Рекомендую к использованию.
    Разделитель namespace'ов в пути — обратный слеш (\).

    Мануал по адресу php.net/namespaces

    4. Тернарный оператор.
    Можно использовать без указания true-альтернативы, тогда ей становится само значение.
    $var = 'Hello World!';
    echo $var?:'false';
    // Hello World!


    * This source code was highlighted with Source Code Highlighter.
    Однако, в этом я вижу очень мало практического применения.

    5. Label'ы. Аналог GOTO.
    Label'ы это именованные позиции в коде к которым можно осуществить переход, разумеется между уровнями переходить нельзя, и для каждого своя область видимости Label'ов.
    $i = 1;
    start:
    echo ($i > 1?'-':'').$i;
    if ($i++ < 5) {goto start;}
    echo ' вышел зайчик погулять';
    // 1-2-3-4-5 вышел зайчик погулять


    * This source code was highlighted with Source Code Highlighter.
    Полезная вещь при создании нетривиальных алгоритмов.
    Эх, чешутся пальцы написать обфускатор кода :)

    6. Garbage Collector.
    Наконец-то в PHP появился нормальный сборщик мусора, то есть можно будет писать долгоиграющие скрипты без утечек памяти.

    7. SPL.

    Во-первых: http://www.php.net/~helly/php/ext/spl/

    И кроме того, о значимых нововведениях: SplFixedArray, SplStack, SplDoublyLinkedList, SplQueue, SplPriorityQueue. Некоторые новые структуры данных при определенных условиях дают прирост производительности.

    Посмотреть информацию о классах, интерфейсах и функциях Spl можно в phpinfo() или из командной строки:
    $ php -i|less
    $ php -r 'var_export(spl_classes());'
    $ php --re spl|less

    Спасибо crocodile2u.
    Спасибо Sherman81 за наводку.

    8. Late Static Binding
    Появился магический метод __callStatic и функция get_called_class().
    Это очень полезное нововведение.

    Помимо этого обновили PCRE до 7.9 (заявлено исправление многих багов), sqlite улучшили, и еще много чего вкусного.

    Наверняка я не учел что-то важное, прошу вежливо ткнуть меня в это носом, допишу.
    Предлагаю всем принять участие в тестировании!

    Similar posts

    Ads
    AdBlock has stolen the banner, but banners are not teeth — they will be back

    More

    Comments 329

      +41
      АААА! Лейблы… Зачем? Теперь что бы разобрать код начинающего кодера с лейблами прийдеться выпивать вдвое больше.
      • UFO just landed and posted this here
          +1
          Но с лейблами станет еще хуже. Не могу понять, зачем они вводят лейблы?
            +2
            Видимо хотят превратить РНР в BASIC. Великолепно, блин.
              +1
              Ну смотрите, вводят нэймспейсы, вводят лямбда функции, великолепно. И тут бац, и лейблы. Просто интересно что двигало логикой тех людей которые добавляли лейблы. Может конечно есть разумное объяснение.
                +14
                register_globals убрали, label'ы вставили ^_^
                свято место пусто не бывает (с) народ
                  0
                  ну, я могу ошибаться, но имхо label хороши при построении try не нужно через жопу переходы делать, как раньше и случаи когда в зависимости от данных которые определяются в конце построения возможен повторный проход по приложению.
                  +1
                  register_globals убрали, label'ы вставили ^_^
                  свято место пусто не бывает (с) народ
                  +3
                  Можно подумать, что goto в одном только Basic и есть. Вспомните Си что ли. Его никто Бейсиком не называет.
                    +1
                    Более того, когда глубина рекурсии на платформе сильно ограничена, остаётся только лишь тот самый goto. :)
                      +1
                      глубина вызова, я хотел сказать. необязательно рекурсии.
                        0
                        Меня всегда радуют разговоры о том что GOTO это плохо. Ведь вызов процедуры (функции) это и есть GOTO + объявление параметров + GOTO обратно. Только в случае с функцией мы пишем адреса в стек. И чем глубже рекурсия, тем больше растёт стек. Это удобно на небольшом уровне вложенности, но не надо забывать что овёс нынче дорог. При большом уровне вложенности лучше брать GOTO на свою совесть.
                          +2
                          > При большом уровне вложенности лучше брать GOTO на свою совесть.

                          Да, и нафиг вообще абстракции нужны? Давайте делать возьмем побольше работы машины на себя.

                          А если серьезно, то ключевое слово тут это оптимизация хвостовых вызовов.
                            +1
                            > Да, и нафиг вообще абстракции нужны? Давайте делать возьмем побольше работы машины на себя.

                            Всё хорошо в меру. Я думаю это и имел в виду TravisBickle.
                              0
                              Именно это и я и имел в виду. Алгоритм для бухгалтерского отчета хорошо писать на языке высокого уровня, но md5-функцию до сих пор оптимизируют на уровне ассемблера. Всегда надо выбирать между гибкостью, удобством, и скоростью.
                            0
                            Никто не говорит, что goto — это безусловно плохо. Есть много задач, в которых применение goto дает вполне весомый выигрыш. Например, конечные автоматы.

                            Другое дело, что, как правильно заметил товарищ chiaroscuro, программирующая часть человечества уже давно придумала более высокоуровневые абстракции чем «метки+goto». Например, вызов функции с оптимизацией хвостовой рекурсии.

                            Подобная абстракция позволяет заменять циклы на рекурсию, а условные или безусловные переходы на вызов функции. И конечный код получается оптимизирован ничуть не хуже, чем при использовании goto, но значительно выигравает в легкости чтения и понимания.
                          –2
                          помнится в ассемблере что-то подобное было, только в русской универовской транскрипции это меткой называлось
                            +1
                            Ну, если мне не изменяет память…

                            В ассемблерах есть команды перехода на адрес и/или перехода по смещению. В ассемблере x86 есть FAR JUMP (на полный адрес с сегментом), NEAR JUMP (длинное смещение, знаковое слово) и SHORT JUMP (короткое смещение, байт со знаком).

                            Чтобы при написании программы, не считать команды вручную и не делать смещение на адрес, были придуманы метки (labels). Ставишь JMP Out, а компилятор сам вычисляет где находится Out и какой сделать JMP.
                      • UFO just landed and posted this here
                          +3
                          Думаю что не стоит путать язык и стандарт кодирования. Не нравится — не пользуйся. Уверен есть ситуации когда это будет к месту.
                            –4
                            Хз, товарищи, когда я лет 5-6 назад делал свой темплейтный движок, лейблов мне очень не хватало для существенного увеличения скорости;
                              +2
                              каждый пхпшник считает своим долгом написать темплейтный движок и цмс
                                0
                                А Вы, как собачка, стойку делаете? ПЯТЬ-ШЕСТЬ ЛЕТ назад (внимательно, пожалуйста, 2003-2004 год) — тогда был только смарти, а смарти меня не устраивал.

                                К тому же, а что, собственно, еще писать на пхп, кроме как темплейтные движки и цмс?
                                  0
                                  Ну это, вебсерверы :) (http://ajaxian.com/archives/crap-i-missed-it-doesnt-miss-your-file-upload)
                                    0
                                    И через это я тогда прошел =)
                                    Правда, я не очень понимаю, зачем конкретно в той задаче вебсервер был нужен. Видимо, как и мне когда-то, просто для практики.
                                    –1
                                    щас вроде уже 3й смарти появися, полностью переписанный. У меня на одном старом проекте смарти ещё используется. Всё думаю перевести его на новую версию или нет смысла
                                    0
                                    Сейчас в моде фреймворки
                              0
                              Что-ж вы так к GOTO цепляетесь? :)

                              Goto есть в очень многих языках, кроме бейсика (C#, тот же Delphi, насчет C не знаю но должен быть тоже)

                              Чем вам лишний функционал языка мешает? Или все сразу начнут использовать GOTO вместо вызова методов? Пока-что такого не происходило вроде-бы и врядли произойдет.

                              У GOTO тоже есть свое применение, особенно когда не хватает размера стека. Просто каждому оператору свое место и время.
                                0
                                Между прочим, все это обсуждалось и свое мнение можно было высказать в открытых списках рассылки, которые читают и в которые пишут разработчики — еще до того, как это было реализовано. Каждый сам кузнец своего [не]счастья
                                  0
                                  Я когда-то сталкивался с такой задачей.

                                  — Начало цитаты.
                                  Да, Вы правы, я без зазрения совести использую операторы безусловного перехода! И это после работы Дейкстры, заклеймившей goto!!! Как можно посягать на каноны программирования, когда в современных языках этот оператор просто не существует!!! А ведь Вы еще не видели программной реализации диаграмм, используемых в синтаксическом анализаторе!!! Я не собираюсь с пеной у рта отстаивать используемое решение, но робко мотивировать его все же попробую.

                                  Во-первых, основным документом, по которому разрабатываются программные модули, является диаграмма Вирта, которая, в общем случае является неструктурированным графом. А такие графы невозможно представить без goto, если только не осуществить соответствующие преобразования. Применение же этих преобразований может снизить наглядность исходных диаграмм, привести к их избыточности, что ведет к соответствующему «захламлению» и формируемого кода. Тогда проще сразу отказаться от диаграмм Вирта и перейти на РБНФ. Именно неструктурированные диаграммы Вирта диктуют мне ранее описанную регулярную схему моделирования каждой ее отдельной связи.

                                  Во-вторых, используя данный подход, можно, с помощью экранного редактора, достаточно быстро набирать фрагменты новых правил, перенося отдельные связи из ранее набранных диаграмм. Особенно удобно такое редактирование при написании синтаксического анализатора.
                                  — конец цитаты.

                                  Источник:
                                  softcraft.ru/translat/lect/t05-02.shtml
                                    +1
                                    я отношусь к goto, как к нежелательному, но допустимому, тоесть нужно стараться обходиться без него, но в меру.
                                      0
                                      Вот блин, я расстроен лейблами. Их если и можно вводить — то только как недефолтную опцию. А чтобы включить данную опцию интерпретаторы — длинные многоуровневые грабли, чтобы начинающий кодер только лишь мечтал, но не включал ее.

                                      Все хорошо, но вот лейблы — это лишнее имхо.
                                      +2
                                      Вкусностей много, а препятствием как всегда будут хостеры.
                                      Честно говоря, для меня остается загадкой, как будут разрабатываться дальше фреймворки типа Zend Framework и symfony. Вести 2 ветки разработки весьма непросто, но и вкусности хочется реализовать (namespaces в Zend Framework были бы весьма кстати) и пролетать мимо хостинга не хочется.
                                        +6
                                        Мне думается что хостеры быстро поставят 5.3, это снизит нагрузку. Да и всё больше людей пользуются VPS.
                                          0
                                          Поправьте меня, если я не прав, но по-моему в этом случае полетят все сайты, у которых register_globals = on. Боюсь, что таких еще очень много…
                                            +3
                                            Поправляю.
                                              +1
                                              register_globals уберут из PHP6, в 5.3 её еще можно сделать = on ;)
                                              Но я бы давно убрал register_globals и magic_quotes — уж больно они ужасны
                                                0
                                                А смысл убирать? По дефолту они отключены, а если надо быстро завести древний скрипт — очень полезно.
                                                  0
                                                  Уже прошло много лет, чтобы можно было перенести старые скрипты. register_globals, если память не изменяет, еще на 4.2 не рекомендовался. Глобалс — большая дыра безопасности, и самое страшное, что и сейчас так пишет много народа.
                                                    +3
                                                    Проблемы индейцев шерифа не…
                                                    Кто хочет наиндусить, тот всегда найдет способ.
                                                    extract($_REQUEST,EXTR_SKIP);

                                                    Это еще хорошо если про EXTR_SKIP будут знать.
                                                      –3
                                                      Индийцы и индейцы разные народы.
                                                        +1
                                                        Про индейцев это фраза из анекдота. TravisBickle, насколько я понял его коммент, не смешивает индейцев и индийцев.
                                                          –3
                                                          Написал так, как будто бы он их смешивает.
                                                          –2
                                                          Вообще-то, тогда уж индусы, а не индийцы.

                                                          bolk +1
                                                            0
                                                            индиец — начиональность. Индус — последователь индуизма.
                                                              +3
                                                              Какие же вы все скучные…
                                                                0
                                                                капитан, капитан! напомните пожалуйста, а кто такие индусска, индианка и индейка?
                                                0
                                                Все будет как и раньше. Например у symfony и так высокие требования к версии ПХП. Думаю со 2-ой версии они уже перепрыгнут на 5.3.
                                                  0
                                                  На 5.3 переедет вся честная компания — и symfony, и Doctrine, и Propel.
                                                  0
                                                  В Zend Framework разработчики давно готовятся к новой версии php, и уж у кого-у кого, а у ZF не будет с этим проблем. Более того, в новых версиях ZF эти новые возможности будут активно использоваться, в отличии от других фреймворков которые до сих пор топчутся с php4.
                                                    +9
                                                    Это не ZendFramework готовится к новой версии php, скорее новая версия php готовится под ZendFramework. :)
                                                  +3
                                                  Нововведение 4 мне, например, кажется полезным. С оптимизационной точки зрения. Хотя, фиг его знает, как оно реализовано, возможно значение вычисляется дважды %))
                                                    0
                                                    я тоже считаю её полезной. Часто использую. Только не понял, в 5.3 можно будет убирать false-часть? Хотя это конечн не важно.
                                                      +1
                                                      Можно будет убирать (опускать) наоборот true-часть. Если убирать false-часть, то зачем тогда вообще тернарник? :)
                                                        0
                                                        ну не знаю. Мне кажется удобно использовать такую конструкцию, когда, например, нужно тег div вывести, но неизвестно, следует ли подставлять имя css-класса:

                                                        $output = '<div class="informer'.($class?' '.$class:'').'">';

                                                        * This source code was highlighted with Source Code Highlighter.


                                                        Может не сильно, но все же короче записать без " :'' " в данном случае.
                                                          0
                                                          Не знаю, может только мне так кажется, но я бы застрелился если бы мне пришлось работать с таким кодом.
                                                            0
                                                            тоже верно) Но если абстрагироваться от этого примера, то в целом фича могла бы быть полезной.
                                                    +5
                                                    Разделитель нэймспейсов решили сделать человеческий? А то, ходили слухи, что будет два слеша…
                                                      0
                                                      ::
                                                        +1
                                                        Да уж давно как нет. Используется бэкслеш (\).
                                                          +6
                                                          Да, будем писать

                                                          use aa\b\ccc;

                                                          и

                                                          $a = new ddd\eee\ccc(1);

                                                          ИМХО разделитель \ вместо :: — все-таки изврат.
                                                          Но с php.net/namespaces не поспоришь…
                                                            +5
                                                            Да, полный изврат.
                                                              0
                                                              В действительности нельзя исключать, что в будущем механизм разбора кода усовершенствуют (если мне не изменяет память, именно слабость текущей реализации парсера явилась главной причиной отказа от двоеточий) и помимо слэшей добавят и поддержку двойных двоеточий применительно к пространствам имён.
                                                                0
                                                                Ну это будет ИМХО еще больший изврат — 2 синтаксиса для абсолютно одного и того же. Так что я бы лично не рассчитывал на то, что мы в ближайшие 5-10 лет увидим :: вместо \…
                                                                  0
                                                                  Да и бог с ним, с этим «::». Дело привычки. Мне вот «@» (декоратор) казался в Python ужасным. Теперь привык.
                                                                    0
                                                                    Бывают решения временные. Парсер слаб — сделали слэши; усовершенствовали парсер — сделали по-человечески, иное пометили как нерекомендуемое и со временем упразднили. Логики не лишено, хотя, конечно, вероятность реализации мала.
                                                                      0
                                                                      Интересно, кто-нибудь и правда верит в версию слабого парсера?
                                                                        0
                                                                        Наверное, только идиоты. Если не путаю, парсер там генерируется YACC (или flex?)
                                                                          0
                                                                          (Безотносительно парсера в пхп) Вы думаете, что парсер, сгенерированный YACC-ом, не может быть слабым? :)
                                                                            0
                                                                            Простите, а относительно чего тогда? Мы тут про разделение неймспейсов и, якобы, слабый парсер. Я, зная синтаксис YACC, утверждаю, что сделать какой угодно разделитель не составляет никаких, я повторяю, никаких проблем.
                                                                              0
                                                                              Под «безотносительно пхп» имелось в виду, что я говорю не про именно парсер пхп, а про «абстрактный сферический парсер в вакууме» на YACC. И да, его можно написать сколь угодно корявым и слабым. Ровно это имелось в виду. То есть утверждение «парсер написан на YACC, поэтому он не может быть слабым» неверно.
                                                                                –1
                                                                                Простите, Вы вообще имеете представление, о чем конкретно Вы говорите? YACC позволяет описывать синтаксис языка, в стиле:
                                                                                top_statement:
                                                                                statement
                                                                                | function_declaration_statement { zend_do_early_binding(TSRMLS_C); }
                                                                                | class_declaration_statement { zend_do_early_binding(TSRMLS_C); }
                                                                                | T_HALT_COMPILER '(' ')' ';' { zend_do_halt_compiler_register(TSRMLS_C); YYACCEPT; }
                                                                                ;

                                                                                и генерировать C-парсер на этой основе. Сделать синтаксис сильным или слабым по-моему невозможно (ибо субъективно), зато описать свой язык так, как хочешь, без заковык и переподвыподвертов можно легко и непринужденно.
                                                                                  0
                                                                                  > Простите, Вы вообще имеете представление, о чем конкретно Вы говорите?

                                                                                  Я — да. Вы — похоже, нет.

                                                                                  Вы утверждаете, что на YACC-е нельзя плохо описать синтаксис? Вы верите в программы с багами? Вы верите в неверно спроектированные архитектуры? Вы когда-нибудь видели плохой код?
                                                                                    0
                                                                                    Если вы не очень толстый тролль (в чем я перестаю сомневаться), перечитайте вот этот комментарий — habrahabr.ru/blogs/php/59876/#comment_1629597 и объясните, как это соотносится с тем, что впариваете мне Вы?

                                                                                    Если же тролль — аривидерчи.
                                                                                      0
                                                                                      Тролль здесь, похоже вы, т.к. совершенно не читаете на что отвечаете и не утруждаете себя подумать перед ответом.

                                                                                      До свидания.
                                                                                        –1
                                                                                        Благодарю за минус в карму, лишить меня возможности писать посты и делиться своими знаниями с такими гениями, как Вы, избавляет от мучительного выбора.

                                                                                        Save the planet, kill yourself
                                                                                          0
                                                                                          Я с вашей кармой ничего не делал. Не надо проецировать своё возможное поведение на других.

                                                                                          Вы очень адекватны, да.
                                                                                            +1
                                                                                            говно можно сделать из любой конфетки, так что zw0rk прав, а вы — нет.
                                                                                              –1
                                                                                              Вы вдвоем похожи на онанистов, которые прицепляются к словам в каждом новом комментарии не потрудившись прокрутить выше и прочитать, о чем собственно речь.
                                                                      0
                                                                      А разве от двоиных двоеточий отказались не из-за неоднозначности?

                                                                      a::b::c — это что? вызов статического метода «с» из класса «b», пространства «а» или вызов функции «с» из пространства «а::b»?
                                                                        –1
                                                                        Любые неоднозначности разрешаются единожды принимаемым соглашением.
                                                                          0
                                                                          Какое соглашение вы приняли бы в этом случае?
                                                                            0
                                                                            Можно принять, что приоритет пространства имён выше приоритета чего-либо иного. Если пространство имён не найдено, ищется класс.
                                                                              +1
                                                                              Примерно так всё и сделали бы, если бы этот синтаксис приняли бы. Но хорошо, что этого не сделали. Так как, если бы я увидел в коде «a::b::c» я не смог бы понять что тут вызывается, не разбираясь с кодом.
                                                                                0
                                                                                Согласен. Хотя на уровне простоты восприятия кода помогло бы (помимо банальной особой подсветки пространств имён в IDE) соглашение именовать пространства имён, например, со строчной буквы — в противоположность классам, имена которых принято начинать с заглавной:

                                                                                myNs::MyClass::myMethod();
                                                                                  0
                                                                                  Или ещё проще — сделать символ разделения namespace каким-нибудь другим, что и было сделано. Кстати, предлагалось «:::», но, видимо, решили, что это набирать очень долго, да и отличать от «::» его сложнее.
                                                                                    0
                                                                                    Можно было бы, кстати, просто предварять пространства имён спецсимволом подобно $ у переменных — например, @, это полностью исключило бы неоднозначности:

                                                                                    @myNs::MyClass::myMethod();

                                                                                    Придумывать новый разделитель, по-моему, решение в любом случае менее удачное.
                                                                                      0
                                                                                      Новый по отношению к чему? Пространств в PHP не существовало. Появились и появился для них синтаксис. «\» ничем не лучше и не хуже любого другого значка.

                                                                                      Вот в Виндах обратный слеш — разделитель путей и ничего, много лет, со времён ДОСа все его используют.
                                                                                        0
                                                                                        Новый по отношению к чему?
                                                                                        Новый разделитель уровней иерархии программных сущностей. Представьте, что «хлебные крошки» на сайте выглядели бы так:
                                                                                        Главная \ Продукция :: Булочки

                                                                                        только потому, что главная страница сайта функционально отличается от всех остальных страниц.

                                                                                        Вариант
                                                                                        Главная → Продукция → Булочки

                                                                                        лучше просто потому, что единообразнее.

                                                                                        Вот в Виндах обратный слеш — разделитель путей и ничего, много лет, со времён ДОСа все его используют.
                                                                                        Несколько отклоняемся от темы, но почему в Windows до сих пор не сделали разделителем фрагментов пути по умолчанию слэши прямые (/), подобно путям в Unix-системах и интернет-адресам — совершенно непостижимо (и это уже при наличии поддержки таких путей в Windows: попробуйте, скажем, C:/WINDOWS/system32).
                                                                                          0
                                                                                          Главная → Продукция → Булочки

                                                                                          Плохой пример. В PHP возникнет двойственность, я уже писал об этом. В хлебных крошках — нет.

                                                                                          Windows до сих пор не сделали разделителем фрагментов пути по умолчанию слэши прямые (/), подобно путям в Unix-системах и интернет-адресам — совершенно непостижимо (и это уже при наличии поддержки таких путей в Windows: попробуйте, скажем, C:/WINDOWS/system32).
                                                                                          Да, я знаю, что она там есть. Ответ в том, что делать прямой слеш разделителем по умолчанию нет никакой необходимости. Это просто символ. Ничем не хуже любого другого символа.
                                                                                            0
                                                                                            В PHP возникнет двойственность, я уже писал об этом.
                                                                                            При использовании спецсимвола для обозначения названия пространства имён (вида @myNs) неоднозначности были бы исключены.

                                                                                            делать прямой слеш разделителем по умолчанию нет никакой необходимости.
                                                                                            Необходимости нет, есть целесообразность — единообразие. Вводить в одну и ту же адресную строку интернет-адреса с прямым слэшом, а локальные пути — почему-то с обратным — несколько странно. ;-)
                                                                                              0
                                                                                              Вводить туда @ не менее странно. Просто выбрали такой вариант, вот и всё. Может быть даже бросили монетку.
                                                                                                0
                                                                                                Мне так не кажется, но дальнейшая дискуссия лишена смысла, все аргументы мной уже озвучены.
                                                                                0
                                                                                Хороший алгоритм, только для человеческого использования он не удобен.
                                                                            –1
                                                                            Концептуально, «class» сам по себе образует пространство имен. Для классов есть чудная арифметика, позволяющая эти пространства имен комбинировать — слово extends все знают?… И главное — эти чудеса живут в языке еще со времен PHP4. =)

                                                                            Т.е. нужно было разрешить расширять класс новыми именами и вкладывать классы друг в друга. Автоматически бы получили всеми любимые mixin'ы, приватные классы и проч. прелести. Все в рамках традиционного ООП. И новый синтаксис тогда был бы не нужен. Но нет — php'шники, ввели новую недо-сущность namespace и новый недо-синтаксис, и докучи чуть не огребли проблемы с парсингом. Где ум, блин?… :)
                                                                          +2
                                                                          :: уже занят, а жертвовать совместимостью ради неймспесов — идиотизм
                                                                          100% через пару дней пользования все привыкнут, так-что думаю не стоит делать из мухи слона
                                                                      +6
                                                                      Тернарный оператор.
                                                                      Можно использовать без указания true-альтернативы, тогда ей становится само значение.
                                                                      Однако, в этом я вижу очень мало практического применения.
                                                                      ?: компактнее, чем отдельный if, и, вероятно, реализован оптимальнее, чем традиционный тернарный оператор, осуществляющий ненужное присваивание переменной самой себе в случае срабатывания true-альтернативы.
                                                                        –4
                                                                        Не соглашусь. Нововведение в ущерб читаемости кода. Я честно говоря всегда наивно полагал, что оптимизация, исключающая лишнее присваивание, совершается при компиляции кода и для этого не нужен еще один синтаксис. Меня неприятно удивит, если это было не так, и Вы правы.
                                                                          0
                                                                          Повышенная оптимальность — не более чем предположение.

                                                                          Читаемость не ниже, чем у обычного тернарного оператора, при этом исключается бессмысленное дублирование переменной в коде. Вам же не приходит в голову, что запись $a = $a + $b — лучше, чем $a += $b. Или приходит? ;-)
                                                                            +1
                                                                            А по-моему, читаемость только выиграет от ?:

                                                                            В Perl, например, можно писать
                                                                            $a = $b || 10;
                                                                            А теперь и в PHP можно будет:
                                                                            $a = $b :? 10;

                                                                            Правда, в Perl можно еще и
                                                                            $a ||= 10;
                                                                            а вот в PHP
                                                                            $a :?= 10 — вроде пока нельзя (а жаль).

                                                                            Удобен ?: тем, что не нужно дважды повторять одно и то же rvalue (особенно когда это rvalue длинное или представляет, например, вызов функции — вот тут-то в 5.2 без временной переменной вообще не обойтись было).
                                                                              0
                                                                              $a or $a = 10;
                                                                                0
                                                                                А что вы собрались присваивать вызову функции? O_o
                                                                                  0
                                                                                  Не понял кому и по какому поводу был комментарий, но замечу, что в том же Перле есть lvalue-функции. Например:

                                                                                  substr($a, 1, 2) = 'a';
                                                                                    0
                                                                                    В пыхе есть конструкция list($a,$b) = array(1,2). Но это исключение, имхо. Т.е. эта синтаксическая конструкция только похожа на функцию.
                                                                                      –3
                                                                                      list — не функция.
                                                                                        +2
                                                                                        … о чем я исказал в комменте, господин Капитан :)
                                                                                          –2
                                                                                          Мне просто показалось странным, что вообще о ней вспомнили. Причём тут list? Тоже со скобками и тоже слева от равно? :)
                                                                              0
                                                                              буквально сегодня правил код, хотелось написать что-то типа:
                                                                              $discount = calcuate_discount($param) >0? calcuate_discount($param): 0;
                                                                              Естественно делать не стал (т.к. не самая легкая функция вызывалась бы дважды)
                                                                              Пришлось писать в две строки, тоже не самое читабельное решение.
                                                                              P.S. Есть субъективные причины почему алгоритм работает именно так и эта проверка нужна.
                                                                                0
                                                                                if ( ($discount = calcuate_discount($param)) < 0) $discount = 0;
                                                                                  0
                                                                                  Конечно, можно и так. Только мне кажется это чуть сложнее в понимании, чем описанный выше пример. Как минимум при беглом скроллинге кода в поисках этой переменной вызовет замешательство. А у новичков, возможно, и панику.
                                                                                  И это, тем более, сложнее чем синтаксис ?:
                                                                                    –1
                                                                                    Imho, код вполне читаем для хоть немного адекватных людей.
                                                                                    И не стоит ориентироваться на новичков.
                                                                                      –2
                                                                                      У меня это замешательство не вызовет. Язык надо знать. Если вокруг работают новички, можно попытаться орентировать на новичков. Мне повезло, я работаю с профи.
                                                                                +2
                                                                                А как там с обратной совместимостью? косяков не будет?
                                                                                  +1
                                                                                  Спасибо, сделал ремарку в начале обзора.
                                                                                    0
                                                                                    > Особенных проблем обратной совместимости нет, за исключением введения новых зарезервированных слов и других малозначительных моментов.
                                                                                      0
                                                                                      Мне вот инетересно что будет если определить статический класс (использую эту методику для эмулирования нэймспэйсов), а потом случайно опеределить такой-же неймспейс… ошибка или разделение приоритетов?
                                                                                        +1
                                                                                        Хо, не заметил. Беру слова обратно.
                                                                                      +5
                                                                                      Лично я от 5.3 жду не дождусь Late Static Bindings. У меня сейчас в одном месте совершенно аццкая определялка текущего класса с помощью debug_backtrace(), а в других я просто отказался от статических методов, хотя они там очень бы пригодились.
                                                                                        –2
                                                                                        а чем get_class() не угодил?
                                                                                          0
                                                                                          get_class(self)? o_O
                                                                                            +1
                                                                                            попробуйте вызвать var_dump(get_class()) в контексте унаследованного статического метода. o_O
                                                                                              +1
                                                                                              Видимо речь идет о выполнении внутри статичного метода.
                                                                                                –1
                                                                                                $className = get_class();
                                                                                                $obj = new $className();
                                                                                                $obj->yourFavouriteStaticMethod();

                                                                                                попробуйте. :)
                                                                                                  +1
                                                                                                  согласитесь, это костыли
                                                                                                    +2
                                                                                                    Согласитесь, это лучше чем backtrace?
                                                                                                    +2
                                                                                                    Речь, насколько я понял, была не об этом. А о том, что безумно криво устроено, например, в том же Propel: невозможность в СТАТИЧЕСКОМ методе базового класса определить, для какого из производных классов он вызван. Например:

                                                                                                    class Base {
                                                                                                    public static function f() { echo что-то-что-дает-имя-класса; }
                                                                                                    public function r() {… }
                                                                                                    public function call() { self::r(); }
                                                                                                    }

                                                                                                    class Derive extends Base {
                                                                                                    public function r() {… }
                                                                                                    }

                                                                                                    Base::f(); // хочется увидеть «Base»
                                                                                                    Derive::f(); // хочется увидеть «Derive»
                                                                                                    Derive::call(); // хочется, чтобы была вызвана Derive::r(), а не Base::r()

                                                                                                    Так вот, из-за того, что в 5.2 не существует способа реализовать функцию f(), чтобы она работала, как описано, они создают громадные генераторы кода, которые в основном только и делают, что создают бесконечные статические методы. Более того, делать у себя в программе производные классы почти невозможно — именно из-за отсутствия полиморфности у статических методов как таковой.
                                                                                                      0
                                                                                                      Late Static Binding *именно* про это.
                                                                                                        –1
                                                                                                        Нет, late static binding — это например возможность обратиться к реализации статического метода, которая будет определена в наследниках.

                                                                                                        То, о чем Дима говорит в 5.3 не решено какой либо константой типа __CLASS__, а решено функцией get_called_class(), о которой я на самом деле и говорил в своих примерах, но забыл точное название и то, что она только в 5.3 и появилась.
                                                                                                          0
                                                                                                          Late Static Bindings это вообще не возможность. Все проблемы, которые решает LSB расписаны вот тут: ua2.php.net/manual/en/language.oop5.late-static-bindings.php

                                                                                                          Решено это не get_called_class'ом, а новой константой static.
                                                                                                            0
                                                                                                            У автора комментария первого уровня и у Димы (функция f()) речь шла именно о том, чтобы получить название класса потомка в статическом, _унаследованном_ методе класса родителя.
                                                                                                            class A {
                                                                                                              static function who() {
                                                                                                                $className = ''; //тут нужно получить название класса;
                                                                                                                echo $className;
                                                                                                              }
                                                                                                            }

                                                                                                            class B extends A {
                                                                                                            }

                                                                                                            B::who()

                                                                                                            * This source code was highlighted with Source Code Highlighter.

                                                                                                            и задача как раз в том, чтoбы именно приведённый код или аналогичные ему при вызове B::who() выводил «B», а не «A».

                                                                                                            Покажи пожалуйста, как ключевое слово static (а не константа, как ты утверждаешь) при вызове статического метода решит поставленную задачу.
                                                                                                              –1
                                                                                                              Я не утверждаю, что static константа. Ключевое слово, пожалуй, да.

                                                                                                              static public function who() {
                                                                                                              echo static::whoAmI();
                                                                                                              }

                                                                                                              static public whoAmI() {
                                                                                                              return __CLASS__;
                                                                                                              }
                                                                                                                0
                                                                                                                class A {
                                                                                                                  static public function who() {
                                                                                                                    echo static::whoAmI();
                                                                                                                  }

                                                                                                                  static public function whoAmI() {
                                                                                                                    return __CLASS__;
                                                                                                                  }
                                                                                                                }

                                                                                                                class B extends A {
                                                                                                                  
                                                                                                                }

                                                                                                                B::who();


                                                                                                                * This source code was highlighted with Source Code Highlighter.


                                                                                                                с последним релиз кандидатом этот код выводит «А», а ведь ты думал что он будет выводить «B»?
                                                                                                                  –1
                                                                                                                  Ну да. Всё я написал-то неверно. Работает нормально, это я ошибся.

                                                                                                                  <?

                                                                                                                  class A {
                                                                                                                  static public function who() {
                                                                                                                  echo static::whoAmI();
                                                                                                                  }

                                                                                                                  static public function whoAmI() {
                                                                                                                  return __CLASS__;
                                                                                                                  }
                                                                                                                  }

                                                                                                                  class B extends A {
                                                                                                                  static public function whoAmI() {
                                                                                                                  return __CLASS__;
                                                                                                                  }
                                                                                                                  }

                                                                                                                  B::who();
                                                                                                                    0
                                                                                                                    В контексте задачи «автора комментария первого уровня» этот код не имеет смысла, так как приходится реализовывать метод whoAmI в наследниках, что реализуемо и в 5.2.8 в лоб.

                                                                                                                    class A {
                                                                                                                     static function who() {
                                                                                                                      echo get_called_class();
                                                                                                                     }
                                                                                                                    }

                                                                                                                    class B extends A {
                                                                                                                    }

                                                                                                                    B::who();


                                                                                                                    * This source code was highlighted with Source Code Highlighter.


                                                                                                                    Вот решение.

                                                                                                                      0
                                                                                                                      * ", что реализуемо и в 5.2.8 в лоб"
                                                                                                                        –2
                                                                                                                        Честно сказать, я не понимаю зачем нам знать имя класса. Для debug'a?

                                                                                                                        Вот вызов из наследуемого класса неперектытого метода в контексте потомка — этого я и ожидал. Сейчас неактуально, правда уже — на PHP пишу всё меньше.
                                                                                                                          0
                                                                                                                          Есть масса случаев, когда нужно знать имя класса наследника — из простых паттернов — это реализация абстрактного синглетона, из более сложных ORMы всякие, как минимум файндерам реализованным в виде статических методов единожды нужно знать какая именно модель запрашивается — сейчас это решается кодогенерацией и название класса просто передаётся как аргумент в файндер, в 5.3 будет достаточно в файндере сделать get_called_class()
                                                                                                                            –3
                                                                                                                            Тут спорить не о чем. Закончим.
                                                                                                                            0
                                                                                                                            Мне тоже етого метода нехватает. Ето полезно в абстрактных класах которые вызываются статически, в моем случаи ето абстрактный класс Extention которого наследуют Widget и Module соответственно каждый из них имеет свои параметры.
                                                                                                                            А пока приходится через debug_backtrace() извлекать.
                                                                                                                              0
                                                                                                                              У вас русский не родной язык?
                                                                                                  –1
                                                                                                  $className = get_class();
                                                                                                  $obj = new $className();
                                                                                                  $obj->yourFavouriteStaticMethod();

                                                                                                  Ы?
                                                                                                    +1
                                                                                                    Не путай вызов метода объекта и статический вызов метода класса.

                                                                                                    В твоём случае:
                                                                                                    1) константа self доступна не будет
                                                                                                    2) get_class у неперекрытого метода родителя будет равняются имени родительского класса, а не класса, расширяющего родительский (именно эту проблему решает Late Static Binding)

                                                                                                    кстати, get_class можно не использовать, есть константа __CLASS__, вызов функции всегда медленее остальных способов получения информации.
                                                                                                      0
                                                                                                      1) ты не прав, self будет доступна
                                                                                                      2) я не прав
                                                                                                        0
                                                                                                        1) судя по твоим ответам, мы говорим о разных вещах. Я комплексно (со вторым ответом вместе) хотел сказать, что константа self в классе-родителе будет равна родителю, а не потомку. Именно эту проблему решает позднее связывание.
                                                                                                        0
                                                                                                        поправочка:
                                                                                                        2) late static binding не решает эту проблему
                                                                                                          –2
                                                                                                          Мда. Ты видимо, забыл с кем споришь.

                                                                                                          2) late static binding решает вот эту проблему (взято из документации):

                                                                                                          <?php
                                                                                                          class A {
                                                                                                          public static function who() {
                                                                                                          echo __CLASS__;
                                                                                                          }
                                                                                                          public static function test() {
                                                                                                          self::who();
                                                                                                          }
                                                                                                          }

                                                                                                          class B extends A {
                                                                                                          public static function who() {
                                                                                                          echo __CLASS__;
                                                                                                          }
                                                                                                          }

                                                                                                          B::test();

                                                                                                          тут вызов B::test() выдаст «A», а хотелось бы — что бы «B».
                                                                                                            0
                                                                                                            да, я не прав.

                                                                                                            late static bindings решает проблему описанную автором коммента первого уровня, но не средствами ключевого слова static, что и ввело меня в заблуждение.
                                                                                                              0
                                                                                                              get_called_class всё же, на мой взгляд, неподходящая штука, чтобы решать такие проблемы.
                                                                                                      +1
                                                                                                      а я __callStatic жду. хочу чтобы можно было делать «registry» на уровне get::db()->…
                                                                                                        0
                                                                                                        Аналогично. 5.3 можно было бы выпускать только ради позднего статического связывания и __callStatic(), и это было бы уже очень полезно.
                                                                                                        +3
                                                                                                        >Однако, в этом я вижу очень мало практического применения.

                                                                                                        $var = $_GET['var'] :? 'default value'
                                                                                                          –2
                                                                                                          Вы ведь наверняка знаете:
                                                                                                          var_dump('0' == FALSE);
                                                                                                          // bool(true)


                                                                                                          * This source code was highlighted with Source Code Highlighter.

                                                                                                          В виду этого необходимо более сложное условие, нежели приведение строки к boolean'у.
                                                                                                            +3
                                                                                                            Более наглядный пример —

                                                                                                            вместо

                                                                                                            $entries = isset($entries)? $entries: array();

                                                                                                            теперь можно просто

                                                                                                            $entries = $entries ?: array();
                                                                                                              +4
                                                                                                              Вообще-то код ни разу не равнозначен, во втором случае будет Notice при отсутствии переменной.
                                                                                                                +1
                                                                                                                Они наверное решили избавить программистов от половины нотисов ))) или немного сэкономить их пальцы при написании лишних буков

                                                                                                                если честно, мне кажется код типа "$entries = $entries ?: array(); " не совсем читаемый, хотя программист ко всему привыкает…

                                                                                                                  +1
                                                                                                                  isset($entries) or $entries = array();
                                                                                                                    +1
                                                                                                                    Кстати, конкретно для этого случая можно сделать
                                                                                                                    $entries = (array) $entries.
                                                                                                                    Во-первых вы будете уверены что всегда на вход попадет именно массив, во-вторых если ее нет — будеть создан пустой массив.
                                                                                                                      0
                                                                                                                      Логика не эквивалетна. Посмотрите как поведёт себя первый и второй код, если $entries = 1;
                                                                                                                        0
                                                                                                                        Согласен, не эквивалентна. Но если я пишу код в котором жду массив, пусть лучше я получу $entries[0] =1, вместо $entries = 1.
                                                                                                                        Хотя спорить не буду, вне конкретного примера жизнеспособны оба случая. Мне в свое время такой подход помог существенно облегчить код, о чем и хотел поделиться.
                                                                                                                          0
                                                                                                                          Как тут ниже совершенно справедливо заметил DenisO, если $entries не определена, то ваш код даст notice.
                                                                                                                        +1
                                                                                                                        А разве в этом случае notice не появится?
                                                                                                                          0
                                                                                                                          Если переменная не определена, то появится. Мало того,

                                                                                                                          если $a = 1

                                                                                                                          $a = isset($a)? $a: array(); даст $a = 1;
                                                                                                                          $a = (array) $a; даст $a = array(1);
                                                                                                                            0
                                                                                                                            Не удалось нагуглить, но я почему-то уверен, что что $entries = $entries ?: array();
                                                                                                                            тоже будет давать notice.
                                                                                                                              0
                                                                                                                              Не будет.
                                                                                                                                0
                                                                                                                                <?php
                                                                                                                                error_reporting(E_ALL);
                                                                                                                                $test = $test ?: 'nope';
                                                                                                                                var_dump ($test);
                                                                                                                                ?>

                                                                                                                                  0
                                                                                                                                  oops… я не разглядел, что вы конструкцию PHP5.3 там поставили. Всё-таки поздновато уже, в сон клонит.
                                                                                                                                    0
                                                                                                                                    Взаимно, тоже слишком резко ответил, видимо устал.

                                                                                                                                    Очень хотелось вам поверить — код получался бы намного проще.
                                                                                                                                    Даже с введением этой конструкции от использования isset отказаться все равно не получится :(
                                                                                                                                      0
                                                                                                                                      Код можно упростить и без этой конструкции. Вуаля:

                                                                                                                                      isset($test) or $test = 'nope';

                                                                                                                                      во многих языках так делают. Например, в JS, Perl, Python (в Python тернарного оператора раньше не было).
                                                                                                                                    0
                                                                                                                                    Прошу прощения, отправил недописанный комментарий.
                                                                                                                                    Этот код возвращает:
                                                                                                                                    Notice: Undefined variable: test in Z:\test.php on line 3
                                                                                                                                    string(4) «nope»

                                                                                                                                    Ваша безапелляционность, кстати, убивает. Если не знаете, не говорите, пожалуйста.
                                                                                                                                    Специально поставил PHP 5.3 свежий что бы это проверить.
                                                                                                                                      0
                                                                                                                                      Я уже написал, что не разглядел ваш код.
                                                                                                                                0
                                                                                                                                Млин… Я использовал для таких целей if (!is_array($var)) $var = array($var); :)
                                                                                                                        –7
                                                                                                                        $var = $_GET['var']: $_GET['var']? 'default value';
                                                                                                                          –6
                                                                                                                          $var = $_GET['var']: $_GET['var']? 'default value';
                                                                                                                          0
                                                                                                                          4. Тернарный оператор.
                                                                                                                          Можно использовать без указания true-альтернативы, тогда ей становится само значение.

                                                                                                                          Однако, в этом я вижу очень мало практического применения.

                                                                                                                          Например, когда нужно в начале функции проверить параметры, и, если хоть один не устраивает, просто вернуть false.
                                                                                                                          Пример из одного моего проекта:
                                                                                                                          static function add($tour, $date, $owner, $guest)
                                                                                                                          {
                                                                                                                            /*
                                                                                                                            * Проверка корректноcти параметров.
                                                                                                                            */
                                                                                                                            $ret = self::$system_s->valid($tour, 'tour_id');
                                                                                                                            $ret = self::$system_s->valid($date, 'date') ? $ret : false;
                                                                                                                            $ret = self::$system_s->valid($owner, 'command_name') ? $ret : false;
                                                                                                                            $ret = self::$system_s->valid($guest, 'command_name') ? $ret : false;
                                                                                                                            
                                                                                                                            if (!$ret)
                                                                                                                            {
                                                                                                                             return false;
                                                                                                                            }
                                                                                                                            //...
                                                                                                                          }


                                                                                                                          * This source code was highlighted with Source Code Highlighter.

                                                                                                                          С новым синтаксисом подобная конструкция должна упроститься.
                                                                                                                            +13
                                                                                                                            $ret = self::$system_s->valid($tour, 'tour_id')
                                                                                                                             && self::$system_s->valid($date, 'date')
                                                                                                                             && self::$system_s->valid($owner, 'command_name')
                                                                                                                             && self::$system_s->valid($guest, 'command_name');


                                                                                                                            * This source code was highlighted with Source Code Highlighter.

                                                                                                                              +1
                                                                                                                              Спасибо. Как-то не додумался до этого варианта.
                                                                                                                                –3
                                                                                                                                Тут плюсовать принято =)
                                                                                                                                  +2
                                                                                                                                  Понимаю, но по причине того, что заинвайтили меня только вот на днях, кармы ещё не набрал, чтобы плюсовать :\
                                                                                                                                0
                                                                                                                                Что-то я не вижу во втором варианте признаков нового синтаксиса… Что раньше-то так мешало делать?
                                                                                                                                  +1
                                                                                                                                  Ничего. А должно было?
                                                                                                                              +1
                                                                                                                              Мануал по неймспейсам в указанной вами ссылке морально устарел (3 марта прошлого года) и не соответствует реалиям.
                                                                                                                              Укажите эту ссылку, если не затруднит: php.net/namespaces
                                                                                                                                0
                                                                                                                                Спасибо, поправил.
                                                                                                                                0
                                                                                                                                Замыкания, конечно, сделали очень по-своему.
                                                                                                                                  +4
                                                                                                                                  Про spl не написали. Там добавилось несколько структур данных, которые, при определенных кейзах могут быть применимы в качестве микрооптимизаций. Например, FixedArray. Ну и плюс это даст более здоровый и ясный код, что конечно субъективно.
                                                                                                                                    0
                                                                                                                                    Спасибо, напишу сейчас.
                                                                                                                                      0
                                                                                                                                      У меня результаты запросов из БД перегоняются в массив и оттуда обрабатываются. Потому как удобно. Так вот во многих случаях перегон в массив по времени занимает как запрос в базу.
                                                                                                                                        +2
                                                                                                                                        Это не имеет отношения к сабжу. Вы в любом случае много раз копируете данные.

                                                                                                                                        Приведу пример того, что я имею в виду.

                                                                                                                                        Возьмем fixed array. Что мы о нем знаем — структура данных фиксированного размера. Ага, значит можно избежать медленного realloc. Уже хорошо. Индексами могут быть только integers. Значит есть надежда что там будет использоваться меньше памяти на элемент + операции побыстрее будут.

                                                                                                                                        Посмотрим чего внутри:
                                                                                                                                        cvs.php.net/viewvc.cgi/php-src/ext/spl/spl_fixedarray.c?view=markup

                                                                                                                                        realloc-а неявного нету. Я нашел только явно, при вызове resize. Но если вам это потребуется, вы не верно выбрали структуру данных :-)

                                                                                                                                        Далее смотри основную стрктуру.

                                                                                                                                        typedef struct _spl_fixedarray { /* {{{ */
                                                                                                                                        long size;
                                                                                                                                        zval **elements;
                                                                                                                                        } spl_fixedarray;

                                                                                                                                        Неплохо, сэкономиле на ключе, считатай размер элемента у нас long + zval(а там внутри union).

                                                                                                                                        Операции тоже будут простыми:

                                                                                                                                        read:
                                                                                                                                        &element[index]

                                                                                                                                        write:
                                                                                                                                        elements[index] = value;

                                                                                                                                        А это тоже самое, что:

                                                                                                                                        *elements+index

                                                                                                                                        То есть используется адресная арифметика, а это очень быстро.

                                                                                                                                        Ну вроде как-то, думаю понятно о чем я хотел сказать.

                                                                                                                                        Ну и вот, в контексте вашей программы, все это называется микрооптимизацией, которая даст вам сколько-нибудь процентов перформанса ну и доставит(йо, я ж теперь тоже могу выжимать поинты из кода, как заправский сишник, правильно выбирая структуры данных). :-))
                                                                                                                                          0
                                                                                                                                          Мужик =)
                                                                                                                                            0
                                                                                                                                            Маленькая поправочка: long конечно же один, а не на каждый элемент.
                                                                                                                                              0
                                                                                                                                              на всяк. случай для особо придиривыч скобки поставлю:

                                                                                                                                              *(elements+index)

                                                                                                                                              :-)
                                                                                                                                                0
                                                                                                                                                > realloc-а неявного нету. Я нашел только явно, при вызове resize. Но если вам это потребуется, вы не верно выбрали структуру данных :-)

                                                                                                                                                Поправочка :). Если она вам часто требуется, то вы неверно выбрали структуру данных.
                                                                                                                                            0
                                                                                                                                            Жду-недождусь 5.3, сразу на нее перейду.
                                                                                                                                              0
                                                                                                                                              Я тоже. Поскольку я сам выбираю что использовать, обновлюсь сразу же. Думаю, ситуация довольно типична, и 5.3 станет распространенной версией с первых дней.
                                                                                                                                              Я даже ставлю "// refactoring PHP 5.3" в тех местах кода, которые нужно будет переделать после перехода.
                                                                                                                                                0
                                                                                                                                                Если площадка позволяет, 5.3 можно по-трогать уже сейчас:
                                                                                                                                                Win — windows.php.net/snapshots/
                                                                                                                                                *nix — snaps.php.net/
                                                                                                                                                  0
                                                                                                                                                  Дык я уже давно потрогал, в прошлом году еще начал =) И на локальной машине, и на devel-сервер.
                                                                                                                                                +1
                                                                                                                                                Жду-недождусь 6.0 с нативным юникодом. И чем больше жду, тем больше кажется, что не дождусь и перейду на питон.
                                                                                                                                                  0
                                                                                                                                                  Что, так много приходится с Unicode-строками работать? Imho, в реальном проекте очень мало такого, разве что функцию обрезания текста сделать.
                                                                                                                                                    +3
                                                                                                                                                    Мне, например, приходится много работать с Unicode-строками. По-правде говоря, я 90% времени именно с ними и работаю.
                                                                                                                                                      0
                                                                                                                                                      Я тоже, но смысл был в том что специфика юникода вылазиет не столь уж часто. Если приноровиться. Хотя конечно native unicode будет очень приятен. Отпадет куча маленьких гемморойчиков.
                                                                                                                                                        0
                                                                                                                                                        Да? Попробуйте сделать dirname или realpath от Unicode-пути. Грабли возникают там, где не ждёшь.
                                                                                                                                                          0
                                                                                                                                                          Да. Проблемы. Но решаются они весьма просто. Если верно понимаю — dirname — с помощью рэгекспов, а realpath вообще опционален (без него кажется сильно может снижаться производительность в виндах. думаю не многие держат продуктовый php на виндах :))) )
                                                                                                                                                            0
                                                                                                                                                            Таких проблем — вагон и маленькая тележка. Особенно, если пытаться перевести что-то большое и уже существующее на Unicode. Функцию dirname, конечно же, регекспами делать не нужно. Лучше сделать strros и отрезать сколько надо.
                                                                                                                                                              0
                                                                                                                                                              Это не критично (привыкли), но конечно переход будет приятен.
                                                                                                                                                                –1
                                                                                                                                                                Я не пишу на PHP с 3-й версии и просто не хочу привыкать. Зачем привыкать к плохому? Держать в голове, что любая функция, обрабатывающая строки, может гикнуться на Unicode неудобно.
                                                                                                                                                +2
                                                                                                                                                А как вам такие Синглтоны в PHP >= 5.3 ?)

                                                                                                                                                <?php

                                                                                                                                                abstract class Singleton {
                                                                                                                                                  private static $instances = array();
                                                                                                                                                 
                                                                                                                                                  public function __construct() {
                                                                                                                                                    $class = get_called_class();
                                                                                                                                                    if (array_key_exists($class, self::$instances))
                                                                                                                                                      trigger_error("Tried to construct a second instance of class \"$class\"", E_USER_WARNING);
                                                                                                                                                  }
                                                                                                                                                 
                                                                                                                                                  public static function getInstance() {
                                                                                                                                                    $class = get_called_class();
                                                                                                                                                    if (array_key_exists($class, self::$instances) === false)
                                                                                                                                                      self::$instances[$class] = new $class();
                                                                                                                                                    return self::$instances[$class];
                                                                                                                                                  }
                                                                                                                                                }

                                                                                                                                                class A extends Singleton {
                                                                                                                                                }

                                                                                                                                                class B extends Singleton {
                                                                                                                                                }

                                                                                                                                                $a1 = A::getInstance();
                                                                                                                                                $a2 = A::getInstance();
                                                                                                                                                $b1 = B::getInstance();
                                                                                                                                                $b2 = B::getInstance();

                                                                                                                                                if (get_class($a1) == "A" &&
                                                                                                                                                  get_class($a2) == "A" &&
                                                                                                                                                  get_class($b1) == "B" &&
                                                                                                                                                  get_class($b2) == "B" &&
                                                                                                                                                  $a1 === $a2 &&
                                                                                                                                                  $b1 === $b2)
                                                                                                                                                  echo "All good\n";
                                                                                                                                                else
                                                                                                                                                  echo "FAIL!\n";

                                                                                                                                                ?>


                                                                                                                                                * This source code was highlighted with Source Code Highlighter.
                                                                                                                                                  +1
                                                                                                                                                  Восхитительно!
                                                                                                                                                    +2
                                                                                                                                                    > public function __construct() {
                                                                                                                                                    Я бы сделал приватным.
                                                                                                                                                      +1
                                                                                                                                                      Синглтон всех синглтонов. Сомнительное решение. А Если A и B нужно еще наследовать от других классов?
                                                                                                                                                        +1
                                                                                                                                                        Да это всё понятно, ключевой момент на который я хотел обратить внимание это функция: get_called_class()
                                                                                                                                                        –1
                                                                                                                                                        мне кажется это называется реестр
                                                                                                                                                        –1
                                                                                                                                                        Лучше бы работу сессий пофиксили
                                                                                                                                                          0
                                                                                                                                                          А что именно с ними не так? Где можно взглянуть на ваш bug report?
                                                                                                                                                            0
                                                                                                                                                            На мой взгляд, сессия в PHP сделана крайне ужасна.
                                                                                                                                                            При старте сессия в хедеры выставляет свой Cache-Control и Expire, жутко гадит на диск в temporary, это камень и в огород и чистильщика сессии. При большом посещении tmp просто засоряется до нельзя и при этом PHP каждый раз лезет в эту кучу что бы найти нужную сессию. Сейчас существует множество алгоритмов хранения данных на диске, почему бы не использовать их?
                                                                                                                                                            То есть всё время надо следить что бы сессия где-нибудь ещё не гадила.
                                                                                                                                                            Если из всех страниц сайта только на некоторых есть сессия то есть вероятность что при переходах на страницы без session_start сессия стухнет.
                                                                                                                                                            На основе претензий: почему session_start всегда должна быть до вывода данных? неужели нельзя считать SID из куки после начала вывода? Понимаю что ей ещё надо нагадить в хедеры, но если сессия стартуется только при некоторых условиях, приходится извращаться с ob_start.
                                                                                                                                                            Я уже не говорю об отсутствии безопасности. Если хочешь обезопасить сессию приходится всегда писать свою обвертку и в итоге обвёртка полностью заменяет сессию и тогда получаем ещё одну не используемую и не отключаемую функциональность.
                                                                                                                                                            Зачем анониму таскать SID? Таким образом каждый раз при анониме скрипт лезет в tmp и искать переменную авторизации в _SESSION, когда проверку авторизации можно было свести к проверке присутствия сессии.
                                                                                                                                                              0
                                                                                                                                                              1) вам никто не мешает перекрыть cache-control и expire. Тем более, что их выставляют не сессия, а PHP.
                                                                                                                                                              2) вам никто не мешает положить сессии не в каталог /tmp/, а в любой другой. Читайте мануал.
                                                                                                                                                              3) вам никто не мешает хранить сессии MySQL, SQLite, memcached и вообще в любом месте, где можно хранить сессии. Читайте мануал.
                                                                                                                                                              4) все сессии всегда устроены именно так — протухать через время, если нет активности. по определению.
                                                                                                                                                              5) session_start() нужно выдать header'ы, как вы справедливо заметили. ob_start — отличный механизм, улучшающий производительность и код, рекомендую его освоить, безотносительно сессий. в чём вопрос я не понял, вы на него отлично ответили.
                                                                                                                                                              6) сессии надо стартавать тогда, когда это необходимо. без вашего участия этого никто не сделает. это не какой-то недостаток сессий, а объективная реальность жизни, если бы компьютеры сами знали, что делать, программистов не было бы. так что ответ — стартуйте сессию, когда нужно. про безопасность я не понял. что вы там обезопасить собираетесь?
                                                                                                                                                                0
                                                                                                                                                                > 2) вам никто не мешает положить сессии не в каталог /tmp/, а в любой другой. Читайте мануал

                                                                                                                                                                Мои 5 копеек: никто также не мешает смонтировать каталог сессий в памяти (это просто проще, чем хранить их в MySQL, SQLite, memcached)
                                                                                                                                                                  –2
                                                                                                                                                                  Обычно памяти на сервере и так в обрез, а вы предлагаете её за какать сессиями.