1. JavaScript / Говнокод #26263

    +1

    1. 1
    https://sun1-28.userapi.com/c854224/v854224060/1a2490/7JEShAFqoEU.jpg

    Сишник половину из этого увидит логичным.
    А JS макаки без должного математического образования не знают даже, как правильно проверять на эквивалентность floating point numbers.

    Запостил: OlegUP, 13 Декабря 2019

    Комментарии (367) RSS

    • >>> [] + []
      []
      >>> [] + {}
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: can only concatenate list (not "dict") to list
      >>> {} + []
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: unsupported operand type(s) for +: 'dict' and 'list'
      >>> 9 + "1"
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: unsupported operand type(s) for +: 'int' and 'str'
      >>> 91 - "1"
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: unsupported operand type(s) for -: 'int' and 'str'

      Я за «сильную типизацию» и против «слабой параши».
      Ответить
      • Хреновый язык - что ни напиши, какую фигню с трейсбеком вывалит.
        Ответить
      • Ну слабая типизация тоже бывает сладкой. Например в Tcl я без проблем могу написать 9+"1" или 91-"1" всё без проблем выполнится как с числами, но при этом с массивами или строки с не-числамы вывалит ошибкой.

        Кстати, инфиксных выражений в самом Tcl нет, их считают через функцию expr, и работают там только числа. Можно переопределить функцию expr и считать ей как угодно и что угодно. Не то что в этой вашей анскильной пайтушне.
        Ответить
    • Зато это позволяет обфусцировать код:
      https://github.com/aemkei/jsfuck

      Бонус для языка с более сильной типизацией:
      https://github.com/wanqizhu/pyfuck
      Ответить
    • Для своих рабочих языков вы стандарты тоже не читаете? Ах да, для с++ издание стандарта платное
      Ответить
      • Приведи реальный пример, когда стандарты к языкам платные.
        Ответить
        • Нахуя нам какие-то стандарты и языки когда есть js?
          Ответить
        • C/C++
          Ответить
          • У меня кстати горит зад от платных стандартов.

            Вот например я хочу разобраться с каким-нить протоколом. Часто, бесплатно я могу скачать только маркетинговый булщит типа "протокол для промышленных задач, в сорок тысяч раз ускоряющий повышение KPI в крупных компаниях"

            А сама спека платная

            За платные спеки надо убивать
            Ответить
          • Ну, строго говоря всегда есть working draft, единственное отличие которого от окончательного стандарта это пометка о том, что это не окончательный стандарт.

            Вообще, не могу понять, зачем нужно лезть в это ISO кроме понтов "Мы — международный стандарт?"
            Ответить
        • Много приведи реальный пример, когда стандарты к языкам платные.
          Малость приведи реальный пример, когда стандарты к языкам платные.
          Зачем приведи реальный пример, когда стандарты к языкам платные?
          Ответить
        • Кстати, забугорные госты вполне бывают платные. Почему?
          Ответить
      • Наличие документации к говну не делает говно конфеткой.
        Ответить
        • Ты не прав. Документация к «PHP» - лучшая документация, что я когда либо видел. (без сарказма)
          Ответить
          • Так я и не документацию ругаю.
            Ответить
          • >Документация к «PHP» - лучшая документация, что я когда либо видел. (без сарказма)

            Признайся, это была единственная документация, что ты когда либо видел.
            Ответить
            • Нет.
              Приведи реальный пример лучшей документации.
              Ответить
              • Сразу скажу, что документация к языку или библиотеки без примеров кода - сразу хуйня.
                Ответить
              • Я за «http://2.python-requests.org/en/master/».
                Ответить
              • Чем, например, это хуже?
                https://docs.python.org/3.8/

                Единственная пользительная штука в документации к «PHP» это мини-версия so в комментах.
                Ответить
                • Открыл первое что попалось на глаза:
                  https://docs.python.org/3.8/library/threading.html

                  Где блядь кусок кода, демонстрирующий как мне посчитать x**2 for x in range(10) параллельно? Он должен быть в начале статьи.
                  Ответить
                • Документация по "python" - это позор для мира документаций. В таком формате можно писать только тьюториалы для какой-нибудь нетривиальной питушни вроде хаскелей, где нельзя начать программировать без нескольких недель последовательного чтения учебников и тьюториалов.

                  Мануал по языку "python" не предназначен для произвольного доступа. И это в то время, когда этот язык рекламируют для быстрого наговнячивания скриптов и SO-программирования. Мануал по языку "python" отвечает требованиям к языку чуть менее, чем никак.

                  - Нет списка классов в одном месте
                  - Нет списка функций в одном месте
                  - Есть только длинная портянка текста, из которой можно выкусить эти списки только юзерскриптом с document.querySelectorAll
                  + Есть примеры, даже несколько

                  В мануале на php.net такого говноподхода нет. Разве что в списке функций есть только имена, а нет сигнатур.

                  + Есть классов в одном месте
                  + Есть список функций в одном месте
                  - В списке функций есть только имена, а нет сигнатур.
                  + Есть примеры, даже несколько

                  С php.net может потягаться только cplusplus.com. Там иерархия модулей/классов раскрывается без перехода на новую страницу. И такая ориентируемость на произвольный доступ для нетривиального языка, где для старта требуется много последовательного чтения.
                  Ответить
              • вот документация
                https://perldoc.perl.org/perlfunc.html#lock-THING

                вот документация
                https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa

                вот документация
                https://man.openbsd.org/pf.4

                вот документация
                https://developer.apple.com/documentation/uikit/uisplitviewcontroller

                а вот говно
                https://www.php.net/manual/en/function.vpopmail-add-domain.php
                Ответить
                • Нечестная выборка. Ты нашёл экспериментальную функцию из PHP4.

                  Тогда для сравнения нужно в остальных примерах тоже показать недокументированные функции. Как минимум у WinAPI недокументированные функции есть.
                  Ответить
                  • Недокументированные функции win32api не документированы, документации по ним нет, и к примеру не относятся
                    Ответить
                  • Вот неэкспериментальная функция, которой уже больше 10 лет
                    https://www.php.net/manual/en/function.register-tick-function.php
                    Какой тик? Какая, блять, функция, с какой сигнатурой? Что за второй параметр с типом mixed? Догадайся сам и напиши об этом в комменты <3
                    Ответить
                    • Документация силами зрителей. Да это же... Википедия!
                      Ответить
                    • Погуглив реальное использование этой функции, мои телепатические таланты подсказали, что второй и последующие параметры передаются в зарегистрированную функцию.

                      Функция с любой сигнатурой (смотри про параметры выше), можно даже использовать члены класса если первым аргументом передать массив [объект, член-класса] (пример на странице документации)

                      Тик — это неведомая ёбаная хуйня, которая происходит когда интерпретатор немного поработает. (ссылка есть на странице документации)


                      Мне приходилось читать много хуёвой документации.
                      Ответить
                • > https://www.php.net/manual/en/function.vpopmail-add-domain.php

                  Специально самую хуёвую страницу нашел, молодец
                  Ответить
                  • найди не хуёвую?
                    Ответить
                    • Да вот по тойже теме «threading». Зашел, сразу увидел пример, скопировал, потёк: https://www.php.net/manual/en/thread.join.php
                      Ответить
                      • у питона правда многобуквенная дока
                        там принято читать ее, как книгу

                        с другой стороны, будет меньше скрипткидди

                        зы: чото ржу с этого кода
                        with pool_sema:
                            conn = connectdb()
                            try:
                        Ответить
                        • У меня не просто так пичот с доки питона. Недавно мне нужно было сделать многопоточный вызов операций, и подсчёт результатов выполнения. За 10 минут не нашел рабочего примера на «stackoveflow», забил болт, и накостылил через «multiprocessing».
                          Ответить
                          • Зачем тебе такое нужно было, кстати?
                            Они упирались в io? Почему тогда не взять asyncio?
                            Ответить
                            • Не упиралось. Просто запуск много тяжелых операции через тредпулл в 4 потока.
                              Ответить
                              • Слыхал про ИГИЛ?
                                Ответить
                                • Что-то слыхал. Если быть точным, запуск bash-скриптов через subprocess.Popen.
                                  Ответить
                                  • В сипайтоне одновременно может работать только один поток. Это делает работу в тредпуле бессмысленной с точки зрения загрузки cpu.

                                    Если же твои потоки уприраются в io (а в случае попена кажется что именно так: ты запустил, и ждешь), то пример анскилл-ио ждет тебя пямо на первой странице

                                    https://docs.python.org/3/library/asyncio-subprocess.html
                                    Ответить
                                    • Поздно, я наговнокодил
                                      Ответить
                                      • Попробуй менее противные языки
                                        ъ
                                        Смотри, у них дока на первой странице
                                        https://ruby-doc.org/core-2.5.0/Thread.html

                                        https://perldoc.perl.org/threads.html

                                        питон -- так себе язык
                                        Ответить
                                        • Там тоже гил. Хуй говна не слаще. Я про руби.
                                          Ответить
                                          • Там, однако, куда приятнее документация
                                            Ответить
                                        • Тогда уж ноде.жсон, в нём с ансинзронщиной всё заебато.
                                          Ответить
                                        • У Ruby хорошие мануалы, да. Примерно как cplusplus.com.
                                          + Список методов и полей
                                          + Список модулей
                                          + Примеры
                                          Ответить
                                    • Чем это лучше запуска через потоки?
                                      Ответить
                                      • Много это лучше запуска через потоки
                                        Ответить
                                      • > Чем это лучше запуска через потоки?
                                        >>> В сипайтоне одновременно может работать только один поток.
                                        Если у тебя есть четырёхъядерный проц, и в языке без «GIL» ты начнёшь считать сумму охуенного массива в четыре потока, то посчитаешь её в четыре (на самом деле меньше, но это не важно) раза быстрее, чем если бы считал одним. В «Python», запустив суммирование на четырёх потоках, никакого увеличения производительности ты не получишь.
                                        Ответить
                • Дока майкрософта тоже нормальная. Также «cplusplus.com», в нём есть примеры кода.
                  Ответить
                • У Эппла такая себе документация. Хорошо задокументированы только самые основные вещи. Остальное - ебитесь, как хотите. После редизайна теперь хер сыщешь ссылки на нормальные мануалы.

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

                    NSUrlSession у меня глючил, если я верно помню
                    Ответить
                • Ну и варианты в качестве конкурентов... Тут только вариант от M$ - адекватный соперник, в остальном чёрт ногу сломит. Годится только для штудирования от корки до корки. Если забыл какую-то мелочь, придётся всё перечитывать заново, ничего не найдёшь.

                  > https://perldoc.perl.org/perlfunc.html#lock-THING
                  Какая-то каша из говна и мёда.
                  + наборы функций объединены в списки
                  + всё на одной странице, удобно искать
                  - недоструктурированная каша, сигнатуры не на первом месте

                  > https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa
                  Более-менее адекватный вариант, но могло бы быть и лучше.
                  + удобная иерархия слева
                  - сигнатура не на первом месте

                  > https://man.openbsd.org/pf.4
                  Адище, в котором ни черта не выцепишь, пока не прочитаешь от корки до корки.
                  - недоструктурированная каша
                  + есть разделы и чётко видно, где какой ключ начинается/заканчивается

                  > https://developer.apple.com/documentation/uikit/uisplitviewcontroller
                  Недоструктурированная каша. Это класс, где тогда сука список полей и методов? Адище, в котором ни черта не выцепишь, пока не прочитаешь от корки до корки.
                  - длинная портянка, где поля и методы употребляются где-то между делом
                  + в See Also есть какой-то логичный список (троллинг такой?)

                  > https://www.php.net/manual/en/function.vpopmail-add-domain.php
                  Более-менее адекватный вариант, но могло бы быть и лучше. Хотя, поудобней майкрософтовской.
                  + сигнатура на первом месте
                  + структурированная питушня
                  Ответить
                  • > сигнатуры не на первом месте
                    нихуя ты слепошарый
                    вот сигнатура "map EXPR,LIST"

                    нихуя ты слепошарый: сигнатура тут просто сразу, со словом Syntax
                    https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa#syntax

                    нихуя ты слепошарый:
                    сигратура сразу в первом разделе https://man.openbsd.org/pf.4#IOCTL_INTERFACE

                    >Это класс, где тогда сука список полей и методов?
                    нихуя ты слепошарый: вот же, со слова Topics начинаются
                    с var и func
                    Ответить
              • У форта годная дока, краткая и информативная.

                https://forth-standard.org/standard/core/DOES

                Тут тебе и описание, и комментарии и примеры.
                Ответить
          • Да, охуенно: 3 строчки документации + 9000 комментов о том, как это говно реально работает.
            Ответить
        • Что вообще значит "говно"? Неконсистентность механизмов языка самих с собой? Неконсистентность механизмов языка с твоим опытом?
          Ответить
          • Слабая типизация.
            Ответить
            • Ну так все скриптовые языки работают. Что нам теперь, скрипты не писать?
              Ответить
              • В «Python» типизация сильная. Именно поэтому…

                Возможно, ты путаешь слабую и динамическую типизации. Не путай.
                Ответить
                • Я про то что на уровне имплементации все лежит в рантайме в выделенном куске памяти и во время интерпретации рантайму глубоко насрать на какие-то типы. Поэтому если в repl питона забить "1" + 1 будет ошибка рантайма а не компиляции и чем это лучше js в котором просто неявно реализованы методы приведения типа мне непонятно
                  Ответить
                  • При статической типизации хранится значение (тип используется только на этапе компиляции).

                    При динамической типизации хранится пара (тип, значение).

                    >> если в repl питона забить "1" + 1 будет ошибка рантайма а не компиляции

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

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

                    >> чем это лучше js в котором просто неявно реализованы методы приведения

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

                    Что мы хотим получить из "1" + 1: число, строку или что-то ещё? Плюс в данном случае означает сложение, конкатенацию или что-то ещё?
                    Ответить
                    • Мы не гадаем на кофейной гуще. Поведение стандартизировано и определено
                      Ответить
                    • Проблемы наличия в языке разных скалярных типов (число, строка).

                      Угадай, в каком языке таких проблем нет, и проблем с плюсом -- тоже?
                      Ответить
                      • В «PHP» плюс никогда не означает конкатенацию строк. Именно поэтому...
                        Ответить
                        • Я не знаю PHP:)
                          Еще варианты?
                          Ответить
                          • Перл.
                            Ответить
                            • бинго.

                              "." это всегда какатинация, а плюс -- всегда сложение

                              1 + 1 == '1' + '1' == '1' + 1 == 1 + '1' == 2
                              1 . 1 == '1' . '1' == '1' . 1 == 1 . '1' == 11


                              Именно потому я против "типизации"
                              Ответить
                              • Это намного лучше, чем как сделали в JS. Тут мы хотя бы знаем, выполнится сложение или конкатенация, т. е. можем предсказать, какие именно преобразования выполнятся (в строку или в число).
                                Ответить
                                • Совершенно верно.

                                  Это так же лучше, чем в питоне (иногда), потому что вместо

                                  int(a) + int(b)
                                  у меня просто a + b и всё

                                  перегрузка оператора + нинужна

                                  Фишка в том, что перл ПРИ ВСЕМ ЖЕЛАНИИ не знает типа переменной:) Ну точнее под капотом может и знать, но семантики такой нет
                                  Ответить
                                  • > лучше, чем в питоне (иногда)
                                    Меня в немногословном питоне бесит, что вместо
                                    xs.join(', ')

                                    или даже развёрнутого
                                    ', '.join(xs)

                                    надо писать
                                    ', '.join([str(x) for x in xs])

                                    или
                                    ', '.join(list(map(str, xs))
                                    Ответить
                                    • А зачем list?
                                      >>> ', '.join(map(str, xs))
                                      '1, 2, 3, 44, 5'
                                      >>> ', '.join((str(x) for x in xs))
                                      '1, 2, 3, 44, 5'
                                      Ответить
                                      • Ну хорошо, без list. Но всё равно многословная питушня выходит.
                                        Ответить
                              • Ну так в PHP то же самое, XYPO3BO3 в первый раз ответил правильно.
                                Ответить
                  • Какая тебе разница, как оно там устроено на уровне имплементации? Мы о языках говорим, а не их конпеляторах/интерпретаторах.

                    Пусть у нас есть какая-нибудь функция, например:
                    function add(a, b) {
                    	return a + b;   
                    }

                    И вот какой-нибудь невнимательный программист допускает ошибку:
                    let huiLen = add(form.nonErectedLength, 10);

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

                    Собственно, то, что слабая типизация — говно, умные люди поняли уже давным-давно, и именно поэтому сделали «Typescript».
                    Ответить
                    • >Какая тебе разница, как оно там устроено на уровне имплементации? Мы о языках говорим, а не их конпеляторах/интерпретаторах.
                      Это важно, чтобы понимать что js отличается только механизмами приведения типов
                      >Он попросту забыл, что в форме хранятся ещё нераспарсенные данные в виде строк. В нормальных языках (с сильной типизацией) на этом месте программист получит ошибку сразу после запуска и пойдёт фиксить. В языках со слабой типизацией язык решит, что он умнее программиста, и выдаст какую-то поебень, которая ещё сто лет будет создавать непонятные глюки.
                      Этот пример абсолютно ничего не значит, потому что с таким же успехом можно придумать пример в котором это полезно. Падает или не падает программа - это абсолютно не важно с точки зрения требований к программе так как оба результата в сущности неверны
                      >Собственно, то, что слабая типизация — говно, умные люди поняли уже давным-давно, и именно поэтому сделали «Typescript».
                      Typescript - это статический анализатор, по сути. Его не остается после компиляции и проверку типов при компиляции можно нахуй отключить. Это другая парадигма относительно питона и других скриптовых языков
                      Ответить
                    • Тут нужна статическая типизация или хотя бы статический анализ для этапа разработки.
                      Иначе сильная типизация только уменьшает вероятность работы программы.
                      Без неё на сервер бы отправилось какое-то говно или клиету бы отобразилось какое-то говно. Пользователь увидел бы, что у него сняли 510 рублей вместо 16 и пожаловался бы в техподдержку. А так оно просто упадёт, пользователь подумает, что кнопка не реализована.
                      Ответить
                      • Нет, не уменьшает. В общем случае для пользователя однохуйственно, упала ли программа или показывает какой-то бред: он всё равно позвонит тебе и скажет, что твоя программа не работает.
                        Однако лично я, например, предпочту, чтобы сбоящее приложение упало вместо отправки произвольной суммы куда-нибудь в Эфиопию. Потому что возврат денег — это адская ебля, как для клиента, так и для компании.

                        > А так оно просто упадёт, пользователь подумает, что кнопка не реализована.
                        Ну естественно, если писать в «JS-way», игнорируя любые ошибки. А нормальные люди™ в случае непредвиденных исключений извиняются перед Кадыровым пользователем и шлют краш-репорт.
                        Ответить
                        • > шлют краш-репорт
                          Кстати, а как его правильно послать?
                          * Пользователь (а то и анонимус) может послать туда любую питушню и затроллить сервер
                          * Если разрешить отправлять только залогиненным, то мы никогда не получим сообщение о том, что пользователь не смог залогиниться из-за ошибки.
                          Ответить
                          • Слать автоматически и прозрачно для пользователя, как та же винда делает. А для приватности сделать либо флажок (как все делают), либо просто одну кнопку «послать репорт».
                            А от желающих посрать ничего не поможет, только бан.
                            Ответить
                • Спутал твой ротик с твоей попкой - разницы не заметил. Проверь...
                  Ответить
          • Неконсистентность механизмов языка самих с собой, что и было показано на этом слайде.
            Ответить
            • Неконсистентность механизмов языка - это когда в php в разных функциях разный порядок одинаковых аргументов.
              На этом слайде какой-то высер который никогда никому не помешает в работе, все "бытовые" приведения типов легко умещаются в мозгу любой веб-макаки. А уж если ты решил складывать массивы с объектами - будь добр почитать стандарт
              Ответить
              • Это именно что неконсистетность.
                К примеру, плюс некоммутативен прямо для встроенных типов.

                > который никогда никому не помешает в работе
                Это сильное заявление.

                Уверен, программист на PHP, Cobol или C++ точно так же скажет про любой изьян языка.

                >стандарт
                В С++ тоже есть стандарт, и это не спасает язык.

                Кстати, что там с типом null? Уже исравили?
                Ответить
                • > К примеру, плюс некоммутативен прямо для встроенных типов.
                  Плюс не обязан быть везде коммутативен, если это не нарушает аксиоматики. Как понимаешь, аксиоматики арифметики массивов и объектов не существует
                  > Уверен, программист на PHP, Cobol или C++ точно так же скажет про любой изьян языка.
                  Я не согласен с тем что это изъян языка
                  > Кстати, что там с типом null? Уже исравили?
                  А что с ним?
                  Ответить
                  • >Плюс не обязан быть везде коммутативен,
                    Приведи пример некоммутативного плюса с нормальной сематикой

                    >Я не согласен с тем что это изъян языка
                    Большинство людей привыкло к коммутативности операции сложения. Следовательно, поведение языка для них неождианно.
                    Неождианное поведение это всегда изьян.


                    >А что с ним?
                    С ним вот.
                    https://2ality.com/2013/10/typeof-null.html

                    Тот факт, что даже такой стронник языка, как ты, не знает о таких вещах, говорит о том, что язык сложен, запутан и имеет массу подводных граблей.
                    Ответить
                    • >Приведи пример некоммутативного плюса с нормальной сематикой
                      Что значит "нормальная семантика"?
                      > Большинство людей привыкло к коммутативности операции сложения.
                      Еще раз: плюс не обязан быть коммутативен там где это не обозначено аксиоматикой. Я не понимаю к чему привыкли люди, которые вычитают строки из чисел
                      >С ним вот.
                      https://2ality.com/2013/10/typeof-null.html
                      ({}) instanceof Object // true
                      null instanceof Object // false

                      Ответить
                      • >Что значит "нормальная семантика"?

                        Перефразирую: приведи ситуацию, где такое поведение лично тебе кажется удобным и понятным.

                        >Плюс не обязан быть коммутативен там где это не обозначено аксиоматикой.

                        Ну вот я и попросил пример. Хочется узнать про такое множество, для элементов которого определена операция "+", и она не коммутативна.

                        >null instanceof Object // false
                        ахахаха, какая прелесть!

                        > typeof null
                        'object'
                        > null instanceof Object
                        false

                        Вот и еще одна неконсистентность.

                        Или теперь ты скажешь, что typeof не обязана быть обратной от instanceof ?
                        Ответить
                        • >Перефразирую: приведи ситуацию, где такое поведение лично тебе кажется удобным и понятным.
                          Не математик, но вот векторное произведение некоммутативно. Примеров именно сложения не знаю.
                          >Ну вот я и попросил пример. Хочется узнать про такое множество, для элементов которого определена операция "+", и она не коммутативна.
                          https://en.wikipedia.org/wiki/Near-ring
                          Операция "+" определена и не обязана быть коммутативной
                          >Или теперь ты скажешь, что typeof не обязана быть обратной от instanceof ?
                          Я хочу сказать что typeof давно неофициально deprecated, была признана ошибкой и ее похоронили без почестей. В современном js это просто мозгоебалка для собеса
                          Добавлю что это значит что ты полностью прав и это говно, но это не должно быть единственной причиной для хейта js, особенно новых стандартов
                          Ответить
                          • >Не математик, но вот векторное произведение некоммутативно.
                            мы, кажется, говорили про сложение?
                            >Near-ring

                            [quote]
                            A near-ring is a ring (not necessarily with unity) if and only if addition is commutative and multiplication is also distributive over addition on the lef
                            [/quote]

                            Я не математик, но кажется тут написано, что плюс у кольца коммутативен, не?

                            >Я хочу сказать что typeof давно неофициально deprecated

                            https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf (212)

                            typeof UnaryExpression[?Yield, ?Await]


                            чото не написано нигде такого. Откуда дровишки?


                            > но это не должно быть единственной причиной для хейта
                            У меня нет какого-то особого хейта, некоторые вещи мне даже нравятся (например, отсутствие разницы между "словарем(картой)" и объектом.

                            Но JS не консистентент
                            Ответить
                            • >Я не математик, но кажется тут написано, что плюс у кольца коммутативен, не?
                              Именно, у кольца коммутативен, у около-кольца - не обязательно
                              >чото не написано нигде такого. Откуда дровишки?
                              Ударение на слово неофициально. Это значит что сам создатель языка признал это говном и не рекомендует к использованию
                              > Но JS не консистентент
                              Жду еще примеров
                              Ответить
                              • >Это значит что сам создатель языка признал это говном и не ре

                                Как-то не понятно.

                                Офицальная спецификая языка про это молчок, откуда я должен узнать, что он депрекейтнут?

                                Из твиттера автора?

                                >Жду еще примеров
                                Двух недостаточно?

                                что дает сложение пустых массивов, и какой пункт спеки про это говорит?
                                > [] + []
                                Ответить
                                • >Офицальная спецификая языка про это молчок, откуда я должен узнать, что он депрекейтнут?
                                  >
                                  >Из твиттера автора?
                                  Нет, ты можешь продолжать писать typeof null и рассказывать всем какое js говно
                                  >Двух недостаточно?
                                  >что дает сложение пустых массивов, и какой пункт спеки про это говорит?
                                  Я уже высказал свое мнение по поводу сложения и привел в пример near-rings, пожалуйста, не приводи эту хуйню в пример
                                  Что дает [] + [] мне не очень интересно, думаю, что пустую строку
                                  Это не является примером неконсистентности
                                  Ответить
                                  • >typeof null и рассказывать всем какое js говно


                                    И так, еще раз:

                                    * typeof не является обратной от instanceof
                                    * ты утверждаешь, что "typeof" deprecated, но "это все знают"
                                    * в официальной спецификации языка нигде не сказано

                                    Это какой-то двойной пиздец. И неконсистентный, и еще и реальное положение вещей не соответствует спецификации.


                                    >Что дает [] + [] мне не очень интересно

                                    То-есть ты даже не знаешь этого без документации?

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

                                    Даже в С++ такого нет

                                    >думаю, что пустую строку
                                    Почему, кстати?
                                    Ответить
                                    • >Это какой-то двойной пиздец. И неконсистентный, и еще и реальное положение вещей не соответствует спецификации.
                                      Не пойми меня неправильно: эта хуйня работает, тебе никто не запрещает ей пользоваться. Я уже признал что это говно, это признал создатель языка и скорее всего на работе на тебя косо посмотрят или нахуй пошлют. Уверен, во многих языках есть такие же конструкции и решения, которые существуют но не очень приветствуются в кодовой базе
                                      >В каких языках бывает ситуация, в которой опытный программист не может сказать, чему равно сложение двух встроенных типов?
                                      Вот прикинь, js-программисты не сидят целый день и складывают массивы с массивами
                                      >Почему, кстати?
                                      По той же причине, что и "1" + 2 === "12" - интерпретирование плюса как конкатенации. Вангую что []-[] === 0 по той же причинеи аналогично числам и строкам. Консистентность!
                                      Ответить
                                      • Малость джаваскрипт говно
                                        Много джаваскрипт говно
                                        Ответить
                                    • > Почему, кстати?
                                      Я не джаваскриптер, но помню, что плюс сначала проверяет оба аргумента на число, потом пытается вызвать valueOf, потом — toString, и всё это переплетено и перемешано так, что хрен запомнишь. Собственно, чем дальше плюс заходит в своих эвристиках — тем неадекватнее получаются результаты, вплоть до преобразования обоих аргументов в строки и их последующей конкатенации.

                                      UPD: Во, нашёл это говно: https://dmitripavlutin.com/javascriptss-addition-operator-demystified/. Какой пиздец )))
                                      Ответить
                                      • Yes! It appears that https://dmitripavlutin.com/javascriptss-addition-operator-demystified/ is currently blocked in Russia.
                                        Details:
                                        URL https://dmitripavlutin.com/javascriptss-addition-operator-demystified/
                                        Domain dmitripavlutin.com
                                        IP 142.93.108.123
                                        Decision 2-6-27/ 2016-07-25-70-АИ made on 2016-07-25 by ФНС.

                                        This block affects IP 142.93.108.123 and domain bkdostup.ru.
                                        Decision 2-50 made on 2018-03-05 by суд.

                                        This block affects IP 142.93.108.123, domain downloadfreegreen.bitballoon.com and URL http://downloadfreegreen.bitballoon.com/instrukciya-samus-725-g.html.
                                        Decision 2-6-27/ 2016-01-31-6-АИ made on 2016-03-09 by ФНС.

                                        This block affects IP 142.93.108.123, domain primedice.com and URL http://primedice.com.
                                        Decision 2019-08-22-1780 made on 2019-08-28 by МВД.

                                        This block affects IP 142.93.108.123 and domain rollsafe.org.
                                        Ответить
                                        • Говорят, они блочат только детскую порнографию и пропаганду нацизма

                                          Так что если ты хотел открыть этот сайт, то ты -- нацист или педофил
                                          Ответить
                              • > Жду еще примеров
                                Я могу привести пример неадекватной неконсистентности плюса:
                                >  'aaa' + 'bbb'
                                "aaabbb"
                                
                                >   [1,2,3] + [4,5,6]
                                "1,2,34,5,6"
                                
                                >    {'a':'b'} + {'b': 'c'}
                                "[object Object][object Object]"
                                
                                >   123 + 456
                                579

                                Очевидно, что для консистентности в последнем примере результатом должно быть «"123456"»: сложение объектов намекает, что в «JS» операция «+» — это «преобразовать-в-строку-и-конкатенировать», в отличие от:
                                >>> [1,2,3]+[4,5,6]
                                [1, 2, 3, 4, 5, 6]



                                Кстати, без рофлов, а что вот это за хуйня?
                                >   {'a': 'b'} + {'c': 'd'}
                                "[object Object][object Object]"
                                >   {'a': 'b'} + 'lol'
                                VM546:1 Uncaught SyntaxError: Unexpected token ':'
                                >   let hui = {'a': 'b'};
                                undefined
                                >   hui + 'lol';
                                "[object Object]lol"
                                Ответить
                                • Еще раз: не существует никакой аксиоматики сложения хуя с жопой, с числами "+" работает нормально. То что поведение математических операций на каком-то говне отличается с вашими ожиданиями - это ваши проблемы.
                                  >Кстати, без рофлов, а что вот это за хуйня?
                                  > {'a': 'b'} + {'c': 'd'}
                                  Типы привелись к строке
                                  > {'a': 'b'} + 'lol'
                                  Выражение интерпретировалось как блок кода
                                  > let hui = {'a': 'b'};
                                  undefined
                                  > hui + 'lol';
                                  Типы привелись к строке
                                  Ответить
                                  • + в JS — это не математическая операция. Это знак. Он может ознчать унарный либо бинарный оператор (на самом деле ещё кое-что: он ещё может быть частью знака инкремента).

                                    Унарный оператор перегружен: он может означать сложение (математическую операцию), а может означать и конкатенацию. Конкатенация строк — это не сложение, просто так совпало, что в JS для неё выбрали тот же знак, что и для сложения. Есть языки программирования, в которых конкатенацию обозначили другим знаком.
                                    Ответить
                                    • Второй абзац следует начинать со слова «бинарный».
                                      Ответить
                                  • > Выражение интерпретировалось как блок кода
                                    Лол. А это беда консоли, или в скрипте такой же багор будет?

                                    > Еще раз: не существует никакой аксиоматики сложения хуя с жопой, с числами "+" работает нормально. То что поведение математических операций на каком-то говне отличается с вашими ожиданиями - это ваши проблемы.
                                    «+» — это операция сложения. Складывая два объекта, любой нормальный человек (не писавший на «JS») ожидает, что два объекта сложатся. В «Python», например, если я к одному списку прибавлю второй, я получу адекватный и, главное, полезный результат. А вот в «JS» я получу хуйню, которая абсолютно бесполезна. Не существует реальных примеров кейсов, в которых такое идиотское поведение можно использовать.

                                    Собственно, это и есть философия «JS»: в любой непонятной ситуации выдать программисту хоть какую-нибудь хуйню, пусть даже полностью бесполезную и неадекватную, вместо нормального сообщения о том, что получается хуйня. Именно поэтому я против «JS».
                                    Ответить
                                    • >Лол. А это беда консоли, или в скрипте такой же багор будет?
                                      Думаю, что да, в скрипте будет так же
                                      >«+» — это операция сложения. Складывая два объекта, любой нормальный человек (не писавший на «JS») ожидает, что два объекта сложатся.
                                      По-моему, вы там все ебанулись
                                      >В «Python», например, если я к одному списку прибавлю второй, я получу адекватный и, главное, полезный результат
                                      От этого само понятие "сложение списков" менее идиотским не становится
                                      [].__proto__.toString = () => {throw "go fuck yourself"}
                                      [] + [] // Uncaught go fuck yourself
                                      console.log([]) // []
                                      JSON.stringify([]) // "[]"

                                      Вот, можешь использовать во всех кодовых базах
                                      Ответить
                                      • > само понятие "сложение списков"

                                        Список же это упорядоченное множество?
                                        Так вот множества вполне себе складываются в математике, нет разве?
                                        Ответить
                                        • Что-то я сомневаюсь, что список в питоне и упорядоченное множество формально соотвествуют
                                          Ответить
                                          • > Что-то я сомневаюсь, что список в питоне и упорядоченное множество формально соотвествуют
                                            Ой, вот не надо формальную математику приплетать. В «JS» даже целые числа формально не соответствуют математике:
                                            >   9999999999999999
                                            10000000000000000

                                            В отличие от «Python», где длинная арифметика искаропки.
                                            Ответить
                                            • Пушо в JS все флоат зачем-то
                                              Ответить
                                              • Ага. Плавучие целые.
                                                Ответить
                                                • Значит-ли это, что все операции выполняются на ФПУ?
                                                  Ответить
                                              • > зачем-то
                                                Проблемы от этого только в случае с % и с пирформансом для менее продвинутых версий с интерпретацией вроде JScript (хотя, python всё равно больше тормозит), где добавляются лишние касты.
                                                В остальном же одни плюсы вроде прозрачных опереций и отсутствия потери точности 32битных интов.
                                                Ответить
                                                • Это какая такая у интов потеря точности? Вот у флоатов да, есть потеря точности:
                                                  >   9999999999999999
                                                  10000000000000000
                                                  Ответить
                                                  • > какая такая у интов потеря точности?
                                                    Ну вот возьмём, скажем, C/C++:
                                                    1/2           // относительная точность упала на 100%
                                                    (double)(1/2) // относительная точность упала на 100%
                                                    (double)(1)/2 // относительная точность не упала
                                                    Ответить
                                                    • Ну как это на 100%? В целых числах 1/2 == 0 точно. Если нужно вещественное деление — то это в плавучку, инты тут не при чём.
                                                      Ответить
                                                      • В математике есть полиморфизм чисел.
                                                        1 - это натуральное число
                                                        1 - это целое число
                                                        1 - это рациональное число
                                                        1 - это действительное число
                                                        1 - это комплексное число
                                                        1 - это гиперкомплексное число (...нион)
                                                        1 - это матрица размера 1*1
                                                        1 - это тензор размера 1*...*1
                                                        И при работе с числами выбирается наименьшее требуемое множество (примерно как работает умножение в numpy). Это удобно и убирает всякую питушню вроде явных кастов там, где прописаны математические правила.

                                                        Чуть менее, чем всегда пользователю нужно 1/2 = 0.5, и по идее нужны явные литералы челых чисел вместо говна вида 1/2 = 0.
                                                        1 = double
                                                        1.0 = double
                                                        1. = double
                                                        (int) 1 = int
                                                        1i = int
                                                        Ответить
                                                        • Ну вот с делением — да, возможно, было бы удобнее автоматически кастовать в плавучку (double operator/(int, int)). Мне в этом плане «Python» нравится:
                                                          >>> 1/2
                                                          0.5
                                                          >>> 1//2
                                                          0

                                                          Потому что целочисленное деление aka div тоже нужно и полезно.
                                                          А с дефолтным даблом не соглашусь — это слишком неочевидное решение. Потому что для пользователя 1 — это в первую очередь целое число: точки-то нет.
                                                          Ответить
                                                          • > для пользователя 1 — это в первую очередь целое число: точки-то нет.
                                                            Но в то же время 1/2 = 0.5.

                                                            Наименьшее требуемое множество
                                                            1 in N
                                                            -1 in Z
                                                            1/2 in Q
                                                            Ответить
                                                            • Ну а -1**(1/2) = i. Уже в C надо переходить.

                                                              Целые числа удобны своей точностью и предсказуемостью: с поправкой на mod 2^N ты всегда можешь их точно складывать, вычитать, умножать и целочисленно делить, не беспокоясь, что в один прекрасный день у тебя внезапно исчезнет единица или чего покрупнее. А плавучка (в любом современном железе) — говно, использовать которое можно только от полной безысходности.
                                                              Ответить
                                            • В js завезли BigInt
                                              Ответить
                                              • >A BigInt is created by appending n to the end of an integer literal

                                                ох, лол)

                                                ни в каком языке я больше не видел, что бы литерал-целое по умолчанию было плавуном:)

                                                разве что в там, где God is Real
                                                Ответить
                                                • >ни в каком языке я больше не видел, что бы литерал-целое по умолчанию было плавуном:)
                                                  В js нету типа "целое", и "литерала-целого" тоже нету
                                                  Ответить
                                                  • То есть в «JS» вообще нет чисел, соответствующих какой-нибудь формальной математической модели? Такой-то багор!
                                                    Ответить
                                                    • В js есть тип "number" соответствующий 64-битному float. Соответствует ли это какой-то формальной математической модели мне не важно, а важно то что ведет оно себя как 64-битный float
                                                      Ответить
                                                      • Если соответствие формальной математической модели для тебя не важно, то зачем ты чуть выше про неё пишешь?
                                                        >>> Что-то я сомневаюсь, что список в питоне и упорядоченное множество формально соотвествуют
                                                        Ответить
                                                        • Я пишу о ней чтобы объяснить почему мне неважно то что вернет [1,2,3]+[4,5,6]
                                                          Ответить
                                                    • Это ж говнопрограммирование, тут можно реализовать честно только бесполезную для всех, кроме пары математиков, питушню вроде чисел из множества {0, 1, 2, 3}.
                                                      А длиннопитухи из пистона тормозят!

                                                      P.S. То ли дело Haskell. Int - как в программировании - быстр и короток, Integer - как в математике - длинен и медленен.
                                                      Ответить
                                                      • Ну как это? Все операции над уинтами вполне себе формально определяются модульной арифметикой.
                                                        Но они есть!
                                                        Ответить
                                      • Приведи реальный пример, где тебе в работе пригодилось, что в JS [1,2,3] + [4,5,6] === "1,2,34,5,6".
                                        Ответить
                                        • ['=('] +[' '] + [')=']
                                          Ответить
                                        • Говнокодерам в работе ничего о чем они здесь пишут не пригождается. И вообще они на работе картриджи заправляют.
                                          Ответить
                                      • > Думаю, что да, в скрипте будет так же
                                        Ну тогда записывай в жсобагры.

                                        > По-моему, вы там все ебанулись
                                        А что для тебя неожиданного в том факте, что, складывая два объекта, нормальный человек ожидает получить их сумму, а не какую-то непонятную хуйню?

                                        > От этого само понятие "сложение списков" менее идиотским не становится
                                        С чего это оно «идиотское»? Такое поведение — полезное и удобное. Подойди к любому программисту (не писавшему на «JS», конечно) и спроси, что он ожидает получить в качестве результата выражения «[1, 2, 3] + [4, 5, 6]».
                                        Хорошо, даже если ты считаешь, что это понятие идиотское — тогда почему «JS» возвращает абсолютно бесполезную хуйню, вместо внятного «HuinyaException('Bbl nblmaemecb cgeJlamb xyuHl0')»?

                                        > [].__proto__.toString = () => {throw "go fuck yourself"}
                                        Ну вот мы и начали фиксить баги жаваскрипта.
                                        Но насколько я знаю, это всё уже есть в «Typescript».
                                        Ответить
                                        • >Ну тогда записывай в жсобагры.
                                          Это просто невалидный синтаксис. В других языках не существует невалидного синтаксиса?
                                          >А что для тебя неожиданного в том факте, что, складывая два объекта, нормальный человек ожидает получить их сумму, а не какую-то непонятную хуйню?
                                          Я не понимаю что такое "сумма двух объектов". Что такое сумма матриц - понимаю, что такое целое - тоже. Как сложить {"a": 1} и {"b": 2} и произвольные два объекта - не понимаю. Вы в своем питоне все подряд можете сложить что ли?
                                          >С чего это оно «идиотское»? Такое поведение — полезное и удобное.
                                          Это не отменяет того факта что это высосанная из пальца хуйня и не имеет каких-то принципиальных преимуществ над говноконкатенацией. Получается, единствоенное, что тебе не нравится - то что они разные?
                                          > Хорошо, даже если ты считаешь, что это понятие идиотское — тогда почему «JS» возвращает абсолютно бесполезную хуйню, вместо внятного «HuinyaException('Bbl nblmaemecb cgeJlamb xyuHl0')»
                                          Я не вижу разницы между ексепшеном и непонятной хуйней, для меня и то и другое - неправильное поведение
                                          Ответить
                                          • > В других языках не существует невалидного синтаксиса?

                                            Существует. Обычно он приводит к сообщению о синатиксической ошибке.

                                            >Как сложить {"a": 1} и {"b": 2}

                                            Это два множества кортежей: {(a,1)} и {(b,2)}, в результате его сложения будет {(a,1), (b,2)}.

                                            >Я не вижу разницы между ексепшеном и непонятной хуйней,

                                            А про Fast Fail слышал?
                                            Ответить
                                            • >Существует. Обычно он приводит к сообщению о синатиксической ошибке.
                                              VM546:1 Uncaught SyntaxError: Unexpected token ':' как бы намекает
                                              >Это два множества кортежей: {(a,1)} и {(b,2)}, в результате его сложения будет {(a,1), (b,2)}.
                                              Это можно интерпретировать только как кортежи? Что если я хочу что-то другое? Что если я вообще не хочу их складывать?
                                              >А про Fast Fail слышал?
                                              Это одна из философий обработки ошибок. В js другая. Что в этом плохого?
                                              Ответить
                                              • > Это одна из философий обработки ошибок. В js другая. Что в этом плохого?
                                                То, что она — говно. «Философия обработки ошибок JS» ошибки не обрабатывает, а заметает под коврик — чтобы через пару лет об них кто-нибудь споткнулся и ёбнулся.
                                                Ответить
                                                • >То, что она — говно. «Философия обработки ошибок JS» ошибки не обрабатывает, а заметает под коврик — чтобы через пару лет об них кто-нибудь споткнулся и ёбнулся.
                                                  js придумали для гостевух. На гостевухах такая политика оправдана
                                                  Ответить
                                                  • >js придумали для гостевух. На гостевухах такая политика оправдана


                                                    Вот кстати плюсану.

                                                    Для скриптов (небольших программок на 5-10 строк кода) нужны совсем другие вещи, не те, которые нужны сложным проектам.

                                                    Нужно просто использовать JS по назначению (писать на ней скрипты в 5-10 строк кода) и всё будет ок
                                                    Ответить
                                                    • >Нужно просто использовать JS по назначению (писать на ней скрипты в 5-10 строк кода)

                                                      Ещё он дико удобен как браузерный калькулятор.
                                                      Ответить
                                                  • > js придумали для гостевух. На гостевухах такая политика оправдана
                                                    Ну вот и всё, с этим отступлением все противоречия разрешаются. Правда, остаются ещё сумасшедшие, которые пишут на «JS» проекты в сотни тысяч строк кода, но с ними уже должны врачи разбираться.
                                                    Ответить
                                                    • Да нет, всё тут нормально. Разве что можно было вместо 'use strict' сделать что-то вида 'enable feature5' и чтоб таким образом включались разные фичи вроде typeof null == 'undefined' и [1]+[1] == [1,1].
                                                      Ответить
                                                      • Нужно просто выпустить «JavaScript 36», исправив все недостатки старых версий.
                                                        Ответить
                                                        • Так уже выпускают. Даже сахарок для классов добавили для ноющих ООПедиков.

                                                          Только зачем-то полусохраняют обратную совместимость. Неясно, зачем в "JavaScript" и "C++"
                                                          * вводят новые фичи
                                                          * стараются поддерживать старое говно
                                                          * умудряются выпускать несовместимое говно со старыми версиями (например, убрали Function.prototype.caller)
                                                          * не вводят директивы явного отключения старого говна

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

                                                          Неясно, почему нельзя отключать говно директивами (вроде 'use strict') на постоянной основе
                                                          * Старый код продолжает работать без потери совместимости
                                                          * Новый код использует новый подход без старого говна
                                                          Ответить
                                                          • > стараются поддерживать старое говно
                                                            Видимо, боятся повторить эпический фейл питона.

                                                            > Неясно, почему нельзя отключать говно директивами (вроде 'use strict') на постоянной основе
                                                            Полагаю, что это будет слишком сложно для разработки: придётся по сути поддерживать два диалекта языка.
                                                            Ответить
                                                            • Так сейчас всё равно поддерживают, только криво.
                                                              Ответить
                                                              • Ну да, потому что у них есть возможность какую-нибудь старую хрень, которая слишком мешает, выкинуть на помойку. А с директивами придётся старое говно тянуть до конца, параллельно поддерживая новое.
                                                                Ответить
                                                                • Так тогда бы старое говно совсем выпиливали...
                                                                  В итоге из-за выпиленного говна, которое слишком мешает одной группе экспертов языка, страдает 100500 групп с кодом, который его использует. И ещё 100500 групп, настрадавшихся от старого говна, не могут писать на нормальном языке.

                                                                  Пусть лучше одна группа компиляторщиков пострадает за всех, но зато 100500 команд программистов будут спокойно работать.
                                                                  Ответить
                                                                  • Проблема в том, что ресурсы людей, разрабатывающих язык, ограничены. Чем больше программистов поддерживают старое говно — тем меньше остаётся тех, кто пилит новые фичи. И в результате от нехватки фич страдают вообще все.

                                                                    Между поддержкой старого говна и выпиливанием старого говна нужен очень тонкий баланс. Уходим в одну сторону — получаем «WinAPI» с приветами из девяностых, уходим в другую — получаем «Python» и цирковое представление «переведи 100500 либ на третью версию».
                                                                    Ответить
                                                                    • Туда можно и вкинуть людей. Сколько людей сейчас правят старый код из-за того, что какую-то фичу языка убрали? Сколько людей пишет костыли, которые прикрывают старые фичи, которые НЕ убрали?

                                                                      Хотя бы 1% от них перевести в разработчики языка - и всё.

                                                                      Тонкий баланс не нужен. Выпиливать старое просто нельзя, т.к. что-нибудь обязательно сломается.
                                                                      Ответить
                                                                      • Люди — не юниты в Казаках. Нельзя взять и кого-то куда-то перевести.

                                                                        Но в любом случае, даже если мы как-то ухитрились так сделать — всё равно в итоге получим десятки-сотни директив, что-то отключающих, включающих, меняющих, и каждое обновление языка 100500 программистов должны будут с ужасом во все свои проекты впиливать новые директивы, причём сначала им надо будет понять, какая из новых фич ломает проект.
                                                                        Ещё остаются проблемы с API: к примеру, в одном из обновлений возьмут и выпилят из parseInt() второй аргумент. Получаем две версии стандартной библиотеки, между собой несовместимых. В следующем обновлении уберут тупую хуйню из forEach() — получаем три версии. Делаем оба изменения опциональными через директивы — получаем четыре версии. Обновляемся ещё пару раз — и выходим в окно, потому что поддерживать это будет попросту нереально.
                                                                        Ответить
                                                                        • > впиливать новые директивы, причём сначала им надо будет понять, какая из новых фич ломает проект
                                                                          Э, это не обратная совместимость.
                                                                          Старый код должен работать как раньше, новый код должен использовать директивы для тех фич, которые ломают обратную совместимость.

                                                                          В принципе, можно вообще ничего не менять по умолчанию, без директив не только не нарушать совместимость, но и новые фичи не включать. А дальше тупо в начале каждого файла будут писать что-то вида "use python 3.8".

                                                                          Если получается кобенаторный рост, можно делать тупо директивы по версиям и генерацию адаптеров между версиями. Это максимум квадратичный рост. Но адаптеры можно писать только на одну версию назад, остальные генерировать и оптимизировать автоматически - линейный рост.
                                                                          Ответить
                                                                          • А, ну так уже лучше. Но всё равно, необходимость создания автоматических адаптеров будет очень сильно снижать возможности по выпилу фич. Убрать аргумент какой-нибудь функции из стандартной либы в большинстве случаев не получится — потому что в автоматическом режиме пофиксить использовавший его код вряд ли возможно. Плюс остаётся проблема совместимости: код из старой версии не сможет использовать новые либы, новый код будет иметь проблемы со старыми версиями либ.
                                                                            Ответить
                                                          • >Так уже выпускают. Даже сахарок для классов добавили для ноющих ООПедиков.

                                                            Стал лучше js после всех их «улучшений»?
                                                            Сомневаюсь.
                                                            Ответить
                                              • >Это одна из философий обработки ошибок. В js другая. Что в этом плохого?

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

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

                                                Точнее говоря, так считалось, пока не пришла эпоха веб.
                                                Теперь, кажется, считается что с точностью до наоборот (во всяком случае, об этом говорит отказ от soap в пользу rest, отказ от статических типизированных языков в пользу js, php и python итд).

                                                А ты как думаешь?
                                                Ответить
                                                • It depends. Там где надежность действительно важна, оправданы сколько угодно параноидальные проверки, я слышал про какие-то стандарты для си, которые специально ограничивают программиста, к примеру.
                                                  Там где надежность чуть поменьше, но важна, это все тестируют до дыр и в тестировании действительно fail fast полезен
                                                  Там где js там обычно принципиально важной логики нет и я могу себе позволить отнять строку от строки потому что так быстрее чем лишние плюсы или конструкторы number писать
                                                  Наконец, это нечестно противопоставлять fail fast подходу js аргументируя "порчей данных"
                                                  Порча данных происходит много где и зачастую от ошибок логики программы а не какой-то js хуйни
                                                  Ответить
                                                  • Всё, я понял.

                                                    Там, где надежность важна, там лучше не использовать JS.

                                                    Там же, где она не важна (например, можно записать человек на счет NaN денег) -- там можно писать на JS.

                                                    Так стало много понятнее, спасибо!
                                                    Ответить
                                                    • >Там же, где она не важна (например, можно записать человек на счет NaN денег) -- там можно писать на JS.
                                                      Именно поэтому я как js разработчик храню деньги наличкой под подушкой
                                                      Там js точно до них не доберется
                                                      Ответить
                                                      • Надо просто чеки, квитанции и выписки собирать. И пофиг, там на жс или на коболе.
                                                        Где-то недавно читал, что когда у банков и ЖКХ-контор херится база, помогает чемодан с квитанциями.
                                                        Ответить
                                          • > Это просто невалидный синтаксис. В других языках не существует невалидного синтаксиса?
                                            Всё, нашёл доку 2, можешь убирать из багров.

                                            > Как сложить {"a": 1} и {"b": 2} и произвольные два объекта - не понимаю.
                                            И я тоже не понимаю. Но именно для этого и нужна консистентность: для тех объектов, для которых понятие суммы определено (математически или соображениями удобства), операция сложения должна возвращать их сумму. Для тех же, к которым такое понятие неприменимо, сама операция должна быть невалидна. В «Python» всё именно так.

                                            > Это не отменяет того факта что это высосанная из пальца хуйня
                                            Для тебя объединение списков — высосанная из пальца хуйня? А зачем тогда нужен «Array.prototype.concat»? Или ты считаешь, что «[1, 2, 3].concat([4, 5, 6])» выглядит проще, чем «[1, 2, 3] + [4, 5, 6]»?

                                            > Я не вижу разницы между ексепшеном и непонятной хуйней, для меня и то и другое - неправильное поведение
                                            Только эксепшон ты получишь сразу же, как только нажмёшь F5 (или что там жаваскриптеры жмут для деплоя). А непонятная хуйня может годами сидеть в системе, по-тихому портя данные клиентов.
                                            Ответить
                                            • >И я тоже не понимаю. Но именно для этого и нужна консистентность: для тех объектов, для которых понятие суммы определено (математически или соображениями удобства)
                                              >Для тебя объединение списков — высосанная из пальца хуйня? А зачем тогда нужен «Array.prototype.concat»? Или ты считаешь, что «[1, 2, 3].concat([4, 5, 6])» выглядит проще, чем «[1, 2, 3] + [4, 5, 6]»?
                                              Вот я например хочу чтобы «[1, 2, 3] + [4, 5, 6]» было операцией сложения векторов. Что, это менее удобно? Менее логично? Менее что? С этой точки зрения, какое мне дело, вернет ли мне конкатенацию или какое-то говно?
                                              >Только эксепшон ты получишь сразу же, как только нажмёшь F5 (или что там жаваскриптеры жмут для деплоя). А непонятная хуйня может годами сидеть в системе, по-тихому портя данные клиентов.
                                              Это не говно, это просто другая модель
                                              Ответить
                                              • > Вот я например хочу чтобы «[1, 2, 3] + [4, 5, 6]» было операцией сложения векторов. Что, это менее удобно? Менее логично?
                                                Да, ожидать от операции сложения списков поведения операции сложения векторов — это нелогично. Если нужно складывать вектора — складывай вектора:
                                                >>> np.array([1, 2, 3]) + np.array([4, 5, 6])
                                                array([5, 7, 9])


                                                > С этой точки зрения, какое мне дело, вернет ли мне конкатенацию или какое-то говно?
                                                > Это не говно, это просто другая модель
                                                Мы сошлись на том, что в языке для написания гостевух такая модель действительно может быть полезна.
                                                Ответить
                                                • >Мы сошлись на том, что в языке для написания гостевух
                                                  Как будто что-то плохое
                                                  Ответить
                                              • Не понял, жс-питушок bootcamp_dropout отрицает все аргументы 1,2,3,4,5,6 только потому, что такое поведение ОПИСАННОГО В СТАНДАРТЕ БОЖЕСТВЕННОГО ЖС?

                                                Ну ведь правда же не самое удобное решение. Сложение значение разных типов и чёткие правила автоматических преобразований типов - отличная фича, что бы там ни говорили сильнопитуизоиды. Но можно было бы выбрать значение для возврата и получше.
                                                Ответить
                                                • > Но можно было бы выбрать значение для возврата и получше.
                                                  «undefined», например.

                                                  Кстати, мне оправдания в стиле «так написано в Книге» до боли напоминают беседы с крестовиками, которым показывают UB. Мол, сам дурак, что произвольные два инта складываешь, надо Стандарт читать!
                                                  Но, справедливости ради, если UB в си/крестах всё таки нужны для оптимизаций, то вот эти вот [1,2]+[3,4]=="1,23,4" — просто непродуманное говно.
                                                  Ответить
                                                  • > UB в си/крестах всё таки нужны для оптимизаций
                                                    Кстати и директивах. Почему бы не сделать safe-версию C/C++ с директивой 'use safe', где все UB заменили на какое-то логичное поведение, когда код либо как-то предсказуемо и медленно работает, либо вовсе не компилируется, если вместо UB нужно сгенерировать слишком сложный код (набор ситуаций описан в стандарте, либо включается флагами вида -Eall -Epedantic)?
                                                    На C/C++ пишут не только цари, которые каждое правило прочитали.
                                                    Ответить
                                                    • А зачем? Если из крестов убрать все UB — получим переусложнённый, кривой, многословный и тормозящий аналог Java/C#. Кресты с UB, конечно, и так переусложнённый, кривой и многословный аналог Java/C#, но хоть не тормозят (если прослойка между стулом и компилятором не тупит).
                                                      Ответить
                                                      • Для простоты есть DSLи. Для скорости есть ассемблеры.
                                                        C++ - язык высокого уровня общего назначения. Тут можно выбирать высокоуроневые "медленные" виртуальные методы или использовать невиртуальное быстроговно уровнем пониже.
                                                        Зачем использовать Java/C# с друним синтаксисом, встроенной виртуальной машиной, автоматически инстанцированными шаблонами вместо C++, если дело касается какой-то мелочи - такой же язык, только с перламутровыми пуговицами?

                                                        У нас не хватает конструкторов. Так же и с техникой: либо ты выбираешь телефон с NFC и плохой прошивкой камеры, либо без NFC с хорошей прошивкой камеры, либо с плохим GPS модулем и кнопками, либо с хорошим GPS модулем и без кнопок, и нельзя взять сразу со всем хорошим потому, что каждый производитель делает свои велосипеды, продвигает отдельные фичи и не может сделать всё и сразу хорошо. В случае с языками нет такой явной прибыли при переманимании всех на свой язык, можно объединиться и внести разные фичи и модульную сборку в один язык или в одну платформу (как F#, C#, JScript.NET в .NET).
                                                        Ответить
                                                        • DSL говно
                                                          Ответить
                                                        • «C++» позиционируется как быстрый язык для системного программирования.
                                                          C++ was designed with a bias toward system programming and
                                                          embedded, resource-constrained software and large systems, with
                                                          performance, efficiency¸ and flexibility of use as its design highlights.

                                                          (Страуструп)
                                                          Насчёт высокоуровневости — спорный вопрос. Собственно, чёткого определения «уровневости» языка пока ещё не придумали и, боюсь, не придумают.

                                                          > Зачем использовать Java/C# с друним синтаксисом, встроенной виртуальной машиной, автоматически инстанцированными шаблонами вместо C++, если дело касается какой-то мелочи - такой же язык, только с перламутровыми пуговицами?
                                                          Какой мелочи? C++ изначально спроектирован с оглядкой на оптимизацию посредством UB (вернее, посредством предположения того, что UB в программе не будет). Убираем из него UB — получаем тормозящее говно (причём последнее — вовсе не от убирания UB). А зачем писать на тормозящем говне, если можно выбрать тормозящее не-говно: хоть «C#», хоть «Python», хоть «JavaScript»?
                                                          И нет, я ни в коем разе не оправдываю UB: это, конечно, говно. Но это говно приходится кушать за то, что конпелятор делает хелловорлды на крестах быстрыми.

                                                          Честно говоря, не понял концепцию языков-конструкторов. Вот, например, я хочу компиляцию в мышиные коды (чтоб быстро!), Вася хочет собрать прогу в бандл once и run её everywhere, а Пете надо хуярить скрипты под Unity. И что с этим делать — пилить по бэкенду на каждый возможный случай?
                                                          Ответить
                                                          • > пилить по бэкенду на каждый возможный случай?
                                                            Почему бы и нет? Компиляторщики напилили 10 бэкэндов -
                                                            * 100000 проектов сэкономили на специалистах в других языках,
                                                            * 100000 проектов получили возможность перекомпилировать мышиные коды в run everywhere, когда мощности компьютеров повысились, а количество клиентов с устройствами нового типа увеличилось. Вкинуть 10000000 в разработку одного инструмента - дешевле, чем вкидывать 10000000000 в зарплаты программистов в 100000 проектах.

                                                            > получаем тормозящее говно
                                                            Ну и ладно.
                                                            > тормозящее не-говно
                                                            Надо учить. А если выучил тормозящее не-говно, но хочешь написать царский код, придётся заметно переучиваться. А так - включил компилятор в один режим - и он скомпилирует логичный, но медленный код; переключил в другой - и будут ошибки компиляции, исправив которые, можно получить быстрый код.
                                                            Ответить
                                                            • Чем больше в продукте кода — тем больше ошибок. В гигантском мега-компиляторе с кучей опций их будет гигантское количество. Да что там говорить, даже в существующих конпеляторах j123123 с завидной регулярностью находит знатные баги.

                                                              > переключил в другой - и будут ошибки компиляции, исправив которые, можно получить быстрый код.
                                                              Дык в том-то и дело, что отлавливать и выдавать по ошибке на все UB попросту нереально. Вот есть у нас какое-нибудь
                                                              int fui(int a, int b) { return a + b; }

                                                              — в крестах с запрещённым UB оно компилироваться не будет (это, кстати, одно из самых ебанутых UB).
                                                              Или вот так:
                                                              int getPetuh(Petooshatnya *petooshatnya, size_t i) { return petooshatnya->petuhi[i]; }

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

                                                              По сути, компилятор с UB и компилятор без UB — это два совершенно разных продукта, пересекаться у них будут только парсеры. Впиливать функциональность одного во второй — только плодить баги и тратить ресурсы на поддержку. Разрабатывать отдельно — никому не нужно (кому нужен язык без UB — просто пишут на джавах).
                                                              Ответить
                                                              • Можно C/C++ компилировать в C/C++ с проверками, а потом компилировать обычный компилятором (по аналогии с GHC, который код на языке без UB компилирует в код на языке с UB).
                                                                Ответить
                                                                • Боюсь, C++ с проверками на UB будет тормозить так, что за время, пока он тормозит, можно будет ЖС выучить.
                                                                  Самый главный багор — это UB в переполнении интов. Чтобы от него избавиться — придётся каждую операцию с интами аккуратно заворачивать в обёрточки. Даже конпелятор с отсутствием оптимизаций на основе UB будет не так сильно тормозить.
                                                                  Ответить
                                                                  • Это может быть заделом на будущее. Выхлоп такого питуизатора сможет обрабатываться компиляторами будущего (если обратную совместимость не нарушат, лол), которые уже смогут убрать лишние проверки.
                                                                    Ответить
                                                                    • >Выхлоп такого питуизатора сможет обрабатываться компиляторами будущего
                                                                      Так уже есть WebAssembly и Emscripten.

                                                                      Я давно говорил что js нужно не расширять всякой сахарозной питушней, но наоборот сужать.

                                                                      Мне в asm.js нравится как они не никак не меняя язык фактически завезли в него явные 32-битные intы.

                                                                      А вместо нечитаемого байт-кода как у CLR или JVM получился няшный js.
                                                                      Ответить
                                                • Да
                                                  Серьезно, вы топите за эту хуйню только потому что где-то еще ее увидали. Она не имеет смысла сама по себе
                                                  Ответить
                                                  • > вы топите за эту хуйню только потому что где-то еще ее увидали. Она не имеет смысла сама по себе
                                                    Типа как умножению чисел обучили в школе, но если бы не обучили, оно бы не имело смысла, и можно было бы жить без него?
                                                    Ну или компьютеры. Увидали их люди и начали использовать, а сама по себе фигня "компьютер" не нужна, без неё жили 100500 лет?

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

                                                    Как работает естественный отбор решений? Человек видит несколько вариантов решения проблемы и выбирает наиболее удобный. Когда появляется новый вариант, процесс выбора повторяется. Если человек ранее нигде не увидал новое решение, он его и и не выберет.

                                                    Чем [1,2,3] + [4,5,6] == '1,2,3,4,5,6' удобнее [1,2,3] + [4,5,6] == [1,2,3,4,5,6], если рассматривать потребности для средней программы?
                                                    Лично мне первый вариант пригождался чуть менее, чем никогда, а вот конкатенацию я регулярно использую.
                                                    Ответить
                                                    • >Ничего само по себе не нужно, можно жить в мировом океане на этапе одноклеточных.
                                                      Непонятно, какое отношение это имеет к теме разговора
                                                      >Чем [1,2,3] + [4,5,6] == '1,2,3,4,5,6' удобнее [1,2,3] + [4,5,6] == [1,2,3,4,5,6], если рассматривать потребности для средней программы?
                                                      Тем что, перефразируя Линуса Торвальдса, это мотивирует людей никогда и нигде не пользоваться этим говном.
                                                      Этот вопрос принципиален для js. Такое поведение допустимо для питона где можно переопределить оператор, затем привести новый тип и переопределить оператор для него. В случае невозможности переопределения операторов если "+" для структуры, которая задается списком, однозначно определить нельзя(я уже привел в пример что это можно считать векторной суммой), то намного лучше иметь совсем неиспользуемый результат и не поощрять чужеродные для языка практики
                                                      Ответить
                                                      • Но это же маразм. Языки пишутся для того, чтобы на них было удобно программировать. «[1,2,3] + [4,5,6] == '1,2,34,5,6'» удобно для 0 программистов. «[1,2,3] + [4,5,6] == [1,2,3,4,5,6]» удобно для x > 0 программистов. Элементарная логика подсказывает, что должен быть выбран второй вариант.

                                                        Кстати, а почему тогда «+» для строк их конкатенирует? Может, я хочу получить строку, в которой каждый символ — это сумма чаркодов соответствующих символов из исходных строк? Неоднозначность! Чужеродная практика!
                                                        А почему «*» работает не в кольце вычетов по модулю 42? Хочу кольцо вычетов! Неоднозначность! Чужеродная практика! Запретить!
                                                        А почему Array.prototype.concat() создаёт новый массив, вместо in-place конкатенирования? Хочу инплейс! Чужеродно!

                                                        В общем, такая логика крайне ущербна и глупа.
                                                        Ответить
                                                        • Еще раз, операция "+" для массивов не определена. Никто не думал специально "а давайте строки конкатенируем". В таком контексте любые разговоры о пользе или логике лишены основания
                                                          >Кстати, а почему тогда «+» для строк их конкатенирует? Может, я хочу получить строку, в которой каждый символ — это сумма чаркодов соответствующих символов из исходных строк? Неоднозначность! Чужеродная практика!
                                                          Совершенно верно. Для строк есть String.prototype.concat. Думаю, это просто издержка дизайна или фича для "фанатов удобства"
                                                          >А почему «*» работает не в кольце вычетов по модулю 42? Хочу кольцо вычетов! Неоднозначность! Чужеродная практика! Запретить!
                                                          >А почему Array.prototype.concat() создаёт новый массив, вместо in-place конкатенирования? Хочу инплейс! Чужеродно!
                                                          Да-да, очень интересно
                                                          Ответить
                                                          • > Еще раз, операция "+" для массивов не определена.
                                                            Что мешало её определить?
                                                            > Никто не думал специально "а давайте строки конкатенируем"
                                                            Да-да, и именно поэтому «+» в жаваскрипте приводит оба аргумента к строкам и конкатенирует их. Ну, просто случайно так получилось.

                                                            > В таком контексте любые разговоры о пользе или логике лишены основания
                                                            Аргументируй, раз уж хочешь дискуссии.
                                                            Если какая-то часть языка бесполезна — значит, она лишняя. Следовательно, её необходимо либо сделать полезной ([1,2,3,4,5,6]), либо явно убрать (undefined/TypeError).
                                                            Ответить
                                                            • >Что мешало её определить?
                                                              Отсутствие понятие "перегрузка оператора"
                                                              >Да-да, и именно поэтому «+» в жаваскрипте приводит оба аргумента к строкам и конкатенирует их. Ну, просто случайно так получилось.
                                                              Именно так. Операция приведения типа и конкатенация - отдельны, зоть и выполняются неявно
                                                              >Аргументируй, раз уж хочешь дискуссии.
                                                              >Если какая-то часть языка бесполезна — значит, она лишняя. Следовательно, её необходимо либо сделать полезной ([1,2,3,4,5,6]), либо явно убрать (undefined/TypeError).
                                                              Сложение массивов - это не часть языка по причине невозможности переопределить операторы
                                                              Ответить
                                                              • Наркоман штоле?

                                                                Как пользовательская перегрузка операторов связана с поведением оператора по умолчанию?

                                                                Почему тогда 1+2 == 3 в жс, если перегрузки + для интов там нет?
                                                                Ответить
                                                                • Я уже писал об этом. Number - встроенный тип js. Операция "+" для номеров определена и может быть однозначно определена как арифметическая операция сложения.
                                                                  Array - не встроенный тип js, а потомок Object. В js невозможно определить оператор "+" для произвольного потомка встроенного типа. Рассказывать как охуенно можно определить "+" для Object надеюсь никто не хочет
                                                                  Ответить
                                                                  • >Рассказывать как охуенно можно определить "+" для Object надеюсь никто не хочет
                                                                    var pituh={valueOf:function(){return ""0xC0C0C0"}}
                                                                    
                                                                    console.log(+pituh)

                                                                    >для произвольного потомка встроенного типа
                                                                    Прототипы, не?
                                                                    Ответить
                                                                  • Причём тут потомки и +?
                                                                    Почему тогда String([1,2,3]) === '1,2,3', а не '[object Object]'?

                                                                    Array - не какой-то пользовательский тип, а встроенный в язык тип! Поведение для него может быть прописано отдельно без упоминания хуерархий классов. Более того, для того, чтобы он не тормозил, в обход абстракций жс ключи массива должны физически быть интами.
                                                                    Ответить
                                                                    • >Почему тогда String([1,2,3]) === '1,2,3', а не '[object Object]'?
                                                                      Потому что toString и valueOf это методы, которые можно переопредеелить, как и конструктор string
                                                                      >Array - не какой-то пользовательский тип, а встроенный в язык тип!
                                                                      Это неправда
                                                                      >Поведение для него может быть прописано отдельно без упоминания хуерархий классов.
                                                                      Как и для любого класса - наследника. в с# тоже все объекты - наследники object, но их поведение можно спокойно переопределить
                                                                      >Более того, для того, чтобы он не тормозил, в обход абстракций жс ключи массива должны физически быть интами.
                                                                      Детали реализации не имеют отношения к теме разговора.
                                                                      Ответить
                                                                      • >>Array - не какой-то пользовательский тип, а встроенный в язык тип!
                                                                        >Это неправда
                                                                        22.1 Array Objects
                                                                        Array objects are exotic objects that give special treatment to a certain class of property names. See 9.4.2 for a definition
                                                                        of this special treatment.

                                                                        > Как и для любого класса - наследника. в с# тоже все объекты - наследники object, но их поведение можно спокойно переопределить
                                                                        Так мы об этом и говорили: поведение + для массивов можно было спокойно переопределить.
                                                                        Ответить
                                                                        • >Array objects are exotic objects that give special treatment to a certain class of property names. See 9.4.2 for a definition
                                                                          of this special treatment.
                                                                          Я не понимаю какое отношение это имеет к тому, что Array - это не встроенный тип, а наследник Object
                                                                          >Так мы об этом и говорили: поведение + для массивов можно было спокойно переопределить.
                                                                          Нет, нельзя было. В с# есть перегрузка операторов, в js - нет
                                                                          Ответить
                                                                          • Почему тогда для String поведение плюса переопределено?
                                                                            Ответить
                                                                            • Я уже писал, что не согласен с этой механикой и считаю ее говном. Оправдывать никак не собираюсь
                                                                              Ответить
                                                                              • От того, что ты считаешь её говном, она не исчезает.
                                                                                Ответить
                                                                          • Стандарт упоминает Array и определяет его свойства.
                                                                            Класс Array встроен в язык.
                                                                            Не важно, он там проходит как наследник Object, или объявлен ещё одним "типом".

                                                                            Ещё раз спрашиваю, причём здесь пользовательская перегрузка операторов? Чтобы определить поведение оператора для любых двух типов, отдельно упомянутых в стандарте, не нужно разрешать пользователю перегружать его. Для этого нужно определить определение оператора в стандарте языка для нужных типов.
                                                                            Ответить
                                                                            • >Стандарт упоминает Array и определяет его свойства.
                                                                              Класс Array встроен в язык.
                                                                              Не важно, он там проходит как наследник Object, или объявлен ещё одним "типом".
                                                                              От этого он отдельным типом не становится.
                                                                              >Чтобы определить поведение оператора для любых двух типов, не нужно разрешать пользователю перегружать его.
                                                                              Конкретно для Array - нужно, так как это не тип
                                                                              В общем случае - можно что угодно со стандартом сделать, непонятно правда, зачем
                                                                              Ответить
                                                                              • > Конкретно для Array - нужно, так как это не тип
                                                                                Не нужно, это даже я могу сделать. Берём параграф 12.8.3.1 и изменяем его (я его изменил, не надо этого искать в Стандарте!) вот таким образом:
                                                                                1. Let lref be the result of evaluating AdditiveExpression.
                                                                                2. Let lval be ? GetValue(lref).
                                                                                3. Let rref be the result of evaluating MultiplicativeExpression.
                                                                                4. Let rval be ? GetValue(rref).
                                                                                5. Let lprim be ? ToPrimitive(lval).
                                                                                6. Let rprim be ? ToPrimitive(rval).
                                                                                7. If Type(lprim) is String or Type(rprim) is String, then
                                                                                    a. Let lstr be ? ToString(lprim).
                                                                                    b. Let rstr be ? ToString(rprim).
                                                                                    c. Return the string-concatenation of lstr and rstr.
                                                                                8. If Type(lprim) is Array and Type(rprim) is Array, then
                                                                                    a. Return an array containing the array elements of the lprim followed by the array elements of lprim.
                                                                                9. Let lnum be ? ToNumber(lprim).
                                                                                10. Let rnum be ? ToNumber(rprim).
                                                                                11. Return the result of applying the addition operation to lnum and rnum. See the Note below 12.8.5.

                                                                                Вуаля, теперь [1, 2, 3] + [4, 5, 6] == [1, 2, 3, 4, 5, 6].
                                                                                Ответить
                                                                  • > Array - не встроенный тип js, а потомок Object. В js невозможно определить оператор "+" для произвольного потомка встроенного типа.
                                                                    Правда?
                                                                    BigInt(100) + BigInt(200)
                                                                    300n
                                                                    BigInt instanceof Object
                                                                    true
                                                                    Ответить
                                                                    • Ты сейчас троллишь? Или на полном серьезе вызываешь instanceof конструктора?
                                                                      Ответить
                                                                      • Это я туплю. Но, например, String — это таки потомок Object. И для него перегружен плюс.
                                                                        Ответить
                                                                        • Ты не знаешь о чем говоришь. String - это функция, как и BigInt. Советую создать объект, а потом использовать instanceof
                                                                          Ответить
                                                                          • var str1 = new String("Huj");
                                                                            undefined
                                                                            var str2 = new String("Huj2");
                                                                            undefined
                                                                            str1 + str2;
                                                                            "HujHuj2"
                                                                            str1 instanceof Object
                                                                            true

                                                                            Создал, проверил.
                                                                            Ответить
                                                              • >Отсутствие понятие "перегрузка оператора"

                                                                В js есть "перегрузка операторов".
                                                                Допустим унарный плюс переопределяется на раз.
                                                                Ответить
                                                              • > Отсутствие понятие "перегрузка оператора"
                                                                Что мешало его определить?

                                                                > Именно так. Операция приведения типа и конкатенация - отдельны, зоть и выполняются неявно
                                                                >> Никто не думал специально "а давайте строки конкатенируем".
                                                                Это предложение неверное. Эйх специально подумал о конкатенации строк. Операция «+» специально кастует оба аргумента в строку, а потом конкатенирует их. Это продуманная часть языка. И она — говно.

                                                                > Сложение массивов - это не часть языка по причине невозможности переопределить операторы
                                                                Мы обсуждаем дизайн языка, а именно то, что поведение плюса в JS — говно. Даже если Эйх не осилил перегрузку операторов, заставлять плюс приводить произвольные аргументы к строкам и конкатенировать их — идея откровенно идиотская, поскольку не приносит ровным счётом ничего полезного. Куда более адекватным поведением был бы возврат «undefined» для любых типов, для которых сложение не (может быть) определено.
                                                                Ответить
                                                          • Операция "+" для массивов определена в стандарте языка.
                                                            Плохие практики прикрывают исключениями или объявляют UB.

                                                            Сделан плюс из желания помочь разработчику. Аналогично с '2'-1, чтобы программисту легче было взять число из формочки и применить к нему формулу. Просто не был продуман.

                                                            Есть в жс вещи вроде прототипов, которые сообщество оопитушков не понимает, есть двоякие '1'+1, которые иногда помогают, а иногда мешают, но питушня вроде []+[] - бесполезная с 99.999% случаях хрень, для которой в жизни есть альтернативы. Даже если бы было Object.prototype.toString = JSON.stringify;, уже плюс стал бы более полезным.
                                                            Ответить
                                                            • >Операция "+" для массивов определена в стандарте языка.
                                                              линк на параграф стандарта?
                                                              >Сделан плюс из желания помочь разработчику. Аналогично с '2'-1, чтобы программисту легче было взять число из формочки и применить к нему формулу. Просто не был продуман.
                                                              Это неправда. Во всех этих примерах первым и ключевым являются механики приведения типа. Приведение строки к числу и непосредственное вычитание - это разные операции которые необязательно были продуманы для работы вместе
                                                              >Есть в жс вещи вроде прототипов, которые сообщество оопитушков не понимает, есть двоякие '1'+1, которые иногда помогают, а иногда мешают, но питушня вроде []+[] - бесполезная с 99.999% случаях хрень, для которой в жизни есть альтернативы. Даже если бы было Object.prototype.toString = JSON.stringify;, уже плюс стал бы более полезным.
                                                              Не лепи вместе toString и "+"
                                                              Ответить
                                                              • 12.8.3 The Addition Operator ( + )
                                                                12.8.3.1 Runtime Semantics: Evaluation
                                                                и далее по ссылкам

                                                                > Во всех этих примерах первым и ключевым являются механики приведения типа. Приведение строки к числу и непосредственное вычитание - это разные операции которые необязательно были продуманы для работы вместе
                                                                Для строк и чисел были продуманы, для массивов - не очень
                                                                > Не лепи вместе toString и "+"
                                                                Шта? В языке они уже слеплены.
                                                                Ответить
                                                                • >12.8.3 The Addition Operator ( + )
                                                                  >12.8.3.1 Runtime Semantics: Evaluation
                                                                  >и далее по ссылкам
                                                                  В параграфе не определена операция "+" для массивов
                                                                  >Для строк и чисел были продуманы, для массивов - не очень
                                                                  Это правда, но утверждение ни имеет никакого смысла
                                                                  >Шта? В языке они уже слеплены.
                                                                  Это тоже неправда. Приведение типов используется много где, "+" как бинарный оператор определен только для строк и чисел
                                                                  Ответить
                                                                  • > В параграфе не определена операция "+" для массивов
                                                                    В параграфе определена операция «+» для любых типов. Включая массив.
                                                                    Ответить
                                                                    • >В параграфе определена операция «+» для любых типов. Включая массив.
                                                                      Это неправда. Параграф определяет механику приведения типов для дальнейшего сложения. Ничего о самой механике сложения не говорится
                                                                      Ответить
                                                                      • > Ничего о самой механике сложения не говорится
                                                                        Let lref be the result of evaluating AdditiveExpression.
                                                                        Let lval be ? GetValue(lref).
                                                                        Let rref be the result of evaluating MultiplicativeExpression.
                                                                        Let rval be ? GetValue(rref).
                                                                        Let lprim be ? ToPrimitive(lval).
                                                                        Let rprim be ? ToPrimitive(rval).
                                                                        If Type(lprim) is String or Type(rprim) is String, then
                                                                        Let lstr be ? ToString(lprim).
                                                                        Let rstr be ? ToString(rprim).
                                                                        Return the string-concatenation of lstr and rstr.
                                                                        Let lnum be ? ToNumber(lprim).
                                                                        Let rnum be ? ToNumber(rprim).
                                                                        Return the result of applying the addition operation to lnum and rnum.


                                                                        > Return the string-concatenation of lstr and rstr.
                                                                        > Return the result of applying the addition operation to lnum and rnum.
                                                                        Это я специально выделил. Или «возвратить результат конкатенации строк lstr и rstr» — это не «механика сложения»?
                                                                        Ответить
                                                                        • >Это я специально выделил. Или «возвратить результат конкатенации строк lstr и rstr» — это не «механика сложения»?
                                                                          Да, все верно. Для примера, механика операции сложения определена в параграфе 12.8.5, механика конкатенации в стандарте не приведена. То что ты процитировал это все еще механика приведения типов
                                                                          Ответить
                                                                          • > механика конкатенации в стандарте не приведена
                                                                            Правда штоле?
                                                                            6.1.4
                                                                            In this specification, the phrase "the string-concatenation of A, B, ..."
                                                                            (where each argument is a String value, a code unit, or a sequence of code units)
                                                                            denotes the String value whose sequence of code units is the concatenation
                                                                            of the code units (in order) of each of the arguments (in order).


                                                                            > То что ты процитировал это все еще механика приведения типов
                                                                            Заканчивай толстить, это уже слишком жирно.
                                                                            Ответить
                                                                            • >В стандарте ES2019, по данному адресу https://www.ecma-international.org/ecma-262/10.0/index.html#sec-ecmascript-data-types-and-values не определена. Ты используешь не тот стандарт
                                                                              >Заканчивай толстить, это уже слишком жирно.
                                                                              Напомню, что ты пытался мне набросить instanceof конструктора, так что уж точно не тебе меня учить как трактовать стандарт моего основного рабочего языка
                                                                              Ответить
                                                                              • Именно тот. Параграф 6.1.4, последний абзац. Ты не можешь прочитать стандарт своего основного рабочего языка? Или, например, нажать «Ctrl+F» и ввести в появившееся окошечко «the string-concatenation of A, B,»?
                                                                                Ответить
                                                        • >Кстати, а почему тогда «+» для строк их конкатенирует?
                                                          Правильный вопрос.

                                                          "123" + "456" = "123456"
                                                          "123" - "456"   = -333

                                                          Какая-то неправильная метаматика.
                                                          Ответить
                                                      • >Такое поведение допустимо для питона где можно переопределить оператор

                                                        В js тоже можно переопределить оператор.

                                                        Array.prototype.toString = function(){return "123"}
                                                        Ответить
                                                        • toString - это не оператор. Переопредели оператор void, например
                                                          Ответить
                                                          • А унарный плюс — это оператор? Или нет?
                                                            Ответить
                                                            • Унарный плюс - это оператор. Его переопределить нельзя. Переопределение valueOf - это просто трюк, который к оператору не имеет никакого отношения
                                                              Ответить
                                                              • >Унарный плюс - это оператор.
                                                                >Его переопределить нельзя.
                                                                >Переопределение valueOf - это просто трюк, который к оператору не имеет никакого отношения

                                                                Н-н-нооо как же тогда изменяется результат его выполнения?
                                                                Если «не имеет никакого отношения».
                                                                var pituh={}
                                                                console.log(+pituh) //NaN
                                                                pituh.valueOf=function(){return "0xC0C0C0"}
                                                                console.log(+pituh) //12632256

                                                                Разве это не есть искомое Переопределение?
                                                                Ответить
                                                                • Унарный оператор "+" вызывает метод valueOf. Ты изменяешь метод, и ничего не делаешь с самим оператором. Что такого сложного?
                                                                  Ответить
                                                                  • И что? В питоне тоже нельзя переопределить оператор +, но в numpy за счёт какой-то магии работает сумма многомерных массивов
                                                                    Ответить
                                                                    • Дискуссия выливается в то, что js - говно потому что это не питон. Замечательно
                                                                      Ответить
                                                                      • Причём здесь это? Я говорю, в питоне нельзя никак определить оператор плюс и в жс нельзя никак определить оператор плюс, но фактически поведение плюса меняется.
                                                                        Ответить
                                                                        • По поводу поведения плюса я уже писал. Number - отдельный тип, как и String. Для них в стандарте определено сложение. Array не является отдельным типом, и определить сложение для него невозожно
                                                                          Ответить
                                                                          • Во-первых, определи понятие «отдельный тип». В Стандарте такого нет.
                                                                            Во-вторых, определить сложение можно для чего угодно: достаточно написать в стандарте строчку «для объектов типа huj операция + возвращает объект типа cock».
                                                                            Ответить
                                                                            • >Во-первых, определи понятие «отдельный тип». В Стандарте такого нет.
                                                                              Пункт 6.1 стандарта
                                                                              >Во-вторых, определить сложение можно для чего угодно: достаточно написать в стандарте строчку «для объектов типа huj операция + возвращает объект типа cock».
                                                                              Конечно можно. Только нахуя раздувать стандарт?
                                                                              Ответить
                                                                              • > 7.1.1 ToPrimitive
                                                                                > Of the objects defined in this specification only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.5) over-ride the default ToPrimitive behaviour. Date objects treat no hint as if the hint were String.

                                                                                Date тоже не входит в святое множество типов из 6.1, но реализует кастомную питушню для ToPrimitive без какого-либо использования возможности задания этой кастомной питушни пользователем.
                                                                                Ответить
                                                                                • ToPrimitive - это метод, а не оператор
                                                                                  Ответить
                                                                                  • Вообще, это абстрактная операция, но какая разница. Метод, операция или оператор, всё это какое-то отображение из декартова произведения исходных типов в конечный тип, за которыми стоят процедуры и машинный код.
                                                                                    Ответить
                                                                                    • Мы обсуждаем дизайн языка. Если в дизайне языка не предусмотрено переопределение оператора, то разница между методом и оператором в разрезе языка становится ощутимой
                                                                                      Ответить
                                                                                      • Переопределить (в терминах bootcamp_dropout) абстрактную операцию ToPrimitive нельзя. Она жёстко задана в 7.1.1 ToPrimitive. Можно повлиять на MyClass.prototype[Symbol.toPrimitive], но это
                                                                                        1. только метод, который используется внутри стандартной реализации ToPrimitive (сам ToPrimitive не меняется) и
                                                                                        2. результат ToPrimitive для не-объектов не может поменяться при определении, скажем, Number.prototype[Symbol.toPrimitive].

                                                                                        То есть пользователю ToPrimitive перегружать нельзя, а для Date смогли описать реализацию. С операторами то же самое. Пользователю явно перегружать не дают, есть возможность повлиять, авторы стандарта могут вписать кастомизацию для каких-угодно случаев.
                                                                                        Ответить
                                                                                        • Из той же сноски:
                                                                                          "However, objects may over-ride this behaviour by defining a @@toPrimitive method."
                                                                                          Пользователю можно перегрузить ToPrimitive
                                                                                          Ответить
                                                                                          • Абстрактная операция ToPrimitive вызывает метод, располагающийся по ключу "хорошо известный символ @@toPrimitive":
                                                                                            > 6.1.5.1 Well-Known Symbols
                                                                                            > @@toPrimitive "Symbol.toPrimitive" A method that converts an object to a corresponding primitive value. Called by the ToPrimitive abstract operation

                                                                                            А в той сноске вообще написано, что определение @@toPrimitive может переопределить поведение "хинт - это число":
                                                                                            > When ToPrimitive is called with no hint, then it generally behaves as if the hint were Number. However, objects may over-ride this behaviour by defining a @@toPrimitive method.

                                                                                            @@toPrimitive - метод, ToPrimitive - абстрактная операция.
                                                                                            ToPrimitive вызывает @@toPrimitive, алгоритм ToPrimitive не меняется.
                                                                                            Ответить
                                                                                            • Да, я это написал к тому что мне кажется что для Date ToPrimitive переопределен именно как метод
                                                                                              Ответить
                                                                                              • > NOTE
                                                                                                > When ToPrimitive is called with no hint, then it generally behaves as if the hint were Number. However, objects may over-ride this behaviour by defining a @@toPrimitive method. Of the objects defined in this specification only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.5) over-ride the default ToPrimitive behaviour. Date objects treat no hint as if the hint were String.

                                                                                                В том же куске текста, который мы тут рассасываем, пишут, что они поведение самой ToPrimitive изменяют.
                                                                                                Ответить
                                                                                                • Это не очень существенное изменение и реализуемо средствами языка. Об этом там и речь, мол "переопределяя метод можно изменить поведение, из стандартных объектов это делают Date и Symbol"
                                                                                                  Ответить
                                                                                          • И вообще, что я хотел сказать, тут ситуация ровно та же, что и с valueOf
                                                                                            1. что valueOf, что @@toPrimitive работает только для Object
                                                                                            2. что определение valueOf, что @@toPrimitive влияет на выполнение какой-то другой операции.
                                                                                            Ответить
                                                                              • Стандарт уже раздут и постоянно раздувается. Если туда внесли Symbol (сделав его святым типом из 6.1), без которого были более важные проблемы, то более адекватное поведение операторов никому бы не повредило.
                                                                                Кстати, я бы заодно туда сравнение для Date ввёл.
                                                                                Ответить
                                                                                • Я думаю что более важной проблемой будет отказ от обратной совместимости.
                                                                                  >Кстати, я бы заодно туда сравнение для Date ввёл.
                                                                                  Оно же и так реализовано за счет приведения к unix timestamp
                                                                                  А вообще я за momentjs
                                                                                  Ответить
                                                                                  • > Оно же и так реализовано за счет приведения к unix timestamp
                                                                                    Частично.
                                                                                    Если сравнивать через <, <=, >=, >, работает каст в число и unix timestamp.
                                                                                    Если сравнивать через ==, !=, работает поведение ==, != для Object со сравнением по ссылке, которое выдаст falsee у двух разных объектов с одинаковым unix timestamp.
                                                                                    Ответить
                                                                              • > Пункт 6.1 стандарта
                                                                                Принимается.
                                                                                > Конечно можно. Только нахуя раздувать стандарт?
                                                                                А нахуя в стандарте такая неадекватная процедура сложения? Её можно переписать так, чтобы она, во-первых, была существенно короче и проще, а во-вторых — более адекватной. Как-нибудь вот так:
                                                                                12.8.3.1
                                                                                1. Let lref be the result of evaluating AdditiveExpression.
                                                                                2. Let lval be ? GetValue(lref).
                                                                                3. Let rref be the result of evaluating MultiplicativeExpression.
                                                                                4. Let rval be ? GetValue(rref).
                                                                                5. If Type(lval) is not Number or Type(rval) is not Number, throw a TypeError exception.
                                                                                6. Return the result of applying the addition operation to lval and rval.
                                                                                Ответить
                                                                                • >А нахуя в стандарте такая неадекватная процедура сложения?
                                                                                  Я согласен с тем что это хуйня. Но изменить что-то уже вряд ли можно из-за обратной совместимости
                                                                                  Ответить
                                                                                  • Но именно из-за этой хуйни и получается производная хуйня вроде "10" + 5 == "105" и [1,2] + [3,4] == "1,23,4", которую надо выпилить к хуям. Но обратная совместимость такого финта ушами не позволит, да.
                                                                                    Ответить
                                                                                  • 'use strict' же сделали
                                                                                    можно сделать 'use stricter'
                                                                                    ещё останется 'use strictest' для случая, если 'use stricter' не всё говно запретит
                                                                                    Ответить
                                                                          • А Array.prototype.map почему работает для массива, но не для объекта, если Array - это Object?

                                                                            Почему вдруг невозможно описать в стандарте поведение сложения для массива? Религия не позволяет?
                                                                            Ответить
                                                                            • Потому что Array.prototype.map это метод а не оператор
                                                                              >Почему вдруг невозможно описать в стандарте поведение сложения для массива? Религия не позволяет?
                                                                              Именно так. Лично я считаю что нахуй не надо
                                                                              Ответить
                                                                      • JS — говно, потому что поведение плюса в нём — говно.
                                                                        Ответить
                                                          • >Переопредели оператор void

                                                            Вот только надо трогать святой void грязными лапами.
                                                            Это практически единственная инвариантная вещь жса.
                                                            Которая спасает от
                                                            var undefined=42;
                                                            Ответить
                                                    • >> [1,2,3] + [4,5,6] == '1,2,34,5,6'
                                                      fixed.
                                                      Ответить
                                            • > Только эксепшон ты получишь сразу же, как только нажмёшь F5
                                              > А непонятная хуйня может годами сидеть в системе, по-тихому портя данные клиентов.
                                              Сразу же, как только нажмёшь F5 и воспроизведёшь хитрожопую ситуацию, в которой возникает исключение.
                                              Ответить
                                      • > Вот, можешь использовать во всех кодовых базах
                                        Как-то раз Пи уже показывал, что JS прекрасен как конструктор языков.
                                        Осталось только написать фреймворки высокого уровня, которые перехреначивают прототипы и делают для JS поведение
                                        * со строгой питуизацией как в python
                                        * со слабой типизацией и полезными результатами как в python
                                        * с кучей математических фич как в Matlab
                                        Ответить
                                    • > Не существует реальных примеров кейсов, в которых такое идиотское поведение можно использовать.
                                      +1

                                      Ну разве что для редких тестов использовать.
                                      Ответить
                            • обявляю операцию "+" как произведение! и ниибет
                              Ответить
                        • > typeof не обязана быть обратной от instanceof
                          Э, "обратная операция" - это совсем другое. Корень и степень - взаимно обратные операции на R+. А typeof и instanceof - как sin и cos - две стороны одной медали.

                          Однако, typeof null === 'object' - старое говно, которое давно пора было бы убрать хотя бы в strict mode.
                          Ответить
                          • Обратная операция к typeof - new.
                            Ответить
                          • >typeof и instanceof - как sin и cos
                            схуяб?

                            При X=typeof(N) я ожидаю истинность instanceof(X, N).

                            Если X есть тип N, то X есть инстанс N.

                            Так работает примерно во всех нормальный языках, включая джаву, откуда instanceof было спижжено
                            Ответить
                            • Где обратность операции?

                              Вот Борманд более логичное написал про new.
                              typeof :: Value -> Type
                              new    :: Type  -> Value


                              > ты скажешь, что typeof не обязана быть обратной от instanceof
                              Даже если считать, что 'number' === Number. Или вовсе считать, что Number === 1 === 2 === ...,
                              typeof(instanceof(Number, 2)) != Number
                              typeof(instanceof(Number, 2)) != 'number'
                              typeof(instanceof(Number, 2)) != 2

                              Где хоть что-то намекающее на обратность?
                              Ответить
                              • Кстати, а что не так с «typeof null = Object»? По-моему, это наоборот логично. Тип пустого объекта — «объект».
                                Ответить
                                • В стандарте под null выделен отдельный тип Null, так что по-хорошему typeof null должен возвращать null
                                  Ответить
                    • Большинство людей привыкло к коммутативности операции умножения. Следовательно, поведение матриц для них неождианно.
                      Неождианное поведение это всегда изьян.
                      Ответить
    • >как правильно проверять на эквивалентность floating point numbers

      На самом деле этого точно не знает никто.
      Ответить
      • bool operator == (const double x, const double y)
        {
            return y < x + 10E-7 && y > x - 10E-7;
        }
        Ответить
        • Почему именно 10E-7? Не будет ли этот допуск слишком большим, если x == 1E-30?
          Ответить
          • Погрешность опциональна, я привел лишь пример.
            Ответить
            • Тебя ещё не завербовало ЦРУ?
              Ответить
            • > На самом деле этого точно не знает никто.
              Ответить
            • Ну вот, как начнём копать, выясняется, что алгоритм нужно дорабатывать.

              Допуск должен быть пропорционален абсолютному значению аргумента. Только какого: большего или меньшего или их среднему значению?

              Когда аргумент близок к нулю, дальше уменьшать допуск дальше мы не можем, иначе можем получить неадекватный результат. Значит, нужно ограничить минимальное значение допуска.

              На следующем шаге получим что-то типа такого:
              bool operator == (const double x, const double y)
              {
                  return fabs(x - y) < max(epsilon1, epsilon2 * min(fabs(x), fabs(y)));
              }

              Ничего не забыл или алгоритм нужно ещё доработать?
              Ответить
              • >Когда аргумент близок к нулю, дальше уменьшать допуск дальше мы не можем, иначе можем получить неадекватный результат. Значит, нужно ограничить минимальное значение допуска.

                Я бы этой антицарской и тормозной хуйнёй не занимался.

                А просто бы вычел их как целые и наложил бы маску на нижние биты.

                > return fabs(x - y) < max(epsilon1, epsilon2 * min(fabs(x), fabs(y)));

                Фууууу. Ну питушня же анскилозная. Какое УМНОЖЕНИЕ )))
                typedef union{
                        double     d;
                        unsigned ui;	    
                	unsigned ef : 63;
                } Unskiloza;
                
                bool eq(const double x, const double y)
                
                {
                     Unskiloza ux={x},uy={y};
                     return 
                       (ux.ef==0 && uy.ef==0                   )       //for ±0
                       ( 0== (ux.ui-uy.ui) & 0x7FFFFFFFFFFFF000L );
                }


                Выделенные жырным нули и есть ворецируемый эпсилон.
                Ответить
                • Эта формула работает при условии, что порядки совпадают.

                  Если они разные, придётся мантиссу одного из чисел сдвигать.
                  Ответить
                  • > работает при условии, что порядки совпадают
                    Если числа отличаются НА ПОРЯДОК, то эпсилон уже не нужен.

                    >Если они разные
                    То и числа разные :)

                    Рабоать она не будет работать с числами разного знака около нуля и NaNaми.
                    Но это легко поправить 2-3 доп. условиями
                    Ответить
                    • 0,999999 и 1,000000 отличаются НА ДЕСЯТИЧНЫЙ ПОРЯДОК, т. к. 0,999999 — это 9,99999 × 10^(-1), а 1,000000 — это 1,000000 × 10^0.

                      Такой же пример можно придумать и для двоичных порядков.
                      Ответить
                      • >Такой же пример можно придумать и для двоичных порядков.

                        Вычитание вынесет 1 бит разницы в порядках в младшие разряды.
                        А там её схавает битовая маска.

                        В противном случае разница между числами слишком велика.
                        Ответить
                        • В армию, сука!
                          Ответить
                        • В приведённом примере вычитаются не исходные числа, а мантиссы. Чтобы он работал корректно, нужно либо вычитать исходные числа, либо перед вычитанием мантисс привести числа к одному порядку.
                          Ответить
                          • >В приведённом примере вычитаются не исходные числа, а мантиссы.

                            Ещё раз: вычитаются мантиссы И порядки. Как одно число.
                            В этом заключается царское изящество данного способа.

                            Причём он работает независимо от порядка чисел.
                            https://ideone.com/wTnBMz

                            Казалось бы, абсолютная разница числе составляет ЦЕЛУЮ единицу.
                            Однако вычитание нивелирует её в младшие разряды.
                            x.d = 40000000000000;
                              y.d = 39999999999999;
                            
                            x.ui =  0x42c2309ce5400000
                            y.ui =  0x42c2309ce53fff80
                            (x.ui - y.ui) ? mask =  0
                            x.ui - y.ui =  128
                            x - y =  1.00e+00
                            Ответить
                        • Я вот о чём:
                          #include <stdio.h>
                          #include <inttypes.h>
                          
                          #pragma pack(push, 1)
                          typedef union{
                                  double     d;
                                  uint64_t ui;	    
                          } Unskiloza;
                          #pragma pack(pop)
                          
                          
                          int main() {
                            Unskiloza x, y;
                            x.d = 4.0000000001;
                            y.d = 3.9999999999;
                          
                            printf("x.ui =  %lld\n", x.ui);
                            printf("y.ui =  %lld\n", y.ui);
                            printf("x.ui - y.ui =  %lld\n", x.ui - y.ui);  // 337770
                            printf("x - y =  %0.2e\n", x.d - y.d);         // 2.00e-010
                          
                            printf("x (hex) =  %0.16a\n", x.d);            // 0x1.000000001b7ce000p+2
                            printf("y (hex)  =  %0.16a\n", y.d);           // 0x1.ffffffffc9064000p+1
                          
                            return 0;
                          }


                          Между 4.0000000001 и 3.9999999999 разность равна 2E-10. Это довольно маленькое число.

                          Однако, в шестнадцатеричном представлении
                          4.0000000001 = 0x1.000000001b7ce000p+2
                          3.9999999999 = 0x1.ffffffffc9064000p+1

                          Поскольку IEEE754 для нормализованных чисел не хранит ведущую единицу, мантиссы будут храниться как 0x000000001b7ce и 0xffffffffc9064 соответственно (т. е. как совершенно непохожие числа), а порядки будут отличаться на единицу.
                          Ответить
                          • Чтобы уравнять порядки, нужно сдвинуть первую мантиссу влево на единицу либо вторую вправо на единицу (предварительно добавив ведущую единицу).

                            Тогда:
                            4.0000000001 = 0x2.0000000036f9cp+1
                            3.9999999999 = 0x1.ffffffffc9064000p+1

                            Или:
                            4.0000000001 = 0x1.000000001b7cep+2
                            3.9999999999 = 0x0.ffffffffe4832p+2

                            Мантиссы 2.0000000036f9 и 1.ffffffffc9064000 либо 1.000000001b7ce и 0.ffffffffe4832 уже́ можно сравнивать.
                            Ответить
                            • >Между 4.0000000001 и 3.9999999999 разность равна 2E-10.
                              Ну правильно

                              И мантиссы как раз отличаются на 1.

                              x.ui =  0x401000000001b7ce
                              y.ui =  0x400ffffffffc9064
                              
                                printf("x.ui - y.ui =  %lld\n", x.ui - y.ui);  // 337770

                              Но разница уходит в младшие разряды. И получается довольно несущественной.
                              Ответить
                            • Собственно вот, сравнение работает, несмотря на разницу мантиссах.

                              https://ideone.com/kdVR1u
                              Unskiloza x, y;
                                x.d = 4.0000000000000; //0x4010000000000000
                                y.d = 3.9999999999999; //0x400fffffffffff1f
                              
                                printf("x.ui =  %#llx\n", x.ui);
                                printf("y.ui =  %#llx\n", y.ui);
                                printf("x.ui - y.ui =  %lld\n", (x.ui-y.ui) & 0x7FFFFFFFFFFFF000L);  // 0
                                printf("x.ui - y.ui =  %lld\n", (x.ui-y.ui) );  // 225


                              Для даблов, с их точностью 2.00e-010 это довольно большая мантисса.
                              Потому я взял 1e-013.
                              Впрочем можно просто увеличить число нулей в 0x7FFFFFFFFFFFF000L
                              Ответить
                          • Приведи реальный пример, когда эти знания пригодились тебе в работе.
                            Ответить
                          • >Поскольку IEEE754 для нормализованных чисел не хранит ведущую единицу, мантиссы будут храниться как 0x000000001b7ce и 0xffffffffc9064 соответственно (т. е. как совершенно непохожие числа), а порядки будут отличаться на единицу.

                            В этом весь смысл хака.
                            Вычитать и порядки ВМЕСТЕ с мантиссами. Как единое целое.

                            0x1000000001b7ce-0x0ffffffffc9064
                            Ответить
        • >проверять на эквивалентность floating point numbers

          Тут ещё большой вопрос что каждый понимает под «эквивалентностью».
          Лично мне кажется два флоата эквивалентны, если их битовые представления эквивалентны *.

          >bool operator ==
          А это я бы обозначил как «приблизительное равенство».

          * А NaNы сведены к одному фиксированному значению.
          Ответить
          • +0 и -0 будем считать разными числами?

            А ещё у плавпитуха бывают денормализованные числа. Когда порядок слишком маленький (иногда это называют underflow в противоположность overflow), включается второй формат битового представления: в мантиссе больше не подразумевается ведущая единица. Я не помню, пересекаются ли множества нормализованных и денормализованных (нужно проверять). Если вдруг они пересекаются, то нормализованное и денормализованное представление одного и того же числа будем считать разными числами?
            Ответить
            • Ага. Я хотел дописать что неплохо бы нормализовать перед сравнением, но 5 минут кончились.

              >+0 и -0 будем считать разными числами?
              Я бы не сказал что они разные. Но они явно неэквивалентные.
              Текстовое представление ведь различается.

              >нормализованное и денормализованное представление одного и того же числа будем считать разными числами?
              См. начало ветки:
              http://govnokod.ru/26263#comment516271
              «на самом деле этого точно не знает никто»
              Ответить
            • Вроде они не должны пересекаться. Подставляя специальную экспоненту (вроде EXP=EXP_MIN-1), можно математически реализацию легко подогнать под такие условия:
              1XXXXXX*2^EXP_MIN (EXP=EXP_MIN) нормализованное
              0XXXXXX*2^EXP_MIN (EXP=EXP_MIN-1) денормализованное
              Ответить
    • что же из этого сишник увидит логичным? что инты в флоате хранят?
      Ответить
    • Именно поэтому я за "JS"
      Кресты для быдла
      Ответить
    • А в J флоаты сравнивают с погрешностью:
      0.3 = 0.2 + 0.1
      1
         NB. погрешность можно настроить
         0.3 =!.(1e_16) 0.2 + 0.1
      0
      Именно поэтому я за 'J'.
      Ответить
      • А PHP циклы по флоатам нормально работают без этой вашей питушни.

        https://www.php.net/manual/en/reserved.constants.php

        PHP_FLOAT_EPSILON (float)
            Smallest representable positive number x, so that x + 1.0 != 1.0. Available as of PHP 7.2.0.


        Именно поэтому я за «PHP».
        Ответить
        • PHP_FLOAT_EPSILON не про это. Оно про размер мантиссы.
          Ответить
          • Как раз про это.
            Чтобы флоат циклы по целым числам не ломались.
            Ответить
            • PHP_FLOAT_EPSILON всего лишь гарантирует, что если x > PHP_FLOAT_EPSILON, то 1.0 + x > 1.0.

              В более общем случае если y > 0, z > y*PHP_FLOAT_EPSILON, то y + z > y.

              Всё, больше ничего оно не гарантирует.

              В «PHP» нет гарантий, что 0.3 + 0.7 === 1.0.

              В «PHP» нет гарантий, что 100000.0 + 500.0 === 100500.0.
              Ответить
      • А я против
        Ответить
    • И да,
      Ещё забыли про
      typeof null
      0.1 + 0.2
      Ответить
      • «typeof» Пророк объявил говном.
        Ответить
        • Анаши шоль накурилсиа?
          Ответить
        • >«typeof» Пророк объявил говном.
          на дваче написал?
          Ответить
          • 'We have reason to believe typeof null === “object” is a bug that could bite real content, from our spidering of the web.'
            Все ссылки ведут на какой-то говносайт, который у меня нет открывается, так что да, на дваче
            Ответить
          • на сосаче
            Ответить
    • >JS макаки без должного математического образования
      И сколько за него прибавят к зарплате?
      Ответить
    • всем спокойно ... я пишу транспайлер что бы TypeScript в C++ перегонял. так что все будут довольны
      Ответить
      • Кто эти "все"? Как это их спасёт от "JS"?
        Ответить
        • Все пользователи софта, написанного на «JavaScript». Тем, что софт будет написан на «C++».
          Ответить
    • https://pbs.twimg.com/media/ELrdxljXkAAZBej.jpg:large
      Ответить
    • Нарисуйте мне язык с резиновой памятью, который не течет сам от себя.
      Ответить
      • а че не с памятью "альцгеймера".. прикиньте сколько AI логик можно будет на ней реализовать :)
        Ответить
    • https://govnokod.ru/20003#comment327042
      Ответить
    • Питушня какая-то. Математическое образование нужно, чтобы уверовать в Math.min() = +Infinity? Math.min() мог бы возвращать NaN или бросать исключение. Лично я за NaN.
      В остальном это лишь говно программирования, в котором привыкли купаться сраные сишники.

      Вот увидите, когда выйдут ЯПы нового поколения, старые жсники будут топить за typeof null === 'object', [1]+[1] = '1,2' и прочее логичное говно как сейчас сишники объясняют, что 0.1 + 0.2 != 0.3 - логично только потому, что прошло достаточно много времени с того момента, как эта "фича" была добавлена в плавающего питуха.

      Сейчас только время возникновения разделяет 0.1 + 0.2 != 0.3 и [1]+[1] = '1,2'. К 0.1 + 0.2 != 0.3 все давно привыкли, а [1]+[1] = '1,2' - всё ещё новое. Но фактически всё это - говно.
      И если числа реализовали через задницу, то 0.1 + 0.2 != 0.3 для адекватного человека никогда не станет логичным.
      Ответить
      • >И если числа реализовали через задницу, то 0.1 + 0.2 != 0.3 для адекватного человека никогда не станет логичным.

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

        Теперь все ловят багры плавающих питухов.

        Причём на момент создания жаб,пнп,жсов (1995) дроби могли оказаться шустрее, чем эмулируемые флоаты или тормознутые инструкции x87-копроцессора.

        ЕМНИП FPU стал обязательным только в Пентиумах. А в 486 он мало того что был опциональным, так ещё и тупил безбожно.

        Но даже Пентиумы не были панацеей, вспомним FDIV-bug, связанный опять-таки с плавающим питухом.

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

          UBASIC version 8 has the high-precision real and complex arithmetic (up to 2600 digits) of prior versions, and adds exact rational arithmetic and arithmetic of single-variable polynomials with complex, rational, or modulo p coefficients, as well as string handling and limited list handling abilities.

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

          ftp://ftp.bu.edu/mirrors/simtelnet/msdos/ubasic/
          Ответить
        • Будем честны: на 486-е создателям жабы было глубоко похуй. Они писали под спарки, а был-ли в спарках отдельный набор инструкций для fpu?
          Ответить
          • Они в первую очередь делали кроссплатформенный, интерпретируемый язык.

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

            К примеру Моторолла и в 1995 году выпускала недорогие модели процессоров без FPU.

            Таков был общий тренд. Интел здесь не исключение. Наоборот, штеуд был одним из пионеров, кто интегрировал FPU и CPU в одном чипе.
            Ответить
      • >Лично я за NaN.

        Нужно просто всё складывать с плюсами.

        Малость WTF. Много NaN.

        >[1]+[1] = '1,2' - всё ещё новое.
        +[1,2,3]+ + [1,2,3] //NaN
        +[5]+ + "koko" //NaN
        +[1]+ +[1] //2
        +[4]+ +[5] //9
        +[5]+ + [] //5
        +123 + +"456" //579
        +123 - +"456" //-333
        Ответить
    • Asm.js is only capable of handling a selection of different number types and no other data structure (this includes strings, booleans, or objects).

      All external data is stored and referenced from a single object, called the heap. Essentially this heap is a massive array (intended to be a typed array, which is highly optimized for performance).
      All data is stored within this array – effectively replacing global variables, data structures, closures, and any other forms of data storage.

      Posted: April 3rd, 2013

      https://johnresig.com/blog/asmjs-javascript-compile-target/


      Царь мудро учил неразумных анскилябр, что массив — единственно полезная структура.
      Все остальные формы данных — есть частный случай массива.
      Глупые анскилябры только кукарекали и насмехались над Царём.

      А теперь уже более 90% популярных сайтов используют данную технологию.
      Ответить
      • Зачем вообще придумали деление на байты? Почему не сделать компьютер с миимально адресумой памятью -- один бит?
        Ответить
        • Я за. Тогда любую арифметическую операцию можно будет назвать SIMD.
          Ответить
        • > один бит
          Ну кстати был микроконтроллер однобитный.
          Ответить
          • У которого даже не было памяти инструкций, и его нужно было кормить инструкциями с руки. У него даже было два выхода: перемотка ленты на шаг вперёд, перемотка ленты на шаг назад. А саму ленту ты должен был организовать сам в виде обвязки.
            Ответить
        • Малость придумали деление на байты.
          Ответить

    Добавить комментарий