Весь PHP в двух строчках

Original author: Richard Wossal
  • Translation
Я с гордостью хочу представить вам способ описать весь опыт программирования на PHP двумя строчками.

Двумя объявлениями функций из стандартной библиотеки PHP:

array_filter($input, $callback);
array_map($callback, $input);

Угумс.

Similar posts

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

More
Ads

Comments 322

    +71
    Let the holy war begin!
      +3
      And the winner is: l3x with this comment.
      +41
      image
        +7
        Не удивили
          +104
          Урок русского языка в грузинской школе. Учительница:
          — Дэти, это нэльзя понять, это надо запомнить: ОТ ВАС пишется раздельно, а КВАС — вместе.
            –31
            Дети это нельзя понять, єто надо запомнить
            слова вилька и тарелька пишутся с мягким знаком, а сол и фасол — без.
              +46
              вообще-то наоборот :)
                –76
                *рукалицо* Читай выше «Урок в грузинской школе»… А это прикол :D Автор — кул))
                  +14
                  Ты что, дурак что ли?
                    –1
                    Спасибо что очень сильно насрали в карму:)
                      –1
                      Вариация: «Сол, фасол и вермишел пишется с мягким знаком, а вилька, тарелька пишется бэз мягкого знака». Так будет немного яснее.
                      –27
                      Кэп, перелогиньтесь
                    +9
                    — Дэти, самый нэпонятный русский слово эсть «груст»! Это нэ тот груст, который грыб, а тот который тоска. И нэ тот тоска, который шашлик рэжищ, а тот, когда пичално-пичално.
                      +7
                      — Ос — это такой полосатый мух, а еще вокруг него вертится Зэмля
                        +2
                        тогда уж прикол более чем 10-летней давности:

                        — ос — это такой палка, на котором колэсо крутится
                        — не, ос — это такой большой полосатый мух!
                        — не, ос — это такой операционный систэма, да и то не систэма а так, половынка!

                        не все читатели поймут, да ;)
                          –1
                          Да, не поймут, полуось отличная система была для своего времени :)
                        0
                        нэ тот тоска, что строит, а тот, что пэщаль. Но нэ тот пэщаль, что ружье. Ну и так далее.
                        +10
                          0
                          Нажал на Play раз 5 прежде чем понять… :D
                            –1
                            Уарабей! :)
                          +15
                          habrahabr.ru/post/142140/ — здесь уже много сказано. В том числе и это. Автор (как и переводчик), очевидно, не в курсе того, что там изложено, и сейчас ему явилось откровение. И этот момент показывают, что они лишь поверхностно владеют проблемой.
                            +1
                            Не знаю за автора, но переводчик изложенное по ссылке пог бы рассказать и пять лет тому назад. Тэги я не зря расставил ;)

                            Считайте этот перевод tl;dr для приведенной ссылки.
                              0
                              А почему тогда не сказали своими словами?
                                +1
                                Сказал что?

                                То, что по ссылке, я говорил на разных форумах и в разных комментариях
                                То, что перевел, я перевел, потому что понравился такой вот tl;dr
                                  +3
                                  Нет, ну а в чем смысл?
                                  Ну да, есть в PHP несостыковки. Они серьезно так сильно лично вам жить мешают, раз аж на многих форумах пишете?
                                    +1
                                    Когда возникает вопрос о недостатках РНР, тогда я и пишу. Не надо приписывать мне действия и задчаи, которые я не делаю и не ставлю
                                      +2
                                      а, то есть это сейчас возник вопрос о недостатках PHP и вы решили ответить в виде очень содержательного топика на хабре?
                                        +1
                                        Хабрахабр не форум ;)
                                      0
                                      Кстати, хочу вот заметить, что пока читал статью понял что за дискомфорт я постоянно ощющал. Все вот эти безсистемно названные функции, аргументы, давно бесило. Даже был удивлен появлению новых фич которые мне были нужны, в новых версиях пхп.
                                        +1
                                        ощющал


                                        Дискомфорт, да.
                                      –1
                                      Т.е. получается, что Вы стараетесь для людей, которые не смогли осилить важную статью для языка, на котором они пишут? Вы уверены, что Вам именно это нужно?
                                        0
                                        Ну, второй тэг под переводом намекает ;)
                                  +2
                                  Благодаря такой простой заметке, до большего числа людей донесутся светлые мысли статьи по ссылке. Всем только польза от этого.
                                    +3
                                    Благодаря такой простой заметке люди, которые не смогли осилить важную статью, пересядут на другой язык где, в свою очередь, так же не будут читать статьи.
                                    +1
                                    Чуть ли не 10 лет назад читал статью про Perl vs PHP, там это тоже было, да.
                                      0
                                      уж не на дклабе ли?
                                      0
                                      Что ж все в этой статье такое нашли.
                                      Там треть притянуто за уши, треть спорно, и только треть — ценная информация.
                                      –9
                                      Вы уже заебали.
                                        +13
                                        «Не выражайся, Билли!» (©)
                                        +8
                                        И что дальше?
                                          –3
                                          В чём прикол?
                                            +36
                                            Традиционная для PHP несогласованность функций стандартной библиотеки. Прикол, мягко говоря, баянистый.
                                              +2
                                              Разный порядок аргументов у двух функций, которые выполняют очень похожие действия.
                                              Как следствие, они не взаимозаменяемы и callback на эти функции нельзя передавать как аргумент для другой функции. Хотя такая возможность должна быть.
                                                +2
                                                Эти функции не взаимозаменяемы по определению или я чего-то не понимаю?
                                                  +1
                                                  Они не взаимозаменяемы, если их вызывать не непосредственно, а через переданный callback.
                                                    –6
                                                    Или лучше раскройте пример, где Вы будете использовать разные array_ функции через указатель?

                                                    Кстати, в php функции не передаются просто так, их в любом случае придётся завернуть в лямбду или передать по имени.
                                                      +6
                                                      1. Не раскрою ;) Потому что это докажет лишь то, что придуманным примером можно доказать все что угодно.

                                                      2. По имени обычно передается. Разница между указателем или именем — не так уж и велика.
                                                        0
                                                        1. Ну уже поделитесь — таки любопытно. Обещаю не использовать как доказательство ни pro, ни contrau )))

                                                        2. Хорошо, с простой функцией — признаю, $callback(...) вполне работает подобно указателю, что с именем, переданным строкой, что с экземпляром Closure. Изящество пропадает при включении в эту модель методов объектов, но они по задумке ФП вроде как и не планировались…
                                                          +2
                                                          Правильно писать: «cointreau».
                                                            0
                                                            Всё зависит от того, на каком языке ;-)
                                                              +2
                                                              Впрочем я в любом случае ошибся с написанием — Вы правы.
                                                        +1
                                                        Обе функции принимают на вход массив и колбэк и возвращают массив. Обе относятся к одному подмножеству функций (работа с массивами абстрагированная от их содержимого). Но по каким-то причинам порядок их аргументов разный. В принципе причины понятны даже в каждом отдельном случае, но непонятно почему им последовали не считая единообразность более веской причиной.
                                                        0
                                                        Это безусловно кривизна, но мотивы оной в документации описаны, array_map принимает несколько массивов, соот-но массив у него вторым параметром потому как может быть ещё и третий, четвертый и т.п., ради этого разработчики php решили испохабить его сигнатуру.
                                                          –1
                                                          ага, ага. Что только не сделаешь, лишь бы самообманом заняться.

                                                          habrahabr.ru/post/148010/?reply_to=4997107#comment_4996999

                                                          «Испохаблена» сигнатура не у array_map, а у array_filter, array_intersect_ukey и т.п.
                                                            0
                                                            И что не так с array_filter? Сигнатура такая-же как у array_reduce, да и по логике оно так как должно быть, в объектном стиле это-бы выглядело $array->filter() / $array->reduce(), если рассматривать функцию как первичный аргумент относительно массивов, как в array_map — то тогда и называться они должны наоборот, function_filter_array, function_reduce_array и т.п., ну или в недостижимом идеале — как в других языках — просто filter, просто map, просто reduce, а префикс array_ однозначно указывает что в первую очередь операция производится над массивом, а уже потом какая, как и чем, это как-бы привычное человеческому восприятию соглашение об именовании, вон например в gtk+ — все функции gtk_window_* принимают первым аргументом структуру GtkWindow, что логично, gtk_widget_* соот-но GtkWidget и т.п.
                                                              0
                                                              > Сигнатура такая-же как у array_reduce, да и по логике оно так как должно быть,

                                                              По какой логике?

                                                              > в объектном стиле

                                                              Причем тут объектный стиль?

                                                              > если рассматривать функцию как первичный аргумент относительно массивов, как в array_map — то тогда и называться они должны наоборот

                                                              Нет, не должны

                                                              > префикс array_ однозначно указывает что в первую очередь операция производится над массивом

                                                              И? Из-за этго в половине функций первый элемнет должен быть массивом, а во второй половине — функцией?

                                                              > это как-бы привычное человеческому восприятию соглашение об именовании

                                                              Еще один. С какого перепугу оно привычно человеческому восприятию?

                                                              > вон например в gtk+ — все функции gtk_window_* принимают первым аргументом структуру GtkWindow, что логично

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

                                                              Чтобы не повторяться: habrahabr.ru/post/148010/?reply_to=4999631#comment_4994223
                                                                0
                                                                Если функция называется array_filter — то первым аргументом она должна принимать массив, это ожидаемое от неё поведение, было-бы как минимум нелогично если-бы preg_replace принимал первым аргументом строку замены, а не шаблон регулярного выражения, str_split количество символов для разбивки строки, а не саму строку и т.п., так как у них в названии это написано:
                                                                массив_фильтровать($массив, $чем_фильтровать);
                                                                строку_разбить($строка, $на_сколько_символов_разбить);
                                                                

                                                                И тон смените, я вам спокойно излагаю свою позицию, а вместо аргументированного ответа получаю какое-то брызганье слюной.
                                                                  0
                                                                  > Если функция называется array_filter — то первым аргументом она должна принимать массив

                                                                  Нет, не должна

                                                                  > это ожидаемое от неё поведение

                                                                  «Ожидаемое» поведение описывается документацией и principle of least surprise. В частности: если все функции, принимающие на вход массив(ы) и callback должны иметь callback в одно и том же месте.

                                                                  > было-бы как минимум нелогично

                                                                  Аналогии идут лесом.

                                                                  > И тон смените, я вам спокойно излагаю свою позицию, а вместо аргументированного ответа получаю какое-то брызганье слюной.

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

                                                                  Потому что аргументация «ах, оно ведь так читается» — это, извините, звиздец.

                                                                  Можно начать с того, что префикс array_ указывает не на то, как читать функцию, а на то, что в PHP не было неймспейсов, а функции надо было как-то разделять. Аналогично с string_*, mysql_*, preg_* и так далее.

                                                                  Но надо же обязательно найти самый убогий аргумент «оно так читается!!» и попытаться притянуть его сюда за уши.
                                                                    0
                                                                    Ну вот с точки зрения principle of least surprise чертова куча библиотек под си работает именно с таким соглашением, а это gtk+, mysql, gd и т.д., и если уж говорить о php — то в нём тоже большинство функций работы с массивами принимает первым аргументом массив, большинство функций работы со строками — строку, с регулярками — регулярярное выражение, это и есть то самое ожидаемое для программиста поведение.

                                                                    «все функции, принимающие на вход массив(ы) и callback должны иметь callback в одном и том же месте» — а что, в этом топике есть хоть один человек который с этим спорит? Должны, и это место — место второго аргумента по вышеобозначенному вами-же принципу, так как в php первый занят массивом в большинстве функций array_*.

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

                                                                      Тогда *все* функции должны быть такими, а не «треть так, треть этак, а треть еще и врастопырку»

                                                                      > callback должны иметь callback в одном и том же месте» — а что, в этом топике есть хоть один человек который с этим спорит?

                                                                      А вы почитайте комменты. «ой, это же логично, что в одной функции аргументы так, а в другой — этак, потому что оно читается так».

                                                                      > И за весь наш разговор ни одного аргумента в поддержку вашей позиции

                                                                      Вообще-то моя позиция ровно одна: порядок в аргументах. Пусть callback будет последним, мне от этого ни холодно ни жарко. Мне холодно и жарко, когда люди с жаром начинают рассказывать про логичность в беспорядке и аргументируют это бредом типа «ну ведь вот так вот читается»
                                                                        0
                                                                        Позиция ясна. Но не ясно, а какой из порядков будет самый порядистый. Желание упорядочить есть у всех, но не факт, что логика разных людей будет одинаковой
                                                                          0
                                                                          В принципе, достаточно выбрать один и придерживаться его.

                                                                          Но, учитывая, что filter/map и т.п. растут из ФП, то там порядок известен давно: fun(Predicate, List)
                                                                            0
                                                                            Какой бы не было выбрано, все равно найдется кто-то, кто скажет, что это не логично. Но, согласен, переделывать надо, что они и делают, заменяя функции на объекты
                                                                              0
                                                                              > все равно найдется кто-то, кто скажет, что это не логично.

                                                                              Если увидеть перевод, который я сделал, то можно четко увидеть, что именно я считаю нелогичным ;)
                                                      +16
                                                      Можно ещё упомянуть, что когда php был маленький, то для работы с массивами сначала были безпрефиксные функции типа sort(), usort(), count()… По мере развития php они придумали префиксы array_, однако они не стали ломать обратную совместимость.
                                                      Что вы хотели сказать постом, что PHP развивается? Да в PHP много несостыковок, вызванных очень бурным развитием от простого скрипта для сборки шапки-футера маленького сайта, до мощного ООП языка.
                                                      Хотя согласен, данный пример функция явно символизирует нескоординированность разработчиков, учитывая что обе эти функции появилмсь в php 4.0.6
                                                        0
                                                        вот только теперь уже поздно что-то менять в данном виде. либо еще плодить новые имена, либо устроить «веселье» разработчикам )
                                                          +10
                                                          Менят не поздно, только есть полно проблем:
                                                          — это скучно и рутинно и никому неинтересно © история с Юникодом
                                                          — это займет много лет, потому что легаси такой легаси

                                                          Хотя постепенный вывод функций в соответсвующие неймспейсы/классы и превращение старых функций в алиасы с пометкой «deprecated» ничто не мешает сделать
                                                            +9
                                                            Собственно, сейчас на php.internals идут жаркие споры среди разработчиков по поводу того, что делать с этим всем наследием. Кому интересно, могут почитать, например, 6.0 And Moving Forward или Pseudo-objects (methods on arrays, strings, etc.).
                                                              +1
                                                              В Ruby on Rails целыми днями меняют имена и всякие штуки.
                                                              Никто от этого не страдает, ну те кто отключил варнинги страдают, наверное…
                                                              За год после изменений предупреждается разработчик, что та или иная магия будет запрещене, используйте вот это заклинание вместо этого.
                                                              Т.о. доступна и та и другая магия в переходной версии.
                                                                +6
                                                                Т.е., грубо говоря, раз в год нужно переписывать все спорные моменты в коде?
                                                                  0
                                                                  За 8 лет работы переписал одну или две функции. В остальном использовал другие методы, уже новые.
                                                                    0
                                                                    Выходит, что просто не использовали тот функционал/синтаксис, который менялся между версиями?
                                                                    Иначе как-то не сходится такое постоянство кода с постоянными изменениями в руби.
                                                                      0
                                                                      Может просто время жизни функций или приложения в целом меньше периода изменений.
                                                                        0
                                                                        Ну тут меня больше интересует, как пишут достаточно большие проекты на ruby с длительной поддержкой и развитием (измеряемые годами). В них многие части могут не меняться месяцами.
                                                                          0
                                                                          1. версия руби и версия рельс четко прописана в проекте. Т.о. без вашего ведом код не может вдруг начать подругому работать
                                                                          2. ветка 2.3.6 — 2.3.11 прошло более 3-х лет
                                                                          3.0.х — 3.1.х — параллельная ветка, все что задекларировано 2.3 как неработающее в 3х неработает
                                                                          Переезд работающего проекта с 2.3 на 3х занимает менее недели в хучшем случае. Конечно если у вас в проекте километры спагети и быдлокод — переезд затрудняется. Список депрецированных функций можно получить из лога, и если избавится от всех варнингов деприкации переезд с ветки 2.3 на 3.0 проходит в считанные минуты
                                                                          3. мой проект, которому больше года, спокойно перелез с 3.0.непомню, на 3.1.1 за 10 минут, с одним багом, по моей вине.
                                                                          4. смена версии руби вообще может не повлиять на поведение системы
                                                                          5. Тесты наше все — не прошел тест — поправили
                                                                  +10
                                                                  Теперь я понимаю ту боль, с которой рубисты пишут про смену версий
                                                                    +2
                                                                    Дайте ссылочку, очень хочется почитать.
                                                                      0
                                                                      Если б я эти ссылочки откладывал, я бы уже предыдущий комментарий оформил ссылочками. Да тут всё на хабре — так же как в этой теме — в комментариях.
                                                                        0
                                                                        Испытал я боль только при первой смене, больше меня эта трудность не беспокоит, ибо опыт.
                                                                          0
                                                                          Как ни старался, я не нашел воплей боли из-за смены версии Ruby на хабре, только радость от нового релиза. Истерички не в счет — истерички вообще боятся изменений.
                                                                            0
                                                                            Ок, попадутся — обязательно пришлю ссылку ))
                                                                      +1
                                                                      В Ruby on Rails исторически сложилось, что у разработчика приложения и/или у администратора приложения больше «контроля» над средой выполнения. Грубо говоря, никто не заменит версию интерпретатора без их ведома. В PHP же это сплошь и рядом: решил хостер обновиться — хорошо если предупредил о факте обновления.
                                                                        –1
                                                                        А можно поподробнее для общего образования. Используется что-то вида /path/to/ruby180 или по другому как-то?
                                                                          +1
                                                                            0
                                                                            Т.е. более удобная и специализированная замена virtualenv?
                                                                              0
                                                                              Точнее даже, просто как некий эквивалент для руби.
                                                                                +1
                                                                                Что-то в этом духе. RVM помимо всего прочего умеет самостоятельно собирать разные версии Ruby, даже те, которые изначально не присутствуют в самой системе. Virtualenv такого не умеет.
                                                                                  0
                                                                                  Ясно, спасибо.
                                                                    +8
                                                                    Это делается просто:
                                                                    WARNING: function array_map($callback, $input); will be depricated in version 5.x. Use array_collect($input, $callback) instead.
                                                                    главное желание
                                                                      +1
                                                                      Можно сделать класс Array, в котором статические функции, среди которых Array::map($input, $callback) и Array::filter($input, $callback) и т.п.
                                                                        0
                                                                        Только обозвать его по другому. Ключевые слова в php не чувствительны к регистру.
                                                                          +1
                                                                          А ещё лучше — неймспейс:
                                                                          array\map, array\filter

                                                                          Давно пора как минимум аллиасы в неймспейсах позаводить.
                                                                            +2
                                                                            Угу, а лучше нынешние объявить алиасами и depricated.
                                                                        +15
                                                                        > вот только теперь уже поздно что-то менять в данном виде. либо еще плодить новые имена, либо устроить «веселье» разработчикам )

                                                                          +2
                                                                          Лучший комментарий в треде
                                                                        +51
                                                                        Прекрасно. Переходим на следующий уровень:

                                                                        mysql_query($query, $connection);
                                                                        pg_query($connection, $query);
                                                                          +2
                                                                          А вот ещё секретный уровень:

                                                                          mixed mysqli_query ( mysqli $link, string $query [, int $resultmode] )
                                                                            0
                                                                            Тут еще другая проблема: не понятно, зачем оставили процедурный стиль для этой функции.
                                                                              +7
                                                                              Для совместимости с разработчиками :-)
                                                                                +3
                                                                                Я полагаю, что разработчики, для которых такая совместимость якобы нужна, про mysqli не слышали и используют mysql-интерфейс.
                                                                                  +1
                                                                                  Всё-таки наверно это было сделано ради простоты конвертации старых проектов, там где много mysql_ вызовов прямо в коде (да, такого ужаса хватает), без всяких абстракций вроде DB.
                                                                                  Но тут ситуация действительно такая: я тоже себе долго планировал перейти на mysqli — вроде и кода менять не много было, всё было вынесено в отдельный класс, но всё руки не доходили, не жало оно мне. А потом оказалось не актуально — перешёл на pg.
                                                                                0
                                                                                Как-то надо было перевести проект с mysql на mysqli. Сделали в 2 этапа — сначала пару регекспов по проекту, заменяя функции на их mysqli аналоги, потом, по ходу разработки, перевели на объекты.
                                                                                Почему на проекте не было PDO-подобной абстракции — это другой вопрос :)
                                                                                  +1
                                                                                  Я почему-то всегда думал, что должен быть отдельный класс для работы с базой, а не прямые вызовы mysql*_*. Дурак я, да? Люди вот регекспят код, это видимо удобнее.
                                                                                    0
                                                                                    Кому должен? Для чего?
                                                                                      0
                                                                                      Сейчас можно мелкие проекты пилить сначала на sqlite, а потом переносить на mysql в случае необходимости.
                                                                                        0
                                                                                        Часто необходимость возникает? Окупаются затраты на DBAL во всех проектах тем, что в некоторых возникает необходимость сменить DBMS?
                                                                                        0
                                                                                        для нормального уровня абстракции, вестимо )

                                                                                        Есть конечно PDO и все такое, но имхо, даже в таком случае лучше единая прослойка, которую потом легко поменять на работу с другим адаптером.
                                                                                    0
                                                                                    Чтобы его можно было использовать.
                                                                                    Я на PHP пишу простые скрипты для штук вроде asterisk или zabbix, мне ООП вообще не нужно, а работа с MySQL — необходима.
                                                                                      0
                                                                                      А в чем проблема использовать объектный синтаксис?
                                                                                      Я не говорю про ООП, использование объектного синтаксиса к ООП не приводит.
                                                                                        0
                                                                                        А какие его преимущества перед процедурным?
                                                                                          0
                                                                                          Не засоряет \.
                                                                                    0
                                                                                    Я когда перешел на этот синтаксис читал, что надо лишь i и будет работать… убил время не понимая почему оно не работает. Оказывается надо было параметры поменять…
                                                                                    +5
                                                                                    Секретный уровень pg_query с разрывом логики:
                                                                                    Вызов этой функции с одним параметром имеет вид pg_query($query);
                                                                                      –1
                                                                                      А какой он ещё мог бы иметь вид?
                                                                                        0
                                                                                        Когда 2 параметра, то pg_query($connection, $query);
                                                                                        0
                                                                                        А в чём разрыв логики?
                                                                                        Эквивалент перегрузки в других языках.
                                                                                        Тут правда в комментариях сойтись не могут, добро это или зло
                                                                                        0
                                                                                        AFAIK mysql устарела и заменена на mysqli лет 5 назад или я что-то путаю?
                                                                                        А в mysqli порядок как в pg
                                                                                      +5
                                                                                      Я понял смысл жизни — он всего в 2 строчках:

                                                                                      Жить
                                                                                      Умереть
                                                                                      
                                                                                        +1
                                                                                        И пусть кто-то попробует поспорить! :)
                                                                                          +14
                                                                                          Мне кажется правильней было бы так написать:
                                                                                          Родиться
                                                                                          Умереть
                                                                                          
                                                                                          +6
                                                                                          42
                                                                                          +69
                                                                                          Могу выразить одной строкой

                                                                                          implode() can, for historical reasons, accept its parameters in either order.
                                                                                            +19
                                                                                            Ваш комментарий куда содержательнее и интереснее, чем капитанский топик в котором он написан.
                                                                                              –2
                                                                                              … For consistency with explode(), however, it may be less confusing to use the documented order of arguments.
                                                                                              –7
                                                                                              Что поделать. Кода на php в виде всяких мелких сайтов и прочего в вебе наверное больше, чем кода на всех остальных языках вместе взятых. Пусть это в основном и мелкие сайты, но когда ищешь нужную информацию, лучше чтобы сайт работал, хоть и криво, чем не работал совсем.
                                                                                                +6
                                                                                                При чем здесь распространенность php на мелких сайтах?
                                                                                                И как она связана с поиском информации?
                                                                                                И что за сайт должен работать, хоть и криво при поиске Вами информации?

                                                                                                Я ничего не понял из вашего комментария.
                                                                                                  0
                                                                                                  Наличие подобных вещей связано с тем, что пхп сначала был языком для домашних страниц. На этих версиях создали множество домашних страниц, форумов, блогов, которые некому патчить если что. Поэтому приходится мирится с сохранением этого помета мамонта в новых версиях php, это лучше, чем ломать эти сайты.
                                                                                                    +1
                                                                                                    а кто заставляет обновлять там php?
                                                                                                      0
                                                                                                      То есть вы вероятно считаете дизайн php дурацким, но абсолютно уверены в том, что его реализация безупречна и без багов?
                                                                                                        0
                                                                                                        А кто спрашивает у владельцев страниц?
                                                                                                          0
                                                                                                          Не совсем понял — на одном сервере не могут работать разные версии php?
                                                                                                    –1
                                                                                                    и аналогичный пример для jQuery:

                                                                                                    $.map( [1,2,3,4], function( ELEMENT, INDEX ) {… } );
                                                                                                    , но
                                                                                                    $(«div»).map( function( INDEX, ELEMENT ) {… } );
                                                                                                      –3
                                                                                                      Это не аналогичный пример.
                                                                                                        +5
                                                                                                        В первом случае — вызывается функция из нэймспейса jquery, принимающая два параметра — коллекцию и коллбек. Во втором случае вызывается метод объекта, уже содержащего коллекцию — дивов, в данном случае.
                                                                                                          +18
                                                                                                          Оба раза вызывается функция map, работающая с коллекцией элементов. С точки зрения предиката, передаваемого в эту функцию, должно быть пофиг, в каком из случаев он используется.

                                                                                                          То есть этот код должны быть эквивалентен:
                                                                                                          $.map($("div"), F);
                                                                                                          $.map([$("#div1"), $("#div2")], F);
                                                                                                          $("div»).map( F );
                                                                                                          
                                                                                                            +4
                                                                                                            Хм. Получил за этот комментарий минус. Неужели кто-то не согласен, и у этого кого-то есть аргументы?
                                                                                                              +9
                                                                                                              Вы просто рушите кому-то стройную картину мира и розовые очки. jQ ему не идеален, вы посмотрите на него!!!
                                                                                                                +6
                                                                                                                Я могу изложить вот какой аргумент: в случае $('div').map( function(index, element){…} ) второй параметр функции необыкновенно часто (да собственно, почти всегда) является необязательным, потому что его и без того можно взять в this.

                                                                                                                То есть на практике в алгоритмах, не учитывающих номер элемента, станет использоваться $('div').map( function(){…} ), в учитывающих — $('div').map( function(index){…} ), а двухпараметрическая функция — почти никогда.

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

                                                                                                                В случае $.map( [1,2,3,4], function(element, index) {…} ) обстоятельства противоположны: номер элемента в некоторых алгоритмах не нужен, а вот сам элемент понадобится непременно, потому что this на сей раз его не содержит, а указывает на глобальный объект (window).

                                                                                                                Изменение практики употребления функции диктует изменение порядка её аргументов.

                                                                                                                Всё логично, как видите.
                                                                                                                  +1
                                                                                                                  Логично, но не до конца.
                                                                                                                  Написать в параметрах i, v — очевидней и короче, чем использовать this. Тем более, что this — всегда приходится использовать с оглядкой — в той ли области видимости мы находимся?
                                                                                                                    +2
                                                                                                                    обычно обнообразность документации ценится выше, чем экономия символов от пропуска параметра функции.

                                                                                                                    кстати, у $.each, к которому применимы ваши аргументы про $.map, порядок не совпадает с $.map. Кроме того, в callbackе, переданном в $.each, this указывет не на window, а на текущий элемент.
                                                                                                                      0
                                                                                                                      Раз уж $.each вызывает callback таким образом, что в нём this указывает не на глобальный объект (window), а на текущий элемент, то к нему применимы те мои тезисы, которые про $('div').map(), а не те мои тезисы, которые про $.map().

                                                                                                                      Для наглядности я повторю здесь эти тезисы: появление текущего элемента в this делает крайне необязательным тот аргумент функции обратного вызова (callback), который содержит текущий элемент (ведь теперь его значение можно преспокойно брать из this). Следовательно, этот аргумент естественно ставить последним среди аргументов функции, потому что именно последний аргумент в джаваскрипте проще всего опустить при описании и при вызове функции.

                                                                                                                      Как видите, к $.each моя логика также применима, и всё вполне логично и в этом случае.
                                                                                                                        +1
                                                                                                                        но дело в том, что то, на что указывает this — это не внешнее обстоятельство, а заданный архитектором способ передачи параметра в функцию.

                                                                                                                        Суть в том, что $.map отличается от остального семейства функций ($.each, $().each, $().map). Отличается оно не только порядком параметров в callbackе, но и значением в this.

                                                                                                                        Кроме того, при некоторой степени педантичности, можно считать, что передача одного и того же значения в функцию двумя способами — это плохо. Речь о том, что this дублирует явные аргументы функции. Хотя, это наверняка сделано для того, чтобы снизить порог вхождения — про this знаю не все.
                                                                                                            +1
                                                                                                            И что? По-моему, тут как раз всё окей.
                                                                                                            • UFO just landed and posted this here
                                                                                                                0
                                                                                                                это точно так? Поскольку $().map(callback(indexInArray, valueOfElement))
                                                                                                                  +1
                                                                                                                  да. из всей четвёрки функций $.each, $().each, $.map и $().map, только $.map принимает callback с обратным порядком аргументов :(
                                                                                                                    +4
                                                                                                                    Вот же «век живи — век учись». Да, от Ресига такого не ожидал. Что лишний раз доказывает, что не стоит обожествлять авторитеты…
                                                                                                                      0
                                                                                                                      Откуда вы взяли что это резиг писал? Там команда человек 20…
                                                                                                                        0
                                                                                                                        Без его ведома? Мне кажется он, как автор библиотеки, немного больше участвует в планировании фич и за ним — решающее слово, как оно будет.
                                                                                                                        Но скорее всего — какое-то legacy, надо будет поинтересоваться историей развития раньше версии 1.3
                                                                                                                  0
                                                                                                                  Я как-то увидел, что можно использовать this в качестве текущего элемента в callback, и с тех пор мне было пофиг на порядок аргументов :))
                                                                                                                    0
                                                                                                                    попробуйте попользоваться $.map :)
                                                                                                                      0
                                                                                                                      Да, но это если в функцию не передан другой контекст.
                                                                                                                  0
                                                                                                                  $callback = function($input_el){ echo `$input_el`; };
                                                                                                                  
                                                                                                                    +15
                                                                                                                    Смотрим в документацию:
                                                                                                                    array_filter — Фильтрует элементы массива с помощью callback-функции
                                                                                                                    array_map — Применяет callback-функцию ко всем элементам указанных массивов
                                                                                                                    т.е. даже в документации порядок разный, как и смысл этих функций.
                                                                                                                    =)
                                                                                                                      +1
                                                                                                                      С точки зрения ФП это не аргумент :)
                                                                                                                        +3
                                                                                                                        с точки зрения любого П не аргумент, мне кажеца :)
                                                                                                                          +13
                                                                                                                          С точки зрения ТП — вполне себе.
                                                                                                                        +14
                                                                                                                        Всё дело в формулировке. Они должны быть последовательными — именно это главное:
                                                                                                                        array_filter — фильтрует элементы массива с помощью callback-функции
                                                                                                                        array_filter — с помощью callback-функции фильтрует элементы массива
                                                                                                                        array_map — применяет callback-функцию ко всем элементам указанных массивов
                                                                                                                        array_map — ко всем элементам указанных массивов применяет callback-функцию
                                                                                                                        +2
                                                                                                                        Тренируем память!
                                                                                                                          +24
                                                                                                                          Тренируем «млять, наоборот!»
                                                                                                                            –3
                                                                                                                            Или используем IDE, имхо проблема высосана из пальца.
                                                                                                                              +2
                                                                                                                              Ох сколько ярых противников IDE )))
                                                                                                                            +3
                                                                                                                            Все, разработчики больше не нужны. Увольняем всех.
                                                                                                                              +8
                                                                                                                              Решение проблемы в две строчки:

                                                                                                                              function filter ($callback, $input) { return array_filter ($input, $callback); }
                                                                                                                              function map ($callback, $input) { return array_map ($callback, $input); }
                                                                                                                              

                                                                                                                                +4
                                                                                                                                Таких «решений» придется плодить на дикое количество функций.
                                                                                                                                  +4
                                                                                                                                  Практика показывает, что «дикое количество» сводится к «паре десятков». Да и их я себе заменил больше из эстетических соображений, чем по практической надобности. PHP далёк от идеала функциональных языков, очень далёк ))
                                                                                                                                    0
                                                                                                                                    Пара десятков — это уже слишком много.
                                                                                                                                      +1
                                                                                                                                      Даже не знаю, каков критерий «много/мало»? По логике «больше нуля» — это уже много. Вопрос в другом — это было неизбежным, это не потребовало много времени, это не приводит к смертельному оверхеду, это до сих пор не вызвало конфликтов. Что ещё требуется от данного решения?

                                                                                                                                      Да, хотелось бы, чтобы оно не понадобилось в принципе. Но оно понадобилось и с этим будем жить дальше.
                                                                                                                                  +1
                                                                                                                                  Да я даже где-то видел специальный класс-фаил подключаемый через include, который имеет обертки такого рода почти ко всем существующим функциям php (и даже ко многим плагинам), но только в едином стандартном формате имен и вызовов.
                                                                                                                                  Писать на таком приятно (после некоторой практики), а вот разбирать чужой код или искать помощь по функциям уже не очень
                                                                                                                                    +1
                                                                                                                                    искать помощь по функциям

                                                                                                                                    В идеале он должен быть документирован phpDoc'ом.
                                                                                                                                    Можно было бы посодействовать его документации.
                                                                                                                                    +7
                                                                                                                                    Сначала вы пишете такое решение. Получается два. Потом вы подключаете какой-нибудь фрэймворк, где тоже есть такое решение. Уже три. Потом подключили дополнительную библиотеку, где тоже есть свое решение. Уже четыре.
                                                                                                                                    В общем, стандартная библиотека языка должна быть настолько мощной и согласованной, чтобы не пришлось ее переделывать.
                                                                                                                                      –4
                                                                                                                                      стандартная библиотека языка должна быть настолько мощной и согласованной, чтобы не пришлось ее переделывать.

                                                                                                                                      Если бы мы жили в идеальном мире — нам хватило бы грубо говоря двух-трёх языков на все случаи жизни. Но основная проблема в том, что PHP ухитрился обогнать конкурентов на рынке и обогнал он их не благодаря качеству. Поэтому имеем то, что имеем.

                                                                                                                                      Проблема конфликта имён — возможно переоценена, я за почти десять лет работы с PHP с подобным конфликтом не сталкивался. Теперь же у нас есть пространства имён, которые призваны решить проблему и вопрос уже не стоит и выеденного яйца.
                                                                                                                                        0
                                                                                                                                        Господа минусующие считают недостойным излагать свои аргументы по теме?
                                                                                                                                      0
                                                                                                                                      namespace спает отца русской демократии. и перегрузите их в своем пространстве а вызывайте как хотите их уже из нативного, если это вас так удручает.
                                                                                                                                        0
                                                                                                                                        А мне IDE подсказывает в каком порядке какие аргументы.
                                                                                                                                          +5
                                                                                                                                          А в Советской России — программисты подсказывают IDE :-)

                                                                                                                                          Вопрос, как выше уже обсудили не в том, чтобы знать порядок, а в том, чтобы порядок не мешал более хитрым динамическим конструкциям. Впрочем, мне переименование понадобилось ради лаконичных имён, позволяющих писать сложные выражения в строчку.
                                                                                                                                        +6
                                                                                                                                        Мало того что это очередной говнопост про то какой PHP не идеальный, так за него еще положительно голосуют… Вы бы лучше что то умное написали про PHP…
                                                                                                                                          0
                                                                                                                                          Т.к. input — всегда массив, а callback — никогда не может быть массивом, могли бы в следующей версии профиксить и добавить проверку, изменить по-человечески в документации и т.д. Печально, что ничего не делается, чтобы не тянуть за собой эти «детские» ошибки.
                                                                                                                                            +2
                                                                                                                                            callback — может быть массивом, если вы используете не функцию, а метод объекта.
                                                                                                                                              +2
                                                                                                                                              Всегда удивляюсь, кто в php придумал передавать метод класса как массив
                                                                                                                                              array(&$this, 'someMethod')
                                                                                                                                                0
                                                                                                                                                Что самое интересное, до сих пор и нет другого способа его передать. Лямбды не признают $this
                                                                                                                                                  0
                                                                                                                                                  5.4.0 Стало возможным использовать $this в анонимных функциях.

                                                                                                                                                  Или про что вы?
                                                                                                                                                    0
                                                                                                                                                    Он про то, что если есть $this->foo(), то нельзя передать в качестве параметра $this->foo
                                                                                                                                                    Аналогичный подход используется в JS
                                                                                                                                                      0
                                                                                                                                                      Да, про это я тоже писал, но про лямбды — таки мои данные оказались устаревшими, анонимные функции теперь замыкаются на экземпляр класса, в котором созданы.
                                                                                                                                                      +1
                                                                                                                                                      Вот же ж блин, таки да — оно. Признаю, был не прав.

                                                                                                                                                      class B {
                                                                                                                                                      
                                                                                                                                                              protected $a = 'test';
                                                                                                                                                              public function b() {
                                                                                                                                                                      $a = function () {
                                                                                                                                                                              return $this->a;
                                                                                                                                                                      };
                                                                                                                                                                      return $a();
                                                                                                                                                              }
                                                                                                                                                      }
                                                                                                                                                      
                                                                                                                                                      $b = new B;
                                                                                                                                                      
                                                                                                                                                      print $b->b()."\n";
                                                                                                                                                      // test
                                                                                                                                                      


                                                                                                                                                      А я его по наивности через use пропихивать пытался, так и пришёл к выводу, что не работает, очень расстроился :-)
                                                                                                                                                  0
                                                                                                                                                  Угу, даже полез в документацию. До этого не знал о подобной «фишке» и, если честно, до сих пор не понимаю почему класс и метод передавать в виде элементов массива, а не class::method()
                                                                                                                                                    0
                                                                                                                                                    Не класс, а объект — экземпляр класса со своими данными.
                                                                                                                                                    Можно спокойно делать array($someObject, $someMethod)
                                                                                                                                                    Почему нельзя делать по-другому? Потому что все другие способы уже заняты:
                                                                                                                                                    $someObject->someMethod — получение значения переменной someMethod
                                                                                                                                                    $someObject->someMethod() — вызов метода someMethod
                                                                                                                                                    $someObject->$someMethod — получение значения переменной, название которой указано в переменной $someMethod
                                                                                                                                                    $someObject->$someMethod() — вызов метода, название которого указано в переменной $someMethod
                                                                                                                                                    Обращения через :: указывают на статические переменные и методы.
                                                                                                                                                      –1
                                                                                                                                                      Что мешает узнать интерпретатору php, что $someObject->someMethod — это метод, а не свойство и вернуть в этом случае лямбда функцию.
                                                                                                                                                        0
                                                                                                                                                        А если нет ни метода, ни свойства, но определены __get && __callback?
                                                                                                                                                          0
                                                                                                                                                          Кинуть исключение логично, ну или как минимум warning и вернуть null. Вы рассуждаете с точки зрения текущего функционала php. Я же говорю о том что можно реализовать.
                                                                                                                                                            0
                                                                                                                                                            Можно реализовать все, что угодно. Книгу дракона в руки — и вперед, реализуйте.
                                                                                                                                                            Я же рассказываю о том, почему все именно так в определенном языке.
                                                                                                                                                              0
                                                                                                                                                              Так в текущем языке по одной простой причине — так проще разработчикам, выкинуть очередной недофункционал с помощью костыля (тот же __get, __set), чем менять синтаксический анализатор и вычищать потом кучу багов.
                                                                                                                                                                +1
                                                                                                                                                                > так проще разработчикам, выкинуть очередной недофункционал с помощью костыля (тот же __get, __set), чем менять синтаксический анализатор и вычищать потом кучу багов.

                                                                                                                                                                вообще-то, разработчики боятся этого анализатора, как огня. Половина обсуждений про новые фичи сводятся к «ой, парсеру будет слишком сложно».
                                                                                                                                                                  0
                                                                                                                                                                  __get, __set, а в особенности __call — офигенные штуки. Вот когда на них пытаются построить property а-ля С#, то кажется, что это костыли и недофункционал.
                                                                                                                                                                    0
                                                                                                                                                                    Во всём можно найти плюсы, согласен с вами магические методы __get и __set также могут найти своё применение. Лучше всего для разработчика когда есть и то и другое, то есть можно задать как традиционный getter/setter так и магический __get/__set для несуществующих свойств.
                                                                                                                                                                      0
                                                                                                                                                                      Тут ещё одна особенность — в php (не знаю с каких пор) нет «несуществующих свойств» в приведённом смысле. Свойства создаются автоматически. То есть

                                                                                                                                                                      $a = new StdClass;
                                                                                                                                                                      $a->b = 123;
                                                                                                                                                                      print $a->b;
                                                                                                                                                                      


                                                                                                                                                                      отработает без запинки.
                                                                                                                                                                        0
                                                                                                                                                                        Причём значительно быстрее, чем при использовании __get и __set.
                                                                                                                                                                          0
                                                                                                                                                                          Ну это понятно, это называется «динамические классы», __get же срабатывает для не инициализированного свойства (isset($a->b)==false). Делать из php строгие неизменяемые классы конечно тоже не надо.
                                                                                                                                                                          Вообще программируя на JavaScript и ActionScript очень часто посещает голову мысль «вот здорово если бы в php было бы также»… Но у каждого языка свои плюсы и свои минусы)
                                                                                                                                                                            0
                                                                                                                                                                            > (isset($a->b)==false)
                                                                                                                                                                            __isset() php.net/manual/en/language.oop5.overloading.php
                                                                                                                                                                              0
                                                                                                                                                                              Да, меня такие мысли тоже часто посещают — к ним ещё добавился опыт программирования на питоне :-)
                                                                                                                                                                              Хочется в действительности совместить лучшие качества всех языков. Но мучает мысль, что лучшие они только до первой попытки создания этой гремучей смеси ))
                                                                                                                                                                            0
                                                                                                                                                                            Иногда мне хочется на __get и __set написать выбрасывание исключения. От опечаток спасает ;)
                                                                                                                                                                              0
                                                                                                                                                                              Пишите. А ещё лучше сделайте trait, если есть возможности.
                                                                                                                                                                                0
                                                                                                                                                                                Я думаю, что можно было бы отладочную версию в первопредке части объектов так и сделать и на продакшене просто убирать или заменять на логи с дампом стека и окружения.

                                                                                                                                                                                По первам, как пример тёмной стороны магии, — поймал грабли такого молчаливого принятия несуществующих методов и свойств, которые поменяли местами логику кода.
                                                                                                                                                                      0
                                                                                                                                                                      Почему вдруг исключение?

                                                                                                                                                                      $b = 'b'
                                                                                                                                                                      $a->$b() — работает,
                                                                                                                                                                      $a->b — выкинет исключение? Это непоследовательно

                                                                                                                                                                      Помимо этого, в php следующий код будет работоспособен

                                                                                                                                                                      class A {
                                                                                                                                                                      
                                                                                                                                                                              public $a = 'property';
                                                                                                                                                                              public function a() {return 'method';}
                                                                                                                                                                      }
                                                                                                                                                                      
                                                                                                                                                                      $a = new A;
                                                                                                                                                                      
                                                                                                                                                                      print $a->a."\n";
                                                                                                                                                                      print $a->a()."\n";
                                                                                                                                                                      


                                                                                                                                                                      И именно это мешает разрулить: ссылка на метод или на функцию.
                                                                                                                                                                  0
                                                                                                                                                                  А что не так со статическими методами? А цепочку он поймет в виде массива $someObject->getSomeProperty()->somePropertyMethod()->… или строго два элемента воспринимает? Пролистал доки и не нашел.
                                                                                                                                                                    0
                                                                                                                                                                    Вроде как строго два.
                                                                                                                                                                      0
                                                                                                                                                                      Строго 2

                                                                                                                                                                      A method of an instantiated object is passed as an array containing an object at index 0 and the method name at index 1.
                                                                                                                                                                      0
                                                                                                                                                                      &$someObject->someMethod() — всё уже придумано до нас :)
                                                                                                                                                                        0
                                                                                                                                                                        Это разве не ссылка на возвращённый результат?
                                                                                                                                                                        Устаревшая с php 5?

                                                                                                                                                                        Или это что-то новое?
                                                                                                                                                                          0
                                                                                                                                                                          Это если определить метод как function &someMethod() { return $some_var; }. Но вообще да, без заглядывания в сигнатуру сложно будет отличить.
                                                                                                                                                                      +1
                                                                                                                                                                      В языке есть возможность вызывать функции и классы по именам, но нет возможности передать ссылку на функцию или на класс. Даже лямбды — это по сути костыль в виде объекта с магическим методом.
                                                                                                                                                                        0
                                                                                                                                                                        Это точно, php много костылей, те же __set и __get. Благо в php 5.5 вроде собираются это решать…
                                                                                                                                                                          0
                                                                                                                                                                          __set, __get, __call — это не совсем костыли, это магия :-)
                                                                                                                                                                          То есть с их помощью можно реализовать куда больше, чем тривиальные геттеры и сеттеры. У меня например с их помощью реализуются миксины в рантайме, чего язык, даже в версии 5.5 до сих пор не предусматривает (trait'ы нельзя скомпоновать динамически).
                                                                                                                                                                          Хотя последнее время магию сильно критикуют и есть за что, но в умелых руках и гомеопатических дозах — она бесценна.
                                                                                                                                                                  +3
                                                                                                                                                                  Интересно, что пока я в холиварных топиках не вычитал, что в PHP проблема с порядком параметров, я никогда не обращал на это внимание.
                                                                                                                                                                    +2
                                                                                                                                                                    Это же классика.
                                                                                                                                                                    int strpos ( string $haystack, mixed $needle [, int $offset = 0 ] )
                                                                                                                                                                    mixed array_search ( mixed $needle, array $haystack [, bool $strict = false ] )
                                                                                                                                                                    +12
                                                                                                                                                                    На php.net давно надо повесить комерческие баннеры на страницах функций со спорным порядком аргументов.
                                                                                                                                                                      +1
                                                                                                                                                                      Несмотря на то, что в php действительно бардак, именно в данном случае как раз все совершенно логично.

                                                                                                                                                                      1)array_filter фильтрует один массив опциональным коллбэком. Можно делать просто array_filter($array), что отфильтрует пустые значения.

                                                                                                                                                                      Иначе говоря, в другом языке это бы выглядело как $Array.filter() или $Array.filter(function()… {}).

                                                                                                                                                                      2)array_map принимает сколько угодно массовов, потому коллбэк первый.

                                                                                                                                                                      Иначе говоря, в другом языке это бы выглядело как $Function.map($Array1, $Array2… );
                                                                                                                                                                        0
                                                                                                                                                                        Нет ничего логичного. Это стандартные функции из «Функциональное программирование для самых маленьких». Все подобные операции над списками должны выглядеть или как fun(Predicate, List) или fun(List, Predicate).

                                                                                                                                                                        Если Predicate опционален, могу подсказать способ сделать его опциональным.
                                                                                                                                                                          +2
                                                                                                                                                                          Давайте прочитаем эти две функции человеческим языком

                                                                                                                                                                          array_filter($input, $callback); — хочу отфильтровать массив при помощи собственной функции
                                                                                                                                                                          array_map($callback, $input); — хочу применить функцию на каждый элемент массива

                                                                                                                                                                          Теперь логика есть?
                                                                                                                                                                            0
                                                                                                                                                                            И молвила ему рыбка человеческим голосом, ага.

                                                                                                                                                                            А что, если мы эти функции прочитаем не по-русски, а по-турецки? ВНЕЗАПНО окажется, что порядок параметров будет прямо противоположный.

                                                                                                                                                                            В общем, аргумент понятный, но менее идиотским от этого не становящийся.
                                                                                                                                                                              0
                                                                                                                                                                              Почему именно идиотским? Ну не совпадает способ мышления разработчика языка с вашим представлением о Прекрасном Коде, ну и что? К чему категоричность мышления?
                                                                                                                                                                                0
                                                                                                                                                                                > Почему именно идиотским?

                                                                                                                                                                                Потому что вы пытаетесь аргументировать неверное решение о дизайне языка попыткой прочтения функции на «человеческом языке». При том, вам даже в голову не пришло, что прочтение на русском может отличаться от прочтения на другом языке.

                                                                                                                                                                                > Ну не совпадает способ мышления разработчика языка с вашим представлением о Прекрасном Коде, ну и что?

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

                                                                                                                                                                                  filter $input by $callback
                                                                                                                                                                                  map $callback to $input

                                                                                                                                                                                  В такой формулировке мне нравится расположение параметров гораздо больше, чем

                                                                                                                                                                                  map to each $input element the $callback

                                                                                                                                                                                  Еще раз прошу прощения за корявый Ынглиж
                                                                                                                                                                                    0
                                                                                                                                                                                    И опять же про английский:

                                                                                                                                                                                    use callback to filter input
                                                                                                                                                                                    use callback to map input

                                                                                                                                                                                    having input, filter it using callback
                                                                                                                                                                                    having input, map it using callback

                                                                                                                                                                                    И ни то ни другое не имеет ни малейшего отношения к дизайну языка
                                                                                                                                                                                      0
                                                                                                                                                                                      В любом, даже мало-мальском моменте найдутся противники и последователи. Но это не значит, что только один из них прав. Скорее всего не правы обе стороны или правы оба. Так что не вижу смысла продолжать наш «спор», каждый останется при своем мнении.
                                                                                                                                                                                        0
                                                                                                                                                                                        > В любом, даже мало-мальском моменте найдутся противники и последователи. Но это не значит, что только один из них прав.

                                                                                                                                                                                        Вообще-то, principle of least surprise и азы ФП никто не отменял. Но я понимаю, что если кроме аргументов «а вот так вот хорошо читается» ничего нет, то разговор действительно не стоит продолжать.
                                                                                                                                                                            +1
                                                                                                                                                                            Какая разница? 95% тех, кто пишет на php, не знают, что такое функциональное программирование, и думают, что это то же самое, что процедурное.

                                                                                                                                                                            Если Predicate опционален, могу подсказать способ сделать его опциональным.


                                                                                                                                                                            Подскажите, я расскажу, почему в php так не выйдет.
                                                                                                                                                                              0
                                                                                                                                                                              > Подскажите, я расскажу, почему в php так не выйдет.

                                                                                                                                                                              > 1) array_filter фильтрует один массив опциональным коллбэком. Можно делать просто array_filter($array), что отфильтрует пустые значения.

                                                                                                                                                                              Вы сами сделали его опциональным. Так почему Predicate в качестве первого параметра не подходит для array_filter? И почему это нельзя сделать в PHP? Я внимательно слушаю
                                                                                                                                                                                +1
                                                                                                                                                                                1) Я ничего не делал опциональным, опциональным его сделали разработчики PHP.
                                                                                                                                                                                2) И это очень удобно: 50% применений array_filter — без указания callback.

                                                                                                                                                                                Что в этом случае делать? array_filter(false, $array)? array_filter(null, $array)? Ужасно.

                                                                                                                                                                                Разве что так — сделать Predicate обязательным и добавить что-то вроде array_filter_empty.

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