Мне не нравится то, во что превращается PHP



    И я уже знаю, что скажете вы, глядя на заголовок статьи:
    — Кто ты такой? Почему ты позволяешь себе так говорить?

    Отвечу сразу, чтобы не было недомолвок:

    • Я профессионально программирую на PHP с 2004 года, то есть вот уже 16 лет на момент написания этой статьи, и продолжаю это делать каждый день
    • Я преподаю программирование, в том числе и на PHP, примерно 10 лет и за это время выпустил в свет несколько тысяч студентов
    • Я всегда был в восторге от каждой новой версии PHP, что выходила со времен от 5.0 до 7.4 и всегда был адептом подхода «пишем на самой свежей версии, тестируем на следующей»

    И всё-таки, несмотря на всё сказанное выше, мне не нравится то, во что превращается PHP сейчас и во что он превратится уже скоро, буквально этой осенью.

    Почти каждый принятый в PHP 8 RFC вызывает во мне боль и недоумение. И я готов объяснить и защитить свою позицию.

    Меняются базовые концепции языка


    С чего обычно начинается изучение нового языка? Значения, выражения, переменные и функции. Так и при изучении PHP — это естественный порядок.

    Когда мы начинаем проходить функции, я обращаю особое внимание студентов на то, что в PHP контекст функций замкнут, «герметичен». Это очень просто и совершенно логично — нужно лишь четко запомнить, какие имена видит функция: свои аргументы и свои внутренние переменные.

    Когда мы доходим до азов ООП и изучаем понятие «метод», мы опираемся на понятие функции, и добавляем еще один пункт к контексту: $this в динамических методах. Меняется ли что-то еще? Нет. Функции по-прежнему замкнуты, их контекст перестает существовать после вызова, снаружи ничто не протекает в функцию, наружу из нее тоже не утекает.

    Доходим до анонимных функций — и тут правила игры тоже не меняются. Аргументы? Да. Внутренние переменные? Да. $this? ОК, давайте обойдем этот вопрос, иначе нам придется обсуждать странную вещь под названием «статическая анонимная функция» :)

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

    А знаете, что происходит дальше?

    А дальше у нас появляются стрелочные функции. И это ломает всё.

    Я вынужден объяснять, что стрелочные функции нарушают усвоенные с таким трудом принципы, поскольку замыкают на себя ВЕСЬ контекст в момент своего создания.

    Опс.

    А как же принцип «герметичности»? А никак, на него наплевали в угоду упрощения написания, сэкономив 6 символов — теперь у нас «fn» вместо «function».

    Плохо. Непоследовательно.

    Вы думаете, что это единственный пример? Как бы не так.

    Задайте любому нубу вопрос — с какого символа в PHP начинаются имена? Правильно, с символа "$"

    • имена переменных
    • имена свойств объектов
    • имена свойств классов
    • имена аргументов
    • даже «переменные переменные» — тоже "$" !

    Логично? Да. Последовательно? Да. Нужно только помнить про константы, которым $ не нужен.

    Что теперь у нас появляется? Именованные аргументы: wiki.php.net/rfc/named_params

    array_fill(value: 50, num: 100, start_index: 0);
    

    Где «доллар»? Нет.

    Это проблема.

    Теперь придется запоминать, что в сигнатуре функции «доллар» писать нужно, а при вызове — нет. И это очень серьезная проблема, нарушающая целостную систему языка. Это плохо и непоследовательно.

    Ради чего? Да так, просто, потому что кому-то захотелось перенести сахарок из Python в PHP, не подумав. Однако в Python хотя бы используется один и тот же символ "=" для сопоставления имени и значения, что в присваивании, что в именованных аргументах, а у нас теперь их будет два — обычное "=" и ":" в новой конструкции.

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

    Смотрите: ( wiki.php.net/rfc/match_expression_v2 )

    echo match (1) {
        0 => 'Foo',
        1 => 'Bar',
        2 => 'Baz',
    };
    

    это новые match-expressions. Можете объяснить, почему в них используется символ "=>", а не привычный по switch-case ":"? И я не могу.

    Это снова нарушение уже сложившейся системы. Символ "=>" всегда (до чертовых стрелочных функций, снова они!) обозначал разделитель пары «ключ-значение». Теперь он обозначает еще и разделитель списка аргументов и возвращаемого значения в «стрелке», и символ выбора значения в операторе match.

    Это плохо. Это очень плохо. Это крайне непоследовательно. Это даже хуже, чем с ключевым словом static, которое используется как минимум в трех принципиально разных значениях.

    Нечитаемость на естественном языке


    Покажите носителю английского текст

    SELECT * 
    FROM users
    WHERE age>=18 AND name LIKE 'J%'
    

    и он, если его IQ превышает 60, с легкостью объяснит — о чем этот текст и что будет сделано при реализации этого текста, как программы.

    Покажите гению, не знакомому с JS, текст

    const f = () => 42;
    

    и он не поймет ничего. Константа? f это скобки? Скобки стремятся к числу? Что это?

    Я всегда был рад, что PHP далек от того, чтобы принести в жертву читаемость кода в угоду краткости. Я был рад, что он далек от JS, где принцип читаемости кода был отринут в пользу «пиши меньше символов, всё равно этот код читать никто не будет».

    Теперь я понял, что в PHP 8 принцип естественной читаемости кода будет нарушен. И, судя по всему, бесповоротно.

    Просто посмотрите на эти примеры:

    wiki.php.net/rfc/constructor_promotion

    class Point {
        public function __construct(
            public float $x = 0.0,
            public float $y = 0.0,
            public float $z = 0.0,
        ) {}
    }
    

    Теперь у нас вместо аргументов конструктора — сразу и объявление свойств и задание им значений из аргументов.

    Догадайтесь, что после знаков "="? Начальные значения свойств? Или дефолтные значения аргументов конструктора? Догадаться невозможно. Узнать, прочтя код — тоже. Это плохо. Еще одно место, которое нужно заучивать наизусть.

    wiki.php.net/rfc/property_write_visibility

    class User {
        public:private int $id;
        public:protected string $name;
    }
    

    Публично-приватное свойство? Серьезно? Как из этого кода понять, что речь идет о свойстве доступном на чтение и недоступном на запись?

    wiki.php.net/rfc/conditional_break_continue_return

        function divide($dividend, $divisor = null) {
            return if ($divisor === null || $divisor === 0): 0; 
            return $dividend / $divisor;
        } 
    

    Серьезно, это кому-то нужно? Кто-то писал годами на PHP и страдал из-за отсутствия возможности написать «return… if» вместо «if… return»? Нам действительно нужен новый йода-синтаксис для банального if и return?

    Слишком много способов сделать одно и тоже


    PHP всегда нарушал знаменитый принцип «должен быть один и только один способ...» Но он делал это разумно, понемногу и обоснованно.

    Теперь же этот принцип растоптан и уничтожен. Каждый принимаемый RFC словно говорит «а давайте добавим еще один способ написать if, ведь я видел такое в Perl/Python/Ruby/Brainfuck!» — причем других обоснований, кроме как «я видел» в общем-то не приводится.

    Что было:

    if ($y == 0)
      return 0;
    
    if ($y == 0) {
      return 0;
    }
    
    if ($y == 0):
      return 0;
    endif;
    

    — целых три способа записи одного и того же. Не очень хорошо, приходится объяснять: зачем их три, почему не стоит писать код без операторных скобок и для чего нужен альтернативный синтаксис.

    Но этого мало! Подождите еще немного, и вы увидите:

    // революционный Йода-If
    return if ($y == 0): 0;
    

    Вот так вызывались функции:

    foo(bar($baz));
    

    Скоро вы увидите вот такое:

    $baz |> 'bar' |> 'foo'
    

    — гениально, не правда ли? Сразу же понятно, что это вызов функций!

    И это я еще ничего не написал про стрелочные функции :)

    Больше, больше способов сделать то, что делалось и раньше без всяких проблем:

    • match-expressions
    • оператор "?->"
    • два разных синтаксиса для замыкания
    • цикл + else
    • статические конструкторы
    • объявление свойств в аргументах конструктора (!)

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

    Итог


    PHP развивается. Это важный процесс, который затрагивает огромное количество людей и влияет на всё сообщество программистов.

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

    Мне не хочется увидеть через год на месте PHP новый Perl. А вам?

    Комментарии 385

      +12
      Без обсуждения самих сахарков.

      Это было неизбежно. Любой язык начнет набирать «лишние» и неконсистентные фичи. Это лишь вопрос времени. Скажите спасибо что лично для Вас он держался так долго.
        +11
        Я вас таки умоляю. Расскажите это создателям C# — который в принципе состоит из таких вещей, чуть менее, чем полностью. И ничего, все счастливы и требуют еще больше сахара!

        PS: Нужно признать что там весь сахар органично накладывается на базу языка, а не как в случае с пхп8, но сам факт…
          +7

          Не все счастливы, я например не очень. Но наличие сахара лучше, чем его отсутствие. Библиотечные расширяемые способы организовывать код были бы лучше, но их пропихивание занимает целые мажорные версии языка, а сахар сыпят в каждом релизе.

            +4
            И таки что в этом плохого? Путь шарписта есть путь смерти от сахарного диабета.
              +10
              Порог входа в язык неоправданно возрастает. Если лет 10 назад C# был сравнительно лаконичным и согласованным языком, то сейчас новчику придется столкнуться с тоннами «магии» которая которая есть простопотомучто.

              Лет через 10 C# превратится в такое же болото, которым сейчас является С++ и никто в здравом уме в это болото не сунется.
                +2
                Вся прелесть заключается в том, что никто не запрещает пилить код на шарпе 10-летней давности (как и в случае с явой). И работать оно будет ничуть не хуже чем код обмазанный современным сахарком (а зачастую оно будет работать даже лучше, ибо никто по зиро кост абстракшн не упарывается).

                Так что это не имеет значения. Порог входа в шарп останется тем же самым, что и 17 лет назад. А если какому-то джуниору придет в голову запихать ArrayList на прод, то ему очень быстро и доходчиво разьяснят, что время таких вещей безвозвратно ушло.
                  +1
                  И работать оно будет ничуть не хуже
                  А с читабельностью и пониманием происходящего все будет очень плохо. Не говоря уже о том, что новчику в голове надо будет держать весь ассортимент фич языка начиная от ArrayList и заканчивая последней пачкой сахара выкаченной Мадсом в год обучения.
                    +1
                    Ничто не идеально в нашем мире. Тут вы безусловно правы.

                    Но никто не говорил, что быть программистом легко. Хочешь, не хочешь а частности, которые нигде не используются, но они есть — придется выучить. С этим ничего не сделать, увы.

                    Но это приходит потом. Совсем потом.
                    +2

                    Я студент который пропускал пары по шарпам. Почему не хорошо запихать ArrayList на прод?

                      +4
                      Если коротко, лучше юзать к примеру List, т.к. он типизированный, в отличии от ArrayList который воспринимает все как object, что влечет к лишним упаковкам и распаковкам (unboxing)
                      0
                      Можно писать и на с++ как на «с с классами», только вот ты ведь не один работаешь на проекте — другие будут использовать все фичи, в которых тебе придется разбираться так или иначе
                        +1
                        никто не запрещает пилить код на шарпе 10-летней давности

                        Дело не в том, чтобы пилить, а в том чтобы читать. Новичок, попадая в обильно посахаренный проект должен знать всё виды сахара и сразу разбираться во всём, иначе он вообще не сможет работать в проекте.
                        +4

                        При всех минусах, до плюсов шарпу ещё лет 40 так же развиваться, а пистать на новых версиях удобнее, чем на старых.

                          0
                          Тут спору нет, но тем, кто сейчас пытается зайти во всю эту махину с нуля можно только посочувствовать, наверное.
                            +1

                            А что там такого невыучиваемого добавилось? Каждый релиз это пяток фич которые прочитваются в блогпосту на 15 минут.

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

                                Там все фичи уровня "один раз прочитал — и умеешь пользоваться". НУ что там — readonly структуры? Оператор ?.? То что разрешили инициализировать проперти без сеттеров? То что разрешили для однострочных функция не писать return?


                                А все версии сишарпа начиная с пятой выглядят именно так. И в следующей версии судя по результатам митингов опять добавят мелочь типа "можно не писать скобочки у неймсейса" или "Relax rules for trailing whitespaces in format specifier".

                                  0

                                  В предыдущей версии появилось nullability, а в следующей record types

                                    0
                                    а в следующей record types

                                    кто? можно ссылку?

                                      0

                                      Ну да, можно писать класс с круглыми скобочками class Person(string Name, string Password), и он нагенерирует рекорд с Equals/GetHashCode и прочей ерундой. Я полгода назад почитал про этот пропозал, вот сейчас я вам рассказываю, что это такое. Один раз прочитал — могу пользоваться ¯\_(ツ)_/¯

                            +4
                            Если лет 10 назад C# был сравнительно лаконичным и согласованным языком, то сейчас новчику придется столкнуться с тоннами «магии» которая которая есть простопотомучто.

                            Потому что надо не языки учить а базовые концепции. Вон как автор статьи жалуется на связывание переменных, которое что-то "ломает".

                            +2

                            Ну основная проблема как я вижу в нерасширяемости и ограниченности сахара, а также фрагментация. Вот сделали оператор ?. — окей, но что делать с вызовом статического метода? x?.Foo() написать можно а Foo(x?) или что-то такое уже не сделать. Соответственно код фрагментируется на тот или иной, и минорный рефакторинг привносит серьезные изменения, даже если дописать this в метод, сделав из обычного хелпера метод-расширения, и уже везде ИДЕ будет ругаться "а вот можно упростить", и наоборот.


                            Во-вторых расширяемость. От синтаксиса нельзя абстрагироваться. И это вообще не удобно.


                            Наконец, многий сахар просто костыльный. Например, завезли нуллябельные типы, вроде все рады? Но код вида T? Foo<T>() написать просто невозможно. Почему? Потому что T? для реф и вэлью типов означает совершенно разные вещи.

                              +2
                              Вот тут вы не правы. Hемного странно в посте о пхп рассуждать о шарпе — но что имеем, то имеем.

                              Шарп базируется на 3 абстракциях — это делегаты, перечисления и синтаксические деревья (привет LINQ).

                              Указанный вами оператор?.. — это всего лишь частный случай вызова делегата. Он не может вызываться как то вне семантики делегатов — т.е. Foo(x?) — будет невалидным с точки зрения именно базового устройства языка. Причем Foo(x)?.(z) — вполне себе идиоматичная конструкция (хоть и не используемая).

                              Весь сахар он четко накладывается именно на каркас языка, на то что в него вложили почти 20 лет назад. Да, кажется — что некоторые конструкции уходят прямо в какие то сверхвысокоуровневые дебри, но это только кажется.

                              За «нуллябельные» типы, в целом согласен, их очень сильно сбоку впилили, но то требование времени и хоть какая то попытка решения проблемы NullReferenceException, не самая идеальная, но ребята стараются. Лучше так, чем никак совсем.
                                +2

                                Оператор x?.y к делегатам отношения не имеет, это просто сахар для x is null ? null : x.y. Где тут какие делегаты?


                                Foo(x?) — будет невалидным с точки зрения именно базового устройства языка.

                                Но с точки зрения того же рефлекшна инстансные методы эквивалентны статическим с дополнительным this-аргументом. И правильно делает, кстати.

                                0

                                Так это не проблема ?, это проблема реф-типов и велью-типов в генериках. Ей уже нцать лет.

                                  0

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

                                    –1

                                    Тaк я и говорю, что описанная тобой проблема, по сути, никак не связана с?.. Поведение? — это просто симптом. А проблема, которая его вызывает, существовала задолго до.

                                      0

                                      Могли просто сделать опшн и задеприкейтить нуллябл, как сделала скала. Они же смогли на Span API как-то переползти, могли бы и опционалньые значения нормальные сделать.


                                      Но им слишком дорого это делать, а их ЦА это монстры с 20-летним легаси которым неинтересны эти игрушки, им херак-херак и в продакшн интереснее, обмазавшись динамиками и рефлекшном вкупе с COM. Что весьма грустно, в середине-конце нулевых язык выглядил революционно, а сейчас просто беттер жаба для дотнета, причем не факт что в самом деле беттер.

                                        0
                                        Так а в чём проблема? Используй скалу для новых проектов, для старых оставь шарп.
                            0
                            C# еще только обрастает сахарком, гляньте, например, на Visual FoxPro, за долгие годы развития он оброс этим самым сахарком (ну по крайней мере когда-то это казалось сахарком), что в 9 версии было уже не видно, где сахар, а где сам язык. Впрочем, функции он свои выполнял, вахту отстоял и ушел на покой.
                              0
                              То что язык Х сегодня все еще развивается консистентно — еще не значит что так и будет дальше. С++ в версии 89 был еще очень даже консистентным. Я бы даже сказал что 9x еще можно было как-то структурировать. Но в двухтысячных С и С++ начали активно наливать все новые фичи и теперь их код я уже не могу читать.
                                +1
                                Писатели кода может и счастливы, а вот читатели — не очень, как мне кажется. Сделать одно и то же несколькими способами — это не всегда преимущество.
                                +6

                                Ну, go пока держится. Даже дженерики ещё не приняли.

                                  +4
                                  К сожалению
                                    +1

                                    Я не понимаю порой, как можно тащить в язык дженерики, и думать о них, когда в языке нет нормального Set (множества), который сделан на Map. Как по мне, это тоже пример непоследовательного подхода и попытки угодить страждущим.
                                    И вот ниже resetme подсказывает, что в таком виде, не стоят дженерики того. Лично я скорее согласен. Они нужны, но в таком виде, субъективно, нет.

                                    +5
                                    К радости. В таком виде не надо.
                                      0

                                      Эм, а разве в go нет дженериков?

                                        +1
                                        Ну вот свеженькое обсуждение — меньше месяца назад.

                                        Впрочем 10 лет назад когда Go только появился про них уже говорилось: Generics may well be added at some point. We don't feel an urgency for them, although we understand some programmers do.

                                        Так что нельзя сказать, что это прям вот неожиданно возникшая фича.
                                          0
                                          Они там изначально есть в виде контейнеров, просто вы свои не сможете объявить.
                                        +1
                                        Я не понимаю хабр. Почему этот комментарий имеет минус — понятно, логично и правильно.
                                        Но за что минус в карму? Какие правила я тут нарушил? Кого обидел?
                                          +2
                                          Издержки местной системы кармы. Расслабьтесь и получайте удовольствие.
                                          +3
                                          Нет, не любой. Особенность PHP в том, что нет человека, который бы направлял его развитие.

                                          Автор языка, Расмус не накладывает вето на подобные «улучшайзинги». Он устранился от руководства. Решения, каким будет PHP, принимаются в духе демократии, голосованием нескольких десятков наиболее активных персон…

                                          Итог закономерен — под руководством толпы язык сползает в мейнстрим.

                                          В мейнстриме сейчас нечитаемый яваскрипт. Поэтому и PHP всё больше становится похожим на яваскрипт и нечитаемым.
                                            0
                                            JS и pyton. Так все и есть и это плохо.
                                            JS стрельнул не потому что чудо как хорош, а потому что оказался безальтернативен для браузерной динамики. При этом у него обфусцированный код не всегда от обычного отличишь. А pyton просто потому что многим захотелось сахарного и скриптового не в вебе ипоэтому теперь он жутко модный.
                                            Можно начинать думать на чем будет писаться веб через 10 лет. Помянутую пару не предлагать.
                                          +19

                                          Дуглас Крокфорд, который придумал JSON и JSLint, говорил, что JavaScript, в общем-то, неплохой язык, если использовать только часть тех возможностей, которые он предлагает. Похоже, 8-я версия лоббируется создателями PHPLint.


                                          Но вообще, те перспективы, что вы описали, навевают грусть.

                                            +6
                                            Видимо, по этому меня потянуло в сторону С.
                                              +1

                                              K&R или С99? Или ещё какой?

                                                +2
                                                C99, а там как пойдет. Главное же начать.

                                                Но уже имею некоторые плоды. Был удивлен тому что:
                                                if (1) {
                                                    char[] variable = "value";
                                                }
                                                
                                                printf("%s", variable);
                                                

                                                этот код не скомпилируется. После PHP это была очень сочная оплевуха черенком грабель :)
                                                  +5

                                                  А я удивляюсь этому в php, когда так пишут программисты с опытом от 3х лет. Ошибки? Какие ошибки? Заглушил на уровне error_reporting и типа норм.

                                                    0

                                                    Ну не, если «фонит» — значит надо чинить. Уже наловился таки сюрпризов при смене окружения во время переезда с непонятных серверов, на что-то более подконтрольное.

                                                    0
                                                    И вот на этом фоне автор статьи «тужит», что у него стрелочные функции куда-то что-то там «проливают». А почему тому факту, что переменная «вылилась» из if у него нареканий не вызывает? Потому что «так всегда было»?

                                                    В C++ можно даже так написать:
                                                      if (auto handle = getHandle(...); handle != INVALID_HANDLE) {
                                                      }
                                                    
                                                    Специально, чтобы этот самый handle нельзя было после if использовать.

                                                    При этом в том же C++ — куча мест, которые сделаны нелогично. Да и в самом PHP… известная же статья. Многое, кстати, из там описанного, починили — но говорить «вот, в PHP всё было просто и логично, а теперь, вдруг, стало ужасно»… как минимум странно.

                                                    Но да — проблема того, что «синтаксический сахар» помогает программы писать, но мешает их «читать» — существует.
                                                      +1

                                                      Вот не согласен с насчёт помогает писать, но мешает читать. Некоторые вещи пишутся на автомате, плюс генераторы и сниппеты в IDE, но потом сам не можешь прочитать, например, цепочку isset и тернарников

                                                        –1
                                                        Скажем так: код становится проще читать посвящённым, но сложнее — непосвящённым.

                                                        Пример из C++. Такой вот код на C++14:
                                                        template<int... values>
                                                        constexpr int sum = 0;
                                                        
                                                        template<>
                                                        constexpr int sum<> = 0;
                                                        
                                                        template<int value, int... values>
                                                        constexpr int sum<value, values...> = value + sum<values...>;
                                                        
                                                        Превращается на C++17 вот в это:
                                                        template<int... values>
                                                        constexpr int sum = (values + ...);
                                                        


                                                        Проще стало понять? Понятнее? Да. Вот только при переписывании возникла ошибка. Нужно было, оказывается, писать так:
                                                        template<int... values>
                                                        constexpr int sum = (values + ...);
                                                        


                                                        И на эти грабли чуть не каждый лично, рано или поздно, наступает, пока не поймёт — почему.

                                                        P.S. А isset и тернарники вроде в PHP, как и в многих других языках, были с прошлого века. И их, в общем, вполне хватало, чтобы создать нечитабельный код без всяких нововведений…
                                                          0
                                                          Скажем так: код становится проще читать посвящённым, но сложнее — непосвящённым.

                                                          Ну, код чтобы читать в большинстве случаев надо быть посвящённым. Вот я как непосвященный в C++ вообще не понимаю о чём речь. Ну, что-то могу предположить, но что конкретно любой из варинтоа делает — хз.


                                                          И их, в общем, вполне хватало, чтобы создать нечитабельный код без всяких нововведений…

                                                          Нововведения (некоторые, как минимум) способствуют том, чтобы создавать более читабельный код при прочих равных.

                                                            0

                                                            Эм, и чем тут отличается первый кусок кода для C++17 от второго?

                                                              +2
                                                              Судя по ссылкам — во втором случае должно быть такое, просто khim неудачно скопировал:
                                                              template<int... values>
                                                              constexpr int sum = (values + ... + 0);
                                                                –1
                                                                Нечаянный эксперимент показал, что вдумчиво читают немногие, а ссылки открывают — ещё меньшее число. И да, извиняюсь, DaemonGloom прав: там нужно не забыть "… + 0" приписать… иначе для нуля элементов компилятор не сможет понять «какой именно нуль» вам нужен (хотя, казалось бы, я же написал int...… но нет — этого недостаточно).
                                                                  +1

                                                                  Тот же самый нечаянный эксперимент показал, что вдумчиво пишут немногие, а перечитывают перед отправкой то, что написали, вообще единицы :)

                                                                    –1
                                                                    Нет — он показал, что даже если перечитывать и вычитывать, всё делать очень аккуратно, но один раз, случайно, ошибиться — то тут же набегут Mingun ы и смешают тебя с грязью.

                                                                    Я мог бы оправдываться, что-то объяснять и так далее… но… зачем?

                                                                    Проще общаться там, где подобные вещи не являются нормой. Что мне, пожалуй, и стоит сделать. Спасибо за то, что раскрыли глаза.
                                                                      +1

                                                                      Гм… Вот значит, как. То есть, по сути справедливое замечание на явно ошибочную ситуацию в коде — это уже «набигают». А ответ на явно язвительный комментарий в той же самой, заметьте, манере (хотя даже там на конце смайлик стоит, что значит — не стоит его воспринимать слишком серьёзно) это — «смешивают с грязью». Только почему-то у khim’а не возникало ощущения, что с грязью мешает он, когда писал свой комментарий (к вопросу о вдумчивом написании, кстати). Да и не нужен был этот комментарий уже — как khim сам отметил, DaemonGloom уже расставил точки над i. Так что же это, двойные стандарты?


                                                                      Но отвечать не обязательно, вы правы, потому что… зачем?

                                                      0
                                                      Да, в Си пока что такого идиотизма инноваций нет. Но и там понемногу внедряют синтаксический сахар вида массивов переменной длины, а также хотят ввести ООП.
                                                      +2
                                                      Все эти RFC не ломают старый api, можете писать код как и писали до этого если вам не нравится новые возможности. Лично я согласен что некоторые RFC например про «Публично-приватное свойство» выглядит ужасно.
                                                        +24

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

                                                          –8
                                                          Далеко не всегда удается попадать в проекты, которые начинают свой жизненный цикл. Бывают ситуации где:
                                                          — PSR??? мы тут три года уже пишем, но о таком еще не слышали
                                                          — пожалуйста не пиши так
                                                          $someobj->$methodName
                                                          , потому что джуниоры этой магии не поймут
                                                          — где 100+ методов, публичных, в классе контроллера это нужно поддерживать
                                                          — где тебя просят сделать элементарные вещи, а получается, что надо сначала там всё отрефакторить, чтобы сделать элементарную вещь. Иначе это будет просто очередной мазок сами знаете чего. Или то что было сделано хорошо, просто утонет в том что было сделано так как умели прошлые коллеги.

                                                          Это те «сливки», с которыми я столкнулся за прошедший, не календарный, год, во время поиска новой работы. А с новыми RFC этот «снежный ком» будет только набирать вес и размеры. Противостоять которым будет всё сложнее и сложнее.

                                                          А бывает, что в разговоре с коллегой слышишь что-то типа: «я как не читал документацию и до сих пор не вижу в этом смысла». Задаешь ему вопрос «какой будет результат?» с примером кода:
                                                          
                                                          <?php
                                                          
                                                          if (false) :
                                                              echo 'one';
                                                          else if (false) :
                                                              echo 'two';
                                                          else :
                                                              echo 'three';
                                                          endif;
                                                          
                                                          


                                                          и в ответ получаешь «three».
                                                            +2

                                                            А какой будет результат кода? На PHP не пишу давно, но вообще либо parse error, либо three.

                                                              –2
                                                              Ошибка компиляции будет, потому как при таком синтаксисе должно быть 'elseif'. Если бы это был простой, без скобочный, синтаксис, то было бы 'three'.
                                                                +39

                                                                Ide подсветит, зачем себе голову забивать, логично что отвечают что будет three, т.к. никто не ждёт что это идиотский вопрос с подвохом про пробельчик

                                                                  +23

                                                                  Согласен, пишу 10 лет на php, но глядя на пример мне даже в голову не пришло, что это про синтаксис.
                                                                  Зачем такое спрашивать — неясно.

                                                              +1
                                                              А какой правильный ответ вы ожидаете?
                                                              syntax error?
                                                                –27
                                                                Да. Вопрос из разряда «на внимательность», но эти знания могут и в практике эти знания могут пригодиться.
                                                                  +9

                                                                  не могут. эти "ньюансы" пусть решает IDE. а забивать голову подобными "особенностями" полезно только разве что для собеседований с вопросами на бумажке на внимательность.

                                                                    +24

                                                                    всякие странные люди ЧСВ так поднимаю перед джунами, когда мозги нечем занять

                                                                      –7
                                                                      IDE это хорошо и замечательно. И я прикручиваю к ней сторонние анализаторы кода. И коллегам советую хорошие плагины и настройки, для упрощения жизни. Но «не знание знание закона, не освобождает от ответственности».

                                                                      Например, IDE может не оказаться под рукой, ушел по SSH на сервер чтобы на горячую произвести изменения «здесь и сейчас» и там у вас vim, или nano.

                                                                      С IDE разработка, условно, выглядит как езда на автомате. Только когда приходится садиться за ручку, у некоторых, начинаются проблемы.

                                                                      Нужно знать и уметь те инструменты которыми приходится работать. IDE хороший помощник, она берет львиную долю работы на себя. Но, я считаю, нужно так же уметь жить без нее.
                                                                        –1

                                                                        Некрофилия какая-то, ssh, vim, php code…

                                                                          +9

                                                                          А когда это всё вышеназванное успело умереть?

                                                                            +5

                                                                            Это про порядок действий, внизу ответили то что я имел ввиду, есть git и запрет редактировать руками файлы на сервере

                                                                          +6
                                                                          чтобы на горячую произвести изменения «здесь и сейчас» и там у вас vim, или nano.

                                                                          У вас разработчики имеют доступ к ssh прода и при этом им разрешается «на горячую» файлы проекта редактировать?

                                                                          И системой контроля версий(git, svn и т.п.), как я понимаю, вы не пользуетесь?
                                                                            –3
                                                                            А ssh только на прод бывает, или вы тоже ЧСВ поднимаете?

                                                                            Системой контроля версий пользуемся, и CI, и CD.
                                                                              0

                                                                              Замените слово "прод" на "дев" и вопрос остается. За любую редактуру на горячую надо бить по рукам оленьими рогами.

                                                                                +4
                                                                                Ну, кстати, иногда легче на стейдже через vim быстренько продебажить, чем у себя на локалке всю пачку микросервисов поднимать.
                                                                                  –1

                                                                                  Мое личное ИМХО, не подумайте что я наезжаю, но — так делать нельзя. Это приводит к проблемам при параллельной работе, это приводит к вещам навроде "изменил тут, тут и там в течении пары дней" а в сорсы локальные что-то забыл внести и баг в очередной раз всплывает в новой версии.


                                                                                  А про микросервисы… ну тут конечно все сложней, хотя с повсеместным приходом гипервизоров и докера — иметь точную копию прода уже вполне типичная задача.

                                                                            +2
                                                                            IDE может не оказаться под рукой, ушел по SSH на сервер чтобы на горячую произвести изменения

                                                                            Тогда ошибку покажет сам PHP при запуске этого кода. Если вы редактируете что бы то ни было на горячую и потом не проверяете результат, то проблемы в этом случае это следствие ваших действий, а не чьего-то незнания синтаксиса.

                                                                              +1
                                                                              > ушел по SSH на сервер чтобы на горячую произвести изменения «здесь и сейчас» и там у вас vim, или nano.

                                                                              Последний раз так делал году в 2013. Надо произвести изменения — коммит в Git пожалуйста и деплой, никаких «на горячую»
                                                                                –1
                                                                                По ssh надо зайти, чтобы запустить git pull, а не чтобы править код.
                                                                            +5
                                                                            Давайте ещё будем спрашивать про порядок аргументов в стандартных функциях PHP.
                                                                              +3
                                                                              Это наверное самый адок в php с давних пор…
                                                                              Я конечно не профессионально пишу на php, скорее уж это у меня больше хобби и все такое, но все же пишу на нем всякие мелочи уже многие годы, но блин до сих пор приходится часто вспоминать или сверяться с хелпом на тему того, в какой очередности в ту или иную функцию передать параметры… ибо однотипность и однообразность в этом плане там даже не ночевала…
                                                                                +3

                                                                                Phpstorm показывает, в доку уже можно не лезть.

                                                                              +1
                                                                              синтакс еррор это когда он приводит к логической ошибке, которая детектится только во время выполнения, например на баше:
                                                                              A=1
                                                                              if [ '$A' == '1' ]; then echo 'True'; fi


                                                                              Так не работает, и IDE тут не подсветит что не так. Надо выполнить код и проверить руками. А то, что вы приводите, приводит к ошибке компиляции, которая в самом плохом случае до пулл реквеста дойдет и упадет от тестов, потому что не скомпилится. А по нормальному даже не попадет коммит, если разработчик хоть изредка проверяет что у него запускается локально.
                                                                            +10
                                                                            — пожалуйста не пиши так

                                                                            $someobj->$methodName

                                                                            , потому что джуниоры этой магии не поймут


                                                                            Я бы вот тоже попросил так не писать. Из-за подобных перлов потом не понятно где конкретная функция используется: статический анализ перестаёт работать, а если там эта $methodName ещё и создаётся с помощью сложения строк или ещё чего похуже, то и даже простой поиск по коду по вхождению строки может не помочь быстро найти откуда ноги растут у той или иной ошибки. По той же причине я предпочитаю не использовать массивы в качестве callable
                                                                              +1
                                                                              Иногда такое всё же нужно, чтобы не городить бойлерплэйты. Но я всё же предпочту через swith прогнать строку, чтобы явно видеть, какие строки к вызову каких методов приводят. А если там нужно 100+ вариантов… Возможно, код уже пахнет сам по себе)
                                                                                +1
                                                                                Иногда такое всё же нужно, чтобы не городить бойлерплэйты

                                                                                Не спорю, вполне возможно, что иногда нужно. Просто в моей практике за последние несколько лет у меня не встречалось случаев, когда использование подобных конструкций значительно сокращало бы количество написанного кода.
                                                                                  0
                                                                                  Ну, как я уже написал, сам стараюсь избегать подобного. Либо закапывать в недрах ядра, с комментариями — если уж других вариантов нет.
                                                                                    0
                                                                                    А у меня наоборот, регулярно в проектах встречается DI через конструктор, которое приводит к такому дублированию. Скорее всего, именно для таких случаев этот сахар и придумали.
                                                                                +1
                                                                                Всегда было интересно, а в чем прикол без скобочного синтаксиса?

                                                                                меня даже такое без скобок бесит
                                                                                if ($num === 1) 
                                                                                    echo 'one';

                                                                                  0

                                                                                  Меньше символов, обычно и меньше строк.

                                                                                    +1
                                                                                    Вот не согласен, что меньше символов

                                                                                    так
                                                                                    if (!empty($elements)):
                                                                                        foreach ($elements as $element):
                                                                                            // ...
                                                                                        endforeach;
                                                                                    endif;
                                                                                    

                                                                                    или так :)
                                                                                    if (!empty($elements)) {
                                                                                        foreach ($elements as $element) {
                                                                                            // ...
                                                                                        }
                                                                                    }
                                                                                    


                                                                                    И я еще могу понять, когда такие конструкции используют в шаблонизаторах, там и выбора особо нету. Но вот зачем так код писать в контроллере или даже при выводе html мне вот не понятно, типа чтоб в скобках не заплутаться?

                                                                                    При гуглении нашел единственное пояснение, что мол если писать в одну строку, без отступов, в блокноте, без подсветки синтаксиса, то вот тогда то будет проще :)
                                                                                      0
                                                                                      А причём тут альтернативный синтаксис управляющих конструкций к возможности не писать скобки вообще?
                                                                                    +1

                                                                                    а я бы просто написал


                                                                                    if ($num === 1) echo 'one';

                                                                                    что совершенно понятно, и не понимаю, что все уперлись в обязательные скобки, слава разработчикам языка, добавляют таки упрощенные конструкции и туда еще пока не додумались сувать никому не нужные скобки {}

                                                                                      0

                                                                                      Точки останова ставить проще, когда тело и условие на разных строках.

                                                                                        0

                                                                                        Ну да, но если там есть необходимость в сложных чего-то там…
                                                                                        Такую конструкцию тоже разносите по строкам?


                                                                                        $num ? 'asdf' : '3454';

                                                                                        или


                                                                                        $num ?? 'asdf';
                                                                                          0

                                                                                          Я-то по разному делаю. И периодически огребаю из-за невозможности поставить точку останова или непонимания в каком месте сейчас остановился дебаггер.

                                                                                            0

                                                                                            Ну, а что говорят "гребатели" на такое? (ну я шучу конечно, имею ввиду людей, кто на вас ругается)


                                                                                            return [];

                                                                                            или они приветствуют только такой код везде?


                                                                                            $map = [];
                                                                                            return $map;
                                                                                              +1

                                                                                              Да я сам на себя ругаюсь. Тоже проблема, да. Из-за кривого дебаггера приходится кочевряжиться с дополнительными локальными переменными.

                                                                                        +1

                                                                                        Однажды, один разработчик придерживался таких же принципов, а потом спутник упал. После этой истории обязательность фигурных скобок даже в ГОСТ (в сишный, если не путаю) добавили.


                                                                                        P.S. История расказанная мне в МГТУ преподавателем, так что истинность не гарантирую.

                                                                                          +1
                                                                                          что совершенно понятно, и не понимаю, что все уперлись в обязательные скобки

                                                                                          Есть такое слово — единообразие. Многострочные конструкции по любому будут со скобками и на отдельных строках, так зачем делать исключение для однострочных? К тому же мой редактор по умолчанию подставляет скобки при наборе if, и удобнее делать нормальную конструкцию, а не сокращённую.
                                                                                            0

                                                                                            Ну не пишите многострочную конструкцию, пишите однострочную, как в моем примере, она же однострочная…
                                                                                            Я уже выше написал пример сокращений в одну строку, никого ведь они не смещают?


                                                                                            $num ?? 'asdf';

                                                                                            Никто не кричит ведь, где же скобки!!! :)


                                                                                            () => 1;

                                                                                            чтоб написать обязательно вот как-то так (не помню, в последней версии php так можно или еще нет… но js точно никто не кричит)


                                                                                            () => {
                                                                                                return 1;
                                                                                            };
                                                                                    +1
                                                                                    В своё время PHP от Perl-а отпочковался, теперь к Perl-у же и возвращается. И круг замкнётся.
                                                                                      +1

                                                                                      ПХП к перлу никакого отношения никогда не имел. Откуда вы это взяли?
                                                                                      Если вы про распространенное заблуждение "первые версии пхп представляли из себя набор перл скриптов", то это тоже не так.
                                                                                      https://museum.php.net/php1/

                                                                                        –1
                                                                                        Доллар перед названиями переменных в PHP откуда? Из bash-a?
                                                                                          +1

                                                                                          О мой бог. Слово "if" откуда?
                                                                                          Вердикт: все языки отпочковались от… английсого языка ?


                                                                                          Вы немного путаете inspired by и "отпочковались".

                                                                                            0
                                                                                            В 1995 году датский программист (ныне живущий в Канаде) Расмус Лердорф (Rasmus Lerdorf) создал набор скриптов на Perl/CGI для вывода и учёта посетителей его онлайн-резюме, обрабатывающий шаблоны HTML-документов. Лердорф назвал набор Personal Home Page (Личная Домашняя Страница). Вскоре функциональности и быстроты Perl — интерпретатора скриптов — перестало хватать, и Лердорф разработал с использованием языка C новый интерпретатор шаблонов PHP/FI (англ. Personal Home Page / Forms Interpreter — «Личная Домашняя Страница / Интерпретатор форм»). PHP/FI включал базовую функциональность современного PHP: оформление переменных в стиле Perl ($имя_переменной для вывода значения), автоматическую обработку форм и встраиваемость в HTML-текст и многое другое. Новорождённый язык отличался от своего прародителя более простым и ограниченным синтаксисом.

                                                                                            ru.wikipedia.org/wiki/%D0%98%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F_PHP
                                                                                              +1

                                                                                              HP development began in 1994 when Rasmus Lerdorf wrote several Common Gateway Interface (CGI) programs in C,[17][18][19] which he used to maintain his personal homepage. He extended them to work with web forms and to communicate with databases, and called this implementation "Personal Home Page/Forms Interpreter" or PHP/FI.


                                                                                              PHP/FI could be used to build simple, dynamic web applications. To accelerate bug reporting and improve the code, Lerdorf initially announced the release of PHP/FI as "Personal Home Page Tools (PHP Tools) version 1.0" on the Usenet discussion group comp.infosystems.www.authoring.cgi on June 8, 1995.[20][21] This release already had the basic functionality that PHP has today. This included Perl-like variables, form handling, and the ability to embed HTML. The syntax resembled that of Perl, but was simpler, more limited and less consistent.[8]


                                                                                              https://en.wikipedia.org/wiki/PHP


                                                                                              Кому будем верить? Учитывая что исходники доступны? )


                                                                                              ЗЫ. создал набор скриптов на Perl/CGI для вывода и учёта посетителей его онлайн-резюме, обрабатывающий шаблоны HTML-документов.


                                                                                              Но даже это никак не подходит под "отпочковалось". Он Решил охуенную проблему и респект ему за это. Но с перлом это связано на уроне "мне не понравился перл"


                                                                                              Хотя никаких перл скриптов в первой версии не было )

                                                                                      –10
                                                                                      const f = () => 42;


                                                                                      и он не поймет ничего. Константа? f это скобки? Скобки стремятся к числу? Что это?

                                                                                      ну вообще да, скобки стремятся к числу. Обычное обозначение функции в великом множестве языков.
                                                                                        +22
                                                                                        Позвольте мне не согласится с автором во всех пунктах данной статьи. И я тоже последние 16 лет ежедневно работаю с PHP.

                                                                                        1. Стрелочные функции.
                                                                                        Идея не меняется, они имеют тоже контекст. Контекст каждой функции заключет в фигурные скобки. Так и со стерлочными функциями.

                                                                                        2. Именные параметры.
                                                                                        С `$` начинается обявленная переменная в памяти, РФЦ вводит `:` как присваивание для будущей переменной. С этим РФЦ есть проблемы, но не одна из них не описанна в этой статье. Например РФЦ включает название переменных в АПИ, что ведет к услажнению рефакторинга, теперь изменить название аргумента функции будет сложнее. Но думаю любая ИДЕ эту проблему решит так что програмисты не особо будут с не сталкиваться.

                                                                                        3. Match
                                                                                        Да, код написанные новым синтаксисом можно уже сделать через switch. Но и switch код легко заменить на if, а while на for. Match всего лишь попытка облегчить код, аналогичный код другими средставми минимум в два-три раза больше, что теоритечески сложнее читать.

                                                                                        4. Сonstructor promotion
                                                                                        Осуждение в статье посторенно на «не возможно догадаться». Я сильно сомневаюсь что читающий код это повар, лесоруб или кто-нибудь другой который должен гадать о написанном. Програмист скорее всего один раз познакомившийся с синтаксимом будет узнавать и понимать читаемое легко. А если представить контекст данной операции, то приемущества видны еще более явно. Давайте просто сравним два аналогичных кода
                                                                                        class Point {
                                                                                            public function __construct(
                                                                                                public float $x = 0.0,
                                                                                                public float $y = 0.0,
                                                                                                public float $z = 0.0,
                                                                                            ) {}
                                                                                        }
                                                                                        

                                                                                        class Point {
                                                                                            public float $x,
                                                                                            public float $y,
                                                                                            public float $z,
                                                                                            public function __construct(
                                                                                                float $x = 0.0,
                                                                                                float $y = 0.0,
                                                                                                float $z = 0.0,
                                                                                            ) {
                                                                                                $this->x = $x;
                                                                                                $this->y = $y;
                                                                                                $this->z = $z;
                                                                                            }
                                                                                        }
                                                                                        

                                                                                        ИМХО первый вариант предпочтительнее.
                                                                                        > Догадайтесь, что после знаков "="? Начальные значения свойств? Или дефолтные значения аргументов конструктора?

                                                                                        А какая разница? В контексте конструктора? После "=" это и то и другое. А если что-то еще надо добавляем в тело конструктора.

                                                                                        5. Property write visibility
                                                                                        Хотя тут я соглашусь что синтаксис довольно сорный и не понятный, но не могу согласится что РФЦ и обсуждение проблемы плохо. Проблема в языке есть и это факт. Сеттеры и геттеры это просто язва PHP, который делает код безобразным. Хотя я надеюсь что этот РФЦ отклонят на голосовании, т.к. сегодня это решается статическими анализаторами более элегантно. Все же думаю что обсуждение пойдет на пользу PHP.

                                                                                        Итого
                                                                                        В статье упор делается на проблемы новичком, что довольно спорно, ИМХО.
                                                                                        Новички читают учебный материал, для них весь язык является чем-то новым, а не только новшества новых RFC. Это скорее пробелма более опытных програмистов, которые сопративляются изменениям. Главное чтоб преподователи и менторы этих новычков не преподносили материал вместе со своим субъективным мнением.
                                                                                          +2
                                                                                          То, что вы не видите проблем, не значит, что их нет.
                                                                                          Итак, смотрим внимательнее на Сonstructor promotion.
                                                                                          Предположим мы написали нечто вроде:
                                                                                          class A {
                                                                                            public function __construct(public int $x, public int $y) {}
                                                                                          }
                                                                                          

                                                                                          Значит ли это, что теперь в любом объекте класса A должны быть свойства $x и $y и они обязаны быть типа int? Причем они обязательно должны быть заданы в конструторе?

                                                                                          Да? Прекрасно!

                                                                                          class B extends A {
                                                                                            public function __construct(public string $z) {}
                                                                                          }
                                                                                          

                                                                                          А в объектах класса B будут свойства $x и $y? И какой у них будет тип?

                                                                                          Если да — откуда они взялись? Где они задаются? Как мне их задать в конструкторе? Где проходит их тайп-чек, если я не вызываю A::__construct()? Ах, он теперь неявно вызывается… ну извините, это полная дичь!

                                                                                          Если нет — вы сломали наследование. Вы просто ко всем чертям сломали наследование, на котором держится всё ООП в PHP.

                                                                                          Оба ответа плохие. Это плохой код и ужасная возможность, которой никогда не стоит пользоваться.
                                                                                            +7
                                                                                            Я не понимаю о чем речь. Без Сonstructor promotion это выглядит как
                                                                                            class A {
                                                                                              public int $x;
                                                                                              public int $y;
                                                                                            }
                                                                                            class B extends A {
                                                                                              public string $z;
                                                                                            }
                                                                                            

                                                                                            Т.е.
                                                                                            Да. Объекты типа B имеет свойства x & y. Не нужно, меняем видимость __construct(private int $x, private int $y).

                                                                                            Откуда они взялись, ясно откуда. Я думаю вы не до конца осознали что такое Сonstructor promotion. Это не значит что свойства класса будут объявлены только если вызвать конструктор.

                                                                                            Тайп-чек проходит на момент присвоения.
                                                                                              –3
                                                                                              >> не значит что свойства класса будут объявлены только если вызвать конструктор
                                                                                              Именно это и значит, читайте RFC. Вам будет неявно добавлен вызов parent::__construct()
                                                                                                +4
                                                                                                > Вам будет неявно добавлен вызов parent::__construct()

                                                                                                Специально перечитал RFC. Можно ссылочку на это заявление?
                                                                                                  –5
                                                                                                  Был неправ. Неявного вызова не будет. Но без явного всё сломается.
                                                                                                    +6
                                                                                                    Не сломается если свойства родительского класса с дефолтными значениями. А не с дефолтными и сейчас сломается. Хочу еще раз уточнить Сonstructor promotion не придносит ничего нового кроме как более короткий синтаксис того что сейчас требует повторять трижды (объявление совйства, аргумент, присваивание свойству значение аргумента).

                                                                                                    Это явно указано в RFC и показан пример после слов
                                                                                                    > Promoted properties follow a simple desugaring, where the following transformation is applied for all promoted parameters
                                                                                                      –2
                                                                                                      Если я правильно понял фразу «Не сломается если свойства родительского класса с дефолтными значениями.» то должно быть так:
                                                                                                      <?php
                                                                                                      
                                                                                                      class A {
                                                                                                          public function __construct(
                                                                                                              public int $a = 1
                                                                                                          ) {}
                                                                                                      }
                                                                                                      
                                                                                                      class B extends A {
                                                                                                          public function __construct(
                                                                                                              public string $b = 'hello'
                                                                                                          ) {}
                                                                                                      }
                                                                                                      
                                                                                                      $b = new B();
                                                                                                      var_dump($b->a, $b->b);
                                                                                                      


                                                                                                      Но вот результат получается вовсе не тот о котором вы пишите:

                                                                                                      Fatal error: Uncaught Error: Typed property A::$a must not be accessed before initialization in /in/kd90M:16
                                                                                                      Stack trace:
                                                                                                      #0 {main}
                                                                                                      thrown in /in/kd90M on line 16

                                                                                                      Process exited with code 255.


                                                                                                      Код в песочнице: 3v4l.org/kd90M

                                                                                                      Не исключаю что авторы в первых бетах реализовали что-то не так. Посмотрим как оно будет дальше. Но пока имеем, что есть.
                                                                                                        +2
                                                                                                        Логично. Конструктор не был вызван, инициализации свойств не было.
                                                                                                        Потому что в аргументах не дефолтные значения свойств, а дефолтные значения аргументов.

                                                                                                        Это адский ад.
                                                                                                          –1
                                                                                                          Коллега пытался сделать акцент на то, что «дешугаринг» должен нас спасти, но не спас.
                                                                                                          +6
                                                                                                          Коллега пытался сделать акцент на то, что «дешугаринг» должен нас спасти, но не спас.

                                                                                                          Нет же. Я такого акцента не делал. Я делал акцент что это сахар и ничего не меняет в работе php. Вот так вы бы написали без сахара, и словили бы туже ошибку


                                                                                                          class A {
                                                                                                            public int $a;
                                                                                                            public function __construct(int $a = 1) {
                                                                                                              $this->a = $a;
                                                                                                            }
                                                                                                          }
                                                                                                          
                                                                                                          class B extends A {
                                                                                                            public string $b;
                                                                                                            public function __construct(string $b = 'hello') {
                                                                                                               $this->b = $b;
                                                                                                            }
                                                                                                          }
                                                                                                          
                                                                                                          $b = new B();
                                                                                                          var_dump($b->a, $b->b);
                                                                                                            +9
                                                                                                            Мда… Я в более спокойной обстановке прочел и RFC, и код потыкал, сравнивая существующие варианты с новыми. Плюс до меня немного дольше доходило «Потому что в аргументах не дефолтные значения свойств, а дефолтные значения аргументов.» в комментарии Альберта

                                                                                                            Пардон, я был не прав, но я разобрался, по этому спасибо вам!
                                                                                                              0
                                                                                                              Согласен с Алексеем, Сonstructor promotion все таки вносит сумбур.

                                                                                                              Давайте сравним два примера:

                                                                                                              Здесь у нас после инициализации, объект $b всё таки имеет свойство a, да к нему сразу нельзя обратиться, так как оно не имеет дефолтное значение, и по смыслу должно хранить в себе null, но тип ограничен int.
                                                                                                              Но после присвоения ему значения в виде 1, всё встает на свои места.
                                                                                                              3v4l.org/1530v
                                                                                                              class A {
                                                                                                                public int $a;
                                                                                                                public function __construct(int $a = 1) {
                                                                                                                  $this->a = $a;
                                                                                                                }
                                                                                                              }
                                                                                                              
                                                                                                              class B extends A {
                                                                                                                public string $b;
                                                                                                                public function __construct(string $b = 'hello') {
                                                                                                                   $this->b = $b;
                                                                                                                }
                                                                                                              }
                                                                                                              
                                                                                                              $b = new B();
                                                                                                              $b->a=1;
                                                                                                              var_dump($b->a, $b->b);
                                                                                                              


                                                                                                              Здесь же, мы используем Сonstructor promotion, и после инициализации объекта $b, при попытке присвоить значение свойству a, получаем ошибку. Так как у объекта $b нет свойства а, так как конструктор class A не был вызван
                                                                                                              3v4l.org/qKUlV
                                                                                                              class A {
                                                                                                                  public function __construct(
                                                                                                                      public int $a = 1
                                                                                                                  ) {}
                                                                                                              }
                                                                                                              
                                                                                                              class B extends A {
                                                                                                                  public function __construct(
                                                                                                                      public string $b = 'hello'
                                                                                                                  ) {}
                                                                                                              }
                                                                                                              
                                                                                                              $b = new B();
                                                                                                              $b=1;
                                                                                                              var_dump($b->a, $b->b);
                                                                                                              

                                                                                                                +1
                                                                                                                Ммм, читая код, ошибка определяется даже без компилятора — у переменной типа int не может быть свойств a и b. Если же написать $b->a = 1 ошибки нет
                                                                                                                  0
                                                                                                                  Пардон, в конце второго блока, конечно же:
                                                                                                                  $b = new B();
                                                                                                                  $b->a=1;
                                                                                                                  var_dump($b->a, $b->b);
                                                                                                                  

                                                                                                                  Вот незадача, выходит что код работает
                                                                                                                    +3
                                                                                                                    Ситуация, когда опытные разработчики продолжительно и аргументированно пытаются понять, что на самом деле происходит (и это получается не с первого раза) в «родном» языке, на мой взгляд, является показательной. Такие изменения больше ломают, чем делают лучше.
                                                                                                                      +4

                                                                                                                      "Опытные разработчики" это от слово "опыт" или "пытка"? :) Если первое, вроде ничего странного что не сразу получается с "новшествами" или "новым синтаксисом", потому что как опыт получен в другом. И с этим появится и вопросов не будет.

                                                                                                                        +1

                                                                                                                        Скорее, пытаются возмутиться. При таком подходе понимать намного сложнее и дольше.


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

                                                                                                                    0

                                                                                                                    Оно сломалось не при создании класса, а при обращении к не инициализированным свойствам. И это не нововведения PHP 8, а уже в языке есть.
                                                                                                                    Если вы намерянно в конструкторе потомка не вызываете конструктор предка — то кто ж вам виноват?

                                                                                                            +1
                                                                                                            Интересно как с этим будет работать например ReflectionClass::newInstanceWithoutConstructor из пакета Reflection. А он много где используется в фреймворках для тестирования.
                                                                                                              +2

                                                                                                              Так же как и без этого сахара.


                                                                                                              <?php
                                                                                                              class A {
                                                                                                                public function __construct(public int $p = 1) {}
                                                                                                              }
                                                                                                              class B {
                                                                                                                public int $p;
                                                                                                                public function __construct(int $p = 1) {
                                                                                                                    $this->p = $p;
                                                                                                                }
                                                                                                              }
                                                                                                              
                                                                                                              var_dump((new ReflectionClass(A::class))->newInstanceWithoutConstructor());
                                                                                                              var_dump((new ReflectionClass(B::class))->newInstanceWithoutConstructor());

                                                                                                              object(A)#2 (0) {
                                                                                                                ["p"]=>
                                                                                                                uninitialized(int)
                                                                                                              }
                                                                                                              object(B)#1 (0) {
                                                                                                                ["p"]=>
                                                                                                                uninitialized(int)
                                                                                                              }
                                                                                                                0
                                                                                                                Интересная магия. Конструктор не вызывали, но в классе А свойство имеет тип, хотя он описан только в сигнатуре конструктора.
                                                                                                                  +2

                                                                                                                  Не магия, а короткий синтаксис. В примере A и B одинаковый код, один написаной с использованием сахара, другой без. Но код идентичный.

                                                                                                                    –2
                                                                                                                    Должен быть один способ объявления свойств класса. Иногда мне хочется своими глазами увидеть в исходниках свойства. Теперь буду искать их еще и в конструкторе?

                                                                                                                    > А какая разница? В контексте конструктора? После "=" это и то и другое. А если что-то еще надо добавляем в тело конструктора.
                                                                                                                    Вы примерами явно показали, что разница есть.
                                                                                                                      +4
                                                                                                                      Должен быть один способ объявления свойств класса.

                                                                                                                      Это тебе повезло наверное в жизни, ты не читал код где свойства класса объявленны не в начале а между классами, что не запрещено. Я это к тому что в данном случае все дело в code standard, если в команде объявлен стандард что писать свойства в начале класса, то не сложно будет объявить что конструктор надо писать тоже сверху. Это кстати даже в RFC рекомендовано, и возможно появится в документации PHP. Остальное дело привычки. Думаю, не надо из-за своих привычек и желаний не давать другим возможности пользоваться чем-то.

                                                                                                          0
                                                                                                          Стрелочные функции отличаются от обычных анонимок:

                                                                                                          <?php
                                                                                                          
                                                                                                          $var = 'val';
                                                                                                          
                                                                                                          $fn = fn () => $var; // Переменная доступна без дополнительных действий
                                                                                                          
                                                                                                          echo $fn(); // var
                                                                                                          
                                                                                                          


                                                                                                          в то время как

                                                                                                          <?php
                                                                                                          
                                                                                                          $var = 'val';
                                                                                                          
                                                                                                          $fn = function () {
                                                                                                              return $var; // Переменная не будет доступна, ошибка компиляции. Но если ее прокинуть через use - мы получим тоже что и в стрелочной версии
                                                                                                          }
                                                                                                          
                                                                                                          echo $fn();
                                                                                                          
                                                                                                          


                                                                                                          Это не говоря о том что стрелочные функции не могут содержать в себе более одной инструкции.

                                                                                                          У меня опыта значительно меньше, но, как мне кажется, разница значительная.
                                                                                                            +8
                                                                                                            Так и в чем же значительная разница? Стрелочные функции это синтаксический сахар для очень простых (с одним expression) анонимок где не нужно писать `use`. Да это новый синтаксис, да его надо один раз выучить. Говрить о сложностях понимания думаю неправильно. Через годик, когда фреймворки подтянутся и когда каждый программист встретит парочку раз такой синтаксис, он не будет уже казаться новым и страшным.

                                                                                                            Привыкаем, прогрессируем и все будет хорошо не хуже.
                                                                                                            $foo = 'foo';
                                                                                                            $f = function() {
                                                                                                               $fn = fn() => $foo; // Тоже ошибка компиляции
                                                                                                               echo $fn();
                                                                                                            }
                                                                                                            $f(); 
                                                                                                            
                                                                                                              +5
                                                                                                              > У меня опыта значительно меньше

                                                                                                              Отдельно хочу уточнить по поводу упоминания мною моего опыта.
                                                                                                              Я совсем не хотел тем самым показать мою крутость или авторитетность моего мнения.
                                                                                                              Я лишь хотел сделать акцент что несмотря на одинаковый карьерный возраст, мнения у нас могут категорически не совпадатью. И это прекрасно.

                                                                                                              Возможно я мог бы выразится лучше, но уже поздно.
                                                                                                                +1
                                                                                                                С этим я согласен и поддерживаю. Я хотел акцентировать внимание на то, что я могу быть несколько слаб в тех, или иных моментах. Всё же практический опыт имеет значение.

                                                                                                                С вашего позволения отвечу тут и на соседний комментарий.

                                                                                                                Разница в том, что в обычных анонимках мы контролируем процесс передачи контекста в область видимости используя `use`, а в случае стрелки нас этого контроля лишили, прокинув в тело стрелки вообще всё. В каких-то моментах это может быть проблемой. И, повторюсь, одна инструкция на стрелку.
                                                                                                                  +4
                                                                                                                  Ну надо уточнить что не «все» а лишь родительский контекст. В моем предыдущем комментарии я как раз показал. То что одна инструкция на функцию это ограничивает юз кейсы для данной функции, толька на те где обычная анонимка слишком громозко выглядит. Например
                                                                                                                  $positiveNumbers = array_filter($numbers, fn($num) => $num > 0);
                                                                                                                  $objects = array_map($items, fn($item => new Foo($num));
                                                                                                                  

                                                                                                                  Пока реальных примеров использования не так много в php, в отличии от других языков. Например я часто использую это в JS, и нахожу это очень удобным и неплохо читабильным. Хотя понимаю, что кто-то другой скажет что читабильность ухудшается.
                                                                                                              +3

                                                                                                              Имхо, матч — по сути же и есть хитрый Key-Value?


                                                                                                              Просто вместо


                                                                                                              $x = 1;
                                                                                                              
                                                                                                              return array(1=> 'one', 2=> 'two')[$x]

                                                                                                              пишем


                                                                                                              return match($x) {
                                                                                                               1 => 'one', 
                                                                                                               2 => 'two'
                                                                                                              }

                                                                                                              если он там работает так же, как в расте?

                                                                                                                +2

                                                                                                                Не совсем. В match могут быть инструкции и слева и справа, а не только значения


                                                                                                                match($action) {
                                                                                                                  1 => $this->save(),
                                                                                                                  2 => $this->delete(),
                                                                                                                }

                                                                                                                match(true) {
                                                                                                                  $this->canSave() => $this->save(),
                                                                                                                  $this->canDelete() => $this->delete(),
                                                                                                                }
                                                                                                                  0
                                                                                                                  Если использовать функции в качестве аргументов, то в случае с массивом все значения будут вычисляться
                                                                                                                    0

                                                                                                                    Значения будут вычисляться, когда вы функцию вызовет.

                                                                                                                      0
                                                                                                                      В случае с массивом, всего его значения будут всегда вычисляться во время создания массива, в отличии от match, где будет вызываться та функция, которая соответствует условию match
                                                                                                                        0

                                                                                                                        Не понимаю.


                                                                                                                        $actions = [
                                                                                                                         1 => function () {$this->save();}, // [$this, 'save()'] вариант
                                                                                                                         2 => function () {$this->delete();},
                                                                                                                        ];
                                                                                                                        $actions[$action]()
                                                                                                                        Только один раз вызовется
                                                                                                                          +1
                                                                                                                          А если не каждый элемент функция? Или $action = 3? Больше писанины. Match лаконичнее, без всяких дополнительных переменных
                                                                                                                  0
                                                                                                                  3. Match
                                                                                                                  Да, код написанные новым синтаксисом можно уже сделать через switch.

                                                                                                                  Кстати, нельзя. Если говорить о строгой проверке. Есть две вещи, которые заставляли меня ненавидеть swith:
                                                                                                                  неявное приведение вида
                                                                                                                  swich(false) {
                                                                                                                      case null: echo 'null';
                                                                                                                  }
                                                                                                                  

                                                                                                                  и обязательный break, который меня просто бесит. Согласитесь, намного чаще приходится писать варианты, которые должны выполняться по принципу или\или, чем варианты, которые должны выполняться подряд после первого удачного. Я не говорю, что второй вариант не бывает нужен, но мне куда более мила конструкция fallthrough из Go.

                                                                                                                  И если вторая проблема решается большим бойлерплэйтом, то первая решается только заменой на if elseif elsif elsif…

                                                                                                                    0

                                                                                                                    Обычно матчи ещё выделяются exhaustive matching'ом, что их сильно отличает от свитчей. Как в пхп сделали, правда, не в курсе

                                                                                                                      0
                                                                                                                      В РНР принципиально невозможно такое сделать. Потому что классы (enum нет, для чего еще exhaustive матчить кроме как их иерархии не знаю) могут подгружаться динамически. Пока не обратишься к классу, его в пространстве нет.
                                                                                                                  +1
                                                                                                                  Я был рад, что он далек от JS, где принцип читаемости кода был отринут в пользу «пиши меньше символов, всё равно этот код читать никто не будет».

                                                                                                                  Ну, в JS это не просто писать меньше символов, это писать очень сильно меньше символов. Потому что из-за повсеместной асинхронности в JS приходится писать очень много функций-колбэков. И я бы сказал, что читаемость там даже повышается (только если раньше видел такой синтаксис). Плюс привязка контекста стрелочных функций иная, что опять же может упростить код для колбэков. В PHP это гораздо менее актуально, но что за современный язык без стрелочных функций?

                                                                                                                  Я согласен с автором, что синтаксис большинства сахарков PHP 8 выбран странный и неочевидный. А сами сахарки в большинстве случаев не то что бы сильно облегчали написание кода и могут вызывать путаницу при чтении.
                                                                                                                    +9
                                                                                                                    array_fill(value: 50, num: 100, start_index: 0);
                                                                                                                    Где «доллар»? Нет.

                                                                                                                    Вообще-то это как-раз логичный компромисс, ибо предполагает отсутствие двойственности при интерполяции того «доллара», чтобы не путать значение переменной с именем аргумента, иначе оно будет смущать еще больше, например что имеем тут:


                                                                                                                    $name = 'arg';
                                                                                                                    //test(name: $val);
                                                                                                                    test($name: $val);

                                                                                                                    Как это читать? И что здесь передается как имя аргумента, name или arg?
                                                                                                                    Или может быть это вообще выражение а не именованный параметр, например есть или появится какая-то новая конструкция ($name: $val), типа сахара для (!is_null($name) ? $name : $val)?


                                                                                                                    Можно было бы сделать что-то типа test($val as $name), но то такое было бы.


                                                                                                                    Это вообще проблема любого языка в котором изначально некоторые конструкции не предусмотрены, потому не продуманы.
                                                                                                                    Хотя меня при декларации функций и в некоторых других местах в php всегда тот "логичный и последовательный" доллар раздражал, почему оно не может быть так:


                                                                                                                    - function test($name)
                                                                                                                    + function test(name)

                                                                                                                    Почему не уйти уже от perl-подобного синтаксиса и не допустить интерполяцию как в некоторых других языках (например как в tcl): без доллара — литерал (т.е. что угодно, в том числе имя переменной, т.е. синтаксически там где оно ожидается), с долларом — значение переменной.
                                                                                                                    Язык от этого только выиграет по моему.

                                                                                                                      0
                                                                                                                      Это будет другой язык.
                                                                                                                        –3

                                                                                                                        И слава богу…
                                                                                                                        Язык умеющий и то и то (когда расширение синтаксиса и продуманно и оправдано) только выиграет — например придут новые люди, которых эта "perl-овщина" с долларом всюду и везде ранее смущала или вовсе отпугивала.
                                                                                                                        Тут как в жизни (только быстрей), если язык не развивается — он стагнирует (и вымирает).

                                                                                                                        +2

                                                                                                                        Вы ставите под сомнения значок $.
                                                                                                                        Помню было много обсуждений на счет него и пришли к выводу что глазу легче цепляться за него.

                                                                                                                          +5
                                                                                                                          Без доллара будет путаница с типами, с константами (не зря их пишут капслоком). Доллар улучшает читаемость.
                                                                                                                          Но в именованных аргументах он действительно не нужен, ибо там передается не значение переменной.
                                                                                                                          +7
                                                                                                                          Похоже на нытье олдфага. Пункт про именованные аргументы вообще дичь, причем там $ вообще. Это не переменные, а имена аргументов.

                                                                                                                          Касательно других пунктов, это все есть в других языках, а не только в JS. Все это есть например в C#. Индустрия развивается, применяются новые «лучшие практики». PHP это уже давно не язык новичков.
                                                                                                                            +1
                                                                                                                            целых три способа записи одного и того же
                                                                                                                            На самом деле два же. Вот эти:
                                                                                                                            if ($y == 0)
                                                                                                                              return 0;
                                                                                                                            
                                                                                                                            if ($y == 0) {
                                                                                                                              return 0;
                                                                                                                            }
                                                                                                                            это одно и то же. Почитайте об управляющих структурах.
                                                                                                                            P.S.: сколькими способами можно обойти массив в PHP?
                                                                                                                            +12
                                                                                                                            Я, наверное, сейчас напишу крайне непопулярное мнение в стиле «сперва добейся», но не могу удержаться.

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

                                                                                                                            И все же, все же в каждом таком посте я постоянно читаю комментарии про исход в другие языки и про то, что вендекапец PHP уже не торт.

                                                                                                                            Хочу добавить, что совсем недавно писал инструмент для командной строки и так вышло, что он мне нужен был на всех версиях PHP от 5.3 до 7.4. Мне, не без труда конечно, но все удалось его написать. Так что не так страшен этот синтаксический сахар. Особенно на фоне невероятного ускорения движка и невероятного прироста стабильности. 10 лет назад я и мечтать не мог, что смогу писать долгоживущие приложения на PHP с аптаймом более 4 месяцев.
                                                                                                                              0
                                                                                                                              Просто проекты становятся всё сложнее, новые запросы (времени и Заказчиков). Языки усложняются. С++ 2a тоже становится всё сложнее. Но что делать? Отменять corutunes? Это не надо драматизировать, просто вопрос привычки.
                                                                                                                                0
                                                                                                                                Так дело-то не в этом.
                                                                                                                                Я пишу о том, что всё, что добавляется в последнее время — это не новые возможности, это новые способы сделать тоже самое. К трем альтернативам добавляется еще десять. Зачем?
                                                                                                                                  +3

                                                                                                                                  Ну давайте с конкретики. Вот есть паттерн матчинг, сделанный так же, как и в любом другом языке (Java/Kotlin/C#/Rust/Haskell/Scala/...). Вы правда не понимаете, зачем он нужен?

                                                                                                                                    –2
                                                                                                                                    Я где-то сказал, что не понимаю «зачем»? Не приписывайте мне свои домыслы, пожалуйста.

                                                                                                                                    «Зачем» — понятно. Непонятно — зачем столько криво и неконсистентно!
                                                                                                                                      +6

                                                                                                                                      Что конкретно кривого. => вместо двоеточия? Ещё раз: так сделано везде, в сишарпе switch statement пишется как в сишке, через двоеточие, а switch expression (он же матч) — через стрелочки.


                                                                                                                                      Так что вопрос — что кривого и какой вариант "не кривой". И я не додумываю, вы буквально пишете "слишком много способов сделать одно и то же". Ну да, ведь 2+2, 2*2 и 2^2 — тоже слишком много способов получить четвёрку.

                                                                                                                                0
                                                                                                                                Мне не хочется увидеть через год на месте PHP новый Perl. А вам?

                                                                                                                                Конечно же это плохо, когда из языка делают слонозебродинохрень.


                                                                                                                                Но я абсолютно не соглашусь с вашим намёком на то, что Perl — это плохо.


                                                                                                                                Как перл программист (раньше я работал на РНР) скажу следующее:
                                                                                                                                Перл намного удобнее и лаконичнее РНР

                                                                                                                                  +2
                                                                                                                                  Надеюсь в Шторме уже есть или скоро будет аналогично Андроид студии.
                                                                                                                                  Эту часть можно преобразовать в лямбду в один клик или обратно по вкусу.
                                                                                                                                    –8
                                                                                                                                    Автор ВЫ гений!!!!!!!..
                                                                                                                                    Суть PHP в том что у него был низкий вход. Типа: хочешь начать писать проги, начни с PHP.
                                                                                                                                    но теперь PHP будет иметь высокий уровень. А значит конец эпохи сайтов на PHP.
                                                                                                                                    При всех равных, и уровнях входа, будут изучать только JS. Будут софт писать на нем.
                                                                                                                                      +9
                                                                                                                                      Ооо, похороны PHP. Опять.
                                                                                                                                        +1
                                                                                                                                        Это не похороны, а обсуждение нового сахара в языке
                                                                                                                                          +7
                                                                                                                                          А значит конец эпохи сайтов на PHP.

                                                                                                                                          А звучит как похороны.

                                                                                                                                      +3

                                                                                                                                      Частично согласен. К примеру чужой джаваскрипт довольно сложно читать. С пхп легко… было

                                                                                                                                        –4
                                                                                                                                        Постоянно бесит что тег <?= ?> вызывает ошибку.
                                                                                                                                        Нельзя писать пустые теги <?= ?> так же как с комментариями <?= //$name?>.
                                                                                                                                        ведь одна из задач php быть языком для шаблонов. Т.е. в разметке HTML по вставлять значения. Но тег <?= //$name?> вызывает ошибку. Для отладки приходится использовать <?php //echo $name?> Смысл тега <?= //$name?> теряется.
                                                                                                                                        Я пытался создать дискусию в форуме PHP, но там сложности. Вначале это нужно обсудить, потом нужно еще что то сделать. Прям целый квест. А для начала нужно было инструкцию где то искать как нужно добавлять запросы на функции. С английским я на ВЫ. С переводчиком провалился на регистрации себя на форуме PHP. Думается что я все таки глуповат. но вроде много языков знаю PHP,C#,JS,WPF
                                                                                                                                          +1
                                                                                                                                          Постоянно бесит что тег <?= ?> вызывает ошибку.
                                                                                                                                          Нельзя писать пустые теги <?= ?> так же как с комментариями <?= //$name?>.

                                                                                                                                          Что мешает писать <?= ''//comment?>?
                                                                                                                                            +1
                                                                                                                                            А ответ-то был совсем рядом:
                                                                                                                                            <?php//= $name?>

                                                                                                                                            Или если включена поддержка коротких тэгов, то:
                                                                                                                                            <?//= $name?>

                                                                                                                                            Но в целом — зачем вообще так комментить в шаблонах, раз уж язык используете как шаблонизатор? Какой практический смысл? Есть же дебаггеры.
                                                                                                                                            но вроде много языков знаю PHP,C#,JS,WPF

                                                                                                                                            А что Вы в это вкладываете?
                                                                                                                                              +1
                                                                                                                                              <?= ''; //$name ?>

                                                                                                                                              А на практике необходимость скрывать переменную подобным образом в шаблонах возникает очень редко.