ЙажаСценарий / Говнокод #26737 Ссылка на оригинал

0

  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 JonMagon, (Updated )

Комментарии (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.
                Ответить
            • А в J примитивы не переопределяемые, < всегда возвращает либо буленов, либо массив буленов, в зависимости от аргументов и ранга, для несовместимых типов просто упадёт.
              Ответить
        • В плюсах можно любую херь откуда угодно вернуть, для крестовиков это вторник.
          Ответить
          • Можно с побочным эффектом компаратор сделать
            Ответить
            • можно еще недетерминированным, работающим за O(random), и да: не идеимпотентным
              Ответить
                • вы просили умную сортировку, вот она и думает
                  Ответить
                • ЙАЖА, кстати, на такое говно ответит «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, только так, чтобы читающий обязательно ёбнулся.
                          Ответить
                            • Да, 10. Причём в std::strong_ordering есть «equivalent» и «equal», которые вроде как «the same».
                              Пиздец, ещё не успели реализовать — а уже напихали каких-то говнокостылей.
                              Ответить
                          • >strong
                            >weak

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

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

                            В других языках и слов-то таких не знают.
                            Ответить
                              • Стал искать исходники. В «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, чтобы никто не догадался.
                                  Ответить

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

Из-за тебя ушел bormand, guest!

    А не использовать ли нам bbcode?


    8