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

0

  1. 1
if (i.toString().indexOf('.') == -1) { ... }

Ещё один способ проверить, целое ли число.

Запостил: someone someone, (Updated )

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

      • Извиняюсь, сами мы не местные, ночь на дворе, начинаю хуйню писать

        (i===i|0) толстая баба пытается загнать тощего мужика в койку (вид в замочную скважину)
        Ответить
      • минус приведёт i к числу => у функции Кегдана больше область определения
        P.S. нужно больше скобок, чем указано: ((i|0)===i)
        Ответить
        • >у функции Кегдана больше область определения
          Насколько больше? Какой от этого толк?
          i="2";//выдаст на строке true
          Полагаю неявных конвертаций типов нужно избегать. Потому я поставил ===, а не == (а именно они приводят тип неявно)
          Ответить
          • > Насколько больше? Какой от этого толк?
            Насколько больше каких-нибудь значений, чем чисел 🙂
            Позволяет меньше думать, писать меньше кода.

            > Полагаю неявных конвертаций типов нужно избегать.
            Нужно, но иногда хочется конвертнуть...
            Ответить
      • Опять фэйл, завязывай. Во первых, это проверка на int32, не укладывается в диапазон - вернет false. 2147483648 уже не "целое". Во вторых, как выше отметили, приоритет | ниже, чем у ===.
        Ответить
        • >Опять фэйл, завязывай. Во первых, это проверка на int32, не укладывается в диапазон - вернет false.
          (i-(i|0)==0) тоже вернет false.
          http://ideone.com/EyxNpH
          Ответить
            • Ты эта, не стесняйся предлагать безошибочные методы. А главное кроссбраузерные, быстрые и безошибочные.
              > 2147483648 уже не целое? 🙂
              Нет конечно.
              Ответить
              • Зачем? Вариант от bormand'а и так норм.
                > Нет конечно.
                Отсюда поподробней 🙂
                Ответить
                  • В js безопасные целые находятся в рамках +-9007199254740991, так что на счет него точно сказать нельзя. А вот о 2147483648 - вполне 🙂
                    Ответить
                    • > так что на счет него точно сказать нельзя
                      Вариант bormandа точно говорит - true.
                      >9007199254740991
                      Понимающий суть вопроса человек написал бы ± ((1<<53)-1).
                      Всем сразу понятно откуда лезет эта мантисса.

                      >23233333333333333
                      >на счет него точно сказать нельзя
                      Насчёт него можно точно сказать что оно целое (как число), однако оно не влазит ни в тип js "целое", и не влазит в тип js Float64.
                      Ответить
                      • > Всем сразу понятно откуда лезет эта мантисса.
                        Но ведь ты так смешно реагируешь 🙂
                        Ответить
                    • Не потрудитесь объяснить почему в множестве "безопасные целые js" не работает операция побитового сдвига, очевидно и естественно применимая к целым числам?
                      4294967296>>1
                      Ответить
                      • Невнимательно читаем. Ссылка на спецификацию, последний абзац 8.5.
                        Ответить
                        • Я не спрашиваю про спецификацию. Я спрашиваю что же это за целые числа такие "безопасные" что в них половина операций не работает корректно?
                          Ответить
                • >Вариант от bormand'а и так норм.
                  http://ideone.com/5wssK7
                  var a= 2.e+22;
                  System.out.println(a % 1 == 0) //true

                  var a= "233"
                  System.out.println(a % 1 == 0) //true
                  Фейл.

                  var a=3.14*Math.pow(2,65)+0.5;
                  System.out.println(a % 1 == 0);
                  Фейл.
                  Ответить
                        • То есть Вас ни разу не смущает что:
                          false % 1 == 0
                          true % 1 == 0
                          new Date() % 1 == 0

                          Получается true,false - целые числа, так?
                          Ответить
                          • Именно. При привидении к числу, булевы приводятся к целым числам. Как и строки. Меня вполне устраивает. Тебя нет? Добавь проверку.
                            Ответить
                            • То есть получается true,false - полноправные целые числа, а вот насчёт 23233333333333333
                              >>на счет него точно сказать нельзя
                              Верно я понимаю?
                              Кстати что там спецификация говорит по этому поводу?
                              Ответить
                                • Что замечательно?
                                  Вопрос был такой:
                                  То есть получается true,false - полноправные целые числа, а вот насчёт 23233333333333333 "на счет него точно сказать нельзя"?
                                  Ответить
                                  • Технически оно является целым, но не является безопасным целым, так что многие операции его не будут воспринимать таковым. Что такое "безопасные целые" хорошо расписано в черновике спеки ES6. Да и в статье, что скинул, в которую, судя по всему, ты заглянуть не потрудился. Хорошо бы знать такие вещи. Или ты и с приведением типов впервые столкнулся, о чем вторая часть вопроса? 😀
                                    Ответить
                                    • >Или ты и с приведением типов впервые столкнулся, о чем вторая часть вопроса? 😀
                                      То что true, false приводятся к числу не делает их числами.
                                      Для проверки является объекта есть оператор typeof. Возможно ту часть спецификации, которая его описывает на русский еще не перевели.

                                      Но typeof false == "boolean".
                                      А typeof 1 == "number".
                                      А number в переводе с английского это число, false не может быть целым числом, поскольку в оригинале спецификации поясняется что это вовсе не число.
                                      Ответить
                                  • Ладно, с тобой весело, но я спать, удачи, неудачник, учи основы 🙂
                                    Ответить
                                    • >Технически оно является целым, но не является безопасным целым,
                                      Ладно. Я беру число из безопасного диапазона и проверяю его "успешным" методом
                                      9007199254740000.5%1==0
                                      Получается 9007199254740000.5 - целое? Верно?
                                      Подтекает абстракция, подтекает.
                                      Ответить
                                      • Не передергивай. В выражении "безопасные целые" никакое слово не смущает? 🙂
                                        console.log(9007199254740000.5); // => 9007199254740000
                                        Ответить
                                        • Я не передергиваю. Я привожу аргумент, подкрепляя его примером.
                                          Проверка не работает. Невозможно установить дробное число или нет. Фейл.

                                          >В выражении "безопасные целые" никакое слово не смущает? 🙂
                                          А насчёт безопасных плавающих там ничего не написано?

                                          То как-то непонятно:
                                          3007199254740000.1 % 1 == 0 //целое
                                          3007199254740000.5 % 1 == 0.5//плавающее
                                          Ответить
                                          • Именно передергиваешь. Была речь именно о безопасных целых, выдрал понравившееся слово безопасный, забыв про второе.
                                            > Проверка не работает. Невозможно установить дробное число или нет.
                                            А оно именно целое, спасибо представлению чисел в js, повторюсь:
                                            console.log(9007199254740000.5); // => 9007199254740000
                                            console.log(3007199254740000.1); // => 3007199254740000
                                            console.log(3007199254740000.5); // => 3007199254740000.5
                                            Так что фэйл твой.
                                            Ответить
                                            • >А оно именно целое, спасибо представлению чисел в js
                                              >console.log(9007199254740000.5); // => 9007199254740000
                                              >console.log(3007199254740000.1); // => 3007199254740000

                                              У вас флоат-абасракция потекла прямо по штанине.
                                              Что в стандарте-то написано или не перевели еще?
                                              Ответить
                                                • var a=[];
                                                  
                                                  a[0.1]=0.1
                                                  a % 1 == 0
                                                  
                                                  a["i'm not a number"]=NaN
                                                  a % 1 == 0
                                                  А по сабжу массив а со всяким мусором внутри тоже получается целое число?
                                                  Что нам скажет console.log?
                                                  [] - какое это число?
                                                  Ответить
                                                  • [] == 0, и?

                                                    Ты так и не ответил, целое ли число -1, ведь побитовый сдвиг >>> с ним не работает.
                                                    Ответить
                                                    • Ну вообще-то в массиве дробные числа, NaN и строки.
                                                      >[] == 0
                                                      Равно потерял [] === 0 //false
                                                      Ответить
                                                      • Это магия js, детка. Привидение к числу через valueOf, затем toString, затем join, join массива с мусором - пустая строка - ноль. А еще одно равно - для слабаков, так и не освоивших приведение типов js.
                                                        Ответить
                                                        • >Привидение к числу
                                                          Это ваши привидения сугубо нематериальная субстанция.

                                                          Я когда был маленький, то боялся привидений, а сейчас особенно боюсь всяких подозрительных приведений типов...
                                                          Ответить
                                                          • Не можешь смириться с логикой - докопайся до орфографии, отшутись и уведи в разговор в сторону - так держать! 🙂
                                                            Ответить
                                                            • Ни примеров, ни ссылок на спеку (хотя раньше они были, хотя бы даже на перевод).

                                                              >Не можешь смириться с логикой
                                                              С логикой что Логический тип boolean является Целочисленным типом int32? Или что массив с мусором является Целочисленным типом?
                                                              Ответить
                                                        • > для слабаков, так и не освоивших приведение типов js.
                                                          Зачем знать, как массив преобразуется в число? (Исключая случай, когда нужно кого-то потроллить в интернетах) Это когда-нибудь нужно в нормальной ситуации?
                                                          Ответить
                                                          • Да шучу же. Кто в адеквате будет массив к числу приводить? 🙂
                                                            Ответить
                                                    • >Ты так и не ответил, целое ли число -1
                                                      Отвечаю. Число -1 целое, поскольку представимо целым типом данных.

                                                      >ведь побитовый сдвиг >>> с ним не работает.
                                                      Редчайшую ахинею порет Мастер ЖС.
                                                      Побитовый сдвиг работает:
                                                      http://ideone.com/MSfk2X
                                                      Ответить
                                                      • > Побитовый сдвиг работает
                                                        Точно так же, как и прочие побитовые операции с целыми, не входящими в int32. Противоречия не находишь? 🙂
                                                        Ответить
                                                        • > Противоречия не находишь? 🙂
                                                          В ваших рассуждениях - постоянно.
                                                          Ответить
                                                          • > В ваших рассуждениях - постоянно.
                                                            Да ладно? Укажите хоть на одно.

                                                            > почему в множестве "безопасные целые js" не работает операция побитового сдвига, очевидно и естественно применимая к целым числам
                                                            2147483648 >> 0 // => -2147483648

                                                            > Побитовый сдвиг работает
                                                            -1 >>> 0 // => 4294967295
                                                            Ответить
                                                            • > Побитовый сдвиг работает
                                                              >-1 >>> 0
                                                              Это фальшивый сдвиг. И хвалёное неявное приведение типов. Их бинарные представления в int32 идентичны.

                                                              Берем число, которое не влазит в int32 в левую руку 8000000000:
                                                              Бинарное представление:
                                                              0b111011100110101100101000000000000
                                                              Должны получить бинарное представление:
                                                              0b11101110011010110010100000000000

                                                              Сдвигаем левой рукой его вправо и получаем:
                                                              1852516352
                                                              Бинарное представление:
                                                              0b1101110011010110010100000000000
                                                              Пропала верхняя 1.
                                                              Ответить
                                                              • > Это фальшивый сдвиг.
                                                                Бля... Убедил. В JS есть честные инты - int32, все целые, что в этот диапазон не входят - не имеют права называться целыми. Оператор >> - честный побитовый сдвиг, а >>> - фальшивый, потому как работает с uint32, а его в js нет. Числа в памяти должны представляться с той же точностью, что используется в литерале. Использующие неявное приведение типов должны гореть на кострах инквизиции, потому как кое-кто его не понимает. А еще у оператора | приоритет выше, чем у ===.

                                                                За сим откланиваюсь.
                                                                Ответить
                                                                • >а >>> - фальшивый
                                                                  Фальшивый в том смысле что это сдвиг на 0 бит.
                                                                  Ответить
                                                                • Вот пример, наглядно показывающий как херятся биты в бинарном виде:
                                                                  http://ideone.com/pJYdpi
                                                                  a=80000000000
                                                                  Orig :1001010100000010111110010000000000000
                                                                  a>>>0:10100000010111110010000000000000
                                                                  a>>>1:1010000001011111001000000000000


                                                                  >В JS есть честные инты - int32, все целые, что в этот диапазон не входят - не имеют права называться целыми.

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

                                                                  Память компьютера ограничена техническими факторами, потому вместо понятия целое число (бесконечное множество) используется понятие "целый тип".
                                                                  Ответить
                • >Отсюда поподробней 🙂
                  Объясняю. В js целым типом является int32, всё что выше неявно сконвертировано в тип float64.
                  Int - сокращение от integer, в переводе это значит "целое".
                  У меня язык не поворачивается назвать Float целым. И строку целым числом я назвать не могу.
                  Ответить
                    • Стандарт на русском - это уже о многом говорит.
                      Тип Number Числовой тип имеет ровно 18437736874454810627 (то есть, 264−253+3) значений, представляющих собой 64-битовые значения с удвоенной точностью в формате IEEE 754 в соответствии со Стандартом IEEE для двоичной арифметики с плавающей точкой
                      Ответить
                      • А теперь: Обратите внимание, что все положительные и отрицательные целые числа, значение которых по модулю не превышает 2^53, представимы типом Number (в действительности, целое число 0 имеет два представления: +0 и -0).
                        Ну да, 2147483648 точно не целое 😀
                        Ответить
                        • >представимы типом Number
                          Числа представимы и типом String, это не делает тип String целочисленным.
                          Ответить
                          • Повторять не буду, см. выше 🙂

                            Про спеку на русском языке - о тебе же, глупеньком, беспокоюсь.

                            Да, с твоей позиции в js вообще нет целых чисел, потому как int32 / uint32 в js отсутствуют, просто некоторые операторы работают с его числами как с int'ами 🙂
                            Ответить
                            • >Про спеку на русском языке - о тебе же, глупеньком, беспокоюсь.
                              Обосрался - притворись что проявил заботу.

                              >Да, с твоей позиции в js вообще нет целых чисел, потому как int32 / uint32 в js отсутствуют
                              Не надо ложить мне в рот слова. Я такого не писал.

                              Рекомендую научиться читать, и осмысливать прочитанное, прежде чем вступать в спор:
                              >> В js целым типом является int32, всё что выше неявно сконвертировано в тип float64.
                              Ответить
                              • > Обосрался - притворись что проявил заботу.
                                Как грубо 🙂 Нечем возразить - начинай хамить.
                                > Не надо ложить мне в рот слова. Я такого не писал.
                                Да ладно, будто под словами, что 2^31 не целое подразумивалось нечто иное 🙂
                                Ответить
                          • Тут двойная логика - с одной стороны строка из цифр - это не число, а строка (кэп). Но с другой если мы попытается обратиться, она будет вести себя как число. А если что то крякает как утка, плавает как утка, но это - утка. В этом трагедия динамических языков
                            Ответить
                        • >Ну да, 2147483648 точно не целое 😀

                          >23233333333333333
                          >>на счет него точно сказать нельзя
                          Ну да :)))))
                          Ответить
                                • А что, Мастер не юный? Тогда вам надо срочно обратиться в Отделение по профилактике фанатизма, там вам бесплатно сделают живительную эвтаназию.
                                  Ответить
                                  • а после эвтанизии дадут вашей жене пососать чупачупс
                                    Ответить
                                    • Я могу тебе прямо счас дать свой горячий, раскалённый чупа-чупс с карамельной головкой...
                                      Ответить
                  • > У меня язык не поворачивается назвать Float целым.

                    А вот авторы Lua без зазрения совести выпилили из языка все числовые типы кроме Float и смело индексируют массивы ("таблицы") числами с плавающей точкой.
                    Мне это тоже мозг выносит. Зато холиваров подобных нет.
                    Ответить
                    • >индексируют массивы ("таблицы") числами с плавающей точкой.
                      О массивы(мапы?) в жс, это что-то:
                      a[7.01]=1
                      console.log(a[7.01])=1
                      console.log(a)=[]
                      Ответить
                      • Зачем Вы массив порвали? Он же при таком использовании тормозить будет.

                        > console.log(a)=[]
                        А надо, чтоб как в Lua работало?
                        Ответить
                        • >А надо, чтоб как в Lua работало?
                          Честно, не знаю как лучше. И так криво, и эдак не очень.
                          Ответить
    • Почему только полтреда заминусовано?
      Давай, на работу. Не ленись.
      Тред сам не заминусуется.
      Проминусуй его, проминисуй его еще раз.
      Ответить
        • Ленивое конардо, некачественно минусуешь, некачественно срёшь, что ты вообще на гкоде делаешь?
          На каникулах для добросовестного выполнения этих занятий должно быть полно времени.
          Ответить
          • Может он инвалид с одним пальцем? Это бы многое обьяснило
            Ответить

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

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

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


    8