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

    +2

    1. 1
    2. 2
    3. 3
    nameState() {
        return this.name.length > 2 ? true : false
    }

    Из документации Bootstrap Vue
    https://bootstrap-vue.org/docs/components/form-input#contextual-states

    Запостил: JonMagon, 06 Июня 2020

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

    • Не знаю как в семействе Яжьих, но в R сравнение с NA даёт NA, а при попытке засунуть в if - эксцептьён.
      print(NA > 2); # NA
      print(if(NA > 2) T else F); # error
      Ответить
      • > NaN > NaN
        false
        > NaN < NaN
        false
        > NaN == NaN
        false


        ваш яжаскрипт


        >R
        ты датасайнтист чтоли??
        Ответить
        • Я привёл реальный пример, когда a > b - это не тоже самое, что a > b ? true : false
          Ответить
          • >print(NA > 2); # NA
            такого быть не может в JS.

            NaN > 2 == false, а не NaN
            Ответить
            • И правда, в жопоскрипте операции сравнения возвращают только true или false. Если хоть один из аргументов NaN, то результат будет false, что напрочь ломает все законы для операторов сравнения:
              NaN > 2 == false
              NaN <= 2 == false

              Даже законами де Моргана пользоваться нельзя для упрощения.

              Осетинский петух же привёл реальный пример на «R» — на ЯП, придуманном математиками из Rашки. У «R» типизация строже, чем у «JS».
              Ответить
    • Оператор ">" может вернуть что-либо кроме Boolean?
      Ответить
      • В «JS» не может. В «PHP» тоже, именно поэтому я за «PHP». Даже в «Паскале» не может.
        Ответить
        • Именно поэтому я за «Python».
          >>> class X:
          ...     def __gt__(self, other):
          ...             return 'huj'
          ...
          >>> x = X()
          >>> x > 2
          'huj'
          Ответить
          • ебучие волшебные методы.
            В яебу все просто
            class Ruby
            	def >(_)
            		"nonono"
            	end
            end
            
            ruby = Ruby.new
            
            puts ruby > 12
            Ответить
            • Подтверждаю. Именно поэтому я за «operator>(const T & other)».
              Ответить
              • в C# тоже можно оверлоаднуть, но там придется возвращать булен (я думаю).

                А в крестах же можно
                class Foo {
                	public:
                		char operator>(const Foo& foo) {
                			return 'z';
                		}
                };
                int main() {
                	Foo a, b;
                	char q = (a > b);
                }

                да?
                Ответить
                • в луа можно
                  local meta = {
                          __lt = function() return true  end
                  }
                  
                  local tab = {}
                  setmetatable(tab, meta)
                  
                  print(tab < tab)--true

                  но там ответ все равно кастанется к булу, так что вернуть можно по сути тока трру или фолс
                  Ответить
                  • А в форте вообще типов нет, можно перебледить слово < и вернуть на стеке сколько угодно ячеек с любым содержанием, правда если дальше вызвать слово требуещее флаг на входе оно проинтерпретирует только верхнюю ячейку, 0 как ложь, а любое другое значение как истину.

                    Почти как в старых сях где не было булена.
                    Ответить
                    • А в ассемблере инструкции сравнения вообще возвращают набор битов в регистре флагов. Там тоже нет буль.
                      Ответить
                      • Ну кстати не на всех процах. У MIPS'а вроде как раз сишный вариант был, когда сравнения выставляют в регистре 0 или 1. А переходы только по 0 и не 0.
                        Ответить
                      • бит во FLAGS можно рассматриваьть как буль, потому что ты потом всё равно кондишенал джамп же делаеш

                        jnz всякие
                        Ответить
                        • Булевой логики нет над ними, надо либо вынимать их из регистра флагов в обычный, либо выставлять флаги в обычном регистры используя ветвления.
                          Ответить
                • Да, именно так. ЕМНИП, не любое говно нужно возвращать только из «operator T()», он же — оператор каста к T.
                  Ответить
            • Именно поэтому я за «Я»:

              '<' = function (a, b) F
               
              print(1 < 4); # FALSE

              https://ideone.com/ioOTht
              Ответить
              • А в J примитивы не переопределяемые, < всегда возвращает либо буленов, либо массив буленов, в зависимости от аргументов и ранга, для несовместимых типов просто упадёт.
                Ответить
        • А в плюсах можно в operator> любую херь вернуть.
          Ответить
          • В плюсах можно любую херь откуда угодно вернуть, для крестовиков это вторник.
            Ответить
            • Можно с побочным эффектом компаратор сделать
              Ответить
              • можно еще недетерминированным, работающим за O(random), и да: не идеимпотентным
                Ответить
                • а потом отдать класс в std::sort - пусть мучается
                  Ответить
                  • вы просили умную сортировку, вот она и думает
                    Ответить
                  • ЙАЖА, кстати, на такое говно ответит «java.lang.IllegalArgumentException: Comparison method violates its general contract!».
                    Ответить
                    • В D вообще только два метода есть для операторов сравнения - bool opEquals(S s) и int opCmp(S s).
                      Замуровали демоны!
                      Ответить
                      • В «C++20» теперь вообще один оператор — «<=>». Можно не писать пять бессмысленных копипаст, ура!

                        UPD: шесть бессмысленных копипаст. «!=» забыл.
                        Ответить
                        • а он может строку вернуть?
                          Ответить
                          • Вроде как нет, но щупать лень, конпеляторов подходящих под рукой нема.
                            Ответить
                        • А что за парашу там нужно возвращать? Я думал -1, 0, 1, как в ЙАЖЕ. Или просто < делаешь, а всё остальное выражается через него (но по перформансу не по царски).

                          А вот это удобно:
                          class Point {
                           int x;
                           int y;
                          public:
                           auto operator<=>(const Point&) const = default;
                           // ... non-comparison functions ...
                          };
                          Ответить
                          • Я не вникал, там какая-то эпичная поебень с std::strong_ordering, std::weak_ordering, std::partial_ordering. Ну, как всегда в крестах это бывает: те же самые -1, 0, 1, только так, чтобы читающий обязательно ёбнулся.
                            Ответить
                            • Я ещё до weak не дочитал...

                              Итого 10 значений что ли?
                              Ответить
                              • Да, 10. Причём в std::strong_ordering есть «equivalent» и «equal», которые вроде как «the same».
                                Пиздец, ещё не успели реализовать — а уже напихали каких-то говнокостылей.
                                Ответить
                                • А weak/partial влияет на выбор алгоритма сортировки?
                                  Ответить
                            • >strong
                              >weak

                              прямо в cppref же сказано
                              implies substitutability
                              и
                              does not imply substitutability

                              сразу видно, что степановы из раш-ки, и знают математику

                              В других языках и слов-то таких не знают.
                              Ответить
                          • Там пиздец. Куча возвращаемых значений:
                            https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way_comparison

                            std::strong_ordering::equal
                            std::strong_ordering::less
                            std::strong_ordering::greater
                            std::partial_ordering::less
                            std::partial_ordering::greater
                            std::partial_ordering::equivalent
                            std::partial_ordering::unordered
                            Ответить
                            • std::unknown_ordering

                              А тьфу, unordered уже есть.
                              Ответить
                              • С единственным значением std::unknown_ordering::hz.
                                Ответить
                                • Стал искать исходники. В «libstdc++» от «gcc» заголовочного файла «compare» нет, а в «libcxx» от «шланга» вот такая питушня:
                                  https://github.com/llvm/llvm-project/blob/master/libcxx/include/compare

                                  Ничего не понял. Вроде std::partial_ordering::unordered = -127, а less всегда равно -1, greater всегда равно +1, equal и equivalent всегда равны нулю.

                                  Только эти все типы друг в друга не кастятся и в число тоже, потому что это enum class, а не int.
                                  Ответить
                                  • Что интересно: базовый тип для этого перечисления signed char, а для unordered они выбрали не число Тараса (которое для signed char равно -128, если моя память не спит с другим), а -127, чтобы никто не догадался.
                                    Ответить
                    • Йажа вообще падучая. Чуть что - эксепшон.
                      Ответить
    • Прочёл как "Blue trap"
      Ответить

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